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