1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /* Copyright 2013-2016 Freescale Semiconductor Inc.
3  * Copyright 2016 NXP
4  * Copyright 2020 NXP
5  */
6 #include <linux/kernel.h>
7 #include <linux/errno.h>
8 #include <linux/fsl/mc.h>
9 #include "dpni.h"
10 #include "dpni-cmd.h"
11 
12 /**
13  * dpni_prepare_key_cfg() - function prepare extract parameters
14  * @cfg: defining a full Key Generation profile (rule)
15  * @key_cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
16  *
17  * This function has to be called before the following functions:
18  *	- dpni_set_rx_tc_dist()
19  *	- dpni_set_qos_table()
20  *
21  * Return:	'0' on Success; Error code otherwise.
22  */
23 int dpni_prepare_key_cfg(const struct dpkg_profile_cfg *cfg, u8 *key_cfg_buf)
24 {
25 	int i, j;
26 	struct dpni_ext_set_rx_tc_dist *dpni_ext;
27 	struct dpni_dist_extract *extr;
28 
29 	if (cfg->num_extracts > DPKG_MAX_NUM_OF_EXTRACTS)
30 		return -EINVAL;
31 
32 	dpni_ext = (struct dpni_ext_set_rx_tc_dist *)key_cfg_buf;
33 	dpni_ext->num_extracts = cfg->num_extracts;
34 
35 	for (i = 0; i < cfg->num_extracts; i++) {
36 		extr = &dpni_ext->extracts[i];
37 
38 		switch (cfg->extracts[i].type) {
39 		case DPKG_EXTRACT_FROM_HDR:
40 			extr->prot = cfg->extracts[i].extract.from_hdr.prot;
41 			dpni_set_field(extr->efh_type, EFH_TYPE,
42 				       cfg->extracts[i].extract.from_hdr.type);
43 			extr->size = cfg->extracts[i].extract.from_hdr.size;
44 			extr->offset = cfg->extracts[i].extract.from_hdr.offset;
45 			extr->field = cpu_to_le32(
46 				cfg->extracts[i].extract.from_hdr.field);
47 			extr->hdr_index =
48 				cfg->extracts[i].extract.from_hdr.hdr_index;
49 			break;
50 		case DPKG_EXTRACT_FROM_DATA:
51 			extr->size = cfg->extracts[i].extract.from_data.size;
52 			extr->offset =
53 				cfg->extracts[i].extract.from_data.offset;
54 			break;
55 		case DPKG_EXTRACT_FROM_PARSE:
56 			extr->size = cfg->extracts[i].extract.from_parse.size;
57 			extr->offset =
58 				cfg->extracts[i].extract.from_parse.offset;
59 			break;
60 		default:
61 			return -EINVAL;
62 		}
63 
64 		extr->num_of_byte_masks = cfg->extracts[i].num_of_byte_masks;
65 		dpni_set_field(extr->extract_type, EXTRACT_TYPE,
66 			       cfg->extracts[i].type);
67 
68 		for (j = 0; j < DPKG_NUM_OF_MASKS; j++) {
69 			extr->masks[j].mask = cfg->extracts[i].masks[j].mask;
70 			extr->masks[j].offset =
71 				cfg->extracts[i].masks[j].offset;
72 		}
73 	}
74 
75 	return 0;
76 }
77 
78 /**
79  * dpni_open() - Open a control session for the specified object
80  * @mc_io:	Pointer to MC portal's I/O object
81  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
82  * @dpni_id:	DPNI unique ID
83  * @token:	Returned token; use in subsequent API calls
84  *
85  * This function can be used to open a control session for an
86  * already created object; an object may have been declared in
87  * the DPL or by calling the dpni_create() function.
88  * This function returns a unique authentication token,
89  * associated with the specific object ID and the specific MC
90  * portal; this token must be used in all subsequent commands for
91  * this specific object.
92  *
93  * Return:	'0' on Success; Error code otherwise.
94  */
95 int dpni_open(struct fsl_mc_io *mc_io,
96 	      u32 cmd_flags,
97 	      int dpni_id,
98 	      u16 *token)
99 {
100 	struct fsl_mc_command cmd = { 0 };
101 	struct dpni_cmd_open *cmd_params;
102 
103 	int err;
104 
105 	/* prepare command */
106 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
107 					  cmd_flags,
108 					  0);
109 	cmd_params = (struct dpni_cmd_open *)cmd.params;
110 	cmd_params->dpni_id = cpu_to_le32(dpni_id);
111 
112 	/* send command to mc*/
113 	err = mc_send_command(mc_io, &cmd);
114 	if (err)
115 		return err;
116 
117 	/* retrieve response parameters */
118 	*token = mc_cmd_hdr_read_token(&cmd);
119 
120 	return 0;
121 }
122 
123 /**
124  * dpni_close() - Close the control session of the object
125  * @mc_io:	Pointer to MC portal's I/O object
126  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
127  * @token:	Token of DPNI object
128  *
129  * After this function is called, no further operations are
130  * allowed on the object without opening a new control session.
131  *
132  * Return:	'0' on Success; Error code otherwise.
133  */
134 int dpni_close(struct fsl_mc_io *mc_io,
135 	       u32 cmd_flags,
136 	       u16 token)
137 {
138 	struct fsl_mc_command cmd = { 0 };
139 
140 	/* prepare command */
141 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
142 					  cmd_flags,
143 					  token);
144 
145 	/* send command to mc*/
146 	return mc_send_command(mc_io, &cmd);
147 }
148 
149 /**
150  * dpni_set_pools() - Set buffer pools configuration
151  * @mc_io:	Pointer to MC portal's I/O object
152  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
153  * @token:	Token of DPNI object
154  * @cfg:	Buffer pools configuration
155  *
156  * mandatory for DPNI operation
157  * warning:Allowed only when DPNI is disabled
158  *
159  * Return:	'0' on Success; Error code otherwise.
160  */
161 int dpni_set_pools(struct fsl_mc_io *mc_io,
162 		   u32 cmd_flags,
163 		   u16 token,
164 		   const struct dpni_pools_cfg *cfg)
165 {
166 	struct fsl_mc_command cmd = { 0 };
167 	struct dpni_cmd_set_pools *cmd_params;
168 	int i;
169 
170 	/* prepare command */
171 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
172 					  cmd_flags,
173 					  token);
174 	cmd_params = (struct dpni_cmd_set_pools *)cmd.params;
175 	cmd_params->num_dpbp = cfg->num_dpbp;
176 	for (i = 0; i < DPNI_MAX_DPBP; i++) {
177 		cmd_params->dpbp_id[i] = cpu_to_le32(cfg->pools[i].dpbp_id);
178 		cmd_params->buffer_size[i] =
179 			cpu_to_le16(cfg->pools[i].buffer_size);
180 		cmd_params->backup_pool_mask |=
181 			DPNI_BACKUP_POOL(cfg->pools[i].backup_pool, i);
182 	}
183 
184 	/* send command to mc*/
185 	return mc_send_command(mc_io, &cmd);
186 }
187 
188 /**
189  * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
190  * @mc_io:	Pointer to MC portal's I/O object
191  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
192  * @token:		Token of DPNI object
193  *
194  * Return:	'0' on Success; Error code otherwise.
195  */
196 int dpni_enable(struct fsl_mc_io *mc_io,
197 		u32 cmd_flags,
198 		u16 token)
199 {
200 	struct fsl_mc_command cmd = { 0 };
201 
202 	/* prepare command */
203 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
204 					  cmd_flags,
205 					  token);
206 
207 	/* send command to mc*/
208 	return mc_send_command(mc_io, &cmd);
209 }
210 
211 /**
212  * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
213  * @mc_io:	Pointer to MC portal's I/O object
214  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
215  * @token:	Token of DPNI object
216  *
217  * Return:	'0' on Success; Error code otherwise.
218  */
219 int dpni_disable(struct fsl_mc_io *mc_io,
220 		 u32 cmd_flags,
221 		 u16 token)
222 {
223 	struct fsl_mc_command cmd = { 0 };
224 
225 	/* prepare command */
226 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
227 					  cmd_flags,
228 					  token);
229 
230 	/* send command to mc*/
231 	return mc_send_command(mc_io, &cmd);
232 }
233 
234 /**
235  * dpni_is_enabled() - Check if the DPNI is enabled.
236  * @mc_io:	Pointer to MC portal's I/O object
237  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
238  * @token:	Token of DPNI object
239  * @en:		Returns '1' if object is enabled; '0' otherwise
240  *
241  * Return:	'0' on Success; Error code otherwise.
242  */
243 int dpni_is_enabled(struct fsl_mc_io *mc_io,
244 		    u32 cmd_flags,
245 		    u16 token,
246 		    int *en)
247 {
248 	struct fsl_mc_command cmd = { 0 };
249 	struct dpni_rsp_is_enabled *rsp_params;
250 	int err;
251 
252 	/* prepare command */
253 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_IS_ENABLED,
254 					  cmd_flags,
255 					  token);
256 
257 	/* send command to mc*/
258 	err = mc_send_command(mc_io, &cmd);
259 	if (err)
260 		return err;
261 
262 	/* retrieve response parameters */
263 	rsp_params = (struct dpni_rsp_is_enabled *)cmd.params;
264 	*en = dpni_get_field(rsp_params->enabled, ENABLE);
265 
266 	return 0;
267 }
268 
269 /**
270  * dpni_reset() - Reset the DPNI, returns the object to initial state.
271  * @mc_io:	Pointer to MC portal's I/O object
272  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
273  * @token:	Token of DPNI object
274  *
275  * Return:	'0' on Success; Error code otherwise.
276  */
277 int dpni_reset(struct fsl_mc_io *mc_io,
278 	       u32 cmd_flags,
279 	       u16 token)
280 {
281 	struct fsl_mc_command cmd = { 0 };
282 
283 	/* prepare command */
284 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
285 					  cmd_flags,
286 					  token);
287 
288 	/* send command to mc*/
289 	return mc_send_command(mc_io, &cmd);
290 }
291 
292 /**
293  * dpni_set_irq_enable() - Set overall interrupt state.
294  * @mc_io:	Pointer to MC portal's I/O object
295  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
296  * @token:	Token of DPNI object
297  * @irq_index:	The interrupt index to configure
298  * @en:		Interrupt state: - enable = 1, disable = 0
299  *
300  * Allows GPP software to control when interrupts are generated.
301  * Each interrupt can have up to 32 causes.  The enable/disable control's the
302  * overall interrupt state. if the interrupt is disabled no causes will cause
303  * an interrupt.
304  *
305  * Return:	'0' on Success; Error code otherwise.
306  */
307 int dpni_set_irq_enable(struct fsl_mc_io *mc_io,
308 			u32 cmd_flags,
309 			u16 token,
310 			u8 irq_index,
311 			u8 en)
312 {
313 	struct fsl_mc_command cmd = { 0 };
314 	struct dpni_cmd_set_irq_enable *cmd_params;
315 
316 	/* prepare command */
317 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_IRQ_ENABLE,
318 					  cmd_flags,
319 					  token);
320 	cmd_params = (struct dpni_cmd_set_irq_enable *)cmd.params;
321 	dpni_set_field(cmd_params->enable, ENABLE, en);
322 	cmd_params->irq_index = irq_index;
323 
324 	/* send command to mc*/
325 	return mc_send_command(mc_io, &cmd);
326 }
327 
328 /**
329  * dpni_get_irq_enable() - Get overall interrupt state
330  * @mc_io:	Pointer to MC portal's I/O object
331  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
332  * @token:	Token of DPNI object
333  * @irq_index:	The interrupt index to configure
334  * @en:		Returned interrupt state - enable = 1, disable = 0
335  *
336  * Return:	'0' on Success; Error code otherwise.
337  */
338 int dpni_get_irq_enable(struct fsl_mc_io *mc_io,
339 			u32 cmd_flags,
340 			u16 token,
341 			u8 irq_index,
342 			u8 *en)
343 {
344 	struct fsl_mc_command cmd = { 0 };
345 	struct dpni_cmd_get_irq_enable *cmd_params;
346 	struct dpni_rsp_get_irq_enable *rsp_params;
347 
348 	int err;
349 
350 	/* prepare command */
351 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_ENABLE,
352 					  cmd_flags,
353 					  token);
354 	cmd_params = (struct dpni_cmd_get_irq_enable *)cmd.params;
355 	cmd_params->irq_index = irq_index;
356 
357 	/* send command to mc*/
358 	err = mc_send_command(mc_io, &cmd);
359 	if (err)
360 		return err;
361 
362 	/* retrieve response parameters */
363 	rsp_params = (struct dpni_rsp_get_irq_enable *)cmd.params;
364 	*en = dpni_get_field(rsp_params->enabled, ENABLE);
365 
366 	return 0;
367 }
368 
369 /**
370  * dpni_set_irq_mask() - Set interrupt mask.
371  * @mc_io:	Pointer to MC portal's I/O object
372  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
373  * @token:	Token of DPNI object
374  * @irq_index:	The interrupt index to configure
375  * @mask:	event mask to trigger interrupt;
376  *			each bit:
377  *				0 = ignore event
378  *				1 = consider event for asserting IRQ
379  *
380  * Every interrupt can have up to 32 causes and the interrupt model supports
381  * masking/unmasking each cause independently
382  *
383  * Return:	'0' on Success; Error code otherwise.
384  */
385 int dpni_set_irq_mask(struct fsl_mc_io *mc_io,
386 		      u32 cmd_flags,
387 		      u16 token,
388 		      u8 irq_index,
389 		      u32 mask)
390 {
391 	struct fsl_mc_command cmd = { 0 };
392 	struct dpni_cmd_set_irq_mask *cmd_params;
393 
394 	/* prepare command */
395 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_IRQ_MASK,
396 					  cmd_flags,
397 					  token);
398 	cmd_params = (struct dpni_cmd_set_irq_mask *)cmd.params;
399 	cmd_params->mask = cpu_to_le32(mask);
400 	cmd_params->irq_index = irq_index;
401 
402 	/* send command to mc*/
403 	return mc_send_command(mc_io, &cmd);
404 }
405 
406 /**
407  * dpni_get_irq_mask() - Get interrupt mask.
408  * @mc_io:	Pointer to MC portal's I/O object
409  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
410  * @token:	Token of DPNI object
411  * @irq_index:	The interrupt index to configure
412  * @mask:	Returned event mask to trigger interrupt
413  *
414  * Every interrupt can have up to 32 causes and the interrupt model supports
415  * masking/unmasking each cause independently
416  *
417  * Return:	'0' on Success; Error code otherwise.
418  */
419 int dpni_get_irq_mask(struct fsl_mc_io *mc_io,
420 		      u32 cmd_flags,
421 		      u16 token,
422 		      u8 irq_index,
423 		      u32 *mask)
424 {
425 	struct fsl_mc_command cmd = { 0 };
426 	struct dpni_cmd_get_irq_mask *cmd_params;
427 	struct dpni_rsp_get_irq_mask *rsp_params;
428 	int err;
429 
430 	/* prepare command */
431 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_MASK,
432 					  cmd_flags,
433 					  token);
434 	cmd_params = (struct dpni_cmd_get_irq_mask *)cmd.params;
435 	cmd_params->irq_index = irq_index;
436 
437 	/* send command to mc*/
438 	err = mc_send_command(mc_io, &cmd);
439 	if (err)
440 		return err;
441 
442 	/* retrieve response parameters */
443 	rsp_params = (struct dpni_rsp_get_irq_mask *)cmd.params;
444 	*mask = le32_to_cpu(rsp_params->mask);
445 
446 	return 0;
447 }
448 
449 /**
450  * dpni_get_irq_status() - Get the current status of any pending interrupts.
451  * @mc_io:	Pointer to MC portal's I/O object
452  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
453  * @token:	Token of DPNI object
454  * @irq_index:	The interrupt index to configure
455  * @status:	Returned interrupts status - one bit per cause:
456  *			0 = no interrupt pending
457  *			1 = interrupt pending
458  *
459  * Return:	'0' on Success; Error code otherwise.
460  */
461 int dpni_get_irq_status(struct fsl_mc_io *mc_io,
462 			u32 cmd_flags,
463 			u16 token,
464 			u8 irq_index,
465 			u32 *status)
466 {
467 	struct fsl_mc_command cmd = { 0 };
468 	struct dpni_cmd_get_irq_status *cmd_params;
469 	struct dpni_rsp_get_irq_status *rsp_params;
470 	int err;
471 
472 	/* prepare command */
473 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_STATUS,
474 					  cmd_flags,
475 					  token);
476 	cmd_params = (struct dpni_cmd_get_irq_status *)cmd.params;
477 	cmd_params->status = cpu_to_le32(*status);
478 	cmd_params->irq_index = irq_index;
479 
480 	/* send command to mc*/
481 	err = mc_send_command(mc_io, &cmd);
482 	if (err)
483 		return err;
484 
485 	/* retrieve response parameters */
486 	rsp_params = (struct dpni_rsp_get_irq_status *)cmd.params;
487 	*status = le32_to_cpu(rsp_params->status);
488 
489 	return 0;
490 }
491 
492 /**
493  * dpni_clear_irq_status() - Clear a pending interrupt's status
494  * @mc_io:	Pointer to MC portal's I/O object
495  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
496  * @token:	Token of DPNI object
497  * @irq_index:	The interrupt index to configure
498  * @status:	bits to clear (W1C) - one bit per cause:
499  *			0 = don't change
500  *			1 = clear status bit
501  *
502  * Return:	'0' on Success; Error code otherwise.
503  */
504 int dpni_clear_irq_status(struct fsl_mc_io *mc_io,
505 			  u32 cmd_flags,
506 			  u16 token,
507 			  u8 irq_index,
508 			  u32 status)
509 {
510 	struct fsl_mc_command cmd = { 0 };
511 	struct dpni_cmd_clear_irq_status *cmd_params;
512 
513 	/* prepare command */
514 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLEAR_IRQ_STATUS,
515 					  cmd_flags,
516 					  token);
517 	cmd_params = (struct dpni_cmd_clear_irq_status *)cmd.params;
518 	cmd_params->irq_index = irq_index;
519 	cmd_params->status = cpu_to_le32(status);
520 
521 	/* send command to mc*/
522 	return mc_send_command(mc_io, &cmd);
523 }
524 
525 /**
526  * dpni_get_attributes() - Retrieve DPNI attributes.
527  * @mc_io:	Pointer to MC portal's I/O object
528  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
529  * @token:	Token of DPNI object
530  * @attr:	Object's attributes
531  *
532  * Return:	'0' on Success; Error code otherwise.
533  */
534 int dpni_get_attributes(struct fsl_mc_io *mc_io,
535 			u32 cmd_flags,
536 			u16 token,
537 			struct dpni_attr *attr)
538 {
539 	struct fsl_mc_command cmd = { 0 };
540 	struct dpni_rsp_get_attr *rsp_params;
541 
542 	int err;
543 
544 	/* prepare command */
545 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
546 					  cmd_flags,
547 					  token);
548 
549 	/* send command to mc*/
550 	err = mc_send_command(mc_io, &cmd);
551 	if (err)
552 		return err;
553 
554 	/* retrieve response parameters */
555 	rsp_params = (struct dpni_rsp_get_attr *)cmd.params;
556 	attr->options = le32_to_cpu(rsp_params->options);
557 	attr->num_queues = rsp_params->num_queues;
558 	attr->num_tcs = rsp_params->num_tcs;
559 	attr->mac_filter_entries = rsp_params->mac_filter_entries;
560 	attr->vlan_filter_entries = rsp_params->vlan_filter_entries;
561 	attr->qos_entries = rsp_params->qos_entries;
562 	attr->fs_entries = le16_to_cpu(rsp_params->fs_entries);
563 	attr->qos_key_size = rsp_params->qos_key_size;
564 	attr->fs_key_size = rsp_params->fs_key_size;
565 	attr->wriop_version = le16_to_cpu(rsp_params->wriop_version);
566 
567 	return 0;
568 }
569 
570 /**
571  * dpni_set_errors_behavior() - Set errors behavior
572  * @mc_io:	Pointer to MC portal's I/O object
573  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
574  * @token:	Token of DPNI object
575  * @cfg:	Errors configuration
576  *
577  * this function may be called numerous times with different
578  * error masks
579  *
580  * Return:	'0' on Success; Error code otherwise.
581  */
582 int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
583 			     u32 cmd_flags,
584 			     u16 token,
585 			     struct dpni_error_cfg *cfg)
586 {
587 	struct fsl_mc_command cmd = { 0 };
588 	struct dpni_cmd_set_errors_behavior *cmd_params;
589 
590 	/* prepare command */
591 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR,
592 					  cmd_flags,
593 					  token);
594 	cmd_params = (struct dpni_cmd_set_errors_behavior *)cmd.params;
595 	cmd_params->errors = cpu_to_le32(cfg->errors);
596 	dpni_set_field(cmd_params->flags, ERROR_ACTION, cfg->error_action);
597 	dpni_set_field(cmd_params->flags, FRAME_ANN, cfg->set_frame_annotation);
598 
599 	/* send command to mc*/
600 	return mc_send_command(mc_io, &cmd);
601 }
602 
603 /**
604  * dpni_get_buffer_layout() - Retrieve buffer layout attributes.
605  * @mc_io:	Pointer to MC portal's I/O object
606  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
607  * @token:	Token of DPNI object
608  * @qtype:	Type of queue to retrieve configuration for
609  * @layout:	Returns buffer layout attributes
610  *
611  * Return:	'0' on Success; Error code otherwise.
612  */
613 int dpni_get_buffer_layout(struct fsl_mc_io *mc_io,
614 			   u32 cmd_flags,
615 			   u16 token,
616 			   enum dpni_queue_type qtype,
617 			   struct dpni_buffer_layout *layout)
618 {
619 	struct fsl_mc_command cmd = { 0 };
620 	struct dpni_cmd_get_buffer_layout *cmd_params;
621 	struct dpni_rsp_get_buffer_layout *rsp_params;
622 	int err;
623 
624 	/* prepare command */
625 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_BUFFER_LAYOUT,
626 					  cmd_flags,
627 					  token);
628 	cmd_params = (struct dpni_cmd_get_buffer_layout *)cmd.params;
629 	cmd_params->qtype = qtype;
630 
631 	/* send command to mc*/
632 	err = mc_send_command(mc_io, &cmd);
633 	if (err)
634 		return err;
635 
636 	/* retrieve response parameters */
637 	rsp_params = (struct dpni_rsp_get_buffer_layout *)cmd.params;
638 	layout->pass_timestamp = dpni_get_field(rsp_params->flags, PASS_TS);
639 	layout->pass_parser_result = dpni_get_field(rsp_params->flags, PASS_PR);
640 	layout->pass_frame_status = dpni_get_field(rsp_params->flags, PASS_FS);
641 	layout->private_data_size = le16_to_cpu(rsp_params->private_data_size);
642 	layout->data_align = le16_to_cpu(rsp_params->data_align);
643 	layout->data_head_room = le16_to_cpu(rsp_params->head_room);
644 	layout->data_tail_room = le16_to_cpu(rsp_params->tail_room);
645 
646 	return 0;
647 }
648 
649 /**
650  * dpni_set_buffer_layout() - Set buffer layout configuration.
651  * @mc_io:	Pointer to MC portal's I/O object
652  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
653  * @token:	Token of DPNI object
654  * @qtype:	Type of queue this configuration applies to
655  * @layout:	Buffer layout configuration
656  *
657  * Return:	'0' on Success; Error code otherwise.
658  *
659  * @warning	Allowed only when DPNI is disabled
660  */
661 int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
662 			   u32 cmd_flags,
663 			   u16 token,
664 			   enum dpni_queue_type qtype,
665 			   const struct dpni_buffer_layout *layout)
666 {
667 	struct fsl_mc_command cmd = { 0 };
668 	struct dpni_cmd_set_buffer_layout *cmd_params;
669 
670 	/* prepare command */
671 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
672 					  cmd_flags,
673 					  token);
674 	cmd_params = (struct dpni_cmd_set_buffer_layout *)cmd.params;
675 	cmd_params->qtype = qtype;
676 	cmd_params->options = cpu_to_le16(layout->options);
677 	dpni_set_field(cmd_params->flags, PASS_TS, layout->pass_timestamp);
678 	dpni_set_field(cmd_params->flags, PASS_PR, layout->pass_parser_result);
679 	dpni_set_field(cmd_params->flags, PASS_FS, layout->pass_frame_status);
680 	cmd_params->private_data_size = cpu_to_le16(layout->private_data_size);
681 	cmd_params->data_align = cpu_to_le16(layout->data_align);
682 	cmd_params->head_room = cpu_to_le16(layout->data_head_room);
683 	cmd_params->tail_room = cpu_to_le16(layout->data_tail_room);
684 
685 	/* send command to mc*/
686 	return mc_send_command(mc_io, &cmd);
687 }
688 
689 /**
690  * dpni_set_offload() - Set DPNI offload configuration.
691  * @mc_io:	Pointer to MC portal's I/O object
692  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
693  * @token:	Token of DPNI object
694  * @type:	Type of DPNI offload
695  * @config:	Offload configuration.
696  *		For checksum offloads, non-zero value enables the offload
697  *
698  * Return:     '0' on Success; Error code otherwise.
699  *
700  * @warning    Allowed only when DPNI is disabled
701  */
702 
703 int dpni_set_offload(struct fsl_mc_io *mc_io,
704 		     u32 cmd_flags,
705 		     u16 token,
706 		     enum dpni_offload type,
707 		     u32 config)
708 {
709 	struct fsl_mc_command cmd = { 0 };
710 	struct dpni_cmd_set_offload *cmd_params;
711 
712 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_OFFLOAD,
713 					  cmd_flags,
714 					  token);
715 	cmd_params = (struct dpni_cmd_set_offload *)cmd.params;
716 	cmd_params->dpni_offload = type;
717 	cmd_params->config = cpu_to_le32(config);
718 
719 	return mc_send_command(mc_io, &cmd);
720 }
721 
722 int dpni_get_offload(struct fsl_mc_io *mc_io,
723 		     u32 cmd_flags,
724 		     u16 token,
725 		     enum dpni_offload type,
726 		     u32 *config)
727 {
728 	struct fsl_mc_command cmd = { 0 };
729 	struct dpni_cmd_get_offload *cmd_params;
730 	struct dpni_rsp_get_offload *rsp_params;
731 	int err;
732 
733 	/* prepare command */
734 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_OFFLOAD,
735 					  cmd_flags,
736 					  token);
737 	cmd_params = (struct dpni_cmd_get_offload *)cmd.params;
738 	cmd_params->dpni_offload = type;
739 
740 	/* send command to mc*/
741 	err = mc_send_command(mc_io, &cmd);
742 	if (err)
743 		return err;
744 
745 	/* retrieve response parameters */
746 	rsp_params = (struct dpni_rsp_get_offload *)cmd.params;
747 	*config = le32_to_cpu(rsp_params->config);
748 
749 	return 0;
750 }
751 
752 /**
753  * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
754  *			for enqueue operations
755  * @mc_io:	Pointer to MC portal's I/O object
756  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
757  * @token:	Token of DPNI object
758  * @qtype:	Type of queue to receive QDID for
759  * @qdid:	Returned virtual QDID value that should be used as an argument
760  *			in all enqueue operations
761  *
762  * Return:	'0' on Success; Error code otherwise.
763  */
764 int dpni_get_qdid(struct fsl_mc_io *mc_io,
765 		  u32 cmd_flags,
766 		  u16 token,
767 		  enum dpni_queue_type qtype,
768 		  u16 *qdid)
769 {
770 	struct fsl_mc_command cmd = { 0 };
771 	struct dpni_cmd_get_qdid *cmd_params;
772 	struct dpni_rsp_get_qdid *rsp_params;
773 	int err;
774 
775 	/* prepare command */
776 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
777 					  cmd_flags,
778 					  token);
779 	cmd_params = (struct dpni_cmd_get_qdid *)cmd.params;
780 	cmd_params->qtype = qtype;
781 
782 	/* send command to mc*/
783 	err = mc_send_command(mc_io, &cmd);
784 	if (err)
785 		return err;
786 
787 	/* retrieve response parameters */
788 	rsp_params = (struct dpni_rsp_get_qdid *)cmd.params;
789 	*qdid = le16_to_cpu(rsp_params->qdid);
790 
791 	return 0;
792 }
793 
794 /**
795  * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
796  * @mc_io:	Pointer to MC portal's I/O object
797  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
798  * @token:	Token of DPNI object
799  * @data_offset: Tx data offset (from start of buffer)
800  *
801  * Return:	'0' on Success; Error code otherwise.
802  */
803 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
804 			    u32 cmd_flags,
805 			    u16 token,
806 			    u16 *data_offset)
807 {
808 	struct fsl_mc_command cmd = { 0 };
809 	struct dpni_rsp_get_tx_data_offset *rsp_params;
810 	int err;
811 
812 	/* prepare command */
813 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET,
814 					  cmd_flags,
815 					  token);
816 
817 	/* send command to mc*/
818 	err = mc_send_command(mc_io, &cmd);
819 	if (err)
820 		return err;
821 
822 	/* retrieve response parameters */
823 	rsp_params = (struct dpni_rsp_get_tx_data_offset *)cmd.params;
824 	*data_offset = le16_to_cpu(rsp_params->data_offset);
825 
826 	return 0;
827 }
828 
829 /**
830  * dpni_set_link_cfg() - set the link configuration.
831  * @mc_io:	Pointer to MC portal's I/O object
832  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
833  * @token:	Token of DPNI object
834  * @cfg:	Link configuration
835  *
836  * Return:	'0' on Success; Error code otherwise.
837  */
838 int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
839 		      u32 cmd_flags,
840 		      u16 token,
841 		      const struct dpni_link_cfg *cfg)
842 {
843 	struct fsl_mc_command cmd = { 0 };
844 	struct dpni_cmd_link_cfg *cmd_params;
845 
846 	/* prepare command */
847 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
848 					  cmd_flags,
849 					  token);
850 	cmd_params = (struct dpni_cmd_link_cfg *)cmd.params;
851 	cmd_params->rate = cpu_to_le32(cfg->rate);
852 	cmd_params->options = cpu_to_le64(cfg->options);
853 
854 	/* send command to mc*/
855 	return mc_send_command(mc_io, &cmd);
856 }
857 
858 /**
859  * dpni_get_link_cfg() - return the link configuration
860  * @mc_io:	Pointer to MC portal's I/O object
861  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
862  * @token:	Token of DPNI object
863  * @cfg:	Link configuration from dpni object
864  *
865  * Return:	'0' on Success; Error code otherwise.
866  */
867 int dpni_get_link_cfg(struct fsl_mc_io *mc_io,
868 		      u32 cmd_flags,
869 		      u16 token,
870 		      struct dpni_link_cfg *cfg)
871 {
872 	struct fsl_mc_command cmd = { 0 };
873 	struct dpni_cmd_link_cfg *rsp_params;
874 	int err;
875 
876 	/* prepare command */
877 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_CFG,
878 					  cmd_flags,
879 					  token);
880 
881 	/* send command to mc*/
882 	err = mc_send_command(mc_io, &cmd);
883 	if (err)
884 		return err;
885 
886 	/* retrieve response parameters */
887 	rsp_params = (struct dpni_cmd_link_cfg *)cmd.params;
888 	cfg->rate = le32_to_cpu(rsp_params->rate);
889 	cfg->options = le64_to_cpu(rsp_params->options);
890 
891 	return err;
892 }
893 
894 /**
895  * dpni_get_link_state() - Return the link state (either up or down)
896  * @mc_io:	Pointer to MC portal's I/O object
897  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
898  * @token:	Token of DPNI object
899  * @state:	Returned link state;
900  *
901  * Return:	'0' on Success; Error code otherwise.
902  */
903 int dpni_get_link_state(struct fsl_mc_io *mc_io,
904 			u32 cmd_flags,
905 			u16 token,
906 			struct dpni_link_state *state)
907 {
908 	struct fsl_mc_command cmd = { 0 };
909 	struct dpni_rsp_get_link_state *rsp_params;
910 	int err;
911 
912 	/* prepare command */
913 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
914 					  cmd_flags,
915 					  token);
916 
917 	/* send command to mc*/
918 	err = mc_send_command(mc_io, &cmd);
919 	if (err)
920 		return err;
921 
922 	/* retrieve response parameters */
923 	rsp_params = (struct dpni_rsp_get_link_state *)cmd.params;
924 	state->up = dpni_get_field(rsp_params->flags, LINK_STATE);
925 	state->rate = le32_to_cpu(rsp_params->rate);
926 	state->options = le64_to_cpu(rsp_params->options);
927 
928 	return 0;
929 }
930 
931 /**
932  * dpni_set_max_frame_length() - Set the maximum received frame length.
933  * @mc_io:	Pointer to MC portal's I/O object
934  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
935  * @token:	Token of DPNI object
936  * @max_frame_length:	Maximum received frame length (in
937  *				bytes); frame is discarded if its
938  *				length exceeds this value
939  *
940  * Return:	'0' on Success; Error code otherwise.
941  */
942 int dpni_set_max_frame_length(struct fsl_mc_io *mc_io,
943 			      u32 cmd_flags,
944 			      u16 token,
945 			      u16 max_frame_length)
946 {
947 	struct fsl_mc_command cmd = { 0 };
948 	struct dpni_cmd_set_max_frame_length *cmd_params;
949 
950 	/* prepare command */
951 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_MAX_FRAME_LENGTH,
952 					  cmd_flags,
953 					  token);
954 	cmd_params = (struct dpni_cmd_set_max_frame_length *)cmd.params;
955 	cmd_params->max_frame_length = cpu_to_le16(max_frame_length);
956 
957 	/* send command to mc*/
958 	return mc_send_command(mc_io, &cmd);
959 }
960 
961 /**
962  * dpni_get_max_frame_length() - Get the maximum received frame length.
963  * @mc_io:	Pointer to MC portal's I/O object
964  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
965  * @token:	Token of DPNI object
966  * @max_frame_length:	Maximum received frame length (in
967  *				bytes); frame is discarded if its
968  *				length exceeds this value
969  *
970  * Return:	'0' on Success; Error code otherwise.
971  */
972 int dpni_get_max_frame_length(struct fsl_mc_io *mc_io,
973 			      u32 cmd_flags,
974 			      u16 token,
975 			      u16 *max_frame_length)
976 {
977 	struct fsl_mc_command cmd = { 0 };
978 	struct dpni_rsp_get_max_frame_length *rsp_params;
979 	int err;
980 
981 	/* prepare command */
982 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_MAX_FRAME_LENGTH,
983 					  cmd_flags,
984 					  token);
985 
986 	/* send command to mc*/
987 	err = mc_send_command(mc_io, &cmd);
988 	if (err)
989 		return err;
990 
991 	/* retrieve response parameters */
992 	rsp_params = (struct dpni_rsp_get_max_frame_length *)cmd.params;
993 	*max_frame_length = le16_to_cpu(rsp_params->max_frame_length);
994 
995 	return 0;
996 }
997 
998 /**
999  * dpni_set_multicast_promisc() - Enable/disable multicast promiscuous mode
1000  * @mc_io:	Pointer to MC portal's I/O object
1001  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1002  * @token:	Token of DPNI object
1003  * @en:		Set to '1' to enable; '0' to disable
1004  *
1005  * Return:	'0' on Success; Error code otherwise.
1006  */
1007 int dpni_set_multicast_promisc(struct fsl_mc_io *mc_io,
1008 			       u32 cmd_flags,
1009 			       u16 token,
1010 			       int en)
1011 {
1012 	struct fsl_mc_command cmd = { 0 };
1013 	struct dpni_cmd_set_multicast_promisc *cmd_params;
1014 
1015 	/* prepare command */
1016 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_MCAST_PROMISC,
1017 					  cmd_flags,
1018 					  token);
1019 	cmd_params = (struct dpni_cmd_set_multicast_promisc *)cmd.params;
1020 	dpni_set_field(cmd_params->enable, ENABLE, en);
1021 
1022 	/* send command to mc*/
1023 	return mc_send_command(mc_io, &cmd);
1024 }
1025 
1026 /**
1027  * dpni_get_multicast_promisc() - Get multicast promiscuous mode
1028  * @mc_io:	Pointer to MC portal's I/O object
1029  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1030  * @token:	Token of DPNI object
1031  * @en:		Returns '1' if enabled; '0' otherwise
1032  *
1033  * Return:	'0' on Success; Error code otherwise.
1034  */
1035 int dpni_get_multicast_promisc(struct fsl_mc_io *mc_io,
1036 			       u32 cmd_flags,
1037 			       u16 token,
1038 			       int *en)
1039 {
1040 	struct fsl_mc_command cmd = { 0 };
1041 	struct dpni_rsp_get_multicast_promisc *rsp_params;
1042 	int err;
1043 
1044 	/* prepare command */
1045 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_MCAST_PROMISC,
1046 					  cmd_flags,
1047 					  token);
1048 
1049 	/* send command to mc*/
1050 	err = mc_send_command(mc_io, &cmd);
1051 	if (err)
1052 		return err;
1053 
1054 	/* retrieve response parameters */
1055 	rsp_params = (struct dpni_rsp_get_multicast_promisc *)cmd.params;
1056 	*en = dpni_get_field(rsp_params->enabled, ENABLE);
1057 
1058 	return 0;
1059 }
1060 
1061 /**
1062  * dpni_set_unicast_promisc() - Enable/disable unicast promiscuous mode
1063  * @mc_io:	Pointer to MC portal's I/O object
1064  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1065  * @token:	Token of DPNI object
1066  * @en:		Set to '1' to enable; '0' to disable
1067  *
1068  * Return:	'0' on Success; Error code otherwise.
1069  */
1070 int dpni_set_unicast_promisc(struct fsl_mc_io *mc_io,
1071 			     u32 cmd_flags,
1072 			     u16 token,
1073 			     int en)
1074 {
1075 	struct fsl_mc_command cmd = { 0 };
1076 	struct dpni_cmd_set_unicast_promisc *cmd_params;
1077 
1078 	/* prepare command */
1079 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_UNICAST_PROMISC,
1080 					  cmd_flags,
1081 					  token);
1082 	cmd_params = (struct dpni_cmd_set_unicast_promisc *)cmd.params;
1083 	dpni_set_field(cmd_params->enable, ENABLE, en);
1084 
1085 	/* send command to mc*/
1086 	return mc_send_command(mc_io, &cmd);
1087 }
1088 
1089 /**
1090  * dpni_get_unicast_promisc() - Get unicast promiscuous mode
1091  * @mc_io:	Pointer to MC portal's I/O object
1092  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1093  * @token:	Token of DPNI object
1094  * @en:		Returns '1' if enabled; '0' otherwise
1095  *
1096  * Return:	'0' on Success; Error code otherwise.
1097  */
1098 int dpni_get_unicast_promisc(struct fsl_mc_io *mc_io,
1099 			     u32 cmd_flags,
1100 			     u16 token,
1101 			     int *en)
1102 {
1103 	struct fsl_mc_command cmd = { 0 };
1104 	struct dpni_rsp_get_unicast_promisc *rsp_params;
1105 	int err;
1106 
1107 	/* prepare command */
1108 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_UNICAST_PROMISC,
1109 					  cmd_flags,
1110 					  token);
1111 
1112 	/* send command to mc*/
1113 	err = mc_send_command(mc_io, &cmd);
1114 	if (err)
1115 		return err;
1116 
1117 	/* retrieve response parameters */
1118 	rsp_params = (struct dpni_rsp_get_unicast_promisc *)cmd.params;
1119 	*en = dpni_get_field(rsp_params->enabled, ENABLE);
1120 
1121 	return 0;
1122 }
1123 
1124 /**
1125  * dpni_set_primary_mac_addr() - Set the primary MAC address
1126  * @mc_io:	Pointer to MC portal's I/O object
1127  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1128  * @token:	Token of DPNI object
1129  * @mac_addr:	MAC address to set as primary address
1130  *
1131  * Return:	'0' on Success; Error code otherwise.
1132  */
1133 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
1134 			      u32 cmd_flags,
1135 			      u16 token,
1136 			      const u8 mac_addr[6])
1137 {
1138 	struct fsl_mc_command cmd = { 0 };
1139 	struct dpni_cmd_set_primary_mac_addr *cmd_params;
1140 	int i;
1141 
1142 	/* prepare command */
1143 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
1144 					  cmd_flags,
1145 					  token);
1146 	cmd_params = (struct dpni_cmd_set_primary_mac_addr *)cmd.params;
1147 	for (i = 0; i < 6; i++)
1148 		cmd_params->mac_addr[i] = mac_addr[5 - i];
1149 
1150 	/* send command to mc*/
1151 	return mc_send_command(mc_io, &cmd);
1152 }
1153 
1154 /**
1155  * dpni_get_primary_mac_addr() - Get the primary MAC address
1156  * @mc_io:	Pointer to MC portal's I/O object
1157  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1158  * @token:	Token of DPNI object
1159  * @mac_addr:	Returned MAC address
1160  *
1161  * Return:	'0' on Success; Error code otherwise.
1162  */
1163 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
1164 			      u32 cmd_flags,
1165 			      u16 token,
1166 			      u8 mac_addr[6])
1167 {
1168 	struct fsl_mc_command cmd = { 0 };
1169 	struct dpni_rsp_get_primary_mac_addr *rsp_params;
1170 	int i, err;
1171 
1172 	/* prepare command */
1173 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
1174 					  cmd_flags,
1175 					  token);
1176 
1177 	/* send command to mc*/
1178 	err = mc_send_command(mc_io, &cmd);
1179 	if (err)
1180 		return err;
1181 
1182 	/* retrieve response parameters */
1183 	rsp_params = (struct dpni_rsp_get_primary_mac_addr *)cmd.params;
1184 	for (i = 0; i < 6; i++)
1185 		mac_addr[5 - i] = rsp_params->mac_addr[i];
1186 
1187 	return 0;
1188 }
1189 
1190 /**
1191  * dpni_get_port_mac_addr() - Retrieve MAC address associated to the physical
1192  *			port the DPNI is attached to
1193  * @mc_io:	Pointer to MC portal's I/O object
1194  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1195  * @token:	Token of DPNI object
1196  * @mac_addr:	MAC address of the physical port, if any, otherwise 0
1197  *
1198  * The primary MAC address is not cleared by this operation.
1199  *
1200  * Return:	'0' on Success; Error code otherwise.
1201  */
1202 int dpni_get_port_mac_addr(struct fsl_mc_io *mc_io,
1203 			   u32 cmd_flags,
1204 			   u16 token,
1205 			   u8 mac_addr[6])
1206 {
1207 	struct fsl_mc_command cmd = { 0 };
1208 	struct dpni_rsp_get_port_mac_addr *rsp_params;
1209 	int i, err;
1210 
1211 	/* prepare command */
1212 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PORT_MAC_ADDR,
1213 					  cmd_flags,
1214 					  token);
1215 
1216 	/* send command to mc*/
1217 	err = mc_send_command(mc_io, &cmd);
1218 	if (err)
1219 		return err;
1220 
1221 	/* retrieve response parameters */
1222 	rsp_params = (struct dpni_rsp_get_port_mac_addr *)cmd.params;
1223 	for (i = 0; i < 6; i++)
1224 		mac_addr[5 - i] = rsp_params->mac_addr[i];
1225 
1226 	return 0;
1227 }
1228 
1229 /**
1230  * dpni_enable_vlan_filter() - Enable/disable VLAN filtering mode
1231  * @mc_io:	Pointer to MC portal's I/O object
1232  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1233  * @token:	Token of DPNI object
1234  * @en:		Set to '1' to enable; '0' to disable
1235  *
1236  * Return:	'0' on Success; Error code otherwise.
1237  */
1238 int dpni_enable_vlan_filter(struct fsl_mc_io *mc_io,
1239 			    u32 cmd_flags,
1240 			    u16 token,
1241 			    u32 en)
1242 {
1243 	struct dpni_cmd_enable_vlan_filter *cmd_params;
1244 	struct fsl_mc_command cmd = { 0 };
1245 
1246 	/* prepare command */
1247 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE_VLAN_FILTER,
1248 					  cmd_flags,
1249 					  token);
1250 	cmd_params = (struct dpni_cmd_enable_vlan_filter *)cmd.params;
1251 	dpni_set_field(cmd_params->en, ENABLE, en);
1252 
1253 	/* send command to mc*/
1254 	return mc_send_command(mc_io, &cmd);
1255 }
1256 
1257 /**
1258  * dpni_add_vlan_id() - Add VLAN ID filter
1259  * @mc_io:	Pointer to MC portal's I/O object
1260  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1261  * @token:	Token of DPNI object
1262  * @vlan_id:	VLAN ID to add
1263  * @flags:   0 - tc_id and flow_id will be ignored.
1264  * Pkt with this vlan_id will be passed to the next
1265  * classification stages
1266  * DPNI_VLAN_SET_QUEUE_ACTION
1267  * Pkt with this vlan_id will be forward directly to
1268  * queue defined by the tc_id and flow_id
1269  *
1270  * @tc_id: Traffic class selection (0-7)
1271  * @flow_id: Selects the specific queue out of the set allocated for the
1272  *           same as tc_id. Value must be in range 0 to NUM_QUEUES - 1
1273  *
1274  * Return:	'0' on Success; Error code otherwise.
1275  */
1276 int dpni_add_vlan_id(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
1277 		     u16 vlan_id, u8 flags, u8 tc_id, u8 flow_id)
1278 {
1279 	struct dpni_cmd_vlan_id *cmd_params;
1280 	struct fsl_mc_command cmd = { 0 };
1281 
1282 	/* prepare command */
1283 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_VLAN_ID,
1284 					  cmd_flags,
1285 					  token);
1286 	cmd_params = (struct dpni_cmd_vlan_id *)cmd.params;
1287 	cmd_params->flags = flags;
1288 	cmd_params->tc_id = tc_id;
1289 	cmd_params->flow_id =  flow_id;
1290 	cmd_params->vlan_id = cpu_to_le16(vlan_id);
1291 
1292 	/* send command to mc*/
1293 	return mc_send_command(mc_io, &cmd);
1294 }
1295 
1296 /**
1297  * dpni_remove_vlan_id() - Remove VLAN ID filter
1298  * @mc_io:	Pointer to MC portal's I/O object
1299  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1300  * @token:	Token of DPNI object
1301  * @vlan_id:	VLAN ID to remove
1302  *
1303  * Return:	'0' on Success; Error code otherwise.
1304  */
1305 int dpni_remove_vlan_id(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
1306 			u16 vlan_id)
1307 {
1308 	struct dpni_cmd_vlan_id *cmd_params;
1309 	struct fsl_mc_command cmd = { 0 };
1310 
1311 	/* prepare command */
1312 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_VLAN_ID,
1313 					  cmd_flags,
1314 					  token);
1315 	cmd_params = (struct dpni_cmd_vlan_id *)cmd.params;
1316 	cmd_params->vlan_id = cpu_to_le16(vlan_id);
1317 
1318 	/* send command to mc*/
1319 	return mc_send_command(mc_io, &cmd);
1320 }
1321 
1322 /**
1323  * dpni_add_mac_addr() - Add MAC address filter
1324  * @mc_io:	Pointer to MC portal's I/O object
1325  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1326  * @token:	Token of DPNI object
1327  * @mac_addr:	MAC address to add
1328  *
1329  * Return:	'0' on Success; Error code otherwise.
1330  */
1331 int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
1332 		      u32 cmd_flags,
1333 		      u16 token,
1334 		      const u8 mac_addr[6])
1335 {
1336 	struct fsl_mc_command cmd = { 0 };
1337 	struct dpni_cmd_add_mac_addr *cmd_params;
1338 	int i;
1339 
1340 	/* prepare command */
1341 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
1342 					  cmd_flags,
1343 					  token);
1344 	cmd_params = (struct dpni_cmd_add_mac_addr *)cmd.params;
1345 	for (i = 0; i < 6; i++)
1346 		cmd_params->mac_addr[i] = mac_addr[5 - i];
1347 
1348 	/* send command to mc*/
1349 	return mc_send_command(mc_io, &cmd);
1350 }
1351 
1352 /**
1353  * dpni_remove_mac_addr() - Remove MAC address filter
1354  * @mc_io:	Pointer to MC portal's I/O object
1355  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1356  * @token:	Token of DPNI object
1357  * @mac_addr:	MAC address to remove
1358  *
1359  * Return:	'0' on Success; Error code otherwise.
1360  */
1361 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
1362 			 u32 cmd_flags,
1363 			 u16 token,
1364 			 const u8 mac_addr[6])
1365 {
1366 	struct fsl_mc_command cmd = { 0 };
1367 	struct dpni_cmd_remove_mac_addr *cmd_params;
1368 	int i;
1369 
1370 	/* prepare command */
1371 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
1372 					  cmd_flags,
1373 					  token);
1374 	cmd_params = (struct dpni_cmd_remove_mac_addr *)cmd.params;
1375 	for (i = 0; i < 6; i++)
1376 		cmd_params->mac_addr[i] = mac_addr[5 - i];
1377 
1378 	/* send command to mc*/
1379 	return mc_send_command(mc_io, &cmd);
1380 }
1381 
1382 /**
1383  * dpni_clear_mac_filters() - Clear all unicast and/or multicast MAC filters
1384  * @mc_io:	Pointer to MC portal's I/O object
1385  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1386  * @token:	Token of DPNI object
1387  * @unicast:	Set to '1' to clear unicast addresses
1388  * @multicast:	Set to '1' to clear multicast addresses
1389  *
1390  * The primary MAC address is not cleared by this operation.
1391  *
1392  * Return:	'0' on Success; Error code otherwise.
1393  */
1394 int dpni_clear_mac_filters(struct fsl_mc_io *mc_io,
1395 			   u32 cmd_flags,
1396 			   u16 token,
1397 			   int unicast,
1398 			   int multicast)
1399 {
1400 	struct fsl_mc_command cmd = { 0 };
1401 	struct dpni_cmd_clear_mac_filters *cmd_params;
1402 
1403 	/* prepare command */
1404 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLR_MAC_FILTERS,
1405 					  cmd_flags,
1406 					  token);
1407 	cmd_params = (struct dpni_cmd_clear_mac_filters *)cmd.params;
1408 	dpni_set_field(cmd_params->flags, UNICAST_FILTERS, unicast);
1409 	dpni_set_field(cmd_params->flags, MULTICAST_FILTERS, multicast);
1410 
1411 	/* send command to mc*/
1412 	return mc_send_command(mc_io, &cmd);
1413 }
1414 
1415 /**
1416  * dpni_set_rx_tc_dist() - Set Rx traffic class distribution configuration
1417  * @mc_io:	Pointer to MC portal's I/O object
1418  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1419  * @token:	Token of DPNI object
1420  * @tc_id:	Traffic class selection (0-7)
1421  * @cfg:	Traffic class distribution configuration
1422  *
1423  * warning: if 'dist_mode != DPNI_DIST_MODE_NONE', call dpni_prepare_key_cfg()
1424  *			first to prepare the key_cfg_iova parameter
1425  *
1426  * Return:	'0' on Success; error code otherwise.
1427  */
1428 int dpni_set_rx_tc_dist(struct fsl_mc_io *mc_io,
1429 			u32 cmd_flags,
1430 			u16 token,
1431 			u8 tc_id,
1432 			const struct dpni_rx_tc_dist_cfg *cfg)
1433 {
1434 	struct fsl_mc_command cmd = { 0 };
1435 	struct dpni_cmd_set_rx_tc_dist *cmd_params;
1436 
1437 	/* prepare command */
1438 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_TC_DIST,
1439 					  cmd_flags,
1440 					  token);
1441 	cmd_params = (struct dpni_cmd_set_rx_tc_dist *)cmd.params;
1442 	cmd_params->dist_size = cpu_to_le16(cfg->dist_size);
1443 	cmd_params->tc_id = tc_id;
1444 	dpni_set_field(cmd_params->flags, DIST_MODE, cfg->dist_mode);
1445 	dpni_set_field(cmd_params->flags, MISS_ACTION, cfg->fs_cfg.miss_action);
1446 	cmd_params->default_flow_id = cpu_to_le16(cfg->fs_cfg.default_flow_id);
1447 	cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1448 
1449 	/* send command to mc*/
1450 	return mc_send_command(mc_io, &cmd);
1451 }
1452 
1453 /**
1454  * dpni_set_congestion_notification() - Set traffic class congestion
1455  *					notification configuration
1456  * @mc_io:	Pointer to MC portal's I/O object
1457  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1458  * @token:	Token of DPNI object
1459  * @qtype:	Type of queue - Rx, Tx and Tx confirm types are supported
1460  * @tc_id:	Traffic class selection (0-7)
1461  * @cfg:	Congestion notification configuration
1462  *
1463  * Return:	'0' on Success; error code otherwise.
1464  */
1465 int dpni_set_congestion_notification(
1466 			struct fsl_mc_io *mc_io,
1467 			u32 cmd_flags,
1468 			u16 token,
1469 			enum dpni_queue_type qtype,
1470 			u8 tc_id,
1471 			const struct dpni_congestion_notification_cfg *cfg)
1472 {
1473 	struct dpni_cmd_set_congestion_notification *cmd_params;
1474 	struct fsl_mc_command cmd = { 0 };
1475 
1476 	/* prepare command */
1477 	cmd.header =
1478 		mc_encode_cmd_header(DPNI_CMDID_SET_CONGESTION_NOTIFICATION,
1479 				     cmd_flags,
1480 				     token);
1481 	cmd_params = (struct dpni_cmd_set_congestion_notification *)cmd.params;
1482 	cmd_params->qtype = qtype;
1483 	cmd_params->tc = tc_id;
1484 	cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
1485 	cmd_params->notification_mode = cpu_to_le16(cfg->notification_mode);
1486 	cmd_params->dest_priority = cfg->dest_cfg.priority;
1487 	dpni_set_field(cmd_params->type_units, DEST_TYPE,
1488 		       cfg->dest_cfg.dest_type);
1489 	dpni_set_field(cmd_params->type_units, CONG_UNITS, cfg->units);
1490 	cmd_params->message_iova = cpu_to_le64(cfg->message_iova);
1491 	cmd_params->message_ctx = cpu_to_le64(cfg->message_ctx);
1492 	cmd_params->threshold_entry = cpu_to_le32(cfg->threshold_entry);
1493 	cmd_params->threshold_exit = cpu_to_le32(cfg->threshold_exit);
1494 
1495 	/* send command to mc*/
1496 	return mc_send_command(mc_io, &cmd);
1497 }
1498 
1499 /**
1500  * dpni_set_queue() - Set queue parameters
1501  * @mc_io:	Pointer to MC portal's I/O object
1502  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1503  * @token:	Token of DPNI object
1504  * @qtype:	Type of queue - all queue types are supported, although
1505  *		the command is ignored for Tx
1506  * @tc:		Traffic class, in range 0 to NUM_TCS - 1
1507  * @index:	Selects the specific queue out of the set allocated for the
1508  *		same TC. Value must be in range 0 to NUM_QUEUES - 1
1509  * @options:	A combination of DPNI_QUEUE_OPT_ values that control what
1510  *		configuration options are set on the queue
1511  * @queue:	Queue structure
1512  *
1513  * Return:	'0' on Success; Error code otherwise.
1514  */
1515 int dpni_set_queue(struct fsl_mc_io *mc_io,
1516 		   u32 cmd_flags,
1517 		   u16 token,
1518 		   enum dpni_queue_type qtype,
1519 		   u8 tc,
1520 		   u8 index,
1521 		   u8 options,
1522 		   const struct dpni_queue *queue)
1523 {
1524 	struct fsl_mc_command cmd = { 0 };
1525 	struct dpni_cmd_set_queue *cmd_params;
1526 
1527 	/* prepare command */
1528 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
1529 					  cmd_flags,
1530 					  token);
1531 	cmd_params = (struct dpni_cmd_set_queue *)cmd.params;
1532 	cmd_params->qtype = qtype;
1533 	cmd_params->tc = tc;
1534 	cmd_params->index = index;
1535 	cmd_params->options = options;
1536 	cmd_params->dest_id = cpu_to_le32(queue->destination.id);
1537 	cmd_params->dest_prio = queue->destination.priority;
1538 	dpni_set_field(cmd_params->flags, DEST_TYPE, queue->destination.type);
1539 	dpni_set_field(cmd_params->flags, STASH_CTRL, queue->flc.stash_control);
1540 	dpni_set_field(cmd_params->flags, HOLD_ACTIVE,
1541 		       queue->destination.hold_active);
1542 	cmd_params->flc = cpu_to_le64(queue->flc.value);
1543 	cmd_params->user_context = cpu_to_le64(queue->user_context);
1544 
1545 	/* send command to mc */
1546 	return mc_send_command(mc_io, &cmd);
1547 }
1548 
1549 /**
1550  * dpni_get_queue() - Get queue parameters
1551  * @mc_io:	Pointer to MC portal's I/O object
1552  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1553  * @token:	Token of DPNI object
1554  * @qtype:	Type of queue - all queue types are supported
1555  * @tc:		Traffic class, in range 0 to NUM_TCS - 1
1556  * @index:	Selects the specific queue out of the set allocated for the
1557  *		same TC. Value must be in range 0 to NUM_QUEUES - 1
1558  * @queue:	Queue configuration structure
1559  * @qid:	Queue identification
1560  *
1561  * Return:	'0' on Success; Error code otherwise.
1562  */
1563 int dpni_get_queue(struct fsl_mc_io *mc_io,
1564 		   u32 cmd_flags,
1565 		   u16 token,
1566 		   enum dpni_queue_type qtype,
1567 		   u8 tc,
1568 		   u8 index,
1569 		   struct dpni_queue *queue,
1570 		   struct dpni_queue_id *qid)
1571 {
1572 	struct fsl_mc_command cmd = { 0 };
1573 	struct dpni_cmd_get_queue *cmd_params;
1574 	struct dpni_rsp_get_queue *rsp_params;
1575 	int err;
1576 
1577 	/* prepare command */
1578 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
1579 					  cmd_flags,
1580 					  token);
1581 	cmd_params = (struct dpni_cmd_get_queue *)cmd.params;
1582 	cmd_params->qtype = qtype;
1583 	cmd_params->tc = tc;
1584 	cmd_params->index = index;
1585 
1586 	/* send command to mc */
1587 	err = mc_send_command(mc_io, &cmd);
1588 	if (err)
1589 		return err;
1590 
1591 	/* retrieve response parameters */
1592 	rsp_params = (struct dpni_rsp_get_queue *)cmd.params;
1593 	queue->destination.id = le32_to_cpu(rsp_params->dest_id);
1594 	queue->destination.priority = rsp_params->dest_prio;
1595 	queue->destination.type = dpni_get_field(rsp_params->flags,
1596 						 DEST_TYPE);
1597 	queue->flc.stash_control = dpni_get_field(rsp_params->flags,
1598 						  STASH_CTRL);
1599 	queue->destination.hold_active = dpni_get_field(rsp_params->flags,
1600 							HOLD_ACTIVE);
1601 	queue->flc.value = le64_to_cpu(rsp_params->flc);
1602 	queue->user_context = le64_to_cpu(rsp_params->user_context);
1603 	qid->fqid = le32_to_cpu(rsp_params->fqid);
1604 	qid->qdbin = le16_to_cpu(rsp_params->qdbin);
1605 
1606 	return 0;
1607 }
1608 
1609 /**
1610  * dpni_get_statistics() - Get DPNI statistics
1611  * @mc_io:	Pointer to MC portal's I/O object
1612  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1613  * @token:	Token of DPNI object
1614  * @page:	Selects the statistics page to retrieve, see
1615  *		DPNI_GET_STATISTICS output. Pages are numbered 0 to 6.
1616  * @stat:	Structure containing the statistics
1617  *
1618  * Return:	'0' on Success; Error code otherwise.
1619  */
1620 int dpni_get_statistics(struct fsl_mc_io *mc_io,
1621 			u32 cmd_flags,
1622 			u16 token,
1623 			u8 page,
1624 			union dpni_statistics *stat)
1625 {
1626 	struct fsl_mc_command cmd = { 0 };
1627 	struct dpni_cmd_get_statistics *cmd_params;
1628 	struct dpni_rsp_get_statistics *rsp_params;
1629 	int i, err;
1630 
1631 	/* prepare command */
1632 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
1633 					  cmd_flags,
1634 					  token);
1635 	cmd_params = (struct dpni_cmd_get_statistics *)cmd.params;
1636 	cmd_params->page_number = page;
1637 
1638 	/* send command to mc */
1639 	err = mc_send_command(mc_io, &cmd);
1640 	if (err)
1641 		return err;
1642 
1643 	/* retrieve response parameters */
1644 	rsp_params = (struct dpni_rsp_get_statistics *)cmd.params;
1645 	for (i = 0; i < DPNI_STATISTICS_CNT; i++)
1646 		stat->raw.counter[i] = le64_to_cpu(rsp_params->counter[i]);
1647 
1648 	return 0;
1649 }
1650 
1651 /**
1652  * dpni_set_taildrop() - Set taildrop per queue or TC
1653  * @mc_io:	Pointer to MC portal's I/O object
1654  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1655  * @token:	Token of DPNI object
1656  * @cg_point:	Congestion point
1657  * @qtype:	Queue type on which the taildrop is configured.
1658  *		Only Rx queues are supported for now
1659  * @tc:		Traffic class to apply this taildrop to
1660  * @index:	Index of the queue if the DPNI supports multiple queues for
1661  *		traffic distribution. Ignored if CONGESTION_POINT is not 0.
1662  * @taildrop:	Taildrop structure
1663  *
1664  * Return:	'0' on Success; Error code otherwise.
1665  */
1666 int dpni_set_taildrop(struct fsl_mc_io *mc_io,
1667 		      u32 cmd_flags,
1668 		      u16 token,
1669 		      enum dpni_congestion_point cg_point,
1670 		      enum dpni_queue_type qtype,
1671 		      u8 tc,
1672 		      u8 index,
1673 		      struct dpni_taildrop *taildrop)
1674 {
1675 	struct fsl_mc_command cmd = { 0 };
1676 	struct dpni_cmd_set_taildrop *cmd_params;
1677 
1678 	/* prepare command */
1679 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TAILDROP,
1680 					  cmd_flags,
1681 					  token);
1682 	cmd_params = (struct dpni_cmd_set_taildrop *)cmd.params;
1683 	cmd_params->congestion_point = cg_point;
1684 	cmd_params->qtype = qtype;
1685 	cmd_params->tc = tc;
1686 	cmd_params->index = index;
1687 	dpni_set_field(cmd_params->enable, ENABLE, taildrop->enable);
1688 	cmd_params->units = taildrop->units;
1689 	cmd_params->threshold = cpu_to_le32(taildrop->threshold);
1690 
1691 	/* send command to mc */
1692 	return mc_send_command(mc_io, &cmd);
1693 }
1694 
1695 /**
1696  * dpni_get_taildrop() - Get taildrop information
1697  * @mc_io:	Pointer to MC portal's I/O object
1698  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1699  * @token:	Token of DPNI object
1700  * @cg_point:	Congestion point
1701  * @qtype:	Queue type on which the taildrop is configured.
1702  *		Only Rx queues are supported for now
1703  * @tc:		Traffic class to apply this taildrop to
1704  * @index:	Index of the queue if the DPNI supports multiple queues for
1705  *		traffic distribution. Ignored if CONGESTION_POINT is not 0.
1706  * @taildrop:	Taildrop structure
1707  *
1708  * Return:	'0' on Success; Error code otherwise.
1709  */
1710 int dpni_get_taildrop(struct fsl_mc_io *mc_io,
1711 		      u32 cmd_flags,
1712 		      u16 token,
1713 		      enum dpni_congestion_point cg_point,
1714 		      enum dpni_queue_type qtype,
1715 		      u8 tc,
1716 		      u8 index,
1717 		      struct dpni_taildrop *taildrop)
1718 {
1719 	struct fsl_mc_command cmd = { 0 };
1720 	struct dpni_cmd_get_taildrop *cmd_params;
1721 	struct dpni_rsp_get_taildrop *rsp_params;
1722 	int err;
1723 
1724 	/* prepare command */
1725 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TAILDROP,
1726 					  cmd_flags,
1727 					  token);
1728 	cmd_params = (struct dpni_cmd_get_taildrop *)cmd.params;
1729 	cmd_params->congestion_point = cg_point;
1730 	cmd_params->qtype = qtype;
1731 	cmd_params->tc = tc;
1732 	cmd_params->index = index;
1733 
1734 	/* send command to mc */
1735 	err = mc_send_command(mc_io, &cmd);
1736 	if (err)
1737 		return err;
1738 
1739 	/* retrieve response parameters */
1740 	rsp_params = (struct dpni_rsp_get_taildrop *)cmd.params;
1741 	taildrop->enable = dpni_get_field(rsp_params->enable, ENABLE);
1742 	taildrop->units = rsp_params->units;
1743 	taildrop->threshold = le32_to_cpu(rsp_params->threshold);
1744 
1745 	return 0;
1746 }
1747 
1748 /**
1749  * dpni_get_api_version() - Get Data Path Network Interface API version
1750  * @mc_io:	Pointer to MC portal's I/O object
1751  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1752  * @major_ver:	Major version of data path network interface API
1753  * @minor_ver:	Minor version of data path network interface API
1754  *
1755  * Return:	'0' on Success; Error code otherwise.
1756  */
1757 int dpni_get_api_version(struct fsl_mc_io *mc_io,
1758 			 u32 cmd_flags,
1759 			 u16 *major_ver,
1760 			 u16 *minor_ver)
1761 {
1762 	struct dpni_rsp_get_api_version *rsp_params;
1763 	struct fsl_mc_command cmd = { 0 };
1764 	int err;
1765 
1766 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
1767 					  cmd_flags, 0);
1768 
1769 	err = mc_send_command(mc_io, &cmd);
1770 	if (err)
1771 		return err;
1772 
1773 	rsp_params = (struct dpni_rsp_get_api_version *)cmd.params;
1774 	*major_ver = le16_to_cpu(rsp_params->major);
1775 	*minor_ver = le16_to_cpu(rsp_params->minor);
1776 
1777 	return 0;
1778 }
1779 
1780 /**
1781  * dpni_set_rx_fs_dist() - Set Rx flow steering distribution
1782  * @mc_io:	Pointer to MC portal's I/O object
1783  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1784  * @token:	Token of DPNI object
1785  * @cfg: Distribution configuration
1786  *
1787  * If the FS is already enabled with a previous call the classification
1788  * key will be changed but all the table rules are kept. If the
1789  * existing rules do not match the key the results will not be
1790  * predictable. It is the user responsibility to keep key integrity.
1791  * If cfg.enable is set to 1 the command will create a flow steering table
1792  * and will classify packets according to this table. The packets that
1793  * miss all the table rules will be classified according to settings
1794  * made in dpni_set_rx_hash_dist()
1795  * If cfg.enable is set to 0 the command will clear flow steering table.
1796  * The packets will be classified according to settings made in
1797  * dpni_set_rx_hash_dist()
1798  *
1799  * Return:	'0' on Success; Error code otherwise.
1800  */
1801 int dpni_set_rx_fs_dist(struct fsl_mc_io *mc_io,
1802 			u32 cmd_flags,
1803 			u16 token,
1804 			const struct dpni_rx_dist_cfg *cfg)
1805 {
1806 	struct dpni_cmd_set_rx_fs_dist *cmd_params;
1807 	struct fsl_mc_command cmd = { 0 };
1808 
1809 	/* prepare command */
1810 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_FS_DIST,
1811 					  cmd_flags,
1812 					  token);
1813 	cmd_params = (struct dpni_cmd_set_rx_fs_dist *)cmd.params;
1814 	cmd_params->dist_size = cpu_to_le16(cfg->dist_size);
1815 	dpni_set_field(cmd_params->enable, RX_FS_DIST_ENABLE, cfg->enable);
1816 	cmd_params->tc = cfg->tc;
1817 	cmd_params->miss_flow_id = cpu_to_le16(cfg->fs_miss_flow_id);
1818 	cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1819 
1820 	/* send command to mc*/
1821 	return mc_send_command(mc_io, &cmd);
1822 }
1823 
1824 /**
1825  * dpni_set_rx_hash_dist() - Set Rx hash distribution
1826  * @mc_io:	Pointer to MC portal's I/O object
1827  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1828  * @token:	Token of DPNI object
1829  * @cfg: Distribution configuration
1830  * If cfg.enable is set to 1 the packets will be classified using a hash
1831  * function based on the key received in cfg.key_cfg_iova parameter.
1832  * If cfg.enable is set to 0 the packets will be sent to the default queue
1833  *
1834  * Return:	'0' on Success; Error code otherwise.
1835  */
1836 int dpni_set_rx_hash_dist(struct fsl_mc_io *mc_io,
1837 			  u32 cmd_flags,
1838 			  u16 token,
1839 			  const struct dpni_rx_dist_cfg *cfg)
1840 {
1841 	struct dpni_cmd_set_rx_hash_dist *cmd_params;
1842 	struct fsl_mc_command cmd = { 0 };
1843 
1844 	/* prepare command */
1845 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_HASH_DIST,
1846 					  cmd_flags,
1847 					  token);
1848 	cmd_params = (struct dpni_cmd_set_rx_hash_dist *)cmd.params;
1849 	cmd_params->dist_size = cpu_to_le16(cfg->dist_size);
1850 	dpni_set_field(cmd_params->enable, RX_HASH_DIST_ENABLE, cfg->enable);
1851 	cmd_params->tc = cfg->tc;
1852 	cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1853 
1854 	/* send command to mc*/
1855 	return mc_send_command(mc_io, &cmd);
1856 }
1857 
1858 /**
1859  * dpni_add_fs_entry() - Add Flow Steering entry for a specific traffic class
1860  *			(to select a flow ID)
1861  * @mc_io:	Pointer to MC portal's I/O object
1862  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1863  * @token:	Token of DPNI object
1864  * @tc_id:	Traffic class selection (0-7)
1865  * @index:	Location in the FS table where to insert the entry.
1866  *		Only relevant if MASKING is enabled for FS
1867  *		classification on this DPNI, it is ignored for exact match.
1868  * @cfg:	Flow steering rule to add
1869  * @action:	Action to be taken as result of a classification hit
1870  *
1871  * Return:	'0' on Success; Error code otherwise.
1872  */
1873 int dpni_add_fs_entry(struct fsl_mc_io *mc_io,
1874 		      u32 cmd_flags,
1875 		      u16 token,
1876 		      u8 tc_id,
1877 		      u16 index,
1878 		      const struct dpni_rule_cfg *cfg,
1879 		      const struct dpni_fs_action_cfg *action)
1880 {
1881 	struct dpni_cmd_add_fs_entry *cmd_params;
1882 	struct fsl_mc_command cmd = { 0 };
1883 
1884 	/* prepare command */
1885 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_FS_ENT,
1886 					  cmd_flags,
1887 					  token);
1888 	cmd_params = (struct dpni_cmd_add_fs_entry *)cmd.params;
1889 	cmd_params->tc_id = tc_id;
1890 	cmd_params->key_size = cfg->key_size;
1891 	cmd_params->index = cpu_to_le16(index);
1892 	cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
1893 	cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
1894 	cmd_params->options = cpu_to_le16(action->options);
1895 	cmd_params->flow_id = cpu_to_le16(action->flow_id);
1896 	cmd_params->flc = cpu_to_le64(action->flc);
1897 
1898 	/* send command to mc*/
1899 	return mc_send_command(mc_io, &cmd);
1900 }
1901 
1902 /**
1903  * dpni_remove_fs_entry() - Remove Flow Steering entry from a specific
1904  *			    traffic class
1905  * @mc_io:	Pointer to MC portal's I/O object
1906  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1907  * @token:	Token of DPNI object
1908  * @tc_id:	Traffic class selection (0-7)
1909  * @cfg:	Flow steering rule to remove
1910  *
1911  * Return:	'0' on Success; Error code otherwise.
1912  */
1913 int dpni_remove_fs_entry(struct fsl_mc_io *mc_io,
1914 			 u32 cmd_flags,
1915 			 u16 token,
1916 			 u8 tc_id,
1917 			 const struct dpni_rule_cfg *cfg)
1918 {
1919 	struct dpni_cmd_remove_fs_entry *cmd_params;
1920 	struct fsl_mc_command cmd = { 0 };
1921 
1922 	/* prepare command */
1923 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_FS_ENT,
1924 					  cmd_flags,
1925 					  token);
1926 	cmd_params = (struct dpni_cmd_remove_fs_entry *)cmd.params;
1927 	cmd_params->tc_id = tc_id;
1928 	cmd_params->key_size = cfg->key_size;
1929 	cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
1930 	cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
1931 
1932 	/* send command to mc*/
1933 	return mc_send_command(mc_io, &cmd);
1934 }
1935 
1936 /**
1937  * dpni_set_qos_table() - Set QoS mapping table
1938  * @mc_io:	Pointer to MC portal's I/O object
1939  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1940  * @token:	Token of DPNI object
1941  * @cfg:	QoS table configuration
1942  *
1943  * This function and all QoS-related functions require that
1944  *'max_tcs > 1' was set at DPNI creation.
1945  *
1946  * warning: Before calling this function, call dpkg_prepare_key_cfg() to
1947  *			prepare the key_cfg_iova parameter
1948  *
1949  * Return:	'0' on Success; Error code otherwise.
1950  */
1951 int dpni_set_qos_table(struct fsl_mc_io *mc_io,
1952 		       u32 cmd_flags,
1953 		       u16 token,
1954 		       const struct dpni_qos_tbl_cfg *cfg)
1955 {
1956 	struct dpni_cmd_set_qos_table *cmd_params;
1957 	struct fsl_mc_command cmd = { 0 };
1958 
1959 	/* prepare command */
1960 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QOS_TBL,
1961 					  cmd_flags,
1962 					  token);
1963 	cmd_params = (struct dpni_cmd_set_qos_table *)cmd.params;
1964 	cmd_params->default_tc = cfg->default_tc;
1965 	cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1966 	dpni_set_field(cmd_params->discard_on_miss, DISCARD_ON_MISS,
1967 		       cfg->discard_on_miss);
1968 
1969 	/* send command to mc*/
1970 	return mc_send_command(mc_io, &cmd);
1971 }
1972 
1973 /**
1974  * dpni_add_qos_entry() - Add QoS mapping entry (to select a traffic class)
1975  * @mc_io:	Pointer to MC portal's I/O object
1976  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
1977  * @token:	Token of DPNI object
1978  * @cfg:	QoS rule to add
1979  * @tc_id:	Traffic class selection (0-7)
1980  * @index:	Location in the QoS table where to insert the entry.
1981  *		Only relevant if MASKING is enabled for QoS classification on
1982  *		this DPNI, it is ignored for exact match.
1983  *
1984  * Return:	'0' on Success; Error code otherwise.
1985  */
1986 int dpni_add_qos_entry(struct fsl_mc_io *mc_io,
1987 		       u32 cmd_flags,
1988 		       u16 token,
1989 		       const struct dpni_rule_cfg *cfg,
1990 		       u8 tc_id,
1991 		       u16 index)
1992 {
1993 	struct dpni_cmd_add_qos_entry *cmd_params;
1994 	struct fsl_mc_command cmd = { 0 };
1995 
1996 	/* prepare command */
1997 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_QOS_ENT,
1998 					  cmd_flags,
1999 					  token);
2000 	cmd_params = (struct dpni_cmd_add_qos_entry *)cmd.params;
2001 	cmd_params->tc_id = tc_id;
2002 	cmd_params->key_size = cfg->key_size;
2003 	cmd_params->index = cpu_to_le16(index);
2004 	cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
2005 	cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
2006 
2007 	/* send command to mc*/
2008 	return mc_send_command(mc_io, &cmd);
2009 }
2010 
2011 /**
2012  * dpni_remove_qos_entry() - Remove QoS mapping entry
2013  * @mc_io:	Pointer to MC portal's I/O object
2014  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
2015  * @token:	Token of DPNI object
2016  * @cfg:	QoS rule to remove
2017  *
2018  * Return:	'0' on Success; Error code otherwise.
2019  */
2020 int dpni_remove_qos_entry(struct fsl_mc_io *mc_io,
2021 			  u32 cmd_flags,
2022 			  u16 token,
2023 			  const struct dpni_rule_cfg *cfg)
2024 {
2025 	struct dpni_cmd_remove_qos_entry *cmd_params;
2026 	struct fsl_mc_command cmd = { 0 };
2027 
2028 	/* prepare command */
2029 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_QOS_ENT,
2030 					  cmd_flags,
2031 					  token);
2032 	cmd_params = (struct dpni_cmd_remove_qos_entry *)cmd.params;
2033 	cmd_params->key_size = cfg->key_size;
2034 	cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
2035 	cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
2036 
2037 	/* send command to mc*/
2038 	return mc_send_command(mc_io, &cmd);
2039 }
2040 
2041 /**
2042  * dpni_clear_qos_table() - Clear all QoS mapping entries
2043  * @mc_io:	Pointer to MC portal's I/O object
2044  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
2045  * @token:	Token of DPNI object
2046  *
2047  * Following this function call, all frames are directed to
2048  * the default traffic class (0)
2049  *
2050  * Return:	'0' on Success; Error code otherwise.
2051  */
2052 int dpni_clear_qos_table(struct fsl_mc_io *mc_io,
2053 			 u32 cmd_flags,
2054 			 u16 token)
2055 {
2056 	struct fsl_mc_command cmd = { 0 };
2057 
2058 	/* prepare command */
2059 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLR_QOS_TBL,
2060 					  cmd_flags,
2061 					  token);
2062 
2063 	/* send command to mc*/
2064 	return mc_send_command(mc_io, &cmd);
2065 }
2066 
2067 /**
2068  * dpni_set_tx_shaping() - Set the transmit shaping
2069  * @mc_io:		Pointer to MC portal's I/O object
2070  * @cmd_flags:		Command flags; one or more of 'MC_CMD_FLAG_'
2071  * @token:		Token of DPNI object
2072  * @tx_cr_shaper:	TX committed rate shaping configuration
2073  * @tx_er_shaper:	TX excess rate shaping configuration
2074  * @coupled:		Committed and excess rate shapers are coupled
2075  *
2076  * Return:	'0' on Success; Error code otherwise.
2077  */
2078 int dpni_set_tx_shaping(struct fsl_mc_io *mc_io,
2079 			u32 cmd_flags,
2080 			u16 token,
2081 			const struct dpni_tx_shaping_cfg *tx_cr_shaper,
2082 			const struct dpni_tx_shaping_cfg *tx_er_shaper,
2083 			int coupled)
2084 {
2085 	struct dpni_cmd_set_tx_shaping *cmd_params;
2086 	struct fsl_mc_command cmd = { 0 };
2087 
2088 	/* prepare command */
2089 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_SHAPING,
2090 					  cmd_flags,
2091 					  token);
2092 	cmd_params = (struct dpni_cmd_set_tx_shaping *)cmd.params;
2093 	cmd_params->tx_cr_max_burst_size = cpu_to_le16(tx_cr_shaper->max_burst_size);
2094 	cmd_params->tx_er_max_burst_size = cpu_to_le16(tx_er_shaper->max_burst_size);
2095 	cmd_params->tx_cr_rate_limit = cpu_to_le32(tx_cr_shaper->rate_limit);
2096 	cmd_params->tx_er_rate_limit = cpu_to_le32(tx_er_shaper->rate_limit);
2097 	dpni_set_field(cmd_params->coupled, COUPLED, coupled);
2098 
2099 	/* send command to mc*/
2100 	return mc_send_command(mc_io, &cmd);
2101 }
2102 
2103 /**
2104  * dpni_get_single_step_cfg() - return current configuration for
2105  *                              single step PTP
2106  * @mc_io:	Pointer to MC portal's I/O object
2107  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
2108  * @token:	Token of DPNI object
2109  * @ptp_cfg:	ptp single step configuration
2110  *
2111  * Return:	'0' on Success; Error code otherwise.
2112  *
2113  */
2114 int dpni_get_single_step_cfg(struct fsl_mc_io *mc_io,
2115 			     u32 cmd_flags,
2116 			     u16 token,
2117 			     struct dpni_single_step_cfg *ptp_cfg)
2118 {
2119 	struct dpni_rsp_single_step_cfg *rsp_params;
2120 	struct fsl_mc_command cmd = { 0 };
2121 	int err;
2122 
2123 	/* prepare command */
2124 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_SINGLE_STEP_CFG,
2125 					  cmd_flags, token);
2126 	/* send command to mc*/
2127 	err =  mc_send_command(mc_io, &cmd);
2128 	if (err)
2129 		return err;
2130 
2131 	/* read command response */
2132 	rsp_params = (struct dpni_rsp_single_step_cfg *)cmd.params;
2133 	ptp_cfg->offset = le16_to_cpu(rsp_params->offset);
2134 	ptp_cfg->en = dpni_get_field(le16_to_cpu(rsp_params->flags),
2135 				     PTP_ENABLE) ? 1 : 0;
2136 	ptp_cfg->ch_update = dpni_get_field(le16_to_cpu(rsp_params->flags),
2137 					    PTP_CH_UPDATE) ? 1 : 0;
2138 	ptp_cfg->peer_delay = le32_to_cpu(rsp_params->peer_delay);
2139 
2140 	return err;
2141 }
2142 
2143 /**
2144  * dpni_set_single_step_cfg() - enable/disable and configure single step PTP
2145  * @mc_io:	Pointer to MC portal's I/O object
2146  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
2147  * @token:	Token of DPNI object
2148  * @ptp_cfg:	ptp single step configuration
2149  *
2150  * Return:	'0' on Success; Error code otherwise.
2151  *
2152  * The function has effect only when dpni object is connected to a dpmac
2153  * object. If the dpni is not connected to a dpmac the configuration will
2154  * be stored inside and applied when connection is made.
2155  */
2156 int dpni_set_single_step_cfg(struct fsl_mc_io *mc_io,
2157 			     u32 cmd_flags,
2158 			     u16 token,
2159 			     struct dpni_single_step_cfg *ptp_cfg)
2160 {
2161 	struct dpni_cmd_single_step_cfg *cmd_params;
2162 	struct fsl_mc_command cmd = { 0 };
2163 	u16 flags;
2164 
2165 	/* prepare command */
2166 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_SINGLE_STEP_CFG,
2167 					  cmd_flags, token);
2168 	cmd_params = (struct dpni_cmd_single_step_cfg *)cmd.params;
2169 	cmd_params->offset = cpu_to_le16(ptp_cfg->offset);
2170 	cmd_params->peer_delay = cpu_to_le32(ptp_cfg->peer_delay);
2171 
2172 	flags = le16_to_cpu(cmd_params->flags);
2173 	dpni_set_field(flags, PTP_ENABLE, !!ptp_cfg->en);
2174 	dpni_set_field(flags, PTP_CH_UPDATE, !!ptp_cfg->ch_update);
2175 	cmd_params->flags = cpu_to_le16(flags);
2176 
2177 	/* send command to mc*/
2178 	return mc_send_command(mc_io, &cmd);
2179 }
2180