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