1 /* Copyright 2013-2016 Freescale Semiconductor Inc.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution.
11 * * Neither the name of the above-listed copyright holders nor the
12 * names of any contributors may be used to endorse or promote products
13 * derived from this software without specific prior written permission.
16 * ALTERNATIVELY, this software may be distributed under the terms of the
17 * GNU General Public License ("GPL") as published by the Free Software
18 * Foundation, either version 2 of that License or (at your option) any
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
33 #include <linux/kernel.h>
34 #include <linux/errno.h>
35 #include "../../fsl-mc/include/mc.h"
36 #include "../../fsl-mc/include/mc-cmd.h"
41 * dpni_prepare_key_cfg() - function prepare extract parameters
42 * @cfg: defining a full Key Generation profile (rule)
43 * @key_cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
45 * This function has to be called before the following functions:
46 * - dpni_set_rx_tc_dist()
47 * - dpni_set_qos_table()
49 int dpni_prepare_key_cfg(const struct dpkg_profile_cfg
*cfg
, u8
*key_cfg_buf
)
52 struct dpni_ext_set_rx_tc_dist
*dpni_ext
;
53 struct dpni_dist_extract
*extr
;
55 if (cfg
->num_extracts
> DPKG_MAX_NUM_OF_EXTRACTS
)
58 dpni_ext
= (struct dpni_ext_set_rx_tc_dist
*)key_cfg_buf
;
59 dpni_ext
->num_extracts
= cfg
->num_extracts
;
61 for (i
= 0; i
< cfg
->num_extracts
; i
++) {
62 extr
= &dpni_ext
->extracts
[i
];
64 switch (cfg
->extracts
[i
].type
) {
65 case DPKG_EXTRACT_FROM_HDR
:
66 extr
->prot
= cfg
->extracts
[i
].extract
.from_hdr
.prot
;
67 dpni_set_field(extr
->efh_type
, EFH_TYPE
,
68 cfg
->extracts
[i
].extract
.from_hdr
.type
);
69 extr
->size
= cfg
->extracts
[i
].extract
.from_hdr
.size
;
70 extr
->offset
= cfg
->extracts
[i
].extract
.from_hdr
.offset
;
71 extr
->field
= cpu_to_le32(
72 cfg
->extracts
[i
].extract
.from_hdr
.field
);
74 cfg
->extracts
[i
].extract
.from_hdr
.hdr_index
;
76 case DPKG_EXTRACT_FROM_DATA
:
77 extr
->size
= cfg
->extracts
[i
].extract
.from_data
.size
;
79 cfg
->extracts
[i
].extract
.from_data
.offset
;
81 case DPKG_EXTRACT_FROM_PARSE
:
82 extr
->size
= cfg
->extracts
[i
].extract
.from_parse
.size
;
84 cfg
->extracts
[i
].extract
.from_parse
.offset
;
90 extr
->num_of_byte_masks
= cfg
->extracts
[i
].num_of_byte_masks
;
91 dpni_set_field(extr
->extract_type
, EXTRACT_TYPE
,
92 cfg
->extracts
[i
].type
);
94 for (j
= 0; j
< DPKG_NUM_OF_MASKS
; j
++) {
95 extr
->masks
[j
].mask
= cfg
->extracts
[i
].masks
[j
].mask
;
96 extr
->masks
[j
].offset
=
97 cfg
->extracts
[i
].masks
[j
].offset
;
105 * dpni_open() - Open a control session for the specified object
106 * @mc_io: Pointer to MC portal's I/O object
107 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
108 * @dpni_id: DPNI unique ID
109 * @token: Returned token; use in subsequent API calls
111 * This function can be used to open a control session for an
112 * already created object; an object may have been declared in
113 * the DPL or by calling the dpni_create() function.
114 * This function returns a unique authentication token,
115 * associated with the specific object ID and the specific MC
116 * portal; this token must be used in all subsequent commands for
117 * this specific object.
119 * Return: '0' on Success; Error code otherwise.
121 int dpni_open(struct fsl_mc_io
*mc_io
,
126 struct mc_command cmd
= { 0 };
127 struct dpni_cmd_open
*cmd_params
;
131 /* prepare command */
132 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_OPEN
,
135 cmd_params
= (struct dpni_cmd_open
*)cmd
.params
;
136 cmd_params
->dpni_id
= cpu_to_le32(dpni_id
);
138 /* send command to mc*/
139 err
= mc_send_command(mc_io
, &cmd
);
143 /* retrieve response parameters */
144 *token
= mc_cmd_hdr_read_token(&cmd
);
150 * dpni_close() - Close the control session of the object
151 * @mc_io: Pointer to MC portal's I/O object
152 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
153 * @token: Token of DPNI object
155 * After this function is called, no further operations are
156 * allowed on the object without opening a new control session.
158 * Return: '0' on Success; Error code otherwise.
160 int dpni_close(struct fsl_mc_io
*mc_io
,
164 struct mc_command cmd
= { 0 };
166 /* prepare command */
167 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_CLOSE
,
171 /* send command to mc*/
172 return mc_send_command(mc_io
, &cmd
);
176 * dpni_set_pools() - Set buffer pools configuration
177 * @mc_io: Pointer to MC portal's I/O object
178 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
179 * @token: Token of DPNI object
180 * @cfg: Buffer pools configuration
182 * mandatory for DPNI operation
183 * warning:Allowed only when DPNI is disabled
185 * Return: '0' on Success; Error code otherwise.
187 int dpni_set_pools(struct fsl_mc_io
*mc_io
,
190 const struct dpni_pools_cfg
*cfg
)
192 struct mc_command cmd
= { 0 };
193 struct dpni_cmd_set_pools
*cmd_params
;
196 /* prepare command */
197 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_POOLS
,
200 cmd_params
= (struct dpni_cmd_set_pools
*)cmd
.params
;
201 cmd_params
->num_dpbp
= cfg
->num_dpbp
;
202 for (i
= 0; i
< DPNI_MAX_DPBP
; i
++) {
203 cmd_params
->dpbp_id
[i
] = cpu_to_le32(cfg
->pools
[i
].dpbp_id
);
204 cmd_params
->buffer_size
[i
] =
205 cpu_to_le16(cfg
->pools
[i
].buffer_size
);
206 cmd_params
->backup_pool_mask
|=
207 DPNI_BACKUP_POOL(cfg
->pools
[i
].backup_pool
, i
);
210 /* send command to mc*/
211 return mc_send_command(mc_io
, &cmd
);
215 * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
216 * @mc_io: Pointer to MC portal's I/O object
217 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
218 * @token: Token of DPNI object
220 * Return: '0' on Success; Error code otherwise.
222 int dpni_enable(struct fsl_mc_io
*mc_io
,
226 struct mc_command cmd
= { 0 };
228 /* prepare command */
229 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_ENABLE
,
233 /* send command to mc*/
234 return mc_send_command(mc_io
, &cmd
);
238 * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
239 * @mc_io: Pointer to MC portal's I/O object
240 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
241 * @token: Token of DPNI object
243 * Return: '0' on Success; Error code otherwise.
245 int dpni_disable(struct fsl_mc_io
*mc_io
,
249 struct mc_command cmd
= { 0 };
251 /* prepare command */
252 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_DISABLE
,
256 /* send command to mc*/
257 return mc_send_command(mc_io
, &cmd
);
261 * dpni_is_enabled() - Check if the DPNI is enabled.
262 * @mc_io: Pointer to MC portal's I/O object
263 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
264 * @token: Token of DPNI object
265 * @en: Returns '1' if object is enabled; '0' otherwise
267 * Return: '0' on Success; Error code otherwise.
269 int dpni_is_enabled(struct fsl_mc_io
*mc_io
,
274 struct mc_command cmd
= { 0 };
275 struct dpni_rsp_is_enabled
*rsp_params
;
278 /* prepare command */
279 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_IS_ENABLED
,
283 /* send command to mc*/
284 err
= mc_send_command(mc_io
, &cmd
);
288 /* retrieve response parameters */
289 rsp_params
= (struct dpni_rsp_is_enabled
*)cmd
.params
;
290 *en
= dpni_get_field(rsp_params
->enabled
, ENABLE
);
296 * dpni_reset() - Reset the DPNI, returns the object to initial state.
297 * @mc_io: Pointer to MC portal's I/O object
298 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
299 * @token: Token of DPNI object
301 * Return: '0' on Success; Error code otherwise.
303 int dpni_reset(struct fsl_mc_io
*mc_io
,
307 struct mc_command cmd
= { 0 };
309 /* prepare command */
310 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_RESET
,
314 /* send command to mc*/
315 return mc_send_command(mc_io
, &cmd
);
319 * dpni_set_irq_enable() - Set overall interrupt state.
320 * @mc_io: Pointer to MC portal's I/O object
321 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
322 * @token: Token of DPNI object
323 * @irq_index: The interrupt index to configure
324 * @en: Interrupt state: - enable = 1, disable = 0
326 * Allows GPP software to control when interrupts are generated.
327 * Each interrupt can have up to 32 causes. The enable/disable control's the
328 * overall interrupt state. if the interrupt is disabled no causes will cause
331 * Return: '0' on Success; Error code otherwise.
333 int dpni_set_irq_enable(struct fsl_mc_io
*mc_io
,
339 struct mc_command cmd
= { 0 };
340 struct dpni_cmd_set_irq_enable
*cmd_params
;
342 /* prepare command */
343 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_IRQ_ENABLE
,
346 cmd_params
= (struct dpni_cmd_set_irq_enable
*)cmd
.params
;
347 dpni_set_field(cmd_params
->enable
, ENABLE
, en
);
348 cmd_params
->irq_index
= irq_index
;
350 /* send command to mc*/
351 return mc_send_command(mc_io
, &cmd
);
355 * dpni_get_irq_enable() - Get overall interrupt state
356 * @mc_io: Pointer to MC portal's I/O object
357 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
358 * @token: Token of DPNI object
359 * @irq_index: The interrupt index to configure
360 * @en: Returned interrupt state - enable = 1, disable = 0
362 * Return: '0' on Success; Error code otherwise.
364 int dpni_get_irq_enable(struct fsl_mc_io
*mc_io
,
370 struct mc_command cmd
= { 0 };
371 struct dpni_cmd_get_irq_enable
*cmd_params
;
372 struct dpni_rsp_get_irq_enable
*rsp_params
;
376 /* prepare command */
377 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_ENABLE
,
380 cmd_params
= (struct dpni_cmd_get_irq_enable
*)cmd
.params
;
381 cmd_params
->irq_index
= irq_index
;
383 /* send command to mc*/
384 err
= mc_send_command(mc_io
, &cmd
);
388 /* retrieve response parameters */
389 rsp_params
= (struct dpni_rsp_get_irq_enable
*)cmd
.params
;
390 *en
= dpni_get_field(rsp_params
->enabled
, ENABLE
);
396 * dpni_set_irq_mask() - Set interrupt mask.
397 * @mc_io: Pointer to MC portal's I/O object
398 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
399 * @token: Token of DPNI object
400 * @irq_index: The interrupt index to configure
401 * @mask: event mask to trigger interrupt;
404 * 1 = consider event for asserting IRQ
406 * Every interrupt can have up to 32 causes and the interrupt model supports
407 * masking/unmasking each cause independently
409 * Return: '0' on Success; Error code otherwise.
411 int dpni_set_irq_mask(struct fsl_mc_io
*mc_io
,
417 struct mc_command cmd
= { 0 };
418 struct dpni_cmd_set_irq_mask
*cmd_params
;
420 /* prepare command */
421 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_IRQ_MASK
,
424 cmd_params
= (struct dpni_cmd_set_irq_mask
*)cmd
.params
;
425 cmd_params
->mask
= cpu_to_le32(mask
);
426 cmd_params
->irq_index
= irq_index
;
428 /* send command to mc*/
429 return mc_send_command(mc_io
, &cmd
);
433 * dpni_get_irq_mask() - Get interrupt mask.
434 * @mc_io: Pointer to MC portal's I/O object
435 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
436 * @token: Token of DPNI object
437 * @irq_index: The interrupt index to configure
438 * @mask: Returned event mask to trigger interrupt
440 * Every interrupt can have up to 32 causes and the interrupt model supports
441 * masking/unmasking each cause independently
443 * Return: '0' on Success; Error code otherwise.
445 int dpni_get_irq_mask(struct fsl_mc_io
*mc_io
,
451 struct mc_command cmd
= { 0 };
452 struct dpni_cmd_get_irq_mask
*cmd_params
;
453 struct dpni_rsp_get_irq_mask
*rsp_params
;
456 /* prepare command */
457 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_MASK
,
460 cmd_params
= (struct dpni_cmd_get_irq_mask
*)cmd
.params
;
461 cmd_params
->irq_index
= irq_index
;
463 /* send command to mc*/
464 err
= mc_send_command(mc_io
, &cmd
);
468 /* retrieve response parameters */
469 rsp_params
= (struct dpni_rsp_get_irq_mask
*)cmd
.params
;
470 *mask
= le32_to_cpu(rsp_params
->mask
);
476 * dpni_get_irq_status() - Get the current status of any pending interrupts.
477 * @mc_io: Pointer to MC portal's I/O object
478 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
479 * @token: Token of DPNI object
480 * @irq_index: The interrupt index to configure
481 * @status: Returned interrupts status - one bit per cause:
482 * 0 = no interrupt pending
483 * 1 = interrupt pending
485 * Return: '0' on Success; Error code otherwise.
487 int dpni_get_irq_status(struct fsl_mc_io
*mc_io
,
493 struct mc_command cmd
= { 0 };
494 struct dpni_cmd_get_irq_status
*cmd_params
;
495 struct dpni_rsp_get_irq_status
*rsp_params
;
498 /* prepare command */
499 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_STATUS
,
502 cmd_params
= (struct dpni_cmd_get_irq_status
*)cmd
.params
;
503 cmd_params
->status
= cpu_to_le32(*status
);
504 cmd_params
->irq_index
= irq_index
;
506 /* send command to mc*/
507 err
= mc_send_command(mc_io
, &cmd
);
511 /* retrieve response parameters */
512 rsp_params
= (struct dpni_rsp_get_irq_status
*)cmd
.params
;
513 *status
= le32_to_cpu(rsp_params
->status
);
519 * dpni_clear_irq_status() - Clear a pending interrupt's status
520 * @mc_io: Pointer to MC portal's I/O object
521 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
522 * @token: Token of DPNI object
523 * @irq_index: The interrupt index to configure
524 * @status: bits to clear (W1C) - one bit per cause:
526 * 1 = clear status bit
528 * Return: '0' on Success; Error code otherwise.
530 int dpni_clear_irq_status(struct fsl_mc_io
*mc_io
,
536 struct mc_command cmd
= { 0 };
537 struct dpni_cmd_clear_irq_status
*cmd_params
;
539 /* prepare command */
540 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_CLEAR_IRQ_STATUS
,
543 cmd_params
= (struct dpni_cmd_clear_irq_status
*)cmd
.params
;
544 cmd_params
->irq_index
= irq_index
;
545 cmd_params
->status
= cpu_to_le32(status
);
547 /* send command to mc*/
548 return mc_send_command(mc_io
, &cmd
);
552 * dpni_get_attributes() - Retrieve DPNI attributes.
553 * @mc_io: Pointer to MC portal's I/O object
554 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
555 * @token: Token of DPNI object
556 * @attr: Object's attributes
558 * Return: '0' on Success; Error code otherwise.
560 int dpni_get_attributes(struct fsl_mc_io
*mc_io
,
563 struct dpni_attr
*attr
)
565 struct mc_command cmd
= { 0 };
566 struct dpni_rsp_get_attr
*rsp_params
;
570 /* prepare command */
571 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_ATTR
,
575 /* send command to mc*/
576 err
= mc_send_command(mc_io
, &cmd
);
580 /* retrieve response parameters */
581 rsp_params
= (struct dpni_rsp_get_attr
*)cmd
.params
;
582 attr
->options
= le32_to_cpu(rsp_params
->options
);
583 attr
->num_queues
= rsp_params
->num_queues
;
584 attr
->num_tcs
= rsp_params
->num_tcs
;
585 attr
->mac_filter_entries
= rsp_params
->mac_filter_entries
;
586 attr
->vlan_filter_entries
= rsp_params
->vlan_filter_entries
;
587 attr
->qos_entries
= rsp_params
->qos_entries
;
588 attr
->fs_entries
= le16_to_cpu(rsp_params
->fs_entries
);
589 attr
->qos_key_size
= rsp_params
->qos_key_size
;
590 attr
->fs_key_size
= rsp_params
->fs_key_size
;
591 attr
->wriop_version
= le16_to_cpu(rsp_params
->wriop_version
);
597 * dpni_set_errors_behavior() - Set errors behavior
598 * @mc_io: Pointer to MC portal's I/O object
599 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
600 * @token: Token of DPNI object
601 * @cfg: Errors configuration
603 * this function may be called numerous times with different
606 * Return: '0' on Success; Error code otherwise.
608 int dpni_set_errors_behavior(struct fsl_mc_io
*mc_io
,
611 struct dpni_error_cfg
*cfg
)
613 struct mc_command cmd
= { 0 };
614 struct dpni_cmd_set_errors_behavior
*cmd_params
;
616 /* prepare command */
617 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR
,
620 cmd_params
= (struct dpni_cmd_set_errors_behavior
*)cmd
.params
;
621 cmd_params
->errors
= cpu_to_le32(cfg
->errors
);
622 dpni_set_field(cmd_params
->flags
, ERROR_ACTION
, cfg
->error_action
);
623 dpni_set_field(cmd_params
->flags
, FRAME_ANN
, cfg
->set_frame_annotation
);
625 /* send command to mc*/
626 return mc_send_command(mc_io
, &cmd
);
630 * dpni_get_buffer_layout() - Retrieve buffer layout attributes.
631 * @mc_io: Pointer to MC portal's I/O object
632 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
633 * @token: Token of DPNI object
634 * @qtype: Type of queue to retrieve configuration for
635 * @layout: Returns buffer layout attributes
637 * Return: '0' on Success; Error code otherwise.
639 int dpni_get_buffer_layout(struct fsl_mc_io
*mc_io
,
642 enum dpni_queue_type qtype
,
643 struct dpni_buffer_layout
*layout
)
645 struct mc_command cmd
= { 0 };
646 struct dpni_cmd_get_buffer_layout
*cmd_params
;
647 struct dpni_rsp_get_buffer_layout
*rsp_params
;
650 /* prepare command */
651 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_BUFFER_LAYOUT
,
654 cmd_params
= (struct dpni_cmd_get_buffer_layout
*)cmd
.params
;
655 cmd_params
->qtype
= qtype
;
657 /* send command to mc*/
658 err
= mc_send_command(mc_io
, &cmd
);
662 /* retrieve response parameters */
663 rsp_params
= (struct dpni_rsp_get_buffer_layout
*)cmd
.params
;
664 layout
->pass_timestamp
= dpni_get_field(rsp_params
->flags
, PASS_TS
);
665 layout
->pass_parser_result
= dpni_get_field(rsp_params
->flags
, PASS_PR
);
666 layout
->pass_frame_status
= dpni_get_field(rsp_params
->flags
, PASS_FS
);
667 layout
->private_data_size
= le16_to_cpu(rsp_params
->private_data_size
);
668 layout
->data_align
= le16_to_cpu(rsp_params
->data_align
);
669 layout
->data_head_room
= le16_to_cpu(rsp_params
->head_room
);
670 layout
->data_tail_room
= le16_to_cpu(rsp_params
->tail_room
);
676 * dpni_set_buffer_layout() - Set buffer layout configuration.
677 * @mc_io: Pointer to MC portal's I/O object
678 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
679 * @token: Token of DPNI object
680 * @qtype: Type of queue this configuration applies to
681 * @layout: Buffer layout configuration
683 * Return: '0' on Success; Error code otherwise.
685 * @warning Allowed only when DPNI is disabled
687 int dpni_set_buffer_layout(struct fsl_mc_io
*mc_io
,
690 enum dpni_queue_type qtype
,
691 const struct dpni_buffer_layout
*layout
)
693 struct mc_command cmd
= { 0 };
694 struct dpni_cmd_set_buffer_layout
*cmd_params
;
696 /* prepare command */
697 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT
,
700 cmd_params
= (struct dpni_cmd_set_buffer_layout
*)cmd
.params
;
701 cmd_params
->qtype
= qtype
;
702 cmd_params
->options
= cpu_to_le16(layout
->options
);
703 dpni_set_field(cmd_params
->flags
, PASS_TS
, layout
->pass_timestamp
);
704 dpni_set_field(cmd_params
->flags
, PASS_PR
, layout
->pass_parser_result
);
705 dpni_set_field(cmd_params
->flags
, PASS_FS
, layout
->pass_frame_status
);
706 cmd_params
->private_data_size
= cpu_to_le16(layout
->private_data_size
);
707 cmd_params
->data_align
= cpu_to_le16(layout
->data_align
);
708 cmd_params
->head_room
= cpu_to_le16(layout
->data_head_room
);
709 cmd_params
->tail_room
= cpu_to_le16(layout
->data_tail_room
);
711 /* send command to mc*/
712 return mc_send_command(mc_io
, &cmd
);
716 * dpni_set_offload() - Set DPNI offload configuration.
717 * @mc_io: Pointer to MC portal's I/O object
718 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
719 * @token: Token of DPNI object
720 * @type: Type of DPNI offload
721 * @config: Offload configuration.
722 * For checksum offloads, non-zero value enables the offload
724 * Return: '0' on Success; Error code otherwise.
726 * @warning Allowed only when DPNI is disabled
729 int dpni_set_offload(struct fsl_mc_io
*mc_io
,
732 enum dpni_offload type
,
735 struct mc_command cmd
= { 0 };
736 struct dpni_cmd_set_offload
*cmd_params
;
738 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_OFFLOAD
,
741 cmd_params
= (struct dpni_cmd_set_offload
*)cmd
.params
;
742 cmd_params
->dpni_offload
= type
;
743 cmd_params
->config
= cpu_to_le32(config
);
745 return mc_send_command(mc_io
, &cmd
);
748 int dpni_get_offload(struct fsl_mc_io
*mc_io
,
751 enum dpni_offload type
,
754 struct mc_command cmd
= { 0 };
755 struct dpni_cmd_get_offload
*cmd_params
;
756 struct dpni_rsp_get_offload
*rsp_params
;
759 /* prepare command */
760 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_OFFLOAD
,
763 cmd_params
= (struct dpni_cmd_get_offload
*)cmd
.params
;
764 cmd_params
->dpni_offload
= type
;
766 /* send command to mc*/
767 err
= mc_send_command(mc_io
, &cmd
);
771 /* retrieve response parameters */
772 rsp_params
= (struct dpni_rsp_get_offload
*)cmd
.params
;
773 *config
= le32_to_cpu(rsp_params
->config
);
779 * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
780 * for enqueue operations
781 * @mc_io: Pointer to MC portal's I/O object
782 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
783 * @token: Token of DPNI object
784 * @qtype: Type of queue to receive QDID for
785 * @qdid: Returned virtual QDID value that should be used as an argument
786 * in all enqueue operations
788 * Return: '0' on Success; Error code otherwise.
790 int dpni_get_qdid(struct fsl_mc_io
*mc_io
,
793 enum dpni_queue_type qtype
,
796 struct mc_command cmd
= { 0 };
797 struct dpni_cmd_get_qdid
*cmd_params
;
798 struct dpni_rsp_get_qdid
*rsp_params
;
801 /* prepare command */
802 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_QDID
,
805 cmd_params
= (struct dpni_cmd_get_qdid
*)cmd
.params
;
806 cmd_params
->qtype
= qtype
;
808 /* send command to mc*/
809 err
= mc_send_command(mc_io
, &cmd
);
813 /* retrieve response parameters */
814 rsp_params
= (struct dpni_rsp_get_qdid
*)cmd
.params
;
815 *qdid
= le16_to_cpu(rsp_params
->qdid
);
821 * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
822 * @mc_io: Pointer to MC portal's I/O object
823 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
824 * @token: Token of DPNI object
825 * @data_offset: Tx data offset (from start of buffer)
827 * Return: '0' on Success; Error code otherwise.
829 int dpni_get_tx_data_offset(struct fsl_mc_io
*mc_io
,
834 struct mc_command cmd
= { 0 };
835 struct dpni_rsp_get_tx_data_offset
*rsp_params
;
838 /* prepare command */
839 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET
,
843 /* send command to mc*/
844 err
= mc_send_command(mc_io
, &cmd
);
848 /* retrieve response parameters */
849 rsp_params
= (struct dpni_rsp_get_tx_data_offset
*)cmd
.params
;
850 *data_offset
= le16_to_cpu(rsp_params
->data_offset
);
856 * dpni_set_link_cfg() - set the link configuration.
857 * @mc_io: Pointer to MC portal's I/O object
858 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
859 * @token: Token of DPNI object
860 * @cfg: Link configuration
862 * Return: '0' on Success; Error code otherwise.
864 int dpni_set_link_cfg(struct fsl_mc_io
*mc_io
,
867 const struct dpni_link_cfg
*cfg
)
869 struct mc_command cmd
= { 0 };
870 struct dpni_cmd_set_link_cfg
*cmd_params
;
872 /* prepare command */
873 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG
,
876 cmd_params
= (struct dpni_cmd_set_link_cfg
*)cmd
.params
;
877 cmd_params
->rate
= cpu_to_le32(cfg
->rate
);
878 cmd_params
->options
= cpu_to_le64(cfg
->options
);
880 /* send command to mc*/
881 return mc_send_command(mc_io
, &cmd
);
885 * dpni_get_link_state() - Return the link state (either up or down)
886 * @mc_io: Pointer to MC portal's I/O object
887 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
888 * @token: Token of DPNI object
889 * @state: Returned link state;
891 * Return: '0' on Success; Error code otherwise.
893 int dpni_get_link_state(struct fsl_mc_io
*mc_io
,
896 struct dpni_link_state
*state
)
898 struct mc_command cmd
= { 0 };
899 struct dpni_rsp_get_link_state
*rsp_params
;
902 /* prepare command */
903 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE
,
907 /* send command to mc*/
908 err
= mc_send_command(mc_io
, &cmd
);
912 /* retrieve response parameters */
913 rsp_params
= (struct dpni_rsp_get_link_state
*)cmd
.params
;
914 state
->up
= dpni_get_field(rsp_params
->flags
, LINK_STATE
);
915 state
->rate
= le32_to_cpu(rsp_params
->rate
);
916 state
->options
= le64_to_cpu(rsp_params
->options
);
922 * dpni_set_max_frame_length() - Set the maximum received frame length.
923 * @mc_io: Pointer to MC portal's I/O object
924 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
925 * @token: Token of DPNI object
926 * @max_frame_length: Maximum received frame length (in
927 * bytes); frame is discarded if its
928 * length exceeds this value
930 * Return: '0' on Success; Error code otherwise.
932 int dpni_set_max_frame_length(struct fsl_mc_io
*mc_io
,
935 u16 max_frame_length
)
937 struct mc_command cmd
= { 0 };
938 struct dpni_cmd_set_max_frame_length
*cmd_params
;
940 /* prepare command */
941 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_MAX_FRAME_LENGTH
,
944 cmd_params
= (struct dpni_cmd_set_max_frame_length
*)cmd
.params
;
945 cmd_params
->max_frame_length
= cpu_to_le16(max_frame_length
);
947 /* send command to mc*/
948 return mc_send_command(mc_io
, &cmd
);
952 * dpni_get_max_frame_length() - Get the maximum received frame length.
953 * @mc_io: Pointer to MC portal's I/O object
954 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
955 * @token: Token of DPNI object
956 * @max_frame_length: Maximum received frame length (in
957 * bytes); frame is discarded if its
958 * length exceeds this value
960 * Return: '0' on Success; Error code otherwise.
962 int dpni_get_max_frame_length(struct fsl_mc_io
*mc_io
,
965 u16
*max_frame_length
)
967 struct mc_command cmd
= { 0 };
968 struct dpni_rsp_get_max_frame_length
*rsp_params
;
971 /* prepare command */
972 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_MAX_FRAME_LENGTH
,
976 /* send command to mc*/
977 err
= mc_send_command(mc_io
, &cmd
);
981 /* retrieve response parameters */
982 rsp_params
= (struct dpni_rsp_get_max_frame_length
*)cmd
.params
;
983 *max_frame_length
= le16_to_cpu(rsp_params
->max_frame_length
);
989 * dpni_set_multicast_promisc() - Enable/disable multicast promiscuous mode
990 * @mc_io: Pointer to MC portal's I/O object
991 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
992 * @token: Token of DPNI object
993 * @en: Set to '1' to enable; '0' to disable
995 * Return: '0' on Success; Error code otherwise.
997 int dpni_set_multicast_promisc(struct fsl_mc_io
*mc_io
,
1002 struct mc_command cmd
= { 0 };
1003 struct dpni_cmd_set_multicast_promisc
*cmd_params
;
1005 /* prepare command */
1006 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_MCAST_PROMISC
,
1009 cmd_params
= (struct dpni_cmd_set_multicast_promisc
*)cmd
.params
;
1010 dpni_set_field(cmd_params
->enable
, ENABLE
, en
);
1012 /* send command to mc*/
1013 return mc_send_command(mc_io
, &cmd
);
1017 * dpni_get_multicast_promisc() - Get multicast promiscuous mode
1018 * @mc_io: Pointer to MC portal's I/O object
1019 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1020 * @token: Token of DPNI object
1021 * @en: Returns '1' if enabled; '0' otherwise
1023 * Return: '0' on Success; Error code otherwise.
1025 int dpni_get_multicast_promisc(struct fsl_mc_io
*mc_io
,
1030 struct mc_command cmd
= { 0 };
1031 struct dpni_rsp_get_multicast_promisc
*rsp_params
;
1034 /* prepare command */
1035 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_MCAST_PROMISC
,
1039 /* send command to mc*/
1040 err
= mc_send_command(mc_io
, &cmd
);
1044 /* retrieve response parameters */
1045 rsp_params
= (struct dpni_rsp_get_multicast_promisc
*)cmd
.params
;
1046 *en
= dpni_get_field(rsp_params
->enabled
, ENABLE
);
1052 * dpni_set_unicast_promisc() - Enable/disable unicast promiscuous mode
1053 * @mc_io: Pointer to MC portal's I/O object
1054 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1055 * @token: Token of DPNI object
1056 * @en: Set to '1' to enable; '0' to disable
1058 * Return: '0' on Success; Error code otherwise.
1060 int dpni_set_unicast_promisc(struct fsl_mc_io
*mc_io
,
1065 struct mc_command cmd
= { 0 };
1066 struct dpni_cmd_set_unicast_promisc
*cmd_params
;
1068 /* prepare command */
1069 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_UNICAST_PROMISC
,
1072 cmd_params
= (struct dpni_cmd_set_unicast_promisc
*)cmd
.params
;
1073 dpni_set_field(cmd_params
->enable
, ENABLE
, en
);
1075 /* send command to mc*/
1076 return mc_send_command(mc_io
, &cmd
);
1080 * dpni_get_unicast_promisc() - Get unicast promiscuous mode
1081 * @mc_io: Pointer to MC portal's I/O object
1082 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1083 * @token: Token of DPNI object
1084 * @en: Returns '1' if enabled; '0' otherwise
1086 * Return: '0' on Success; Error code otherwise.
1088 int dpni_get_unicast_promisc(struct fsl_mc_io
*mc_io
,
1093 struct mc_command cmd
= { 0 };
1094 struct dpni_rsp_get_unicast_promisc
*rsp_params
;
1097 /* prepare command */
1098 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_UNICAST_PROMISC
,
1102 /* send command to mc*/
1103 err
= mc_send_command(mc_io
, &cmd
);
1107 /* retrieve response parameters */
1108 rsp_params
= (struct dpni_rsp_get_unicast_promisc
*)cmd
.params
;
1109 *en
= dpni_get_field(rsp_params
->enabled
, ENABLE
);
1115 * dpni_set_primary_mac_addr() - Set the primary MAC address
1116 * @mc_io: Pointer to MC portal's I/O object
1117 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1118 * @token: Token of DPNI object
1119 * @mac_addr: MAC address to set as primary address
1121 * Return: '0' on Success; Error code otherwise.
1123 int dpni_set_primary_mac_addr(struct fsl_mc_io
*mc_io
,
1126 const u8 mac_addr
[6])
1128 struct mc_command cmd
= { 0 };
1129 struct dpni_cmd_set_primary_mac_addr
*cmd_params
;
1132 /* prepare command */
1133 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC
,
1136 cmd_params
= (struct dpni_cmd_set_primary_mac_addr
*)cmd
.params
;
1137 for (i
= 0; i
< 6; i
++)
1138 cmd_params
->mac_addr
[i
] = mac_addr
[5 - i
];
1140 /* send command to mc*/
1141 return mc_send_command(mc_io
, &cmd
);
1145 * dpni_get_primary_mac_addr() - Get the primary MAC address
1146 * @mc_io: Pointer to MC portal's I/O object
1147 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1148 * @token: Token of DPNI object
1149 * @mac_addr: Returned MAC address
1151 * Return: '0' on Success; Error code otherwise.
1153 int dpni_get_primary_mac_addr(struct fsl_mc_io
*mc_io
,
1158 struct mc_command cmd
= { 0 };
1159 struct dpni_rsp_get_primary_mac_addr
*rsp_params
;
1162 /* prepare command */
1163 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC
,
1167 /* send command to mc*/
1168 err
= mc_send_command(mc_io
, &cmd
);
1172 /* retrieve response parameters */
1173 rsp_params
= (struct dpni_rsp_get_primary_mac_addr
*)cmd
.params
;
1174 for (i
= 0; i
< 6; i
++)
1175 mac_addr
[5 - i
] = rsp_params
->mac_addr
[i
];
1181 * dpni_get_port_mac_addr() - Retrieve MAC address associated to the physical
1182 * port the DPNI is attached to
1183 * @mc_io: Pointer to MC portal's I/O object
1184 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1185 * @token: Token of DPNI object
1186 * @mac_addr: MAC address of the physical port, if any, otherwise 0
1188 * The primary MAC address is not cleared by this operation.
1190 * Return: '0' on Success; Error code otherwise.
1192 int dpni_get_port_mac_addr(struct fsl_mc_io
*mc_io
,
1197 struct mc_command cmd
= { 0 };
1198 struct dpni_rsp_get_port_mac_addr
*rsp_params
;
1201 /* prepare command */
1202 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_PORT_MAC_ADDR
,
1206 /* send command to mc*/
1207 err
= mc_send_command(mc_io
, &cmd
);
1211 /* retrieve response parameters */
1212 rsp_params
= (struct dpni_rsp_get_port_mac_addr
*)cmd
.params
;
1213 for (i
= 0; i
< 6; i
++)
1214 mac_addr
[5 - i
] = rsp_params
->mac_addr
[i
];
1220 * dpni_add_mac_addr() - Add MAC address filter
1221 * @mc_io: Pointer to MC portal's I/O object
1222 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1223 * @token: Token of DPNI object
1224 * @mac_addr: MAC address to add
1226 * Return: '0' on Success; Error code otherwise.
1228 int dpni_add_mac_addr(struct fsl_mc_io
*mc_io
,
1231 const u8 mac_addr
[6])
1233 struct mc_command cmd
= { 0 };
1234 struct dpni_cmd_add_mac_addr
*cmd_params
;
1237 /* prepare command */
1238 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR
,
1241 cmd_params
= (struct dpni_cmd_add_mac_addr
*)cmd
.params
;
1242 for (i
= 0; i
< 6; i
++)
1243 cmd_params
->mac_addr
[i
] = mac_addr
[5 - i
];
1245 /* send command to mc*/
1246 return mc_send_command(mc_io
, &cmd
);
1250 * dpni_remove_mac_addr() - Remove MAC address filter
1251 * @mc_io: Pointer to MC portal's I/O object
1252 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1253 * @token: Token of DPNI object
1254 * @mac_addr: MAC address to remove
1256 * Return: '0' on Success; Error code otherwise.
1258 int dpni_remove_mac_addr(struct fsl_mc_io
*mc_io
,
1261 const u8 mac_addr
[6])
1263 struct mc_command cmd
= { 0 };
1264 struct dpni_cmd_remove_mac_addr
*cmd_params
;
1267 /* prepare command */
1268 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR
,
1271 cmd_params
= (struct dpni_cmd_remove_mac_addr
*)cmd
.params
;
1272 for (i
= 0; i
< 6; i
++)
1273 cmd_params
->mac_addr
[i
] = mac_addr
[5 - i
];
1275 /* send command to mc*/
1276 return mc_send_command(mc_io
, &cmd
);
1280 * dpni_clear_mac_filters() - Clear all unicast and/or multicast MAC filters
1281 * @mc_io: Pointer to MC portal's I/O object
1282 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1283 * @token: Token of DPNI object
1284 * @unicast: Set to '1' to clear unicast addresses
1285 * @multicast: Set to '1' to clear multicast addresses
1287 * The primary MAC address is not cleared by this operation.
1289 * Return: '0' on Success; Error code otherwise.
1291 int dpni_clear_mac_filters(struct fsl_mc_io
*mc_io
,
1297 struct mc_command cmd
= { 0 };
1298 struct dpni_cmd_clear_mac_filters
*cmd_params
;
1300 /* prepare command */
1301 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_CLR_MAC_FILTERS
,
1304 cmd_params
= (struct dpni_cmd_clear_mac_filters
*)cmd
.params
;
1305 dpni_set_field(cmd_params
->flags
, UNICAST_FILTERS
, unicast
);
1306 dpni_set_field(cmd_params
->flags
, MULTICAST_FILTERS
, multicast
);
1308 /* send command to mc*/
1309 return mc_send_command(mc_io
, &cmd
);
1313 * dpni_set_rx_tc_dist() - Set Rx traffic class distribution configuration
1314 * @mc_io: Pointer to MC portal's I/O object
1315 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1316 * @token: Token of DPNI object
1317 * @tc_id: Traffic class selection (0-7)
1318 * @cfg: Traffic class distribution configuration
1320 * warning: if 'dist_mode != DPNI_DIST_MODE_NONE', call dpni_prepare_key_cfg()
1321 * first to prepare the key_cfg_iova parameter
1323 * Return: '0' on Success; error code otherwise.
1325 int dpni_set_rx_tc_dist(struct fsl_mc_io
*mc_io
,
1329 const struct dpni_rx_tc_dist_cfg
*cfg
)
1331 struct mc_command cmd
= { 0 };
1332 struct dpni_cmd_set_rx_tc_dist
*cmd_params
;
1334 /* prepare command */
1335 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_RX_TC_DIST
,
1338 cmd_params
= (struct dpni_cmd_set_rx_tc_dist
*)cmd
.params
;
1339 cmd_params
->dist_size
= cpu_to_le16(cfg
->dist_size
);
1340 cmd_params
->tc_id
= tc_id
;
1341 dpni_set_field(cmd_params
->flags
, DIST_MODE
, cfg
->dist_mode
);
1342 dpni_set_field(cmd_params
->flags
, MISS_ACTION
, cfg
->fs_cfg
.miss_action
);
1343 cmd_params
->default_flow_id
= cpu_to_le16(cfg
->fs_cfg
.default_flow_id
);
1344 cmd_params
->key_cfg_iova
= cpu_to_le64(cfg
->key_cfg_iova
);
1346 /* send command to mc*/
1347 return mc_send_command(mc_io
, &cmd
);
1351 * dpni_set_queue() - Set queue parameters
1352 * @mc_io: Pointer to MC portal's I/O object
1353 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1354 * @token: Token of DPNI object
1355 * @qtype: Type of queue - all queue types are supported, although
1356 * the command is ignored for Tx
1357 * @tc: Traffic class, in range 0 to NUM_TCS - 1
1358 * @index: Selects the specific queue out of the set allocated for the
1359 * same TC. Value must be in range 0 to NUM_QUEUES - 1
1360 * @options: A combination of DPNI_QUEUE_OPT_ values that control what
1361 * configuration options are set on the queue
1362 * @queue: Queue structure
1364 * Return: '0' on Success; Error code otherwise.
1366 int dpni_set_queue(struct fsl_mc_io
*mc_io
,
1369 enum dpni_queue_type qtype
,
1373 const struct dpni_queue
*queue
)
1375 struct mc_command cmd
= { 0 };
1376 struct dpni_cmd_set_queue
*cmd_params
;
1378 /* prepare command */
1379 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE
,
1382 cmd_params
= (struct dpni_cmd_set_queue
*)cmd
.params
;
1383 cmd_params
->qtype
= qtype
;
1384 cmd_params
->tc
= tc
;
1385 cmd_params
->index
= index
;
1386 cmd_params
->options
= options
;
1387 cmd_params
->dest_id
= cpu_to_le32(queue
->destination
.id
);
1388 cmd_params
->dest_prio
= queue
->destination
.priority
;
1389 dpni_set_field(cmd_params
->flags
, DEST_TYPE
, queue
->destination
.type
);
1390 dpni_set_field(cmd_params
->flags
, STASH_CTRL
, queue
->flc
.stash_control
);
1391 dpni_set_field(cmd_params
->flags
, HOLD_ACTIVE
,
1392 queue
->destination
.hold_active
);
1393 cmd_params
->flc
= cpu_to_le64(queue
->flc
.value
);
1394 cmd_params
->user_context
= cpu_to_le64(queue
->user_context
);
1396 /* send command to mc */
1397 return mc_send_command(mc_io
, &cmd
);
1401 * dpni_get_queue() - Get queue parameters
1402 * @mc_io: Pointer to MC portal's I/O object
1403 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1404 * @token: Token of DPNI object
1405 * @qtype: Type of queue - all queue types are supported
1406 * @tc: Traffic class, in range 0 to NUM_TCS - 1
1407 * @index: Selects the specific queue out of the set allocated for the
1408 * same TC. Value must be in range 0 to NUM_QUEUES - 1
1409 * @queue: Queue configuration structure
1410 * @qid: Queue identification
1412 * Return: '0' on Success; Error code otherwise.
1414 int dpni_get_queue(struct fsl_mc_io
*mc_io
,
1417 enum dpni_queue_type qtype
,
1420 struct dpni_queue
*queue
,
1421 struct dpni_queue_id
*qid
)
1423 struct mc_command cmd
= { 0 };
1424 struct dpni_cmd_get_queue
*cmd_params
;
1425 struct dpni_rsp_get_queue
*rsp_params
;
1428 /* prepare command */
1429 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE
,
1432 cmd_params
= (struct dpni_cmd_get_queue
*)cmd
.params
;
1433 cmd_params
->qtype
= qtype
;
1434 cmd_params
->tc
= tc
;
1435 cmd_params
->index
= index
;
1437 /* send command to mc */
1438 err
= mc_send_command(mc_io
, &cmd
);
1442 /* retrieve response parameters */
1443 rsp_params
= (struct dpni_rsp_get_queue
*)cmd
.params
;
1444 queue
->destination
.id
= le32_to_cpu(rsp_params
->dest_id
);
1445 queue
->destination
.priority
= rsp_params
->dest_prio
;
1446 queue
->destination
.type
= dpni_get_field(rsp_params
->flags
,
1448 queue
->flc
.stash_control
= dpni_get_field(rsp_params
->flags
,
1450 queue
->destination
.hold_active
= dpni_get_field(rsp_params
->flags
,
1452 queue
->flc
.value
= le64_to_cpu(rsp_params
->flc
);
1453 queue
->user_context
= le64_to_cpu(rsp_params
->user_context
);
1454 qid
->fqid
= le32_to_cpu(rsp_params
->fqid
);
1455 qid
->qdbin
= le16_to_cpu(rsp_params
->qdbin
);
1461 * dpni_get_statistics() - Get DPNI statistics
1462 * @mc_io: Pointer to MC portal's I/O object
1463 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1464 * @token: Token of DPNI object
1465 * @page: Selects the statistics page to retrieve, see
1466 * DPNI_GET_STATISTICS output. Pages are numbered 0 to 2.
1467 * @stat: Structure containing the statistics
1469 * Return: '0' on Success; Error code otherwise.
1471 int dpni_get_statistics(struct fsl_mc_io
*mc_io
,
1475 union dpni_statistics
*stat
)
1477 struct mc_command cmd
= { 0 };
1478 struct dpni_cmd_get_statistics
*cmd_params
;
1479 struct dpni_rsp_get_statistics
*rsp_params
;
1482 /* prepare command */
1483 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS
,
1486 cmd_params
= (struct dpni_cmd_get_statistics
*)cmd
.params
;
1487 cmd_params
->page_number
= page
;
1489 /* send command to mc */
1490 err
= mc_send_command(mc_io
, &cmd
);
1494 /* retrieve response parameters */
1495 rsp_params
= (struct dpni_rsp_get_statistics
*)cmd
.params
;
1496 for (i
= 0; i
< DPNI_STATISTICS_CNT
; i
++)
1497 stat
->raw
.counter
[i
] = le64_to_cpu(rsp_params
->counter
[i
]);
1503 * dpni_set_taildrop() - Set taildrop per queue or TC
1504 * @mc_io: Pointer to MC portal's I/O object
1505 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1506 * @token: Token of DPNI object
1507 * @cg_point: Congestion point
1508 * @q_type: Queue type on which the taildrop is configured.
1509 * Only Rx queues are supported for now
1510 * @tc: Traffic class to apply this taildrop to
1511 * @q_index: Index of the queue if the DPNI supports multiple queues for
1512 * traffic distribution. Ignored if CONGESTION_POINT is not 0.
1513 * @taildrop: Taildrop structure
1515 * Return: '0' on Success; Error code otherwise.
1517 int dpni_set_taildrop(struct fsl_mc_io
*mc_io
,
1520 enum dpni_congestion_point cg_point
,
1521 enum dpni_queue_type qtype
,
1524 struct dpni_taildrop
*taildrop
)
1526 struct mc_command cmd
= { 0 };
1527 struct dpni_cmd_set_taildrop
*cmd_params
;
1529 /* prepare command */
1530 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_SET_TAILDROP
,
1533 cmd_params
= (struct dpni_cmd_set_taildrop
*)cmd
.params
;
1534 cmd_params
->congestion_point
= cg_point
;
1535 cmd_params
->qtype
= qtype
;
1536 cmd_params
->tc
= tc
;
1537 cmd_params
->index
= index
;
1538 dpni_set_field(cmd_params
->enable
, ENABLE
, taildrop
->enable
);
1539 cmd_params
->units
= taildrop
->units
;
1540 cmd_params
->threshold
= cpu_to_le32(taildrop
->threshold
);
1542 /* send command to mc */
1543 return mc_send_command(mc_io
, &cmd
);
1547 * dpni_get_taildrop() - Get taildrop information
1548 * @mc_io: Pointer to MC portal's I/O object
1549 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1550 * @token: Token of DPNI object
1551 * @cg_point: Congestion point
1552 * @q_type: Queue type on which the taildrop is configured.
1553 * Only Rx queues are supported for now
1554 * @tc: Traffic class to apply this taildrop to
1555 * @q_index: Index of the queue if the DPNI supports multiple queues for
1556 * traffic distribution. Ignored if CONGESTION_POINT is not 0.
1557 * @taildrop: Taildrop structure
1559 * Return: '0' on Success; Error code otherwise.
1561 int dpni_get_taildrop(struct fsl_mc_io
*mc_io
,
1564 enum dpni_congestion_point cg_point
,
1565 enum dpni_queue_type qtype
,
1568 struct dpni_taildrop
*taildrop
)
1570 struct mc_command cmd
= { 0 };
1571 struct dpni_cmd_get_taildrop
*cmd_params
;
1572 struct dpni_rsp_get_taildrop
*rsp_params
;
1575 /* prepare command */
1576 cmd
.header
= mc_encode_cmd_header(DPNI_CMDID_GET_TAILDROP
,
1579 cmd_params
= (struct dpni_cmd_get_taildrop
*)cmd
.params
;
1580 cmd_params
->congestion_point
= cg_point
;
1581 cmd_params
->qtype
= qtype
;
1582 cmd_params
->tc
= tc
;
1583 cmd_params
->index
= index
;
1585 /* send command to mc */
1586 err
= mc_send_command(mc_io
, &cmd
);
1590 /* retrieve response parameters */
1591 rsp_params
= (struct dpni_rsp_get_taildrop
*)cmd
.params
;
1592 taildrop
->enable
= dpni_get_field(rsp_params
->enable
, ENABLE
);
1593 taildrop
->units
= rsp_params
->units
;
1594 taildrop
->threshold
= le32_to_cpu(rsp_params
->threshold
);