[linux-block.git] / net / bridge / br_private_mrp.h

/* SPDX-License-Identifier: GPL-2.0-or-later */

#ifndef _BR_PRIVATE_MRP_H_
#define _BR_PRIVATE_MRP_H_

#include "br_private.h"
#include <uapi/linux/mrp_bridge.h>

#define MRP_OPT_PADDING		0x2

struct br_mrp {
	/* list of mrp instances */
	struct hlist_node		list;

	struct net_bridge_port __rcu	*p_port;
	struct net_bridge_port __rcu	*s_port;
	struct net_bridge_port __rcu	*i_port;

	u32				ring_id;
	u16				in_id;
	u16				prio;

	enum br_mrp_ring_role_type	ring_role;
	u8				ring_role_offloaded;
	enum br_mrp_ring_state_type	ring_state;
	u32				ring_transitions;

	enum br_mrp_in_role_type	in_role;
	u8				in_role_offloaded;
	enum br_mrp_in_state_type	in_state;
	u32				in_transitions;

	struct delayed_work		test_work;
	u32				test_interval;
	unsigned long			test_end;
	u32				test_count_miss;
	u32				test_max_miss;
	bool				test_monitor;

	struct delayed_work		in_test_work;
	u32				in_test_interval;
	unsigned long			in_test_end;
	u32				in_test_count_miss;
	u32				in_test_max_miss;

	u32				seq_id;

	struct rcu_head			rcu;
};

/* This type is returned by br_mrp_switchdev functions that allow to have a SW
 * backup in case the HW can't implement completely the protocol.
 * BR_MRP_NONE - means the HW can't run at all the protocol, so the SW stops
 *               configuring the node anymore.
 * BR_MRP_SW - the HW can help the SW to run the protocol, by redirecting MRP
 *             frames to CPU.
 * BR_MRP_HW - the HW can implement completely the protocol.
 */
enum br_mrp_hw_support {
	BR_MRP_NONE,
	BR_MRP_SW,
	BR_MRP_HW,
};

/* br_mrp.c */
int br_mrp_add(struct net_bridge *br, struct br_mrp_instance *instance);
int br_mrp_del(struct net_bridge *br, struct br_mrp_instance *instance);
int br_mrp_set_port_state(struct net_bridge_port *p,
			  enum br_mrp_port_state_type state);
int br_mrp_set_port_role(struct net_bridge_port *p,
			 enum br_mrp_port_role_type role);
int br_mrp_set_ring_state(struct net_bridge *br,
			  struct br_mrp_ring_state *state);
int br_mrp_set_ring_role(struct net_bridge *br, struct br_mrp_ring_role *role);
int br_mrp_start_test(struct net_bridge *br, struct br_mrp_start_test *test);
int br_mrp_set_in_state(struct net_bridge *br, struct br_mrp_in_state *state);
int br_mrp_set_in_role(struct net_bridge *br, struct br_mrp_in_role *role);
int br_mrp_start_in_test(struct net_bridge *br,
			 struct br_mrp_start_in_test *test);

/* br_mrp_switchdev.c */
int br_mrp_switchdev_add(struct net_bridge *br, struct br_mrp *mrp);
int br_mrp_switchdev_del(struct net_bridge *br, struct br_mrp *mrp);
enum br_mrp_hw_support
br_mrp_switchdev_set_ring_role(struct net_bridge *br, struct br_mrp *mrp,
			       enum br_mrp_ring_role_type role);
int br_mrp_switchdev_set_ring_state(struct net_bridge *br, struct br_mrp *mrp,
				    enum br_mrp_ring_state_type state);
enum br_mrp_hw_support
br_mrp_switchdev_send_ring_test(struct net_bridge *br, struct br_mrp *mrp,
				u32 interval, u8 max_miss, u32 period,
				bool monitor);
int br_mrp_port_switchdev_set_state(struct net_bridge_port *p, u32 state);
int br_mrp_port_switchdev_set_role(struct net_bridge_port *p,
				   enum br_mrp_port_role_type role);
enum br_mrp_hw_support
br_mrp_switchdev_set_in_role(struct net_bridge *br, struct br_mrp *mrp,
			     u16 in_id, u32 ring_id,
			     enum br_mrp_in_role_type role);
int br_mrp_switchdev_set_in_state(struct net_bridge *br, struct br_mrp *mrp,
				  enum br_mrp_in_state_type state);
enum br_mrp_hw_support
br_mrp_switchdev_send_in_test(struct net_bridge *br, struct br_mrp *mrp,
			      u32 interval, u8 max_miss, u32 period);

/* br_mrp_netlink.c  */
int br_mrp_ring_port_open(struct net_device *dev, u8 loc);
int br_mrp_in_port_open(struct net_device *dev, u8 loc);

/* MRP protocol data units */
struct br_mrp_tlv_hdr {
	__u8 type;
	__u8 length;
};

struct br_mrp_common_hdr {
	__be16 seq_id;
	__u8 domain[MRP_DOMAIN_UUID_LENGTH];
};

struct br_mrp_ring_test_hdr {
	__be16 prio;
	__u8 sa[ETH_ALEN];
	__be16 port_role;
	__be16 state;
	__be16 transitions;
	__be32 timestamp;
} __attribute__((__packed__));

struct br_mrp_in_test_hdr {
	__be16 id;
	__u8 sa[ETH_ALEN];
	__be16 port_role;
	__be16 state;
	__be16 transitions;
	__be32 timestamp;
} __attribute__((__packed__));

struct br_mrp_oui_hdr {
	__u8 oui[MRP_OUI_LENGTH];
};

struct br_mrp_sub_option1_hdr {
	__u8 type;
	__u8 data[MRP_MANUFACTURE_DATA_LENGTH];
};

#endif /* _BR_PRIVATE_MRP_H */
Commit	Line	Data
2f1a11ae HV	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
	2
	3	#ifndef _BR_PRIVATE_MRP_H_
	4	#define _BR_PRIVATE_MRP_H_
	5
	6	#include "br_private.h"
	7	#include <uapi/linux/mrp_bridge.h>
	8
f7458934 HV	9	#define MRP_OPT_PADDING 0x2
f7458934 HV	10
2f1a11ae HV	11	struct br_mrp {
2f1a11ae HV	12	/* list of mrp instances */
0169b820	13	struct hlist_node list;
2f1a11ae HV	14
	15	struct net_bridge_port __rcu *p_port;
	16	struct net_bridge_port __rcu *s_port;
78c1b4fb	17	struct net_bridge_port __rcu *i_port;
2f1a11ae HV	18
2f1a11ae HV	19	u32 ring_id;
78c1b4fb	20	u16 in_id;
4b3a61b0	21	u16 prio;
2f1a11ae HV	22
	23	enum br_mrp_ring_role_type ring_role;
	24	u8 ring_role_offloaded;
	25	enum br_mrp_ring_state_type ring_state;
	26	u32 ring_transitions;
	27
78c1b4fb HV	28	enum br_mrp_in_role_type in_role;
	29	u8 in_role_offloaded;
	30	enum br_mrp_in_state_type in_state;
	31	u32 in_transitions;
	32
2f1a11ae HV	33	struct delayed_work test_work;
	34	u32 test_interval;
	35	unsigned long test_end;
	36	u32 test_count_miss;
	37	u32 test_max_miss;
c6676e7d	38	bool test_monitor;
2f1a11ae	39
78c1b4fb HV	40	struct delayed_work in_test_work;
	41	u32 in_test_interval;
	42	unsigned long in_test_end;
	43	u32 in_test_count_miss;
	44	u32 in_test_max_miss;
	45
2f1a11ae HV	46	u32 seq_id;
	47
	48	struct rcu_head rcu;
	49	};
	50
e1bd99d0 HV	51	/* This type is returned by br_mrp_switchdev functions that allow to have a SW
	52	* backup in case the HW can't implement completely the protocol.
	53	* BR_MRP_NONE - means the HW can't run at all the protocol, so the SW stops
	54	* configuring the node anymore.
	55	* BR_MRP_SW - the HW can help the SW to run the protocol, by redirecting MRP
	56	* frames to CPU.
	57	* BR_MRP_HW - the HW can implement completely the protocol.
	58	*/
	59	enum br_mrp_hw_support {
	60	BR_MRP_NONE,
	61	BR_MRP_SW,
	62	BR_MRP_HW,
	63	};
	64
2f1a11ae HV	65	/* br_mrp.c */
	66	int br_mrp_add(struct net_bridge br, struct br_mrp_instance instance);
	67	int br_mrp_del(struct net_bridge br, struct br_mrp_instance instance);
	68	int br_mrp_set_port_state(struct net_bridge_port *p,
	69	enum br_mrp_port_state_type state);
	70	int br_mrp_set_port_role(struct net_bridge_port *p,
20f6a05e	71	enum br_mrp_port_role_type role);
2f1a11ae HV	72	int br_mrp_set_ring_state(struct net_bridge *br,
	73	struct br_mrp_ring_state *state);
	74	int br_mrp_set_ring_role(struct net_bridge br, struct br_mrp_ring_role role);
	75	int br_mrp_start_test(struct net_bridge br, struct br_mrp_start_test test);
537ed567 HV	76	int br_mrp_set_in_state(struct net_bridge br, struct br_mrp_in_state state);
	77	int br_mrp_set_in_role(struct net_bridge br, struct br_mrp_in_role role);
	78	int br_mrp_start_in_test(struct net_bridge *br,
	79	struct br_mrp_start_in_test *test);
2f1a11ae HV	80
	81	/* br_mrp_switchdev.c */
	82	int br_mrp_switchdev_add(struct net_bridge br, struct br_mrp mrp);
	83	int br_mrp_switchdev_del(struct net_bridge br, struct br_mrp mrp);
1a3ddb0b HV	84	enum br_mrp_hw_support
	85	br_mrp_switchdev_set_ring_role(struct net_bridge br, struct br_mrp mrp,
	86	enum br_mrp_ring_role_type role);
2f1a11ae HV	87	int br_mrp_switchdev_set_ring_state(struct net_bridge br, struct br_mrp mrp,
2f1a11ae HV	88	enum br_mrp_ring_state_type state);
1a3ddb0b HV	89	enum br_mrp_hw_support
	90	br_mrp_switchdev_send_ring_test(struct net_bridge br, struct br_mrp mrp,
	91	u32 interval, u8 max_miss, u32 period,
	92	bool monitor);
b2bdba1c	93	int br_mrp_port_switchdev_set_state(struct net_bridge_port *p, u32 state);
2f1a11ae HV	94	int br_mrp_port_switchdev_set_role(struct net_bridge_port *p,
2f1a11ae HV	95	enum br_mrp_port_role_type role);
1a3ddb0b HV	96	enum br_mrp_hw_support
	97	br_mrp_switchdev_set_in_role(struct net_bridge br, struct br_mrp mrp,
	98	u16 in_id, u32 ring_id,
	99	enum br_mrp_in_role_type role);
f23f0db3 HV	100	int br_mrp_switchdev_set_in_state(struct net_bridge br, struct br_mrp mrp,
f23f0db3 HV	101	enum br_mrp_in_state_type state);
1a3ddb0b HV	102	enum br_mrp_hw_support
	103	br_mrp_switchdev_send_in_test(struct net_bridge br, struct br_mrp mrp,
	104	u32 interval, u8 max_miss, u32 period);
2f1a11ae HV	105
2f1a11ae HV	106	/* br_mrp_netlink.c */
4cc625c6	107	int br_mrp_ring_port_open(struct net_device *dev, u8 loc);
4139d4b5	108	int br_mrp_in_port_open(struct net_device *dev, u8 loc);
2f1a11ae	109
67819390 RV	110	/* MRP protocol data units */
	111	struct br_mrp_tlv_hdr {
	112	__u8 type;
	113	__u8 length;
	114	};
	115
	116	struct br_mrp_common_hdr {
	117	__be16 seq_id;
	118	__u8 domain[MRP_DOMAIN_UUID_LENGTH];
	119	};
	120
	121	struct br_mrp_ring_test_hdr {
	122	__be16 prio;
	123	__u8 sa[ETH_ALEN];
	124	__be16 port_role;
	125	__be16 state;
	126	__be16 transitions;
	127	__be32 timestamp;
	128	} __attribute__((__packed__));
	129
	130	struct br_mrp_in_test_hdr {
	131	__be16 id;
	132	__u8 sa[ETH_ALEN];
	133	__be16 port_role;
	134	__be16 state;
	135	__be16 transitions;
	136	__be32 timestamp;
	137	} __attribute__((__packed__));
	138
f7458934 HV	139	struct br_mrp_oui_hdr {
	140	__u8 oui[MRP_OUI_LENGTH];
	141	};
	142
	143	struct br_mrp_sub_option1_hdr {
	144	__u8 type;
	145	__u8 data[MRP_MANUFACTURE_DATA_LENGTH];
	146	};
	147
2f1a11ae	148	#endif /* _BR_PRIVATE_MRP_H */