[mirror_ubuntu-jammy-kernel.git] / include / net / devlink.h

/*
 * include/net/devlink.h - Network physical device Netlink interface
 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
#ifndef _NET_DEVLINK_H_
#define _NET_DEVLINK_H_

#include <linux/device.h>
#include <linux/slab.h>
#include <linux/gfp.h>
#include <linux/list.h>
#include <linux/netdevice.h>
#include <net/net_namespace.h>
#include <uapi/linux/devlink.h>

struct devlink_ops;

struct devlink {
	struct list_head list;
	struct list_head port_list;
	struct list_head sb_list;
	struct list_head dpipe_table_list;
	struct devlink_dpipe_headers *dpipe_headers;
	const struct devlink_ops *ops;
	struct device *dev;
	possible_net_t _net;
	char priv[0] __aligned(NETDEV_ALIGN);
};

struct devlink_port {
	struct list_head list;
	struct devlink *devlink;
	unsigned index;
	bool registered;
	enum devlink_port_type type;
	enum devlink_port_type desired_type;
	void *type_dev;
	bool split;
	u32 split_group;
};

struct devlink_sb_pool_info {
	enum devlink_sb_pool_type pool_type;
	u32 size;
	enum devlink_sb_threshold_type threshold_type;
};

/**
 * struct devlink_dpipe_field - dpipe field object
 * @name: field name
 * @id: index inside the headers field array
 * @bitwidth: bitwidth
 * @mapping_type: mapping type
 */
struct devlink_dpipe_field {
	const char *name;
	unsigned int id;
	unsigned int bitwidth;
	enum devlink_dpipe_field_mapping_type mapping_type;
};

/**
 * struct devlink_dpipe_header - dpipe header object
 * @name: header name
 * @id: index, global/local detrmined by global bit
 * @fields: fields
 * @fields_count: number of fields
 * @global: indicates if header is shared like most protocol header
 *	    or driver specific
 */
struct devlink_dpipe_header {
	const char *name;
	unsigned int id;
	struct devlink_dpipe_field *fields;
	unsigned int fields_count;
	bool global;
};

/**
 * struct devlink_dpipe_match - represents match operation
 * @type: type of match
 * @header_index: header index (packets can have several headers of same
 *		  type like in case of tunnels)
 * @header: header
 * @fieled_id: field index
 */
struct devlink_dpipe_match {
	enum devlink_dpipe_match_type type;
	unsigned int header_index;
	struct devlink_dpipe_header *header;
	unsigned int field_id;
};

/**
 * struct devlink_dpipe_action - represents action operation
 * @type: type of action
 * @header_index: header index (packets can have several headers of same
 *		  type like in case of tunnels)
 * @header: header
 * @fieled_id: field index
 */
struct devlink_dpipe_action {
	enum devlink_dpipe_action_type type;
	unsigned int header_index;
	struct devlink_dpipe_header *header;
	unsigned int field_id;
};

/**
 * struct devlink_dpipe_value - represents value of match/action
 * @action: action
 * @match: match
 * @mapping_value: in case the field has some mapping this value
 *                 specified the mapping value
 * @mapping_valid: specify if mapping value is valid
 * @value_size: value size
 * @value: value
 * @mask: bit mask
 */
struct devlink_dpipe_value {
	union {
		struct devlink_dpipe_action *action;
		struct devlink_dpipe_match *match;
	};
	unsigned int mapping_value;
	bool mapping_valid;
	unsigned int value_size;
	void *value;
	void *mask;
};

/**
 * struct devlink_dpipe_entry - table entry object
 * @index: index of the entry in the table
 * @match_values: match values
 * @matche_values_count: count of matches tuples
 * @action_values: actions values
 * @action_values_count: count of actions values
 * @counter: value of counter
 * @counter_valid: Specify if value is valid from hardware
 */
struct devlink_dpipe_entry {
	u64 index;
	struct devlink_dpipe_value *match_values;
	unsigned int match_values_count;
	struct devlink_dpipe_value *action_values;
	unsigned int action_values_count;
	u64 counter;
	bool counter_valid;
};

/**
 * struct devlink_dpipe_dump_ctx - context provided to driver in order
 *				   to dump
 * @info: info
 * @cmd: devlink command
 * @skb: skb
 * @nest: top attribute
 * @hdr: hdr
 */
struct devlink_dpipe_dump_ctx {
	struct genl_info *info;
	enum devlink_command cmd;
	struct sk_buff *skb;
	struct nlattr *nest;
	void *hdr;
};

struct devlink_dpipe_table_ops;

/**
 * struct devlink_dpipe_table - table object
 * @priv: private
 * @name: table name
 * @counters_enabled: indicates if counters are active
 * @counter_control_extern: indicates if counter control is in dpipe or
 *			    external tool
 * @table_ops: table operations
 * @rcu: rcu
 */
struct devlink_dpipe_table {
	void *priv;
	struct list_head list;
	const char *name;
	bool counters_enabled;
	bool counter_control_extern;
	struct devlink_dpipe_table_ops *table_ops;
	struct rcu_head rcu;
};

/**
 * struct devlink_dpipe_table_ops - dpipe_table ops
 * @actions_dump - dumps all tables actions
 * @matches_dump - dumps all tables matches
 * @entries_dump - dumps all active entries in the table
 * @counters_set_update - when changing the counter status hardware sync
 *			  maybe needed to allocate/free counter related
 *			  resources
 * @size_get - get size
 */
struct devlink_dpipe_table_ops {
	int (*actions_dump)(void *priv, struct sk_buff *skb);
	int (*matches_dump)(void *priv, struct sk_buff *skb);
	int (*entries_dump)(void *priv, bool counters_enabled,
			    struct devlink_dpipe_dump_ctx *dump_ctx);
	int (*counters_set_update)(void *priv, bool enable);
	u64 (*size_get)(void *priv);
};

/**
 * struct devlink_dpipe_headers - dpipe headers
 * @headers - header array can be shared (global bit) or driver specific
 * @headers_count - count of headers
 */
struct devlink_dpipe_headers {
	struct devlink_dpipe_header **headers;
	unsigned int headers_count;
};

struct devlink_ops {
	int (*port_type_set)(struct devlink_port *devlink_port,
			     enum devlink_port_type port_type);
	int (*port_split)(struct devlink *devlink, unsigned int port_index,
			  unsigned int count);
	int (*port_unsplit)(struct devlink *devlink, unsigned int port_index);
	int (*sb_pool_get)(struct devlink *devlink, unsigned int sb_index,
			   u16 pool_index,
			   struct devlink_sb_pool_info *pool_info);
	int (*sb_pool_set)(struct devlink *devlink, unsigned int sb_index,
			   u16 pool_index, u32 size,
			   enum devlink_sb_threshold_type threshold_type);
	int (*sb_port_pool_get)(struct devlink_port *devlink_port,
				unsigned int sb_index, u16 pool_index,
				u32 *p_threshold);
	int (*sb_port_pool_set)(struct devlink_port *devlink_port,
				unsigned int sb_index, u16 pool_index,
				u32 threshold);
	int (*sb_tc_pool_bind_get)(struct devlink_port *devlink_port,
				   unsigned int sb_index,
				   u16 tc_index,
				   enum devlink_sb_pool_type pool_type,
				   u16 *p_pool_index, u32 *p_threshold);
	int (*sb_tc_pool_bind_set)(struct devlink_port *devlink_port,
				   unsigned int sb_index,
				   u16 tc_index,
				   enum devlink_sb_pool_type pool_type,
				   u16 pool_index, u32 threshold);
	int (*sb_occ_snapshot)(struct devlink *devlink,
			       unsigned int sb_index);
	int (*sb_occ_max_clear)(struct devlink *devlink,
				unsigned int sb_index);
	int (*sb_occ_port_pool_get)(struct devlink_port *devlink_port,
				    unsigned int sb_index, u16 pool_index,
				    u32 *p_cur, u32 *p_max);
	int (*sb_occ_tc_port_bind_get)(struct devlink_port *devlink_port,
				       unsigned int sb_index,
				       u16 tc_index,
				       enum devlink_sb_pool_type pool_type,
				       u32 *p_cur, u32 *p_max);

	int (*eswitch_mode_get)(struct devlink *devlink, u16 *p_mode);
	int (*eswitch_mode_set)(struct devlink *devlink, u16 mode);
	int (*eswitch_inline_mode_get)(struct devlink *devlink, u8 *p_inline_mode);
	int (*eswitch_inline_mode_set)(struct devlink *devlink, u8 inline_mode);
	int (*eswitch_encap_mode_get)(struct devlink *devlink, u8 *p_encap_mode);
	int (*eswitch_encap_mode_set)(struct devlink *devlink, u8 encap_mode);
};

static inline void *devlink_priv(struct devlink *devlink)
{
	BUG_ON(!devlink);
	return &devlink->priv;
}

static inline struct devlink *priv_to_devlink(void *priv)
{
	BUG_ON(!priv);
	return container_of(priv, struct devlink, priv);
}

struct ib_device;

#if IS_ENABLED(CONFIG_NET_DEVLINK)

struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size);
int devlink_register(struct devlink *devlink, struct device *dev);
void devlink_unregister(struct devlink *devlink);
void devlink_free(struct devlink *devlink);
int devlink_port_register(struct devlink *devlink,
			  struct devlink_port *devlink_port,
			  unsigned int port_index);
void devlink_port_unregister(struct devlink_port *devlink_port);
void devlink_port_type_eth_set(struct devlink_port *devlink_port,
			       struct net_device *netdev);
void devlink_port_type_ib_set(struct devlink_port *devlink_port,
			      struct ib_device *ibdev);
void devlink_port_type_clear(struct devlink_port *devlink_port);
void devlink_port_split_set(struct devlink_port *devlink_port,
			    u32 split_group);
int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
			u32 size, u16 ingress_pools_count,
			u16 egress_pools_count, u16 ingress_tc_count,
			u16 egress_tc_count);
void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index);
int devlink_dpipe_table_register(struct devlink *devlink,
				 const char *table_name,
				 struct devlink_dpipe_table_ops *table_ops,
				 void *priv, bool counter_control_extern);
void devlink_dpipe_table_unregister(struct devlink *devlink,
				    const char *table_name);
int devlink_dpipe_headers_register(struct devlink *devlink,
				   struct devlink_dpipe_headers *dpipe_headers);
void devlink_dpipe_headers_unregister(struct devlink *devlink);
bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
					 const char *table_name);
int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx);
int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
				   struct devlink_dpipe_entry *entry);
int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx);
int devlink_dpipe_action_put(struct sk_buff *skb,
			     struct devlink_dpipe_action *action);
int devlink_dpipe_match_put(struct sk_buff *skb,
			    struct devlink_dpipe_match *match);
extern struct devlink_dpipe_header devlink_dpipe_header_ethernet;
extern struct devlink_dpipe_header devlink_dpipe_header_ipv4;

#else

static inline struct devlink *devlink_alloc(const struct devlink_ops *ops,
					    size_t priv_size)
{
	return kzalloc(sizeof(struct devlink) + priv_size, GFP_KERNEL);
}

static inline int devlink_register(struct devlink *devlink, struct device *dev)
{
	return 0;
}

static inline void devlink_unregister(struct devlink *devlink)
{
}

static inline void devlink_free(struct devlink *devlink)
{
	kfree(devlink);
}

static inline int devlink_port_register(struct devlink *devlink,
					struct devlink_port *devlink_port,
					unsigned int port_index)
{
	return 0;
}

static inline void devlink_port_unregister(struct devlink_port *devlink_port)
{
}

static inline void devlink_port_type_eth_set(struct devlink_port *devlink_port,
					     struct net_device *netdev)
{
}

static inline void devlink_port_type_ib_set(struct devlink_port *devlink_port,
					    struct ib_device *ibdev)
{
}

static inline void devlink_port_type_clear(struct devlink_port *devlink_port)
{
}

static inline void devlink_port_split_set(struct devlink_port *devlink_port,
					  u32 split_group)
{
}

static inline int devlink_sb_register(struct devlink *devlink,
				      unsigned int sb_index, u32 size,
				      u16 ingress_pools_count,
				      u16 egress_pools_count,
				      u16 ingress_tc_count,
				      u16 egress_tc_count)
{
	return 0;
}

static inline void devlink_sb_unregister(struct devlink *devlink,
					 unsigned int sb_index)
{
}

static inline int
devlink_dpipe_table_register(struct devlink *devlink,
			     const char *table_name,
			     struct devlink_dpipe_table_ops *table_ops,
			     void *priv, u64 size,
			     bool counter_control_extern)
{
	return 0;
}

static inline void devlink_dpipe_table_unregister(struct devlink *devlink,
						  const char *table_name)
{
}

static inline int devlink_dpipe_headers_register(struct devlink *devlink,
						 struct devlink_dpipe_headers *
						 dpipe_headers)
{
	return 0;
}

static inline void devlink_dpipe_headers_unregister(struct devlink *devlink)
{
}

static inline bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
						       const char *table_name)
{
	return false;
}

static inline int
devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
{
	return 0;
}

static inline int
devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
			       struct devlink_dpipe_entry *entry)
{
	return 0;
}

static inline int
devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
{
	return 0;
}

static inline int
devlink_dpipe_action_put(struct sk_buff *skb,
			 struct devlink_dpipe_action *action)
{
	return 0;
}

static inline int
devlink_dpipe_match_put(struct sk_buff *skb,
			struct devlink_dpipe_match *match)
{
	return 0;
}

#endif

#endif /* _NET_DEVLINK_H_ */
Commit	Line	Data
bfcd3a46 JP	1	/*
	2	* include/net/devlink.h - Network physical device Netlink interface
	3	* Copyright (c) 2016 Mellanox Technologies. All rights reserved.
	4	* Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*/
	11	#ifndef _NET_DEVLINK_H_
	12	#define _NET_DEVLINK_H_
	13
	14	#include <linux/device.h>
	15	#include <linux/slab.h>
	16	#include <linux/gfp.h>
	17	#include <linux/list.h>
	18	#include <linux/netdevice.h>
	19	#include <net/net_namespace.h>
	20	#include <uapi/linux/devlink.h>
	21
	22	struct devlink_ops;
	23
	24	struct devlink {
	25	struct list_head list;
	26	struct list_head port_list;
bf797471	27	struct list_head sb_list;
1555d204 AS	28	struct list_head dpipe_table_list;
1555d204 AS	29	struct devlink_dpipe_headers *dpipe_headers;
bfcd3a46 JP	30	const struct devlink_ops *ops;
	31	struct device *dev;
	32	possible_net_t _net;
	33	char priv[0] __aligned(NETDEV_ALIGN);
	34	};
	35
	36	struct devlink_port {
	37	struct list_head list;
	38	struct devlink *devlink;
	39	unsigned index;
	40	bool registered;
	41	enum devlink_port_type type;
	42	enum devlink_port_type desired_type;
	43	void *type_dev;
	44	bool split;
	45	u32 split_group;
	46	};
	47
bf797471 JP	48	struct devlink_sb_pool_info {
	49	enum devlink_sb_pool_type pool_type;
	50	u32 size;
	51	enum devlink_sb_threshold_type threshold_type;
	52	};
	53
1555d204 AS	54	/**
	55	* struct devlink_dpipe_field - dpipe field object
	56	* @name: field name
	57	* @id: index inside the headers field array
	58	* @bitwidth: bitwidth
	59	* @mapping_type: mapping type
	60	*/
	61	struct devlink_dpipe_field {
	62	const char *name;
	63	unsigned int id;
	64	unsigned int bitwidth;
	65	enum devlink_dpipe_field_mapping_type mapping_type;
	66	};
	67
	68	/**
	69	* struct devlink_dpipe_header - dpipe header object
	70	* @name: header name
	71	* @id: index, global/local detrmined by global bit
	72	* @fields: fields
	73	* @fields_count: number of fields
	74	* @global: indicates if header is shared like most protocol header
	75	* or driver specific
	76	*/
	77	struct devlink_dpipe_header {
	78	const char *name;
	79	unsigned int id;
	80	struct devlink_dpipe_field *fields;
	81	unsigned int fields_count;
	82	bool global;
	83	};
	84
	85	/**
	86	* struct devlink_dpipe_match - represents match operation
	87	* @type: type of match
	88	* @header_index: header index (packets can have several headers of same
	89	* type like in case of tunnels)
	90	* @header: header
	91	* @fieled_id: field index
	92	*/
	93	struct devlink_dpipe_match {
	94	enum devlink_dpipe_match_type type;
	95	unsigned int header_index;
	96	struct devlink_dpipe_header *header;
	97	unsigned int field_id;
	98	};
	99
	100	/**
	101	* struct devlink_dpipe_action - represents action operation
	102	* @type: type of action
	103	* @header_index: header index (packets can have several headers of same
	104	* type like in case of tunnels)
	105	* @header: header
	106	* @fieled_id: field index
	107	*/
	108	struct devlink_dpipe_action {
	109	enum devlink_dpipe_action_type type;
	110	unsigned int header_index;
	111	struct devlink_dpipe_header *header;
	112	unsigned int field_id;
	113	};
	114
	115	/**
	116	* struct devlink_dpipe_value - represents value of match/action
	117	* @action: action
118	* @match: match
119	* @mapping_value: in case the field has some mapping this value
120	* specified the mapping value
121	* @mapping_valid: specify if mapping value is valid
122	* @value_size: value size
123	* @value: value
124	* @mask: bit mask
125	*/
126	struct devlink_dpipe_value {
127	union {
128	struct devlink_dpipe_action *action;
129	struct devlink_dpipe_match *match;
130	};
131	unsigned int mapping_value;
132	bool mapping_valid;
133	unsigned int value_size;
134	void *value;
135	void *mask;
136	};
137
138	/**
139	* struct devlink_dpipe_entry - table entry object
140	* @index: index of the entry in the table
141	* @match_values: match values
142	* @matche_values_count: count of matches tuples
143	* @action_values: actions values
144	* @action_values_count: count of actions values
145	* @counter: value of counter
146	* @counter_valid: Specify if value is valid from hardware
147	*/
148	struct devlink_dpipe_entry {
149	u64 index;
150	struct devlink_dpipe_value *match_values;
151	unsigned int match_values_count;
152	struct devlink_dpipe_value *action_values;
153	unsigned int action_values_count;
154	u64 counter;
155	bool counter_valid;
156	};
157
158	/**
159	* struct devlink_dpipe_dump_ctx - context provided to driver in order
160	* to dump
161	* @info: info
162	* @cmd: devlink command
163	* @skb: skb
164	* @nest: top attribute
165	* @hdr: hdr
166	*/
167	struct devlink_dpipe_dump_ctx {
168	struct genl_info *info;
169	enum devlink_command cmd;
170	struct sk_buff *skb;
171	struct nlattr *nest;
172	void *hdr;
173	};
174
175	struct devlink_dpipe_table_ops;
176
177	/**
178	* struct devlink_dpipe_table - table object
179	* @priv: private
180	* @name: table name
1555d204 AS	181	* @counters_enabled: indicates if counters are active
	182	* @counter_control_extern: indicates if counter control is in dpipe or
	183	* external tool
	184	* @table_ops: table operations
	185	* @rcu: rcu
	186	*/
	187	struct devlink_dpipe_table {
	188	void *priv;
	189	struct list_head list;
	190	const char *name;
1555d204 AS	191	bool counters_enabled;
	192	bool counter_control_extern;
	193	struct devlink_dpipe_table_ops *table_ops;
	194	struct rcu_head rcu;
	195	};
	196
	197	/**
	198	* struct devlink_dpipe_table_ops - dpipe_table ops
	199	* @actions_dump - dumps all tables actions
	200	* @matches_dump - dumps all tables matches
	201	* @entries_dump - dumps all active entries in the table
	202	* @counters_set_update - when changing the counter status hardware sync
	203	* maybe needed to allocate/free counter related
	204	* resources
ffd3cdcc	205	* @size_get - get size
1555d204 AS	206	*/
	207	struct devlink_dpipe_table_ops {
	208	int (actions_dump)(void priv, struct sk_buff *skb);
	209	int (matches_dump)(void priv, struct sk_buff *skb);
	210	int (entries_dump)(void priv, bool counters_enabled,
	211	struct devlink_dpipe_dump_ctx *dump_ctx);
	212	int (counters_set_update)(void priv, bool enable);
ffd3cdcc	213	u64 (size_get)(void priv);
1555d204 AS	214	};
	215
	216	/**
	217	* struct devlink_dpipe_headers - dpipe headers
	218	* @headers - header array can be shared (global bit) or driver specific
	219	* @headers_count - count of headers
	220	*/
	221	struct devlink_dpipe_headers {
	222	struct devlink_dpipe_header **headers;
	223	unsigned int headers_count;
	224	};
	225
bfcd3a46	226	struct devlink_ops {
bfcd3a46 JP	227	int (port_type_set)(struct devlink_port devlink_port,
	228	enum devlink_port_type port_type);
	229	int (port_split)(struct devlink devlink, unsigned int port_index,
	230	unsigned int count);
	231	int (port_unsplit)(struct devlink devlink, unsigned int port_index);
bf797471 JP	232	int (sb_pool_get)(struct devlink devlink, unsigned int sb_index,
	233	u16 pool_index,
	234	struct devlink_sb_pool_info *pool_info);
	235	int (sb_pool_set)(struct devlink devlink, unsigned int sb_index,
	236	u16 pool_index, u32 size,
	237	enum devlink_sb_threshold_type threshold_type);
	238	int (sb_port_pool_get)(struct devlink_port devlink_port,
	239	unsigned int sb_index, u16 pool_index,
	240	u32 *p_threshold);
	241	int (sb_port_pool_set)(struct devlink_port devlink_port,
	242	unsigned int sb_index, u16 pool_index,
	243	u32 threshold);
	244	int (sb_tc_pool_bind_get)(struct devlink_port devlink_port,
	245	unsigned int sb_index,
	246	u16 tc_index,
	247	enum devlink_sb_pool_type pool_type,
	248	u16 p_pool_index, u32 p_threshold);
	249	int (sb_tc_pool_bind_set)(struct devlink_port devlink_port,
	250	unsigned int sb_index,
	251	u16 tc_index,
	252	enum devlink_sb_pool_type pool_type,
	253	u16 pool_index, u32 threshold);
df38dafd JP	254	int (sb_occ_snapshot)(struct devlink devlink,
	255	unsigned int sb_index);
	256	int (sb_occ_max_clear)(struct devlink devlink,
	257	unsigned int sb_index);
	258	int (sb_occ_port_pool_get)(struct devlink_port devlink_port,
	259	unsigned int sb_index, u16 pool_index,
	260	u32 p_cur, u32 p_max);
	261	int (sb_occ_tc_port_bind_get)(struct devlink_port devlink_port,
	262	unsigned int sb_index,
	263	u16 tc_index,
	264	enum devlink_sb_pool_type pool_type,
	265	u32 p_cur, u32 p_max);
08f4b591 OG	266
	267	int (eswitch_mode_get)(struct devlink devlink, u16 *p_mode);
	268	int (eswitch_mode_set)(struct devlink devlink, u16 mode);
59bfde01 RD	269	int (eswitch_inline_mode_get)(struct devlink devlink, u8 *p_inline_mode);
59bfde01 RD	270	int (eswitch_inline_mode_set)(struct devlink devlink, u8 inline_mode);
f43e9b06 RD	271	int (eswitch_encap_mode_get)(struct devlink devlink, u8 *p_encap_mode);
f43e9b06 RD	272	int (eswitch_encap_mode_set)(struct devlink devlink, u8 encap_mode);
bfcd3a46 JP	273	};
	274
	275	static inline void devlink_priv(struct devlink devlink)
	276	{
	277	BUG_ON(!devlink);
	278	return &devlink->priv;
	279	}
	280
	281	static inline struct devlink priv_to_devlink(void priv)
	282	{
	283	BUG_ON(!priv);
	284	return container_of(priv, struct devlink, priv);
	285	}
	286
	287	struct ib_device;
	288
	289	#if IS_ENABLED(CONFIG_NET_DEVLINK)
	290
	291	struct devlink devlink_alloc(const struct devlink_ops ops, size_t priv_size);
	292	int devlink_register(struct devlink devlink, struct device dev);
	293	void devlink_unregister(struct devlink *devlink);
	294	void devlink_free(struct devlink *devlink);
	295	int devlink_port_register(struct devlink *devlink,
	296	struct devlink_port *devlink_port,
	297	unsigned int port_index);
	298	void devlink_port_unregister(struct devlink_port *devlink_port);
	299	void devlink_port_type_eth_set(struct devlink_port *devlink_port,
	300	struct net_device *netdev);
	301	void devlink_port_type_ib_set(struct devlink_port *devlink_port,
	302	struct ib_device *ibdev);
	303	void devlink_port_type_clear(struct devlink_port *devlink_port);
	304	void devlink_port_split_set(struct devlink_port *devlink_port,
	305	u32 split_group);
bf797471 JP	306	int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
	307	u32 size, u16 ingress_pools_count,
	308	u16 egress_pools_count, u16 ingress_tc_count,
	309	u16 egress_tc_count);
	310	void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index);
1555d204 AS	311	int devlink_dpipe_table_register(struct devlink *devlink,
	312	const char *table_name,
	313	struct devlink_dpipe_table_ops *table_ops,
ffd3cdcc	314	void *priv, bool counter_control_extern);
1555d204 AS	315	void devlink_dpipe_table_unregister(struct devlink *devlink,
	316	const char *table_name);
	317	int devlink_dpipe_headers_register(struct devlink *devlink,
	318	struct devlink_dpipe_headers *dpipe_headers);
	319	void devlink_dpipe_headers_unregister(struct devlink *devlink);
	320	bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
	321	const char *table_name);
	322	int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx);
	323	int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
	324	struct devlink_dpipe_entry *entry);
	325	int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx);
	326	int devlink_dpipe_action_put(struct sk_buff *skb,
	327	struct devlink_dpipe_action *action);
	328	int devlink_dpipe_match_put(struct sk_buff *skb,
	329	struct devlink_dpipe_match *match);
11770091	330	extern struct devlink_dpipe_header devlink_dpipe_header_ethernet;
3fb886ec	331	extern struct devlink_dpipe_header devlink_dpipe_header_ipv4;
bfcd3a46 JP	332
	333	#else
	334
	335	static inline struct devlink devlink_alloc(const struct devlink_ops ops,
	336	size_t priv_size)
	337	{
	338	return kzalloc(sizeof(struct devlink) + priv_size, GFP_KERNEL);
	339	}
	340
	341	static inline int devlink_register(struct devlink devlink, struct device dev)
	342	{
	343	return 0;
	344	}
	345
	346	static inline void devlink_unregister(struct devlink *devlink)
	347	{
	348	}
	349
	350	static inline void devlink_free(struct devlink *devlink)
	351	{
	352	kfree(devlink);
	353	}
	354
	355	static inline int devlink_port_register(struct devlink *devlink,
	356	struct devlink_port *devlink_port,
	357	unsigned int port_index)
	358	{
	359	return 0;
	360	}
	361
	362	static inline void devlink_port_unregister(struct devlink_port *devlink_port)
	363	{
	364	}
	365
	366	static inline void devlink_port_type_eth_set(struct devlink_port *devlink_port,
	367	struct net_device *netdev)
	368	{
	369	}
	370
	371	static inline void devlink_port_type_ib_set(struct devlink_port *devlink_port,
	372	struct ib_device *ibdev)
	373	{
	374	}
	375
	376	static inline void devlink_port_type_clear(struct devlink_port *devlink_port)
	377	{
	378	}
	379
	380	static inline void devlink_port_split_set(struct devlink_port *devlink_port,
	381	u32 split_group)
	382	{
	383	}
	384
bf797471 JP	385	static inline int devlink_sb_register(struct devlink *devlink,
	386	unsigned int sb_index, u32 size,
	387	u16 ingress_pools_count,
de33efd0 JP	388	u16 egress_pools_count,
	389	u16 ingress_tc_count,
	390	u16 egress_tc_count)
bf797471 JP	391	{
	392	return 0;
	393	}
	394
	395	static inline void devlink_sb_unregister(struct devlink *devlink,
	396	unsigned int sb_index)
	397	{
	398	}
	399
1555d204 AS	400	static inline int
	401	devlink_dpipe_table_register(struct devlink *devlink,
	402	const char *table_name,
	403	struct devlink_dpipe_table_ops *table_ops,
	404	void *priv, u64 size,
	405	bool counter_control_extern)
	406	{
	407	return 0;
	408	}
	409
	410	static inline void devlink_dpipe_table_unregister(struct devlink *devlink,
	411	const char *table_name)
	412	{
	413	}
	414
	415	static inline int devlink_dpipe_headers_register(struct devlink *devlink,
	416	struct devlink_dpipe_headers *
	417	dpipe_headers)
	418	{
	419	return 0;
	420	}
	421
	422	static inline void devlink_dpipe_headers_unregister(struct devlink *devlink)
	423	{
	424	}
	425
	426	static inline bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
	427	const char *table_name)
	428	{
	429	return false;
	430	}
	431
	432	static inline int
	433	devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
	434	{
	435	return 0;
	436	}
	437
	438	static inline int
	439	devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
	440	struct devlink_dpipe_entry *entry)
	441	{
	442	return 0;
	443	}
	444
	445	static inline int
	446	devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
	447	{
	448	return 0;
	449	}
	450
	451	static inline int
	452	devlink_dpipe_action_put(struct sk_buff *skb,
	453	struct devlink_dpipe_action *action)
	454	{
	455	return 0;
	456	}
	457
	458	static inline int
	459	devlink_dpipe_match_put(struct sk_buff *skb,
	460	struct devlink_dpipe_match *match)
	461	{
	462	return 0;
	463	}
464
bfcd3a46 JP	465	#endif
	466
	467	#endif /* _NET_DEVLINK_H_ */