• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3  * Copyright 2013-2016 Freescale Semiconductor, Inc.
4  * Copyright 2017 NXP
5  */
6 #ifndef _FSL_DPNI_H
7 #define _FSL_DPNI_H
8 
9 /* DPNI Version */
10 #define DPNI_VER_MAJOR				7
11 #define DPNI_VER_MINOR				3
12 
13 /* Command IDs */
14 #define DPNI_CMDID_OPEN				0x8011
15 #define DPNI_CMDID_CLOSE			0x8001
16 #define DPNI_CMDID_CREATE			0x9011
17 #define DPNI_CMDID_DESTROY			0x9811
18 #define DPNI_CMDID_GET_API_VERSION              0xa011
19 
20 #define DPNI_CMDID_ENABLE			0x0021
21 #define DPNI_CMDID_DISABLE			0x0031
22 #define DPNI_CMDID_GET_ATTR			0x0041
23 #define DPNI_CMDID_RESET			0x0051
24 
25 #define DPNI_CMDID_SET_POOLS			0x2002
26 #define DPNI_CMDID_SET_BUFFER_LAYOUT		0x2651
27 #define DPNI_CMDID_GET_BUFFER_LAYOUT		0x2641
28 #define DPNI_CMDID_SET_ERRORS_BEHAVIOR		0x20B1
29 
30 #define DPNI_CMDID_GET_QDID			0x2101
31 #define DPNI_CMDID_GET_TX_DATA_OFFSET		0x2121
32 #define DPNI_CMDID_GET_LINK_STATE		0x2151
33 #define DPNI_CMDID_SET_LINK_CFG			0x21A1
34 
35 #define DPNI_CMDID_SET_PRIM_MAC			0x2241
36 #define DPNI_CMDID_GET_PRIM_MAC			0x2251
37 #define DPNI_CMDID_ADD_MAC_ADDR			0x2261
38 #define DPNI_CMDID_REMOVE_MAC_ADDR		0x2271
39 
40 #define DPNI_CMDID_GET_STATISTICS		0x25D1
41 #define DPNI_CMDID_RESET_STATISTICS		0x25E1
42 #define DPNI_CMDID_GET_QUEUE			0x25F1
43 #define DPNI_CMDID_SET_QUEUE			0x2601
44 #define DPNI_CMDID_SET_TX_CONFIRMATION_MODE	0x2661
45 
46 /*                cmd, param, offset, width, type, arg_name */
47 #define DPNI_CMD_OPEN(cmd, dpni_id) \
48 	MC_CMD_OP(cmd,	 0,	0,	32,	int,	dpni_id)
49 
50 /*                cmd, param, offset, width, type, arg_name */
51 #define DPNI_PREP_CFG(param, cfg) \
52 do { \
53 	MC_PREP_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
54 	MC_PREP_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
55 	MC_PREP_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
56 	MC_PREP_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
57 	MC_PREP_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
58 	MC_PREP_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
59 	MC_PREP_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \
60 } while (0)
61 
62 /*                cmd, param, offset, width, type, arg_name */
63 #define DPNI_EXT_CFG(param, cfg) \
64 do { \
65 	MC_EXT_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
66 	MC_EXT_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
67 	MC_EXT_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
68 	MC_EXT_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
69 	MC_EXT_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
70 	MC_EXT_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
71 	MC_EXT_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \
72 } while (0)
73 
74 /*                cmd, param, offset, width, type, arg_name */
75 #define DPNI_CMD_CREATE(cmd, cfg) \
76 do { \
77 	MC_CMD_OP(cmd, 0, 0,	32,	uint32_t,  cfg->adv.options); \
78 	MC_CMD_OP(cmd, 0, 32,	8,	uint8_t,   cfg->adv.num_queues); \
79 	MC_CMD_OP(cmd, 0, 40,	8,	uint8_t,   cfg->adv.num_tcs); \
80 	MC_CMD_OP(cmd, 0, 48,	8,	uint8_t,   cfg->adv.mac_entries); \
81 	MC_CMD_OP(cmd, 1, 0,	8,	uint8_t,   cfg->adv.vlan_entries); \
82 	MC_CMD_OP(cmd, 1, 16,	8,	uint8_t,   cfg->adv.qos_entries); \
83 	MC_CMD_OP(cmd, 1, 32,	16,	uint8_t,   cfg->adv.fs_entries); \
84 } while (0)
85 
86 /*                cmd, param, offset, width, type, arg_name */
87 #define DPNI_CMD_SET_POOLS(cmd, cfg) \
88 do { \
89 	MC_CMD_OP(cmd, 0, 0,  8,  uint8_t,  cfg->num_dpbp); \
90 	MC_CMD_OP(cmd, 0, 8,  1,  int,      cfg->pools[0].backup_pool); \
91 	MC_CMD_OP(cmd, 0, 9,  1,  int,      cfg->pools[1].backup_pool); \
92 	MC_CMD_OP(cmd, 0, 10, 1,  int,      cfg->pools[2].backup_pool); \
93 	MC_CMD_OP(cmd, 0, 11, 1,  int,      cfg->pools[3].backup_pool); \
94 	MC_CMD_OP(cmd, 0, 12, 1,  int,      cfg->pools[4].backup_pool); \
95 	MC_CMD_OP(cmd, 0, 13, 1,  int,      cfg->pools[5].backup_pool); \
96 	MC_CMD_OP(cmd, 0, 14, 1,  int,      cfg->pools[6].backup_pool); \
97 	MC_CMD_OP(cmd, 0, 15, 1,  int,      cfg->pools[7].backup_pool); \
98 	MC_CMD_OP(cmd, 0, 32, 32, int,      cfg->pools[0].dpbp_id); \
99 	MC_CMD_OP(cmd, 4, 32, 16, uint16_t, cfg->pools[0].buffer_size);\
100 	MC_CMD_OP(cmd, 1, 0,  32, int,      cfg->pools[1].dpbp_id); \
101 	MC_CMD_OP(cmd, 4, 48, 16, uint16_t, cfg->pools[1].buffer_size);\
102 	MC_CMD_OP(cmd, 1, 32, 32, int,      cfg->pools[2].dpbp_id); \
103 	MC_CMD_OP(cmd, 5, 0,  16, uint16_t, cfg->pools[2].buffer_size);\
104 	MC_CMD_OP(cmd, 2, 0,  32, int,      cfg->pools[3].dpbp_id); \
105 	MC_CMD_OP(cmd, 5, 16, 16, uint16_t, cfg->pools[3].buffer_size);\
106 	MC_CMD_OP(cmd, 2, 32, 32, int,      cfg->pools[4].dpbp_id); \
107 	MC_CMD_OP(cmd, 5, 32, 16, uint16_t, cfg->pools[4].buffer_size);\
108 	MC_CMD_OP(cmd, 3, 0,  32, int,      cfg->pools[5].dpbp_id); \
109 	MC_CMD_OP(cmd, 5, 48, 16, uint16_t, cfg->pools[5].buffer_size);\
110 	MC_CMD_OP(cmd, 3, 32, 32, int,      cfg->pools[6].dpbp_id); \
111 	MC_CMD_OP(cmd, 6, 0,  16, uint16_t, cfg->pools[6].buffer_size);\
112 	MC_CMD_OP(cmd, 4, 0,  32, int,      cfg->pools[7].dpbp_id); \
113 	MC_CMD_OP(cmd, 6, 16, 16, uint16_t, cfg->pools[7].buffer_size);\
114 } while (0)
115 
116 /*                cmd, param, offset, width, type, arg_name */
117 #define DPNI_RSP_GET_ATTR(cmd, attr) \
118 do { \
119 	MC_RSP_OP(cmd, 0, 0,  32, int,	    attr->options);\
120 	MC_RSP_OP(cmd, 0, 32,  8,  uint8_t,  attr->max_num_queues); \
121 	MC_RSP_OP(cmd, 0, 40,  8,  uint8_t,  attr->max_num_tcs); \
122 	MC_RSP_OP(cmd, 0, 48,  8,  uint8_t,  attr->max_mac_entries); \
123 	MC_RSP_OP(cmd, 1,  0,  8,  uint8_t,  attr->max_vlan_entries); \
124 	MC_RSP_OP(cmd, 1, 16,  8,  uint8_t,  attr->max_qos_entries); \
125 	MC_RSP_OP(cmd, 1, 32, 16,  uint16_t,  attr->max_fs_entries); \
126 	MC_RSP_OP(cmd, 2,  0,  8,  uint8_t,  attr->max_qos_key_size); \
127 	MC_RSP_OP(cmd, 2,  8,  8,  uint8_t,  attr->max_fs_key_size); \
128 	MC_RSP_OP(cmd, 2, 16, 16,  uint16_t,  attr->wriop_version); \
129 } while (0)
130 
131 /*                cmd, param, offset, width, type, arg_name */
132 #define DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg) \
133 do { \
134 	MC_CMD_OP(cmd, 0, 0,  32, uint32_t, cfg->errors); \
135 	MC_CMD_OP(cmd, 0, 32, 4,  enum dpni_error_action, cfg->error_action); \
136 	MC_CMD_OP(cmd, 0, 36, 1,  int,      cfg->set_frame_annotation); \
137 } while (0)
138 
139 /*                cmd, param, offset, width, type, arg_name */
140 #define DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, queue) \
141 do { \
142 	MC_CMD_OP(cmd, 0, 0,  8, enum dpni_queue_type, queue); \
143 	MC_CMD_OP(cmd, 1, 0,  16, uint16_t, layout->private_data_size); \
144 	MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_align); \
145 	MC_CMD_OP(cmd, 0, 32, 16, uint16_t, layout->options); \
146 	MC_CMD_OP(cmd, 0, 48,  1,  int,	    layout->pass_timestamp); \
147 	MC_CMD_OP(cmd, 0, 49,  1,  int,	    layout->pass_parser_result); \
148 	MC_CMD_OP(cmd, 0, 50,  1,  int,	    layout->pass_frame_status); \
149 	MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_head_room); \
150 	MC_CMD_OP(cmd, 1, 48, 16, uint16_t, layout->data_tail_room); \
151 } while (0)
152 
153 /*                cmd, param, offset, width, type, arg_name */
154 #define DPNI_RSP_GET_QDID(cmd, qdid) \
155 	MC_RSP_OP(cmd, 0, 0,  16, uint16_t, qdid)
156 
157 /*                cmd, param, offset, width, type, arg_name */
158 #define DPNI_RSP_GET_TX_DATA_OFFSET(cmd, data_offset) \
159 	MC_RSP_OP(cmd, 0, 0,  16, uint16_t, data_offset)
160 
161 /*                cmd, param, offset, width, type, arg_name */
162 #define DPNI_CMD_SET_LINK_CFG(cmd, cfg) \
163 do { \
164 	MC_CMD_OP(cmd, 1, 0,  32, uint32_t, cfg->rate);\
165 	MC_CMD_OP(cmd, 2, 0,  64, uint64_t, cfg->options);\
166 } while (0)
167 
168 /*                cmd, param, offset, width, type, arg_name */
169 #define DPNI_RSP_GET_LINK_STATE(cmd, state) \
170 do { \
171 	MC_RSP_OP(cmd, 0, 32,  1, int,      state->up);\
172 	MC_RSP_OP(cmd, 1, 0,  32, uint32_t, state->rate);\
173 	MC_RSP_OP(cmd, 2, 0,  64, uint64_t, state->options);\
174 } while (0)
175 
176 
177 
178 /*                cmd, param, offset, width, type, arg_name */
179 #define DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
180 do { \
181 	MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
182 	MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
183 	MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
184 	MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
185 	MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
186 	MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
187 } while (0)
188 
189 /*                cmd, param, offset, width, type, arg_name */
190 #define DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
191 do { \
192 	MC_RSP_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
193 	MC_RSP_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
194 	MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
195 	MC_RSP_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
196 	MC_RSP_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
197 	MC_RSP_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
198 } while (0)
199 
200 /*                cmd, param, offset, width, type, arg_name */
201 #define DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr) \
202 do { \
203 	MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
204 	MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
205 	MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
206 	MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
207 	MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
208 	MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
209 } while (0)
210 
211 /*                cmd, param, offset, width, type, arg_name */
212 #define DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr) \
213 do { \
214 	MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
215 	MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
216 	MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
217 	MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
218 	MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
219 	MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
220 } while (0)
221 
222 #define DPNI_CMD_GET_QUEUE(cmd, type, tc, index) \
223 do { \
224 	MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
225 	MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
226 	MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \
227 } while (0)
228 
229 #define DPNI_RSP_GET_QUEUE(cmd, queue) \
230 do { \
231 	MC_RSP_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
232 	MC_RSP_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
233 	MC_RSP_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
234 	MC_RSP_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
235 	MC_RSP_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
236 	MC_RSP_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \
237 	MC_RSP_OP(cmd, 4,  0, 32, uint32_t, (queue)->fqid); \
238 	MC_RSP_OP(cmd, 4, 32, 16, uint16_t, (queue)->qdbin); \
239 } while (0)
240 
241 #define DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue) \
242 do { \
243 	MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
244 	MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
245 	MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \
246 	MC_CMD_OP(cmd, 0, 24,  8, uint8_t, (queue)->options); \
247 	MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
248 	MC_CMD_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
249 	MC_CMD_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
250 	MC_CMD_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
251 	MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
252 	MC_CMD_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
253 	MC_CMD_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \
254 } while (0)
255 
256 /*			cmd, param, offset, width, type, arg_name */
257 #define DPNI_CMD_GET_STATISTICS(cmd, page) \
258 	MC_CMD_OP(cmd, 0, 0, 8, uint8_t, page)
259 
260 /*                cmd, param, offset, width, type, arg_name */
261 #define DPNI_RSP_GET_STATISTICS(cmd, stat) \
262 do { \
263 	MC_RSP_OP(cmd, 0, 0, 64, uint64_t, (stat)->counter0); \
264 	MC_RSP_OP(cmd, 1, 0, 64, uint64_t, (stat)->counter1); \
265 	MC_RSP_OP(cmd, 2, 0, 64, uint64_t, (stat)->counter2); \
266 	MC_RSP_OP(cmd, 3, 0, 64, uint64_t, (stat)->counter3); \
267 	MC_RSP_OP(cmd, 4, 0, 64, uint64_t, (stat)->counter4); \
268 	MC_RSP_OP(cmd, 5, 0, 64, uint64_t, (stat)->counter5); \
269 	MC_RSP_OP(cmd, 6, 0, 64, uint64_t, (stat)->counter6); \
270 } while (0)
271 
272 enum net_prot {
273 	NET_PROT_NONE = 0,
274 	NET_PROT_PAYLOAD,
275 	NET_PROT_ETH,
276 	NET_PROT_VLAN,
277 	NET_PROT_IPV4,
278 	NET_PROT_IPV6,
279 	NET_PROT_IP,
280 	NET_PROT_TCP,
281 	NET_PROT_UDP,
282 	NET_PROT_UDP_LITE,
283 	NET_PROT_IPHC,
284 	NET_PROT_SCTP,
285 	NET_PROT_SCTP_CHUNK_DATA,
286 	NET_PROT_PPPOE,
287 	NET_PROT_PPP,
288 	NET_PROT_PPPMUX,
289 	NET_PROT_PPPMUX_SUBFRM,
290 	NET_PROT_L2TPV2,
291 	NET_PROT_L2TPV3_CTRL,
292 	NET_PROT_L2TPV3_SESS,
293 	NET_PROT_LLC,
294 	NET_PROT_LLC_SNAP,
295 	NET_PROT_NLPID,
296 	NET_PROT_SNAP,
297 	NET_PROT_MPLS,
298 	NET_PROT_IPSEC_AH,
299 	NET_PROT_IPSEC_ESP,
300 	NET_PROT_UDP_ENC_ESP, /* RFC 3948 */
301 	NET_PROT_MACSEC,
302 	NET_PROT_GRE,
303 	NET_PROT_MINENCAP,
304 	NET_PROT_DCCP,
305 	NET_PROT_ICMP,
306 	NET_PROT_IGMP,
307 	NET_PROT_ARP,
308 	NET_PROT_CAPWAP_DATA,
309 	NET_PROT_CAPWAP_CTRL,
310 	NET_PROT_RFC2684,
311 	NET_PROT_ICMPV6,
312 	NET_PROT_FCOE,
313 	NET_PROT_FIP,
314 	NET_PROT_ISCSI,
315 	NET_PROT_GTP,
316 	NET_PROT_USER_DEFINED_L2,
317 	NET_PROT_USER_DEFINED_L3,
318 	NET_PROT_USER_DEFINED_L4,
319 	NET_PROT_USER_DEFINED_L5,
320 	NET_PROT_USER_DEFINED_SHIM1,
321 	NET_PROT_USER_DEFINED_SHIM2,
322 
323 	NET_PROT_DUMMY_LAST
324 };
325 
326 /**
327  * Data Path Network Interface API
328  * Contains initialization APIs and runtime control APIs for DPNI
329  */
330 
331 struct fsl_mc_io;
332 
333 /* General DPNI macros */
334 
335 /* Maximum number of traffic classes */
336 #define DPNI_MAX_TC				8
337 /* Maximum number of buffer pools per DPNI */
338 #define DPNI_MAX_DPBP				8
339 
340 /* All traffic classes considered; see dpni_set_rx_flow() */
341 #define DPNI_ALL_TCS				(uint8_t)(-1)
342 /* All flows within traffic class considered; see dpni_set_rx_flow() */
343 #define DPNI_ALL_TC_FLOWS			(uint16_t)(-1)
344 /* Generate new flow ID; see dpni_set_tx_flow() */
345 #define DPNI_NEW_FLOW_ID			(uint16_t)(-1)
346 /* use for common tx-conf queue; see dpni_set_tx_conf_<x>() */
347 #define DPNI_COMMON_TX_CONF			(uint16_t)(-1)
348 
349 /**
350  * dpni_open() - Open a control session for the specified object
351  * @mc_io:	Pointer to MC portal's I/O object
352  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
353  * @dpni_id:	DPNI unique ID
354  * @token:	Returned token; use in subsequent API calls
355  *
356  * This function can be used to open a control session for an
357  * already created object; an object may have been declared in
358  * the DPL or by calling the dpni_create() function.
359  * This function returns a unique authentication token,
360  * associated with the specific object ID and the specific MC
361  * portal; this token must be used in all subsequent commands for
362  * this specific object.
363  *
364  * Return:	'0' on Success; Error code otherwise.
365  */
366 int dpni_open(struct fsl_mc_io	*mc_io,
367 	      uint32_t		cmd_flags,
368 	      int		dpni_id,
369 	      uint16_t		*token);
370 
371 /**
372  * dpni_close() - Close the control session of the object
373  * @mc_io:	Pointer to MC portal's I/O object
374  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
375  * @token:	Token of DPNI object
376  *
377  * After this function is called, no further operations are
378  * allowed on the object without opening a new control session.
379  *
380  * Return:	'0' on Success; Error code otherwise.
381  */
382 int dpni_close(struct fsl_mc_io	*mc_io,
383 	       uint32_t		cmd_flags,
384 	       uint16_t		token);
385 
386 /* DPNI configuration options */
387 
388 /**
389  * Allow different distribution key profiles for different traffic classes;
390  * if not set, a single key profile is assumed
391  */
392 #define DPNI_OPT_ALLOW_DIST_KEY_PER_TC		0x00000001
393 
394 /**
395  * Disable all non-error transmit confirmation; error frames are reported
396  * back to a common Tx error queue
397  */
398 #define DPNI_OPT_TX_CONF_DISABLED		0x00000002
399 
400 /* Disable per-sender private Tx confirmation/error queue */
401 #define DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED	0x00000004
402 
403 /**
404  * Support distribution based on hashed key;
405  * allows statistical distribution over receive queues in a traffic class
406  */
407 #define DPNI_OPT_DIST_HASH			0x00000010
408 
409 /**
410  * Support distribution based on flow steering;
411  * allows explicit control of distribution over receive queues in a traffic
412  * class
413  */
414 #define DPNI_OPT_DIST_FS			0x00000020
415 
416 /* Unicast filtering support */
417 #define DPNI_OPT_UNICAST_FILTER			0x00000080
418 /* Multicast filtering support */
419 #define DPNI_OPT_MULTICAST_FILTER		0x00000100
420 /* VLAN filtering support */
421 #define DPNI_OPT_VLAN_FILTER			0x00000200
422 /* Support IP reassembly on received packets */
423 #define DPNI_OPT_IPR				0x00000800
424 /* Support IP fragmentation on transmitted packets */
425 #define DPNI_OPT_IPF				0x00001000
426 /* VLAN manipulation support */
427 #define DPNI_OPT_VLAN_MANIPULATION		0x00010000
428 /* Support masking of QoS lookup keys */
429 #define DPNI_OPT_QOS_MASK_SUPPORT		0x00020000
430 /* Support masking of Flow Steering lookup keys */
431 #define DPNI_OPT_FS_MASK_SUPPORT		0x00040000
432 
433 /**
434  * enum dpni_queue_type - Identifies a type of queue targeted by the command
435  * @DPNI_QUEUE_RX: Rx queue
436  * @DPNI_QUEUE_TX: Tx queue
437  * @DPNI_QUEUE_TX_CONFIRM: Tx confirmation queue
438  * @DPNI_QUEUE_RX_ERR: Rx error queue
439  */
440 enum dpni_queue_type {
441 	DPNI_QUEUE_RX,
442 	DPNI_QUEUE_TX,
443 	DPNI_QUEUE_TX_CONFIRM,
444 	DPNI_QUEUE_RX_ERR,
445 };
446 
447 struct dpni_cfg {
448 		uint8_t mac_addr[6];
449 	struct {
450 		uint32_t		options;
451 		uint16_t		fs_entries;
452 		uint8_t			num_queues;
453 		uint8_t			num_tcs;
454 		uint8_t			mac_entries;
455 		uint8_t			vlan_entries;
456 		uint8_t			qos_entries;
457 	} adv;
458 };
459 
460 /**
461  * struct dpni_extended_cfg - Structure representing extended DPNI configuration
462  * @tc_cfg: TCs configuration
463  * @ipr_cfg: IP reassembly configuration
464  */
465 struct dpni_extended_cfg {
466 	/**
467 	 * struct tc_cfg - TC configuration
468 	 * @max_dist: Maximum distribution size for Rx traffic class;
469 	 *	supported values: 1,2,3,4,6,7,8,12,14,16,24,28,32,48,56,64,96,
470 	 *	112,128,192,224,256,384,448,512,768,896,1024;
471 	 *	value '0' will be treated as '1'.
472 	 *	other unsupported values will be round down to the nearest
473 	 *	supported value.
474 	 * @max_fs_entries: Maximum FS entries for Rx traffic class;
475 	 *	'0' means no support for this TC;
476 	 */
477 	struct {
478 		uint16_t	max_dist;
479 		uint16_t	max_fs_entries;
480 	} tc_cfg[DPNI_MAX_TC];
481 	/**
482 	 * struct ipr_cfg - Structure representing IP reassembly configuration
483 	 * @max_reass_frm_size: Maximum size of the reassembled frame
484 	 * @min_frag_size_ipv4: Minimum fragment size of IPv4 fragments
485 	 * @min_frag_size_ipv6: Minimum fragment size of IPv6 fragments
486 	 * @max_open_frames_ipv4: Maximum concurrent IPv4 packets in reassembly
487 	 *		process
488 	 * @max_open_frames_ipv6: Maximum concurrent IPv6 packets in reassembly
489 	 *		process
490 	 */
491 	struct {
492 		uint16_t max_reass_frm_size;
493 		uint16_t min_frag_size_ipv4;
494 		uint16_t min_frag_size_ipv6;
495 		uint16_t max_open_frames_ipv4;
496 		uint16_t max_open_frames_ipv6;
497 	} ipr_cfg;
498 };
499 
500 /**
501  * dpni_prepare_cfg() - function prepare parameters
502  * @cfg: cfg structure
503  * @cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
504  *
505  * This function has to be called before dpni_create()
506  */
507 int dpni_prepare_cfg(const struct dpni_cfg	*cfg,
508 		     uint8_t			*cfg_buf);
509 /**
510  * dpni_create() - Create the DPNI object
511  * @mc_io:	Pointer to MC portal's I/O object
512  * @token:	Authentication token.
513  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
514  * @cfg:	Configuration structure
515  * @obj_id:	Returned obj_id; use in subsequent API calls
516  *
517  * Create the DPNI object, allocate required resources and
518  * perform required initialization.
519  *
520  * The object can be created either by declaring it in the
521  * DPL file, or by calling this function.
522  *
523  * This function returns a unique authentication token,
524  * associated with the specific object ID and the specific MC
525  * portal; this token must be used in all subsequent calls to
526  * this specific object. For objects that are created using the
527  * DPL file, call dpni_open() function to get an authentication
528  * token first.
529  *
530  * Return:	'0' on Success; Error code otherwise.
531  */
532 int dpni_create(struct fsl_mc_io	*mc_io,
533 		uint16_t		token,
534 		uint32_t		cmd_flags,
535 		const struct dpni_cfg	*cfg,
536 		uint32_t		*obj_id);
537 
538 /**
539  * dpni_destroy() - Destroy the DPNI object and release all its resources.
540  * @mc_io:	Pointer to MC portal's I/O object
541  * @token:	Authentication token.
542  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
543  * @obj_id:	Returned obj_id; use in subsequent API calls
544  *
545  * Return:	'0' on Success; error code otherwise.
546  */
547 int dpni_destroy(struct fsl_mc_io	*mc_io,
548 		 uint16_t		token,
549 		 uint32_t		cmd_flags,
550 		 uint32_t		obj_id);
551 
552 /**
553  * struct dpni_pools_cfg - Structure representing buffer pools configuration
554  * @num_dpbp: Number of DPBPs
555  * @pools: Array of buffer pools parameters; The number of valid entries
556  *	must match 'num_dpbp' value
557  */
558 struct dpni_pools_cfg {
559 	uint8_t num_dpbp;
560 	/**
561 	 * struct pools - Buffer pools parameters
562 	 * @dpbp_id: DPBP object ID
563 	 * @buffer_size: Buffer size
564 	 * @backup_pool: Backup pool
565 	 */
566 	struct {
567 		int		dpbp_id;
568 		uint16_t	buffer_size;
569 		int		backup_pool;
570 	} pools[DPNI_MAX_DPBP];
571 };
572 
573 /**
574  * dpni_set_pools() - Set buffer pools configuration
575  * @mc_io:	Pointer to MC portal's I/O object
576  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
577  * @token:	Token of DPNI object
578  * @cfg:	Buffer pools configuration
579  *
580  * mandatory for DPNI operation
581  * warning:Allowed only when DPNI is disabled
582  *
583  * Return:	'0' on Success; Error code otherwise.
584  */
585 int dpni_set_pools(struct fsl_mc_io		*mc_io,
586 		   uint32_t			cmd_flags,
587 		   uint16_t			token,
588 		   const struct dpni_pools_cfg	*cfg);
589 
590 /**
591  * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
592  * @mc_io:	Pointer to MC portal's I/O object
593  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
594  * @token:		Token of DPNI object
595  *
596  * Return:	'0' on Success; Error code otherwise.
597  */
598 int dpni_enable(struct fsl_mc_io	*mc_io,
599 		uint32_t		cmd_flags,
600 		uint16_t		token);
601 
602 /**
603  * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
604  * @mc_io:	Pointer to MC portal's I/O object
605  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
606  * @token:	Token of DPNI object
607  *
608  * Return:	'0' on Success; Error code otherwise.
609  */
610 int dpni_disable(struct fsl_mc_io	*mc_io,
611 		 uint32_t		cmd_flags,
612 		 uint16_t		token);
613 
614 
615 /**
616  * dpni_reset() - Reset the DPNI, returns the object to initial state.
617  * @mc_io:	Pointer to MC portal's I/O object
618  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
619  * @token:	Token of DPNI object
620  *
621  * Return:	'0' on Success; Error code otherwise.
622  */
623 int dpni_reset(struct fsl_mc_io	*mc_io,
624 	       uint32_t		cmd_flags,
625 	       uint16_t		token);
626 
627 /**
628  * struct dpni_attr - Structure representing DPNI attributes
629  * @options: Mask of available options; reflects the value as was given in
630  *		object's creation
631  * @max_num_queues: Number of queues available (for both Tx and Rx)
632  * @max_num_tcs: Maximum number of traffic classes (for both Tx and Rx)
633  * @max_mac_entries: Maximum number of traffic classes (for both Tx and Rx)
634  * @max_unicast_filters: Maximum number of unicast filters
635  * @max_multicast_filters: Maximum number of multicast filters
636  * @max_vlan_entries: Maximum number of VLAN filters
637  * @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in QoS table
638  * @max_fs_entries: declares the maximum entries in flow steering table
639  * @max_qos_key_size: Maximum key size for the QoS look-up
640  * @max_fs_key_size: Maximum key size for the flow steering
641  * @wriop_version: Indicates revision of WRIOP hardware block
642  */
643 struct dpni_attr {
644 	uint32_t id;
645 	uint32_t options;
646 	uint8_t max_num_queues;
647 	uint8_t max_num_tcs;
648 	uint8_t max_mac_entries;
649 	uint8_t max_vlan_entries;
650 	uint8_t max_qos_entries;
651 	uint16_t max_fs_entries;
652 	uint8_t max_qos_key_size;
653 	uint8_t max_fs_key_size;
654 	uint16_t wriop_version;
655 };
656 
657 /**
658  * dpni_get_attributes() - Retrieve DPNI attributes.
659  * @mc_io:	Pointer to MC portal's I/O object
660  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
661  * @token:	Token of DPNI object
662  * @attr:	Object's attributes
663  *
664  * Return:	'0' on Success; Error code otherwise.
665  */
666 int dpni_get_attributes(struct fsl_mc_io	*mc_io,
667 			uint32_t		cmd_flags,
668 			uint16_t		token,
669 			struct dpni_attr	*attr);
670 
671 /**
672  * dpni_extract_cfg() - extract the parameters
673  * @cfg: cfg structure
674  * @cfg_buf: 256 bytes of DMA-able memory
675  *
676  * This function has to be called after dpni_get_attributes()
677  */
678 int dpni_extract_cfg(struct dpni_cfg	*cfg,
679 		     const uint8_t	*cfg_buf);
680 
681 /**
682  * DPNI errors
683  */
684 
685 /**
686  * Extract out of frame header error
687  */
688 #define DPNI_ERROR_EOFHE	0x00020000
689 /**
690  * Frame length error
691  */
692 #define DPNI_ERROR_FLE		0x00002000
693 /**
694  * Frame physical error
695  */
696 #define DPNI_ERROR_FPE		0x00001000
697 /**
698  * Parsing header error
699  */
700 #define DPNI_ERROR_PHE		0x00000020
701 /**
702  * Parser L3 checksum error
703  */
704 #define DPNI_ERROR_L3CE		0x00000004
705 /**
706  * Parser L3 checksum error
707  */
708 #define DPNI_ERROR_L4CE		0x00000001
709 
710 /**
711  * enum dpni_error_action - Defines DPNI behavior for errors
712  * @DPNI_ERROR_ACTION_DISCARD: Discard the frame
713  * @DPNI_ERROR_ACTION_CONTINUE: Continue with the normal flow
714  * @DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE: Send the frame to the error queue
715  */
716 enum dpni_error_action {
717 	DPNI_ERROR_ACTION_DISCARD = 0,
718 	DPNI_ERROR_ACTION_CONTINUE = 1,
719 	DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE = 2
720 };
721 
722 /**
723  * struct dpni_error_cfg - Structure representing DPNI errors treatment
724  * @errors: Errors mask; use 'DPNI_ERROR__<X>
725  * @error_action: The desired action for the errors mask
726  * @set_frame_annotation: Set to '1' to mark the errors in frame annotation
727  *		status (FAS); relevant only for the non-discard action
728  */
729 struct dpni_error_cfg {
730 	uint32_t		errors;
731 	enum dpni_error_action	error_action;
732 	int			set_frame_annotation;
733 };
734 
735 /**
736  * dpni_set_errors_behavior() - Set errors behavior
737  * @mc_io:	Pointer to MC portal's I/O object
738  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
739  * @token:	Token of DPNI object
740  * @cfg:	Errors configuration
741  *
742  * this function may be called numerous times with different
743  * error masks
744  *
745  * Return:	'0' on Success; Error code otherwise.
746  */
747 int dpni_set_errors_behavior(struct fsl_mc_io		*mc_io,
748 			     uint32_t			cmd_flags,
749 			     uint16_t			token,
750 			     struct dpni_error_cfg	*cfg);
751 
752 /* DPNI buffer layout modification options */
753 
754 /* Select to modify the time-stamp setting */
755 #define DPNI_BUF_LAYOUT_OPT_TIMESTAMP		0x00000001
756 /* Select to modify the parser-result setting; not applicable for Tx */
757 #define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT	0x00000002
758 /* Select to modify the frame-status setting */
759 #define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS	0x00000004
760 /* Select to modify the private-data-size setting */
761 #define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE	0x00000008
762 /* Select to modify the data-alignment setting */
763 #define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN		0x00000010
764 /* Select to modify the data-head-room setting */
765 #define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM	0x00000020
766 /*!< Select to modify the data-tail-room setting */
767 #define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM	0x00000040
768 
769 /**
770  * struct dpni_buffer_layout - Structure representing DPNI buffer layout
771  * @options: Flags representing the suggested modifications to the buffer
772  *		layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags
773  * @pass_timestamp: Pass timestamp value
774  * @pass_parser_result: Pass parser results
775  * @pass_frame_status: Pass frame status
776  * @private_data_size: Size kept for private data (in bytes)
777  * @data_align: Data alignment
778  * @data_head_room: Data head room
779  * @data_tail_room: Data tail room
780  */
781 struct dpni_buffer_layout {
782 	uint16_t options;
783 	int pass_timestamp;
784 	int pass_parser_result;
785 	int pass_frame_status;
786 	uint16_t private_data_size;
787 	uint16_t data_align;
788 	uint16_t data_head_room;
789 	uint16_t data_tail_room;
790 };
791 
792 /**
793  * dpni_get_buffer_layout() - Retrieve buffer layout attributes.
794  * @mc_io:	Pointer to MC portal's I/O object
795  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
796  * @token:	Token of DPNI object
797  * @layout:	Returns buffer layout attributes
798  * @type:	DPNI queue type
799  *
800  * Return:	'0' on Success; Error code otherwise.
801  */
802 int dpni_get_buffer_layout(struct fsl_mc_io			*mc_io,
803 			   uint32_t				cmd_flags,
804 			   uint16_t				token,
805 			   const struct dpni_buffer_layout	*layout,
806 			   enum dpni_queue_type			type);
807 
808 /**
809  * dpni_set_buffer_layout() - Set buffer layout configuration.
810  * @mc_io:	Pointer to MC portal's I/O object
811  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
812  * @token:	Token of DPNI object
813  * @layout:	Buffer layout configuration
814  * @type:	DPNI queue type
815  *
816  * Return:	'0' on Success; Error code otherwise.
817  *
818  * @warning	Allowed only when DPNI is disabled
819  */
820 int dpni_set_buffer_layout(struct fsl_mc_io			*mc_io,
821 			   uint32_t				cmd_flags,
822 			   uint16_t				token,
823 			   const struct dpni_buffer_layout	*layout,
824 			   enum dpni_queue_type			type);
825 
826 /**
827  * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
828  *			for enqueue operations
829  * @mc_io:	Pointer to MC portal's I/O object
830  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
831  * @token:	Token of DPNI object
832  * @qdid:	Returned virtual QDID value that should be used as an argument
833  *			in all enqueue operations
834  *
835  * Return:	'0' on Success; Error code otherwise.
836  */
837 int dpni_get_qdid(struct fsl_mc_io	*mc_io,
838 		  uint32_t		cmd_flags,
839 		  uint16_t		token,
840 		  uint16_t		*qdid);
841 
842 /**
843  * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
844  * @mc_io:	Pointer to MC portal's I/O object
845  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
846  * @token:	Token of DPNI object
847  * @data_offset: Tx data offset (from start of buffer)
848  *
849  * Return:	'0' on Success; Error code otherwise.
850  */
851 int dpni_get_tx_data_offset(struct fsl_mc_io	*mc_io,
852 			    uint32_t		cmd_flags,
853 			    uint16_t		token,
854 			    uint16_t		*data_offset);
855 
856 /* Enable auto-negotiation */
857 #define DPNI_LINK_OPT_AUTONEG		0x0000000000000001ULL
858 /* Enable half-duplex mode */
859 #define DPNI_LINK_OPT_HALF_DUPLEX	0x0000000000000002ULL
860 /* Enable pause frames */
861 #define DPNI_LINK_OPT_PAUSE		0x0000000000000004ULL
862 /* Enable a-symmetric pause frames */
863 #define DPNI_LINK_OPT_ASYM_PAUSE	0x0000000000000008ULL
864 
865 /**
866  * struct - Structure representing DPNI link configuration
867  * @rate: Rate
868  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
869  */
870 struct dpni_link_cfg {
871 	uint32_t rate;
872 	uint64_t options;
873 };
874 
875 /**
876  * dpni_set_link_cfg() - set the link configuration.
877  * @mc_io:	Pointer to MC portal's I/O object
878  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
879  * @token:	Token of DPNI object
880  * @cfg:	Link configuration
881  *
882  * Return:	'0' on Success; Error code otherwise.
883  */
884 int dpni_set_link_cfg(struct fsl_mc_io			*mc_io,
885 		      uint32_t				cmd_flags,
886 		      uint16_t				token,
887 		      const struct dpni_link_cfg	*cfg);
888 
889 /**
890  * struct dpni_link_state - Structure representing DPNI link state
891  * @rate: Rate
892  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
893  * @up: Link state; '0' for down, '1' for up
894  */
895 struct dpni_link_state {
896 	uint32_t rate;
897 	uint64_t options;
898 	int up;
899 };
900 
901 /**
902  * dpni_get_link_state() - Return the link state (either up or down)
903  * @mc_io:	Pointer to MC portal's I/O object
904  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
905  * @token:	Token of DPNI object
906  * @state:	Returned link state;
907  *
908  * Return:	'0' on Success; Error code otherwise.
909  */
910 int dpni_get_link_state(struct fsl_mc_io	*mc_io,
911 			uint32_t		cmd_flags,
912 			uint16_t		token,
913 			struct dpni_link_state	*state);
914 
915 /**
916  * dpni_set_primary_mac_addr() - Set the primary MAC address
917  * @mc_io:	Pointer to MC portal's I/O object
918  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
919  * @token:	Token of DPNI object
920  * @mac_addr:	MAC address to set as primary address
921  *
922  * Return:	'0' on Success; Error code otherwise.
923  */
924 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
925 			      uint32_t		cmd_flags,
926 			      uint16_t		token,
927 			      const uint8_t	mac_addr[6]);
928 
929 /**
930  * dpni_get_primary_mac_addr() - Get the primary MAC address
931  * @mc_io:	Pointer to MC portal's I/O object
932  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
933  * @token:	Token of DPNI object
934  * @mac_addr:	Returned MAC address
935  *
936  * Return:	'0' on Success; Error code otherwise.
937  */
938 int dpni_get_primary_mac_addr(struct fsl_mc_io	*mc_io,
939 			      uint32_t		cmd_flags,
940 			      uint16_t		token,
941 			      uint8_t		mac_addr[6]);
942 
943 /**
944  * dpni_add_mac_addr() - Add MAC address filter
945  * @mc_io:	Pointer to MC portal's I/O object
946  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
947  * @token:	Token of DPNI object
948  * @mac_addr:	MAC address to add
949  *
950  * Return:	'0' on Success; Error code otherwise.
951  */
952 int dpni_add_mac_addr(struct fsl_mc_io	*mc_io,
953 		      uint32_t		cmd_flags,
954 		      uint16_t		token,
955 		      const uint8_t	mac_addr[6]);
956 
957 /**
958  * dpni_remove_mac_addr() - Remove MAC address filter
959  * @mc_io:	Pointer to MC portal's I/O object
960  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
961  * @token:	Token of DPNI object
962  * @mac_addr:	MAC address to remove
963  *
964  * Return:	'0' on Success; Error code otherwise.
965  */
966 int dpni_remove_mac_addr(struct fsl_mc_io	*mc_io,
967 			 uint32_t		cmd_flags,
968 			 uint16_t		token,
969 			 const uint8_t		mac_addr[6]);
970 
971 /**
972  * enum dpni_dest - DPNI destination types
973  * @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
974  *		does not generate FQDAN notifications; user is expected to
975  *		dequeue from the queue based on polling or other user-defined
976  *		method
977  * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
978  *		notifications to the specified DPIO; user is expected to dequeue
979  *		from the queue only after notification is received
980  * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
981  *		FQDAN notifications, but is connected to the specified DPCON
982  *		object; user is expected to dequeue from the DPCON channel
983  */
984 enum dpni_dest {
985 	DPNI_DEST_NONE = 0,
986 	DPNI_DEST_DPIO = 1,
987 	DPNI_DEST_DPCON = 2
988 };
989 
990 /**
991  * struct dpni_dest_cfg - Structure representing DPNI destination parameters
992  * @dest_type: Destination type
993  * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
994  * @priority: Priority selection within the DPIO or DPCON channel; valid values
995  *		are 0-1 or 0-7, depending on the number of priorities in that
996  *		channel; not relevant for 'DPNI_DEST_NONE' option
997  */
998 struct dpni_dest_cfg {
999 	enum dpni_dest dest_type;
1000 	int dest_id;
1001 	uint8_t priority;
1002 };
1003 
1004 /**
1005  * enum dpni_flc_type - DPNI FLC types
1006  * @DPNI_FLC_USER_DEFINED: select the FLC to be used for user defined value
1007  * @DPNI_FLC_STASH: select the FLC to be used for stash control
1008  */
1009 enum dpni_flc_type {
1010 	DPNI_FLC_USER_DEFINED = 0,
1011 	DPNI_FLC_STASH = 1,
1012 };
1013 
1014 /**
1015  * enum dpni_stash_size - DPNI FLC stashing size
1016  * @DPNI_STASH_SIZE_0B: no stash
1017  * @DPNI_STASH_SIZE_64B: stashes 64 bytes
1018  * @DPNI_STASH_SIZE_128B: stashes 128 bytes
1019  * @DPNI_STASH_SIZE_192B: stashes 192 bytes
1020  */
1021 enum dpni_stash_size {
1022 	DPNI_STASH_SIZE_0B = 0,
1023 	DPNI_STASH_SIZE_64B = 1,
1024 	DPNI_STASH_SIZE_128B = 2,
1025 	DPNI_STASH_SIZE_192B = 3,
1026 };
1027 
1028 /* DPNI FLC stash options */
1029 
1030 /* stashes the whole annotation area (up to 192 bytes) */
1031 #define DPNI_FLC_STASH_FRAME_ANNOTATION	0x00000001
1032 
1033 /**
1034  * struct dpni_flc_cfg - Structure representing DPNI FLC configuration
1035  * @flc_type: FLC type
1036  * @options: Mask of available options;
1037  *	use 'DPNI_FLC_STASH_<X>' values
1038  * @frame_data_size: Size of frame data to be stashed
1039  * @flow_context_size: Size of flow context to be stashed
1040  * @flow_context: 1. In case flc_type is 'DPNI_FLC_USER_DEFINED':
1041  *			this value will be provided in the frame descriptor
1042  *			(FD[FLC])
1043  *		  2. In case flc_type is 'DPNI_FLC_STASH':
1044  *			this value will be I/O virtual address of the
1045  *			flow-context;
1046  *			Must be cacheline-aligned and DMA-able memory
1047  */
1048 struct dpni_flc_cfg {
1049 	enum dpni_flc_type flc_type;
1050 	uint32_t options;
1051 	enum dpni_stash_size frame_data_size;
1052 	enum dpni_stash_size flow_context_size;
1053 	uint64_t flow_context;
1054 };
1055 
1056 /* DPNI queue modification options */
1057 
1058 /* Select to modify the user's context associated with the queue */
1059 #define DPNI_QUEUE_OPT_USER_CTX		0x00000001
1060 /* Select to modify the queue's destination */
1061 #define DPNI_QUEUE_OPT_DEST		0x00000002
1062 /** Select to modify the flow-context parameters;
1063  * not applicable for Tx-conf/Err queues as the FD comes from the user
1064  */
1065 #define DPNI_QUEUE_OPT_FLC		0x00000004
1066 /* Select to modify the queue's order preservation */
1067 #define DPNI_QUEUE_OPT_ORDER_PRESERVATION 0x00000008
1068 /* Select to modify the queue's tail-drop threshold */
1069 #define DPNI_QUEUE_OPT_TAILDROP_THRESHOLD 0x00000010
1070 
1071 /**
1072  * struct dpni_queue_cfg - Structure representing queue configuration
1073  * @options: Flags representing the suggested modifications to the queue;
1074  *		Use any combination of 'DPNI_QUEUE_OPT_<X>' flags
1075  * @user_ctx: User context value provided in the frame descriptor of each
1076  *		dequeued frame; valid only if 'DPNI_QUEUE_OPT_USER_CTX'
1077  *		is contained in 'options'
1078  * @dest_cfg: Queue destination parameters;
1079  *		valid only if 'DPNI_QUEUE_OPT_DEST' is contained in 'options'
1080  * @flc_cfg: Flow context configuration; in case the TC's distribution
1081  *		is either NONE or HASH the FLC's settings of flow#0 are used.
1082  *		in the case of FS (flow-steering) the flow's FLC settings
1083  *		are used.
1084  *		valid only if 'DPNI_QUEUE_OPT_FLC' is contained in 'options'
1085  * @order_preservation_en: enable/disable order preservation;
1086  *		valid only if 'DPNI_QUEUE_OPT_ORDER_PRESERVATION' is contained
1087  *		in 'options'
1088  * @tail_drop_threshold: set the queue's tail drop threshold in bytes;
1089  *		'0' value disable the threshold; maximum value is 0xE000000;
1090  *		valid only if 'DPNI_QUEUE_OPT_TAILDROP_THRESHOLD' is contained
1091  *		in 'options'
1092  */
1093 struct dpni_queue_cfg {
1094 	uint32_t options;
1095 	uint64_t user_ctx;
1096 	struct dpni_dest_cfg dest_cfg;
1097 	struct dpni_flc_cfg flc_cfg;
1098 	int order_preservation_en;
1099 	uint32_t tail_drop_threshold;
1100 };
1101 
1102 /**
1103  * struct dpni_queue_attr - Structure representing queue attributes
1104  * @user_ctx: User context value provided in the frame descriptor of each
1105  *	dequeued frame
1106  * @dest_cfg: Queue destination configuration
1107  * @flc_cfg: Flow context configuration
1108  * @order_preservation_en: enable/disable order preservation
1109  * @tail_drop_threshold: queue's tail drop threshold in bytes;
1110  * @fqid: Virtual fqid value to be used for dequeue operations
1111  */
1112 struct dpni_queue_attr {
1113 	uint64_t user_ctx;
1114 	struct dpni_dest_cfg dest_cfg;
1115 	struct dpni_flc_cfg flc_cfg;
1116 	int order_preservation_en;
1117 	uint32_t tail_drop_threshold;
1118 	uint32_t fqid;
1119 };
1120 
1121 /* DPNI Tx flow modification options */
1122 
1123 /* Select to modify the settings for dedicate Tx confirmation/error */
1124 #define DPNI_TX_FLOW_OPT_TX_CONF_ERROR	0x00000001
1125 /*!< Select to modify the L3 checksum generation setting */
1126 #define DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN	0x00000010
1127 /*!< Select to modify the L4 checksum generation setting */
1128 #define DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN	0x00000020
1129 
1130 /**
1131  * dpni_get_api_version - Retrieve DPNI Major and Minor version info.
1132  *
1133  * @mc_io:	Pointer to MC portal's I/O object
1134  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1135  * @major_ver:	DPNI major version
1136  * @minor_ver:	DPNI minor version
1137  *
1138  * Return:     '0' on Success; Error code otherwise.
1139  */
1140 int dpni_get_api_version(struct fsl_mc_io *mc_io,
1141 			 u32 cmd_flags,
1142 			 u16 *major_ver,
1143 			 u16 *minor_ver);
1144 
1145 /**
1146  * enum dpni_confirmation_mode - Defines DPNI options supported for Tx
1147  * confirmation
1148  * @DPNI_CONF_AFFINE: For each Tx queue set associated with a sender there is
1149  * an affine Tx Confirmation queue
1150  * @DPNI_CONF_SINGLE: All Tx queues are associated with a single Tx
1151  * confirmation queue
1152  * @DPNI_CONF_DISABLE: Tx frames are not confirmed.  This must be associated
1153  * with proper FD set-up to have buffers release to a Buffer Pool, otherwise
1154  * buffers will be leaked.
1155  */
1156 enum dpni_confirmation_mode {
1157 	DPNI_CONF_AFFINE,
1158 	DPNI_CONF_SINGLE,
1159 	DPNI_CONF_DISABLE,
1160 };
1161 
1162 struct dpni_tx_confirmation_mode {
1163 	uint32_t pad;
1164 	uint8_t confirmation_mode;
1165 };
1166 
1167 /**
1168  * struct dpni_queue - Queue structure
1169  * @fqid:  FQID used for enqueueing to and/or configuration of this specific FQ
1170  * @qdbin: Queueing bin, used to enqueue using QDID, DQBIN, QPRI. Only relevant
1171  *         for Tx queues.
1172  * @flc:   FLC value for traffic dequeued from this queue.
1173  * @user_context:    User data, presented to the user along with any frames
1174  *                   from this queue. Not relevant for Tx queues.
1175  */
1176 struct dpni_queue {
1177 	/**
1178 	* struct destination - Destination structure
1179 	* @id:   ID of the destination, only relevant if DEST_TYPE is > 0.
1180 	*        Identifies either a DPIO or a DPCON object. Not relevant for Tx
1181 	*        queues.
1182 	* @type: May be one of the following:
1183 	*         0 - No destination, queue can be manually queried, but won't
1184 	*             push traffic or notifications to a DPIO;
1185 	*         1 - The destination is DPIO. When traffic becomes available in
1186 	*             the queue a FQDAN (FQ data available notification) will be
1187 	*             generated to selected DPIO;
1188 	*         2 - The destination is a DPCON. The queue is associated with a
1189 	*             DPCON object for purpose of scheduling between multiple
1190 	*             queues. The DPCON may be independently configured to
1191 	*             generate notifications. Not relevant for Tx queues.
1192 	* @hold_active: Hold active
1193 	*/
1194 	struct {
1195 		uint32_t id;
1196 		enum dpni_dest type;
1197 		char hold_active;
1198 		char stash_ctrl;
1199 	} destination;
1200 	uint8_t  options;
1201 	uint32_t fqid;
1202 	uint16_t qdbin;
1203 	uint64_t flc;
1204 	uint64_t user_context;
1205 };
1206 
1207 /**
1208  * dpni_set_queue() - Set queue parameters
1209  * @mc_io:      Pointer to MC portal's I/O object
1210  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1211  * @token:      Token of DPNI object
1212  * @type:       Type of queue
1213  * @tc:         Traffic class, in range 0 to NUM_TCS - 1
1214  * @index:      Selects the specific queue out of the set allocated for the same
1215  *              TC. Value must be in range 0 to NUM_QUEUES - 1
1216  * @queue:      Queue structure
1217  *
1218  * Return:     '0' on Success; Error code otherwise.
1219  */
1220 int dpni_set_queue(struct fsl_mc_io		*mc_io,
1221 		   uint32_t			cmd_flags,
1222 		   uint16_t			token,
1223 		   enum dpni_queue_type		type,
1224 		   uint8_t			tc,
1225 		   uint8_t			index,
1226 		   const struct dpni_queue	*queue);
1227 
1228 /**
1229  * dpni_get_queue() - Get queue parameters
1230  * @mc_io:      Pointer to MC portal's I/O object
1231  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1232  * @token:      Token of DPNI object
1233  * @type:       Type of queue
1234  * @tc:         Traffic class, in range 0 to NUM_TCS - 1
1235  * @index:      Selects the specific queue out of the set allocated for the same
1236  *              TC. Value must be in range 0 to NUM_QUEUES - 1
1237  * @queue:      Queue structure
1238  *
1239  * Return:      '0' on Success; Error code otherwise.
1240  */
1241 int dpni_get_queue(struct fsl_mc_io		*mc_io,
1242 		   uint32_t			cmd_flags,
1243 		   uint16_t			token,
1244 		   enum dpni_queue_type		type,
1245 		   uint8_t			tc,
1246 		   uint8_t			index,
1247 		   struct dpni_queue		*queue);
1248 
1249 /**
1250  * dpni_set_tx_confirmation_mode() - Set TX conf mode
1251  * @mc_io:      Pointer to MC portal's I/O object
1252  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1253  * @token:      Token of DPNI object
1254  * @mode:       DPNI confirmation mode type
1255  *
1256  * Return:      '0' on Success; Error code otherwise.
1257  */
1258 int dpni_set_tx_confirmation_mode(struct fsl_mc_io	*mc_io,
1259 				  uint32_t		cmd_flags,
1260 				  uint16_t		token,
1261 				  enum dpni_confirmation_mode mode);
1262 struct dpni_statistics {
1263 	/**
1264 	 * Page_0 statistics structure
1265 	 * @ingress_all_frames: Ingress frame count
1266 	 * @ingress_all_bytes: Ingress byte count
1267 	 * @ingress_multicast_frames: Ingress multicast frame count
1268 	 * @ingress_multicast_bytes: Ingress multicast byte count
1269 	 * @ingress_broadcast_frames: Ingress broadcast frame count
1270 	 * @ingress_broadcast_bytes: Ingress broadcast byte count
1271 	 *
1272 	 * Page_1 statistics structure
1273 	 * @egress_all_frames: Egress frame count
1274 	 * @egress_all_bytes: Egress byte count
1275 	 * @egress_multicast_frames: Egress multicast frame count
1276 	 * @egress_multicast_bytes: Egress multicast byte count
1277 	 * @egress_broadcast_frames: Egress broadcast frame count
1278 	 * @egress_broadcast_bytes: Egress broadcast byte count
1279 	 *
1280 	 * Page_2 statistics structure
1281 	 * @ingress_filtered_frames: Ingress filtered frame count
1282 	 * @ingress_discarded_frames: Ingress discarded frame count
1283 	 * @ingress_nobuffer_discards: Ingress discarded frame count due to
1284 	 *  lack of buffers.
1285 	 * @egress_discarded_frames: Egress discarded frame count
1286 	 * @egress_confirmed_frames: Egress confirmed frame count
1287 	 */
1288 
1289 	uint64_t counter0;
1290 	uint64_t counter1;
1291 	uint64_t counter2;
1292 	uint64_t counter3;
1293 	uint64_t counter4;
1294 	uint64_t counter5;
1295 	uint64_t counter6;
1296 };
1297 
1298 /**
1299  * dpni_get_statistics() - Get DPNI statistics
1300  * @mc_io:	Pointer to MC portal's I/O object
1301  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1302  * @token:	Token of DPNI object
1303  * @page:	Selects the statistics page to retrieve, see DPNI_GET_STATISTICS
1304  *		output. Pages are numbered 0 to 2.
1305  * @stat:	Structure containing the statistics
1306  *
1307  * Return:	'0' on Success; Error code otherwise.
1308  */
1309 int dpni_get_statistics(struct fsl_mc_io *mc_io,
1310 			uint32_t cmd_flags,
1311 			uint16_t token,
1312 			uint8_t page,
1313 			struct dpni_statistics *stat);
1314 
1315 /**
1316  * dpni_reset_statistics() - Clears DPNI statistics
1317  * @mc_io:	Pointer to MC portal's I/O object
1318  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1319  * @token:	Token of DPNI object
1320  *
1321  * Return:	'0' on Success; Error code otherwise.
1322  */
1323 int dpni_reset_statistics(struct fsl_mc_io *mc_io,
1324 			  uint32_t cmd_flags,
1325 			  uint16_t token);
1326 #endif /* _FSL_DPNI_H */
1327