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