1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0) 2 * 3 * Copyright 2013-2016 Freescale Semiconductor Inc. 4 * Copyright 2018-2021 NXP 5 * 6 */ 7 #include <fsl_mc_sys.h> 8 #include <fsl_mc_cmd.h> 9 #include <fsl_dpdmux.h> 10 #include <fsl_dpdmux_cmd.h> 11 12 /** @addtogroup dpdmux 13 * @{ 14 */ 15 16 /** 17 * dpdmux_open() - Open a control session for the specified object 18 * @mc_io: Pointer to MC portal's I/O object 19 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 20 * @dpdmux_id: DPDMUX unique ID 21 * @token: Returned token; use in subsequent API calls 22 * 23 * This function can be used to open a control session for an 24 * already created object; an object may have been declared in 25 * the DPL or by calling the dpdmux_create() function. 26 * This function returns a unique authentication token, 27 * associated with the specific object ID and the specific MC 28 * portal; this token must be used in all subsequent commands for 29 * this specific object. 30 * 31 * Return: '0' on Success; Error code otherwise. 32 */ 33 int dpdmux_open(struct fsl_mc_io *mc_io, 34 uint32_t cmd_flags, 35 int dpdmux_id, 36 uint16_t *token) 37 { 38 struct mc_command cmd = { 0 }; 39 struct dpdmux_cmd_open *cmd_params; 40 int err; 41 42 /* prepare command */ 43 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_OPEN, 44 cmd_flags, 45 0); 46 cmd_params = (struct dpdmux_cmd_open *)cmd.params; 47 cmd_params->dpdmux_id = cpu_to_le32(dpdmux_id); 48 49 /* send command to mc*/ 50 err = mc_send_command(mc_io, &cmd); 51 if (err) 52 return err; 53 54 /* retrieve response parameters */ 55 *token = mc_cmd_hdr_read_token(&cmd); 56 57 return 0; 58 } 59 60 /** 61 * dpdmux_close() - Close the control session of the object 62 * @mc_io: Pointer to MC portal's I/O object 63 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 64 * @token: Token of DPDMUX object 65 * 66 * After this function is called, no further operations are 67 * allowed on the object without opening a new control session. 68 * 69 * Return: '0' on Success; Error code otherwise. 70 */ 71 int dpdmux_close(struct fsl_mc_io *mc_io, 72 uint32_t cmd_flags, 73 uint16_t token) 74 { 75 struct mc_command cmd = { 0 }; 76 77 /* prepare command */ 78 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_CLOSE, 79 cmd_flags, 80 token); 81 82 /* send command to mc*/ 83 return mc_send_command(mc_io, &cmd); 84 } 85 86 /** 87 * dpdmux_create() - Create the DPDMUX object 88 * @mc_io: Pointer to MC portal's I/O object 89 * @dprc_token: Parent container token; '0' for default container 90 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 91 * @cfg: Configuration structure 92 * @obj_id: returned object id 93 * 94 * Create the DPDMUX object, allocate required resources and 95 * perform required initialization. 96 * 97 * The object can be created either by declaring it in the 98 * DPL file, or by calling this function. 99 * 100 * The function accepts an authentication token of a parent 101 * container that this object should be assigned to. The token 102 * can be '0' so the object will be assigned to the default container. 103 * The newly created object can be opened with the returned 104 * object id and using the container's associated tokens and MC portals. 105 * 106 * Return: '0' on Success; Error code otherwise. 107 */ 108 int dpdmux_create(struct fsl_mc_io *mc_io, 109 uint16_t dprc_token, 110 uint32_t cmd_flags, 111 const struct dpdmux_cfg *cfg, 112 uint32_t *obj_id) 113 { 114 struct mc_command cmd = { 0 }; 115 struct dpdmux_cmd_create *cmd_params; 116 int err; 117 118 /* prepare command */ 119 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_CREATE, 120 cmd_flags, 121 dprc_token); 122 cmd_params = (struct dpdmux_cmd_create *)cmd.params; 123 cmd_params->method = cfg->method; 124 cmd_params->manip = cfg->manip; 125 cmd_params->num_ifs = cpu_to_le16(cfg->num_ifs); 126 cmd_params->default_if = cpu_to_le16(cfg->default_if); 127 cmd_params->adv_max_dmat_entries = 128 cpu_to_le16(cfg->adv.max_dmat_entries); 129 cmd_params->adv_max_mc_groups = cpu_to_le16(cfg->adv.max_mc_groups); 130 cmd_params->adv_max_vlan_ids = cpu_to_le16(cfg->adv.max_vlan_ids); 131 cmd_params->mem_size = cpu_to_le16(cfg->adv.mem_size); 132 cmd_params->options = cpu_to_le64(cfg->adv.options); 133 134 /* send command to mc*/ 135 err = mc_send_command(mc_io, &cmd); 136 if (err) 137 return err; 138 139 /* retrieve response parameters */ 140 *obj_id = mc_cmd_read_object_id(&cmd); 141 142 return 0; 143 } 144 145 /** 146 * dpdmux_destroy() - Destroy the DPDMUX object and release all its resources. 147 * @mc_io: Pointer to MC portal's I/O object 148 * @dprc_token: Parent container token; '0' for default container 149 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 150 * @object_id: The object id; it must be a valid id within the container that 151 * created this object; 152 * 153 * The function accepts the authentication token of the parent container that 154 * created the object (not the one that currently owns the object). The object 155 * is searched within parent using the provided 'object_id'. 156 * All tokens to the object must be closed before calling destroy. 157 * 158 * Return: '0' on Success; error code otherwise. 159 */ 160 int dpdmux_destroy(struct fsl_mc_io *mc_io, 161 uint16_t dprc_token, 162 uint32_t cmd_flags, 163 uint32_t object_id) 164 { 165 struct mc_command cmd = { 0 }; 166 struct dpdmux_cmd_destroy *cmd_params; 167 168 /* prepare command */ 169 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_DESTROY, 170 cmd_flags, 171 dprc_token); 172 cmd_params = (struct dpdmux_cmd_destroy *)cmd.params; 173 cmd_params->dpdmux_id = cpu_to_le32(object_id); 174 175 /* send command to mc*/ 176 return mc_send_command(mc_io, &cmd); 177 } 178 179 /** 180 * dpdmux_enable() - Enable DPDMUX functionality 181 * @mc_io: Pointer to MC portal's I/O object 182 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 183 * @token: Token of DPDMUX object 184 * 185 * Return: '0' on Success; Error code otherwise. 186 */ 187 int dpdmux_enable(struct fsl_mc_io *mc_io, 188 uint32_t cmd_flags, 189 uint16_t token) 190 { 191 struct mc_command cmd = { 0 }; 192 193 /* prepare command */ 194 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_ENABLE, 195 cmd_flags, 196 token); 197 198 /* send command to mc*/ 199 return mc_send_command(mc_io, &cmd); 200 } 201 202 /** 203 * dpdmux_disable() - Disable DPDMUX functionality 204 * @mc_io: Pointer to MC portal's I/O object 205 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 206 * @token: Token of DPDMUX object 207 * 208 * Return: '0' on Success; Error code otherwise. 209 */ 210 int dpdmux_disable(struct fsl_mc_io *mc_io, 211 uint32_t cmd_flags, 212 uint16_t token) 213 { 214 struct mc_command cmd = { 0 }; 215 216 /* prepare command */ 217 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_DISABLE, 218 cmd_flags, 219 token); 220 221 /* send command to mc*/ 222 return mc_send_command(mc_io, &cmd); 223 } 224 225 /** 226 * dpdmux_is_enabled() - Check if the DPDMUX is enabled. 227 * @mc_io: Pointer to MC portal's I/O object 228 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 229 * @token: Token of DPDMUX object 230 * @en: Returns '1' if object is enabled; '0' otherwise 231 * 232 * Return: '0' on Success; Error code otherwise. 233 */ 234 int dpdmux_is_enabled(struct fsl_mc_io *mc_io, 235 uint32_t cmd_flags, 236 uint16_t token, 237 int *en) 238 { 239 struct mc_command cmd = { 0 }; 240 struct dpdmux_rsp_is_enabled *rsp_params; 241 int err; 242 243 /* prepare command */ 244 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IS_ENABLED, 245 cmd_flags, 246 token); 247 248 /* send command to mc*/ 249 err = mc_send_command(mc_io, &cmd); 250 if (err) 251 return err; 252 253 /* retrieve response parameters */ 254 rsp_params = (struct dpdmux_rsp_is_enabled *)cmd.params; 255 *en = dpdmux_get_field(rsp_params->en, ENABLE); 256 257 return 0; 258 } 259 260 /** 261 * dpdmux_reset() - Reset the DPDMUX, returns the object to initial state. 262 * @mc_io: Pointer to MC portal's I/O object 263 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 264 * @token: Token of DPDMUX object 265 * 266 * Return: '0' on Success; Error code otherwise. 267 */ 268 int dpdmux_reset(struct fsl_mc_io *mc_io, 269 uint32_t cmd_flags, 270 uint16_t token) 271 { 272 struct mc_command cmd = { 0 }; 273 274 /* prepare command */ 275 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_RESET, 276 cmd_flags, 277 token); 278 279 /* send command to mc*/ 280 return mc_send_command(mc_io, &cmd); 281 } 282 283 /** 284 * dpdmux_set_resetable() - Set overall resetable DPDMUX parameters. 285 * @mc_io: Pointer to MC portal's I/O object 286 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 287 * @token: Token of DPDMUX object 288 * @skip_reset_flags: By default all are 0. 289 * By setting 1 will deactivate the reset. 290 * The flags are: 291 * DPDMUX_SKIP_DEFAULT_INTERFACE 0x01 292 * DPDMUX_SKIP_UNICAST_RULES 0x02 293 * DPDMUX_SKIP_MULTICAST_RULES 0x04 294 * 295 * For example, by default, through DPDMUX_RESET the default 296 * interface will be restored with the one from create. 297 * By setting DPDMUX_SKIP_DEFAULT_INTERFACE flag, 298 * through DPDMUX_RESET the default interface will not be modified. 299 * 300 * Return: '0' on Success; Error code otherwise. 301 */ 302 int dpdmux_set_resetable(struct fsl_mc_io *mc_io, 303 uint32_t cmd_flags, 304 uint16_t token, 305 uint8_t skip_reset_flags) 306 { 307 struct mc_command cmd = { 0 }; 308 struct dpdmux_cmd_set_skip_reset_flags *cmd_params; 309 310 /* prepare command */ 311 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_RESETABLE, 312 cmd_flags, 313 token); 314 cmd_params = (struct dpdmux_cmd_set_skip_reset_flags *)cmd.params; 315 dpdmux_set_field(cmd_params->skip_reset_flags, 316 SKIP_RESET_FLAGS, 317 skip_reset_flags); 318 319 /* send command to mc*/ 320 return mc_send_command(mc_io, &cmd); 321 } 322 323 /** 324 * dpdmux_get_resetable() - Get overall resetable parameters. 325 * @mc_io: Pointer to MC portal's I/O object 326 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 327 * @token: Token of DPDMUX object 328 * @skip_reset_flags: Get the reset flags. 329 * 330 * The flags are: 331 * DPDMUX_SKIP_DEFAULT_INTERFACE 0x01 332 * DPDMUX_SKIP_UNICAST_RULES 0x02 333 * DPDMUX_SKIP_MULTICAST_RULES 0x04 334 * 335 * Return: '0' on Success; Error code otherwise. 336 */ 337 int dpdmux_get_resetable(struct fsl_mc_io *mc_io, 338 uint32_t cmd_flags, 339 uint16_t token, 340 uint8_t *skip_reset_flags) 341 { 342 struct mc_command cmd = { 0 }; 343 struct dpdmux_rsp_get_skip_reset_flags *rsp_params; 344 int err; 345 346 /* prepare command */ 347 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_RESETABLE, 348 cmd_flags, 349 token); 350 351 /* send command to mc*/ 352 err = mc_send_command(mc_io, &cmd); 353 if (err) 354 return err; 355 356 /* retrieve response parameters */ 357 rsp_params = (struct dpdmux_rsp_get_skip_reset_flags *)cmd.params; 358 *skip_reset_flags = dpdmux_get_field(rsp_params->skip_reset_flags, 359 SKIP_RESET_FLAGS); 360 361 return 0; 362 } 363 364 /** 365 * dpdmux_get_attributes() - Retrieve DPDMUX attributes 366 * @mc_io: Pointer to MC portal's I/O object 367 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 368 * @token: Token of DPDMUX object 369 * @attr: Returned object's attributes 370 * 371 * Return: '0' on Success; Error code otherwise. 372 */ 373 int dpdmux_get_attributes(struct fsl_mc_io *mc_io, 374 uint32_t cmd_flags, 375 uint16_t token, 376 struct dpdmux_attr *attr) 377 { 378 struct mc_command cmd = { 0 }; 379 struct dpdmux_rsp_get_attr *rsp_params; 380 int err; 381 382 /* prepare command */ 383 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_ATTR, 384 cmd_flags, 385 token); 386 387 /* send command to mc*/ 388 err = mc_send_command(mc_io, &cmd); 389 if (err) 390 return err; 391 392 /* retrieve response parameters */ 393 rsp_params = (struct dpdmux_rsp_get_attr *)cmd.params; 394 attr->id = le32_to_cpu(rsp_params->id); 395 attr->options = le64_to_cpu(rsp_params->options); 396 attr->method = rsp_params->method; 397 attr->manip = rsp_params->manip; 398 attr->num_ifs = le16_to_cpu(rsp_params->num_ifs); 399 attr->mem_size = le16_to_cpu(rsp_params->mem_size); 400 attr->default_if = le16_to_cpu(rsp_params->default_if); 401 402 return 0; 403 } 404 405 /** 406 * dpdmux_if_enable() - Enable Interface 407 * @mc_io: Pointer to MC portal's I/O object 408 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 409 * @token: Token of DPDMUX object 410 * @if_id: Interface Identifier 411 * 412 * Return: Completion status. '0' on Success; Error code otherwise. 413 */ 414 int dpdmux_if_enable(struct fsl_mc_io *mc_io, 415 uint32_t cmd_flags, 416 uint16_t token, 417 uint16_t if_id) 418 { 419 struct dpdmux_cmd_if *cmd_params; 420 struct mc_command cmd = { 0 }; 421 422 /* prepare command */ 423 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_ENABLE, 424 cmd_flags, 425 token); 426 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 427 cmd_params->if_id = cpu_to_le16(if_id); 428 429 /* send command to mc*/ 430 return mc_send_command(mc_io, &cmd); 431 } 432 433 /** 434 * dpdmux_if_disable() - Disable Interface 435 * @mc_io: Pointer to MC portal's I/O object 436 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 437 * @token: Token of DPDMUX object 438 * @if_id: Interface Identifier 439 * 440 * Return: Completion status. '0' on Success; Error code otherwise. 441 */ 442 int dpdmux_if_disable(struct fsl_mc_io *mc_io, 443 uint32_t cmd_flags, 444 uint16_t token, 445 uint16_t if_id) 446 { 447 struct dpdmux_cmd_if *cmd_params; 448 struct mc_command cmd = { 0 }; 449 450 /* prepare command */ 451 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_DISABLE, 452 cmd_flags, 453 token); 454 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 455 cmd_params->if_id = cpu_to_le16(if_id); 456 457 /* send command to mc*/ 458 return mc_send_command(mc_io, &cmd); 459 } 460 461 /** 462 * dpdmux_set_max_frame_length() - Set the maximum frame length in DPDMUX 463 * @mc_io: Pointer to MC portal's I/O object 464 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 465 * @token: Token of DPDMUX object 466 * @max_frame_length: The required maximum frame length 467 * 468 * Update the maximum frame length on all DMUX interfaces. 469 * In case of VEPA, the maximum frame length on all dmux interfaces 470 * will be updated with the minimum value of the mfls of the connected 471 * dpnis and the actual value of dmux mfl. 472 * 473 * Return: '0' on Success; Error code otherwise. 474 */ 475 int dpdmux_set_max_frame_length(struct fsl_mc_io *mc_io, 476 uint32_t cmd_flags, 477 uint16_t token, 478 uint16_t max_frame_length) 479 { 480 struct mc_command cmd = { 0 }; 481 struct dpdmux_cmd_set_max_frame_length *cmd_params; 482 483 /* prepare command */ 484 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_MAX_FRAME_LENGTH, 485 cmd_flags, 486 token); 487 cmd_params = (struct dpdmux_cmd_set_max_frame_length *)cmd.params; 488 cmd_params->max_frame_length = cpu_to_le16(max_frame_length); 489 490 /* send command to mc*/ 491 return mc_send_command(mc_io, &cmd); 492 } 493 494 /** 495 * dpdmux_get_max_frame_length() - Return the maximum frame length for DPDMUX 496 * interface 497 * @mc_io: Pointer to MC portal's I/O object 498 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 499 * @token: Token of DPDMUX object 500 * @if_id: Interface id 501 * @max_frame_length: maximum frame length 502 * 503 * When dpdmux object is in VEPA mode this function will ignore if_id parameter 504 * and will return maximum frame length for uplink interface (if_id==0). 505 * 506 * Return: '0' on Success; Error code otherwise. 507 */ 508 int dpdmux_get_max_frame_length(struct fsl_mc_io *mc_io, 509 uint32_t cmd_flags, 510 uint16_t token, 511 uint16_t if_id, 512 uint16_t *max_frame_length) 513 { 514 struct mc_command cmd = { 0 }; 515 struct dpdmux_cmd_get_max_frame_len *cmd_params; 516 struct dpdmux_rsp_get_max_frame_len *rsp_params; 517 int err = 0; 518 519 /* prepare command */ 520 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_MAX_FRAME_LENGTH, 521 cmd_flags, 522 token); 523 cmd_params = (struct dpdmux_cmd_get_max_frame_len *)cmd.params; 524 cmd_params->if_id = cpu_to_le16(if_id); 525 526 err = mc_send_command(mc_io, &cmd); 527 if (err) 528 return err; 529 530 rsp_params = (struct dpdmux_rsp_get_max_frame_len *)cmd.params; 531 *max_frame_length = le16_to_cpu(rsp_params->max_len); 532 533 /* send command to mc*/ 534 return err; 535 } 536 537 /** 538 * dpdmux_ul_reset_counters() - Function resets the uplink counter 539 * @mc_io: Pointer to MC portal's I/O object 540 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 541 * @token: Token of DPDMUX object 542 * 543 * Return: '0' on Success; Error code otherwise. 544 */ 545 int dpdmux_ul_reset_counters(struct fsl_mc_io *mc_io, 546 uint32_t cmd_flags, 547 uint16_t token) 548 { 549 struct mc_command cmd = { 0 }; 550 551 /* prepare command */ 552 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_UL_RESET_COUNTERS, 553 cmd_flags, 554 token); 555 556 /* send command to mc*/ 557 return mc_send_command(mc_io, &cmd); 558 } 559 560 /** 561 * dpdmux_if_set_accepted_frames() - Set the accepted frame types 562 * @mc_io: Pointer to MC portal's I/O object 563 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 564 * @token: Token of DPDMUX object 565 * @if_id: Interface ID (0 for uplink, or 1-num_ifs); 566 * @cfg: Frame types configuration 567 * 568 * if 'DPDMUX_ADMIT_ONLY_VLAN_TAGGED' is set - untagged frames or 569 * priority-tagged frames are discarded. 570 * if 'DPDMUX_ADMIT_ONLY_UNTAGGED' is set - untagged frames or 571 * priority-tagged frames are accepted. 572 * if 'DPDMUX_ADMIT_ALL' is set (default mode) - all VLAN tagged, 573 * untagged and priority-tagged frame are accepted; 574 * 575 * Return: '0' on Success; Error code otherwise. 576 */ 577 int dpdmux_if_set_accepted_frames(struct fsl_mc_io *mc_io, 578 uint32_t cmd_flags, 579 uint16_t token, 580 uint16_t if_id, 581 const struct dpdmux_accepted_frames *cfg) 582 { 583 struct mc_command cmd = { 0 }; 584 struct dpdmux_cmd_if_set_accepted_frames *cmd_params; 585 586 /* prepare command */ 587 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_ACCEPTED_FRAMES, 588 cmd_flags, 589 token); 590 cmd_params = (struct dpdmux_cmd_if_set_accepted_frames *)cmd.params; 591 cmd_params->if_id = cpu_to_le16(if_id); 592 dpdmux_set_field(cmd_params->frames_options, 593 ACCEPTED_FRAMES_TYPE, 594 cfg->type); 595 dpdmux_set_field(cmd_params->frames_options, 596 UNACCEPTED_FRAMES_ACTION, 597 cfg->unaccept_act); 598 599 /* send command to mc*/ 600 return mc_send_command(mc_io, &cmd); 601 } 602 603 /** 604 * dpdmux_if_get_attributes() - Obtain DPDMUX interface attributes 605 * @mc_io: Pointer to MC portal's I/O object 606 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 607 * @token: Token of DPDMUX object 608 * @if_id: Interface ID (0 for uplink, or 1-num_ifs); 609 * @attr: Interface attributes 610 * 611 * Return: '0' on Success; Error code otherwise. 612 */ 613 int dpdmux_if_get_attributes(struct fsl_mc_io *mc_io, 614 uint32_t cmd_flags, 615 uint16_t token, 616 uint16_t if_id, 617 struct dpdmux_if_attr *attr) 618 { 619 struct mc_command cmd = { 0 }; 620 struct dpdmux_cmd_if *cmd_params; 621 struct dpdmux_rsp_if_get_attr *rsp_params; 622 int err; 623 624 /* prepare command */ 625 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_ATTR, 626 cmd_flags, 627 token); 628 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 629 cmd_params->if_id = cpu_to_le16(if_id); 630 631 /* send command to mc*/ 632 err = mc_send_command(mc_io, &cmd); 633 if (err) 634 return err; 635 636 /* retrieve response parameters */ 637 rsp_params = (struct dpdmux_rsp_if_get_attr *)cmd.params; 638 attr->rate = le32_to_cpu(rsp_params->rate); 639 attr->enabled = dpdmux_get_field(rsp_params->enabled, ENABLE); 640 attr->is_default = dpdmux_get_field(rsp_params->enabled, IS_DEFAULT); 641 attr->accept_frame_type = dpdmux_get_field( 642 rsp_params->accepted_frames_type, 643 ACCEPTED_FRAMES_TYPE); 644 645 return 0; 646 } 647 648 /** 649 * dpdmux_if_remove_l2_rule() - Remove L2 rule from DPDMUX table 650 * @mc_io: Pointer to MC portal's I/O object 651 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 652 * @token: Token of DPDMUX object 653 * @if_id: Destination interface ID 654 * @rule: L2 rule 655 * 656 * Function removes a L2 rule from DPDMUX table 657 * or adds an interface to an existing multicast address 658 * 659 * Return: '0' on Success; Error code otherwise. 660 */ 661 int dpdmux_if_remove_l2_rule(struct fsl_mc_io *mc_io, 662 uint32_t cmd_flags, 663 uint16_t token, 664 uint16_t if_id, 665 const struct dpdmux_l2_rule *rule) 666 { 667 struct mc_command cmd = { 0 }; 668 struct dpdmux_cmd_if_l2_rule *cmd_params; 669 670 /* prepare command */ 671 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_REMOVE_L2_RULE, 672 cmd_flags, 673 token); 674 cmd_params = (struct dpdmux_cmd_if_l2_rule *)cmd.params; 675 cmd_params->if_id = cpu_to_le16(if_id); 676 cmd_params->vlan_id = cpu_to_le16(rule->vlan_id); 677 cmd_params->mac_addr5 = rule->mac_addr[5]; 678 cmd_params->mac_addr4 = rule->mac_addr[4]; 679 cmd_params->mac_addr3 = rule->mac_addr[3]; 680 cmd_params->mac_addr2 = rule->mac_addr[2]; 681 cmd_params->mac_addr1 = rule->mac_addr[1]; 682 cmd_params->mac_addr0 = rule->mac_addr[0]; 683 684 /* send command to mc*/ 685 return mc_send_command(mc_io, &cmd); 686 } 687 688 /** 689 * dpdmux_if_add_l2_rule() - Add L2 rule into DPDMUX table 690 * @mc_io: Pointer to MC portal's I/O object 691 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 692 * @token: Token of DPDMUX object 693 * @if_id: Destination interface ID 694 * @rule: L2 rule 695 * 696 * Function adds a L2 rule into DPDMUX table 697 * or adds an interface to an existing multicast address 698 * 699 * Return: '0' on Success; Error code otherwise. 700 */ 701 int dpdmux_if_add_l2_rule(struct fsl_mc_io *mc_io, 702 uint32_t cmd_flags, 703 uint16_t token, 704 uint16_t if_id, 705 const struct dpdmux_l2_rule *rule) 706 { 707 struct mc_command cmd = { 0 }; 708 struct dpdmux_cmd_if_l2_rule *cmd_params; 709 710 /* prepare command */ 711 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_ADD_L2_RULE, 712 cmd_flags, 713 token); 714 cmd_params = (struct dpdmux_cmd_if_l2_rule *)cmd.params; 715 cmd_params->if_id = cpu_to_le16(if_id); 716 cmd_params->vlan_id = cpu_to_le16(rule->vlan_id); 717 cmd_params->mac_addr5 = rule->mac_addr[5]; 718 cmd_params->mac_addr4 = rule->mac_addr[4]; 719 cmd_params->mac_addr3 = rule->mac_addr[3]; 720 cmd_params->mac_addr2 = rule->mac_addr[2]; 721 cmd_params->mac_addr1 = rule->mac_addr[1]; 722 cmd_params->mac_addr0 = rule->mac_addr[0]; 723 724 /* send command to mc*/ 725 return mc_send_command(mc_io, &cmd); 726 } 727 728 /** 729 * dpdmux_if_get_counter() - Functions obtains specific counter of an interface 730 * @mc_io: Pointer to MC portal's I/O object 731 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 732 * @token: Token of DPDMUX object 733 * @if_id: Interface Id 734 * @counter_type: counter type 735 * @counter: Returned specific counter information 736 * 737 * Return: '0' on Success; Error code otherwise. 738 */ 739 int dpdmux_if_get_counter(struct fsl_mc_io *mc_io, 740 uint32_t cmd_flags, 741 uint16_t token, 742 uint16_t if_id, 743 enum dpdmux_counter_type counter_type, 744 uint64_t *counter) 745 { 746 struct mc_command cmd = { 0 }; 747 struct dpdmux_cmd_if_get_counter *cmd_params; 748 struct dpdmux_rsp_if_get_counter *rsp_params; 749 int err; 750 751 /* prepare command */ 752 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_COUNTER, 753 cmd_flags, 754 token); 755 cmd_params = (struct dpdmux_cmd_if_get_counter *)cmd.params; 756 cmd_params->if_id = cpu_to_le16(if_id); 757 cmd_params->counter_type = counter_type; 758 759 /* send command to mc*/ 760 err = mc_send_command(mc_io, &cmd); 761 if (err) 762 return err; 763 764 /* retrieve response parameters */ 765 rsp_params = (struct dpdmux_rsp_if_get_counter *)cmd.params; 766 *counter = le64_to_cpu(rsp_params->counter); 767 768 return 0; 769 } 770 771 /** 772 * dpdmux_if_set_link_cfg() - set the link configuration. 773 * @mc_io: Pointer to MC portal's I/O object 774 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 775 * @token: Token of DPSW object 776 * @if_id: interface id 777 * @cfg: Link configuration 778 * 779 * Return: '0' on Success; Error code otherwise. 780 */ 781 int dpdmux_if_set_link_cfg(struct fsl_mc_io *mc_io, 782 uint32_t cmd_flags, 783 uint16_t token, 784 uint16_t if_id, 785 struct dpdmux_link_cfg *cfg) 786 { 787 struct mc_command cmd = { 0 }; 788 struct dpdmux_cmd_if_set_link_cfg *cmd_params; 789 790 /* prepare command */ 791 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_LINK_CFG, 792 cmd_flags, 793 token); 794 cmd_params = (struct dpdmux_cmd_if_set_link_cfg *)cmd.params; 795 cmd_params->if_id = cpu_to_le16(if_id); 796 cmd_params->rate = cpu_to_le32(cfg->rate); 797 cmd_params->options = cpu_to_le64(cfg->options); 798 cmd_params->advertising = cpu_to_le64(cfg->advertising); 799 800 /* send command to mc*/ 801 return mc_send_command(mc_io, &cmd); 802 } 803 804 /** 805 * dpdmux_if_get_link_state - Return the link state 806 * @mc_io: Pointer to MC portal's I/O object 807 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 808 * @token: Token of DPSW object 809 * @if_id: interface id 810 * @state: link state 811 * 812 * @returns '0' on Success; Error code otherwise. 813 */ 814 int dpdmux_if_get_link_state(struct fsl_mc_io *mc_io, 815 uint32_t cmd_flags, 816 uint16_t token, 817 uint16_t if_id, 818 struct dpdmux_link_state *state) 819 { 820 struct mc_command cmd = { 0 }; 821 struct dpdmux_cmd_if_get_link_state *cmd_params; 822 struct dpdmux_rsp_if_get_link_state *rsp_params; 823 int err; 824 825 /* prepare command */ 826 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_LINK_STATE, 827 cmd_flags, 828 token); 829 cmd_params = (struct dpdmux_cmd_if_get_link_state *)cmd.params; 830 cmd_params->if_id = cpu_to_le16(if_id); 831 832 /* send command to mc*/ 833 err = mc_send_command(mc_io, &cmd); 834 if (err) 835 return err; 836 837 /* retrieve response parameters */ 838 rsp_params = (struct dpdmux_rsp_if_get_link_state *)cmd.params; 839 state->rate = le32_to_cpu(rsp_params->rate); 840 state->options = le64_to_cpu(rsp_params->options); 841 state->up = dpdmux_get_field(rsp_params->up, UP); 842 state->state_valid = dpdmux_get_field(rsp_params->up, STATE_VALID); 843 state->supported = le64_to_cpu(rsp_params->supported); 844 state->advertising = le64_to_cpu(rsp_params->advertising); 845 846 return 0; 847 } 848 849 /** 850 * dpdmux_if_set_default - Set default interface 851 * @mc_io: Pointer to MC portal's I/O object 852 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 853 * @token: Token of DPSW object 854 * @if_id: interface id 855 * 856 * @returns '0' on Success; Error code otherwise. 857 */ 858 int dpdmux_if_set_default(struct fsl_mc_io *mc_io, 859 uint32_t cmd_flags, 860 uint16_t token, 861 uint16_t if_id) 862 { 863 struct dpdmux_cmd_if *cmd_params; 864 struct mc_command cmd = { 0 }; 865 866 /* prepare command */ 867 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_DEFAULT, 868 cmd_flags, 869 token); 870 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 871 cmd_params->if_id = cpu_to_le16(if_id); 872 873 /* send command to mc*/ 874 return mc_send_command(mc_io, &cmd); 875 } 876 877 /** 878 * dpdmux_if_get_default - Get default interface 879 * @mc_io: Pointer to MC portal's I/O object 880 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 881 * @token: Token of DPSW object 882 * @if_id: interface id 883 * 884 * @returns '0' on Success; Error code otherwise. 885 */ 886 int dpdmux_if_get_default(struct fsl_mc_io *mc_io, 887 uint32_t cmd_flags, 888 uint16_t token, 889 uint16_t *if_id) 890 { 891 struct dpdmux_cmd_if *rsp_params; 892 struct mc_command cmd = { 0 }; 893 int err; 894 895 /* prepare command */ 896 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_DEFAULT, 897 cmd_flags, 898 token); 899 900 /* send command to mc*/ 901 err = mc_send_command(mc_io, &cmd); 902 if (err) 903 return err; 904 905 /* retrieve response parameters */ 906 rsp_params = (struct dpdmux_cmd_if *)cmd.params; 907 *if_id = le16_to_cpu(rsp_params->if_id); 908 909 return 0; 910 } 911 912 /** 913 * dpdmux_set_custom_key - Set a custom classification key. 914 * 915 * This API is only available for DPDMUX instance created with 916 * DPDMUX_METHOD_CUSTOM. This API must be called before populating the 917 * classification table using dpdmux_add_custom_cls_entry. 918 * 919 * Calls to dpdmux_set_custom_key remove all existing classification entries 920 * that may have been added previously using dpdmux_add_custom_cls_entry. 921 * 922 * @mc_io: Pointer to MC portal's I/O object 923 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 924 * @token: Token of DPSW object 925 * @if_id: Interface id 926 * @key_cfg_iova: DMA address of a configuration structure set up using 927 * dpkg_prepare_key_cfg. Maximum key size is 24 bytes 928 * 929 * @returns '0' on Success; Error code otherwise. 930 */ 931 int dpdmux_set_custom_key(struct fsl_mc_io *mc_io, 932 uint32_t cmd_flags, 933 uint16_t token, 934 uint64_t key_cfg_iova) 935 { 936 struct dpdmux_set_custom_key *cmd_params; 937 struct mc_command cmd = { 0 }; 938 939 /* prepare command */ 940 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_CUSTOM_KEY, 941 cmd_flags, 942 token); 943 cmd_params = (struct dpdmux_set_custom_key *)cmd.params; 944 cmd_params->key_cfg_iova = cpu_to_le64(key_cfg_iova); 945 946 /* send command to mc*/ 947 return mc_send_command(mc_io, &cmd); 948 } 949 950 /** 951 * dpdmux_add_custom_cls_entry - Adds a custom classification entry. 952 * 953 * This API is only available for DPDMUX instances created with 954 * DPDMUX_METHOD_CUSTOM. Before calling this function a classification key 955 * composition rule must be set up using dpdmux_set_custom_key. 956 * 957 * @mc_io: Pointer to MC portal's I/O object 958 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 959 * @token: Token of DPSW object 960 * @rule: Classification rule to insert. Rules cannot be duplicated, if a 961 * matching rule already exists, the action will be replaced. 962 * @action: Action to perform for matching traffic. 963 * 964 * @returns '0' on Success; Error code otherwise. 965 */ 966 int dpdmux_add_custom_cls_entry(struct fsl_mc_io *mc_io, 967 uint32_t cmd_flags, 968 uint16_t token, 969 struct dpdmux_rule_cfg *rule, 970 struct dpdmux_cls_action *action) 971 { 972 struct dpdmux_cmd_add_custom_cls_entry *cmd_params; 973 struct mc_command cmd = { 0 }; 974 975 /* prepare command */ 976 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_ADD_CUSTOM_CLS_ENTRY, 977 cmd_flags, 978 token); 979 980 cmd_params = (struct dpdmux_cmd_add_custom_cls_entry *)cmd.params; 981 cmd_params->key_size = rule->key_size; 982 cmd_params->entry_index = rule->entry_index; 983 cmd_params->dest_if = cpu_to_le16(action->dest_if); 984 cmd_params->key_iova = cpu_to_le64(rule->key_iova); 985 cmd_params->mask_iova = cpu_to_le64(rule->mask_iova); 986 987 /* send command to mc*/ 988 return mc_send_command(mc_io, &cmd); 989 } 990 991 /** 992 * dpdmux_remove_custom_cls_entry - Removes a custom classification entry. 993 * 994 * This API is only available for DPDMUX instances created with 995 * DPDMUX_METHOD_CUSTOM. The API can be used to remove classification 996 * entries previously inserted using dpdmux_add_custom_cls_entry. 997 * 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 DPSW object 1001 * @rule: Classification rule to remove 1002 * 1003 * @returns '0' on Success; Error code otherwise. 1004 */ 1005 int dpdmux_remove_custom_cls_entry(struct fsl_mc_io *mc_io, 1006 uint32_t cmd_flags, 1007 uint16_t token, 1008 struct dpdmux_rule_cfg *rule) 1009 { 1010 struct dpdmux_cmd_remove_custom_cls_entry *cmd_params; 1011 struct mc_command cmd = { 0 }; 1012 1013 /* prepare command */ 1014 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_REMOVE_CUSTOM_CLS_ENTRY, 1015 cmd_flags, 1016 token); 1017 cmd_params = (struct dpdmux_cmd_remove_custom_cls_entry *)cmd.params; 1018 cmd_params->key_size = rule->key_size; 1019 cmd_params->key_iova = cpu_to_le64(rule->key_iova); 1020 cmd_params->mask_iova = cpu_to_le64(rule->mask_iova); 1021 1022 /* send command to mc*/ 1023 return mc_send_command(mc_io, &cmd); 1024 } 1025 1026 /** 1027 * dpdmux_get_api_version() - Get Data Path Demux API version 1028 * @mc_io: Pointer to MC portal's I/O object 1029 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1030 * @major_ver: Major version of data path demux API 1031 * @minor_ver: Minor version of data path demux API 1032 * 1033 * Return: '0' on Success; Error code otherwise. 1034 */ 1035 int dpdmux_get_api_version(struct fsl_mc_io *mc_io, 1036 uint32_t cmd_flags, 1037 uint16_t *major_ver, 1038 uint16_t *minor_ver) 1039 { 1040 struct mc_command cmd = { 0 }; 1041 struct dpdmux_rsp_get_api_version *rsp_params; 1042 int err; 1043 1044 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_API_VERSION, 1045 cmd_flags, 1046 0); 1047 1048 err = mc_send_command(mc_io, &cmd); 1049 if (err) 1050 return err; 1051 1052 rsp_params = (struct dpdmux_rsp_get_api_version *)cmd.params; 1053 *major_ver = le16_to_cpu(rsp_params->major); 1054 *minor_ver = le16_to_cpu(rsp_params->minor); 1055 1056 return 0; 1057 } 1058 1059 /** 1060 * dpdmux_if_set_errors_behavior() - Set errors behavior 1061 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1062 * @token: Token of DPSW object 1063 * @if_id: Interface Identifier 1064 * @cfg: Errors configuration 1065 * 1066 * Provides a set of frame errors that will be rejected or accepted by the 1067 * dpdmux interface. The frame with this errors will no longer be dropped by 1068 * the dpdmux interface. When frame has parsing error the distribution to 1069 * expected interface may fail. If the frame must be distributed using the 1070 * information from a header that was not parsed due errors the frame may 1071 * be discarded or end up on a default interface because needed data was not 1072 * parsed properly. 1073 * This function may be called numerous times with different error masks 1074 * 1075 * Return: '0' on Success; Error code otherwise. 1076 */ 1077 int dpdmux_if_set_errors_behavior(struct fsl_mc_io *mc_io, uint32_t cmd_flags, 1078 uint16_t token, uint16_t if_id, struct dpdmux_error_cfg *cfg) 1079 { 1080 struct mc_command cmd = { 0 }; 1081 struct dpdmux_cmd_set_errors_behavior *cmd_params; 1082 1083 /* prepare command */ 1084 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_ERRORS_BEHAVIOR, 1085 cmd_flags, 1086 token); 1087 cmd_params = (struct dpdmux_cmd_set_errors_behavior *)cmd.params; 1088 cmd_params->errors = cpu_to_le32(cfg->errors); 1089 dpdmux_set_field(cmd_params->flags, ERROR_ACTION, cfg->error_action); 1090 cmd_params->if_id = cpu_to_le16(if_id); 1091 1092 /* send command to mc*/ 1093 return mc_send_command(mc_io, &cmd); 1094 } 1095