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