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