1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0) 2 * 3 * Copyright 2013-2016 Freescale Semiconductor Inc. 4 * Copyright 2018 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->adv_max_dmat_entries = 127 cpu_to_le16(cfg->adv.max_dmat_entries); 128 cmd_params->adv_max_mc_groups = cpu_to_le16(cfg->adv.max_mc_groups); 129 cmd_params->adv_max_vlan_ids = cpu_to_le16(cfg->adv.max_vlan_ids); 130 cmd_params->options = cpu_to_le64(cfg->adv.options); 131 132 /* send command to mc*/ 133 err = mc_send_command(mc_io, &cmd); 134 if (err) 135 return err; 136 137 /* retrieve response parameters */ 138 *obj_id = mc_cmd_read_object_id(&cmd); 139 140 return 0; 141 } 142 143 /** 144 * dpdmux_destroy() - Destroy the DPDMUX object and release all its resources. 145 * @mc_io: Pointer to MC portal's I/O object 146 * @dprc_token: Parent container token; '0' for default container 147 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 148 * @object_id: The object id; it must be a valid id within the container that 149 * created this object; 150 * 151 * The function accepts the authentication token of the parent container that 152 * created the object (not the one that currently owns the object). The object 153 * is searched within parent using the provided 'object_id'. 154 * All tokens to the object must be closed before calling destroy. 155 * 156 * Return: '0' on Success; error code otherwise. 157 */ 158 int dpdmux_destroy(struct fsl_mc_io *mc_io, 159 uint16_t dprc_token, 160 uint32_t cmd_flags, 161 uint32_t object_id) 162 { 163 struct mc_command cmd = { 0 }; 164 struct dpdmux_cmd_destroy *cmd_params; 165 166 /* prepare command */ 167 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_DESTROY, 168 cmd_flags, 169 dprc_token); 170 cmd_params = (struct dpdmux_cmd_destroy *)cmd.params; 171 cmd_params->dpdmux_id = cpu_to_le32(object_id); 172 173 /* send command to mc*/ 174 return mc_send_command(mc_io, &cmd); 175 } 176 177 /** 178 * dpdmux_enable() - Enable DPDMUX functionality 179 * @mc_io: Pointer to MC portal's I/O object 180 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 181 * @token: Token of DPDMUX object 182 * 183 * Return: '0' on Success; Error code otherwise. 184 */ 185 int dpdmux_enable(struct fsl_mc_io *mc_io, 186 uint32_t cmd_flags, 187 uint16_t token) 188 { 189 struct mc_command cmd = { 0 }; 190 191 /* prepare command */ 192 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_ENABLE, 193 cmd_flags, 194 token); 195 196 /* send command to mc*/ 197 return mc_send_command(mc_io, &cmd); 198 } 199 200 /** 201 * dpdmux_disable() - Disable DPDMUX functionality 202 * @mc_io: Pointer to MC portal's I/O object 203 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 204 * @token: Token of DPDMUX object 205 * 206 * Return: '0' on Success; Error code otherwise. 207 */ 208 int dpdmux_disable(struct fsl_mc_io *mc_io, 209 uint32_t cmd_flags, 210 uint16_t token) 211 { 212 struct mc_command cmd = { 0 }; 213 214 /* prepare command */ 215 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_DISABLE, 216 cmd_flags, 217 token); 218 219 /* send command to mc*/ 220 return mc_send_command(mc_io, &cmd); 221 } 222 223 /** 224 * dpdmux_is_enabled() - Check if the DPDMUX is enabled. 225 * @mc_io: Pointer to MC portal's I/O object 226 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 227 * @token: Token of DPDMUX object 228 * @en: Returns '1' if object is enabled; '0' otherwise 229 * 230 * Return: '0' on Success; Error code otherwise. 231 */ 232 int dpdmux_is_enabled(struct fsl_mc_io *mc_io, 233 uint32_t cmd_flags, 234 uint16_t token, 235 int *en) 236 { 237 struct mc_command cmd = { 0 }; 238 struct dpdmux_rsp_is_enabled *rsp_params; 239 int err; 240 241 /* prepare command */ 242 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IS_ENABLED, 243 cmd_flags, 244 token); 245 246 /* send command to mc*/ 247 err = mc_send_command(mc_io, &cmd); 248 if (err) 249 return err; 250 251 /* retrieve response parameters */ 252 rsp_params = (struct dpdmux_rsp_is_enabled *)cmd.params; 253 *en = dpdmux_get_field(rsp_params->en, ENABLE); 254 255 return 0; 256 } 257 258 /** 259 * dpdmux_reset() - Reset the DPDMUX, returns the object to initial state. 260 * @mc_io: Pointer to MC portal's I/O object 261 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 262 * @token: Token of DPDMUX object 263 * 264 * Return: '0' on Success; Error code otherwise. 265 */ 266 int dpdmux_reset(struct fsl_mc_io *mc_io, 267 uint32_t cmd_flags, 268 uint16_t token) 269 { 270 struct mc_command cmd = { 0 }; 271 272 /* prepare command */ 273 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_RESET, 274 cmd_flags, 275 token); 276 277 /* send command to mc*/ 278 return mc_send_command(mc_io, &cmd); 279 } 280 281 /** 282 * dpdmux_get_attributes() - Retrieve DPDMUX attributes 283 * @mc_io: Pointer to MC portal's I/O object 284 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 285 * @token: Token of DPDMUX object 286 * @attr: Returned object's attributes 287 * 288 * Return: '0' on Success; Error code otherwise. 289 */ 290 int dpdmux_get_attributes(struct fsl_mc_io *mc_io, 291 uint32_t cmd_flags, 292 uint16_t token, 293 struct dpdmux_attr *attr) 294 { 295 struct mc_command cmd = { 0 }; 296 struct dpdmux_rsp_get_attr *rsp_params; 297 int err; 298 299 /* prepare command */ 300 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_ATTR, 301 cmd_flags, 302 token); 303 304 /* send command to mc*/ 305 err = mc_send_command(mc_io, &cmd); 306 if (err) 307 return err; 308 309 /* retrieve response parameters */ 310 rsp_params = (struct dpdmux_rsp_get_attr *)cmd.params; 311 attr->id = le32_to_cpu(rsp_params->id); 312 attr->options = le64_to_cpu(rsp_params->options); 313 attr->method = rsp_params->method; 314 attr->manip = rsp_params->manip; 315 attr->num_ifs = le16_to_cpu(rsp_params->num_ifs); 316 attr->mem_size = le16_to_cpu(rsp_params->mem_size); 317 318 return 0; 319 } 320 321 /** 322 * dpdmux_if_enable() - Enable Interface 323 * @mc_io: Pointer to MC portal's I/O object 324 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 325 * @token: Token of DPDMUX object 326 * @if_id: Interface Identifier 327 * 328 * Return: Completion status. '0' on Success; Error code otherwise. 329 */ 330 int dpdmux_if_enable(struct fsl_mc_io *mc_io, 331 uint32_t cmd_flags, 332 uint16_t token, 333 uint16_t if_id) 334 { 335 struct dpdmux_cmd_if *cmd_params; 336 struct mc_command cmd = { 0 }; 337 338 /* prepare command */ 339 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_ENABLE, 340 cmd_flags, 341 token); 342 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 343 cmd_params->if_id = cpu_to_le16(if_id); 344 345 /* send command to mc*/ 346 return mc_send_command(mc_io, &cmd); 347 } 348 349 /** 350 * dpdmux_if_disable() - Disable Interface 351 * @mc_io: Pointer to MC portal's I/O object 352 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 353 * @token: Token of DPDMUX object 354 * @if_id: Interface Identifier 355 * 356 * Return: Completion status. '0' on Success; Error code otherwise. 357 */ 358 int dpdmux_if_disable(struct fsl_mc_io *mc_io, 359 uint32_t cmd_flags, 360 uint16_t token, 361 uint16_t if_id) 362 { 363 struct dpdmux_cmd_if *cmd_params; 364 struct mc_command cmd = { 0 }; 365 366 /* prepare command */ 367 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_DISABLE, 368 cmd_flags, 369 token); 370 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 371 cmd_params->if_id = cpu_to_le16(if_id); 372 373 /* send command to mc*/ 374 return mc_send_command(mc_io, &cmd); 375 } 376 377 /** 378 * dpdmux_set_max_frame_length() - Set the maximum frame length in DPDMUX 379 * @mc_io: Pointer to MC portal's I/O object 380 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 381 * @token: Token of DPDMUX object 382 * @max_frame_length: The required maximum frame length 383 * 384 * Update the maximum frame length on all DMUX interfaces. 385 * In case of VEPA, the maximum frame length on all dmux interfaces 386 * will be updated with the minimum value of the mfls of the connected 387 * dpnis and the actual value of dmux mfl. 388 * 389 * Return: '0' on Success; Error code otherwise. 390 */ 391 int dpdmux_set_max_frame_length(struct fsl_mc_io *mc_io, 392 uint32_t cmd_flags, 393 uint16_t token, 394 uint16_t max_frame_length) 395 { 396 struct mc_command cmd = { 0 }; 397 struct dpdmux_cmd_set_max_frame_length *cmd_params; 398 399 /* prepare command */ 400 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_MAX_FRAME_LENGTH, 401 cmd_flags, 402 token); 403 cmd_params = (struct dpdmux_cmd_set_max_frame_length *)cmd.params; 404 cmd_params->max_frame_length = cpu_to_le16(max_frame_length); 405 406 /* send command to mc*/ 407 return mc_send_command(mc_io, &cmd); 408 } 409 410 /** 411 * dpdmux_ul_reset_counters() - Function resets the uplink counter 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 DPDMUX object 415 * 416 * Return: '0' on Success; Error code otherwise. 417 */ 418 int dpdmux_ul_reset_counters(struct fsl_mc_io *mc_io, 419 uint32_t cmd_flags, 420 uint16_t token) 421 { 422 struct mc_command cmd = { 0 }; 423 424 /* prepare command */ 425 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_UL_RESET_COUNTERS, 426 cmd_flags, 427 token); 428 429 /* send command to mc*/ 430 return mc_send_command(mc_io, &cmd); 431 } 432 433 /** 434 * dpdmux_if_set_accepted_frames() - Set the accepted frame types 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 ID (0 for uplink, or 1-num_ifs); 439 * @cfg: Frame types configuration 440 * 441 * if 'DPDMUX_ADMIT_ONLY_VLAN_TAGGED' is set - untagged frames or 442 * priority-tagged frames are discarded. 443 * if 'DPDMUX_ADMIT_ONLY_UNTAGGED' is set - untagged frames or 444 * priority-tagged frames are accepted. 445 * if 'DPDMUX_ADMIT_ALL' is set (default mode) - all VLAN tagged, 446 * untagged and priority-tagged frame are accepted; 447 * 448 * Return: '0' on Success; Error code otherwise. 449 */ 450 int dpdmux_if_set_accepted_frames(struct fsl_mc_io *mc_io, 451 uint32_t cmd_flags, 452 uint16_t token, 453 uint16_t if_id, 454 const struct dpdmux_accepted_frames *cfg) 455 { 456 struct mc_command cmd = { 0 }; 457 struct dpdmux_cmd_if_set_accepted_frames *cmd_params; 458 459 /* prepare command */ 460 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_ACCEPTED_FRAMES, 461 cmd_flags, 462 token); 463 cmd_params = (struct dpdmux_cmd_if_set_accepted_frames *)cmd.params; 464 cmd_params->if_id = cpu_to_le16(if_id); 465 dpdmux_set_field(cmd_params->frames_options, 466 ACCEPTED_FRAMES_TYPE, 467 cfg->type); 468 dpdmux_set_field(cmd_params->frames_options, 469 UNACCEPTED_FRAMES_ACTION, 470 cfg->unaccept_act); 471 472 /* send command to mc*/ 473 return mc_send_command(mc_io, &cmd); 474 } 475 476 /** 477 * dpdmux_if_get_attributes() - Obtain DPDMUX interface attributes 478 * @mc_io: Pointer to MC portal's I/O object 479 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 480 * @token: Token of DPDMUX object 481 * @if_id: Interface ID (0 for uplink, or 1-num_ifs); 482 * @attr: Interface attributes 483 * 484 * Return: '0' on Success; Error code otherwise. 485 */ 486 int dpdmux_if_get_attributes(struct fsl_mc_io *mc_io, 487 uint32_t cmd_flags, 488 uint16_t token, 489 uint16_t if_id, 490 struct dpdmux_if_attr *attr) 491 { 492 struct mc_command cmd = { 0 }; 493 struct dpdmux_cmd_if *cmd_params; 494 struct dpdmux_rsp_if_get_attr *rsp_params; 495 int err; 496 497 /* prepare command */ 498 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_ATTR, 499 cmd_flags, 500 token); 501 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 502 cmd_params->if_id = cpu_to_le16(if_id); 503 504 /* send command to mc*/ 505 err = mc_send_command(mc_io, &cmd); 506 if (err) 507 return err; 508 509 /* retrieve response parameters */ 510 rsp_params = (struct dpdmux_rsp_if_get_attr *)cmd.params; 511 attr->rate = le32_to_cpu(rsp_params->rate); 512 attr->enabled = dpdmux_get_field(rsp_params->enabled, ENABLE); 513 attr->is_default = dpdmux_get_field(rsp_params->enabled, IS_DEFAULT); 514 attr->accept_frame_type = dpdmux_get_field( 515 rsp_params->accepted_frames_type, 516 ACCEPTED_FRAMES_TYPE); 517 518 return 0; 519 } 520 521 /** 522 * dpdmux_if_remove_l2_rule() - Remove L2 rule from DPDMUX table 523 * @mc_io: Pointer to MC portal's I/O object 524 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 525 * @token: Token of DPDMUX object 526 * @if_id: Destination interface ID 527 * @rule: L2 rule 528 * 529 * Function removes a L2 rule from DPDMUX table 530 * or adds an interface to an existing multicast address 531 * 532 * Return: '0' on Success; Error code otherwise. 533 */ 534 int dpdmux_if_remove_l2_rule(struct fsl_mc_io *mc_io, 535 uint32_t cmd_flags, 536 uint16_t token, 537 uint16_t if_id, 538 const struct dpdmux_l2_rule *rule) 539 { 540 struct mc_command cmd = { 0 }; 541 struct dpdmux_cmd_if_l2_rule *cmd_params; 542 543 /* prepare command */ 544 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_REMOVE_L2_RULE, 545 cmd_flags, 546 token); 547 cmd_params = (struct dpdmux_cmd_if_l2_rule *)cmd.params; 548 cmd_params->if_id = cpu_to_le16(if_id); 549 cmd_params->vlan_id = cpu_to_le16(rule->vlan_id); 550 cmd_params->mac_addr5 = rule->mac_addr[5]; 551 cmd_params->mac_addr4 = rule->mac_addr[4]; 552 cmd_params->mac_addr3 = rule->mac_addr[3]; 553 cmd_params->mac_addr2 = rule->mac_addr[2]; 554 cmd_params->mac_addr1 = rule->mac_addr[1]; 555 cmd_params->mac_addr0 = rule->mac_addr[0]; 556 557 /* send command to mc*/ 558 return mc_send_command(mc_io, &cmd); 559 } 560 561 /** 562 * dpdmux_if_add_l2_rule() - Add L2 rule into DPDMUX table 563 * @mc_io: Pointer to MC portal's I/O object 564 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 565 * @token: Token of DPDMUX object 566 * @if_id: Destination interface ID 567 * @rule: L2 rule 568 * 569 * Function adds a L2 rule into DPDMUX table 570 * or adds an interface to an existing multicast address 571 * 572 * Return: '0' on Success; Error code otherwise. 573 */ 574 int dpdmux_if_add_l2_rule(struct fsl_mc_io *mc_io, 575 uint32_t cmd_flags, 576 uint16_t token, 577 uint16_t if_id, 578 const struct dpdmux_l2_rule *rule) 579 { 580 struct mc_command cmd = { 0 }; 581 struct dpdmux_cmd_if_l2_rule *cmd_params; 582 583 /* prepare command */ 584 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_ADD_L2_RULE, 585 cmd_flags, 586 token); 587 cmd_params = (struct dpdmux_cmd_if_l2_rule *)cmd.params; 588 cmd_params->if_id = cpu_to_le16(if_id); 589 cmd_params->vlan_id = cpu_to_le16(rule->vlan_id); 590 cmd_params->mac_addr5 = rule->mac_addr[5]; 591 cmd_params->mac_addr4 = rule->mac_addr[4]; 592 cmd_params->mac_addr3 = rule->mac_addr[3]; 593 cmd_params->mac_addr2 = rule->mac_addr[2]; 594 cmd_params->mac_addr1 = rule->mac_addr[1]; 595 cmd_params->mac_addr0 = rule->mac_addr[0]; 596 597 /* send command to mc*/ 598 return mc_send_command(mc_io, &cmd); 599 } 600 601 /** 602 * dpdmux_if_get_counter() - Functions obtains specific counter of an interface 603 * @mc_io: Pointer to MC portal's I/O object 604 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 605 * @token: Token of DPDMUX object 606 * @if_id: Interface Id 607 * @counter_type: counter type 608 * @counter: Returned specific counter information 609 * 610 * Return: '0' on Success; Error code otherwise. 611 */ 612 int dpdmux_if_get_counter(struct fsl_mc_io *mc_io, 613 uint32_t cmd_flags, 614 uint16_t token, 615 uint16_t if_id, 616 enum dpdmux_counter_type counter_type, 617 uint64_t *counter) 618 { 619 struct mc_command cmd = { 0 }; 620 struct dpdmux_cmd_if_get_counter *cmd_params; 621 struct dpdmux_rsp_if_get_counter *rsp_params; 622 int err; 623 624 /* prepare command */ 625 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_COUNTER, 626 cmd_flags, 627 token); 628 cmd_params = (struct dpdmux_cmd_if_get_counter *)cmd.params; 629 cmd_params->if_id = cpu_to_le16(if_id); 630 cmd_params->counter_type = counter_type; 631 632 /* send command to mc*/ 633 err = mc_send_command(mc_io, &cmd); 634 if (err) 635 return err; 636 637 /* retrieve response parameters */ 638 rsp_params = (struct dpdmux_rsp_if_get_counter *)cmd.params; 639 *counter = le64_to_cpu(rsp_params->counter); 640 641 return 0; 642 } 643 644 /** 645 * dpdmux_if_set_link_cfg() - set the link configuration. 646 * @mc_io: Pointer to MC portal's I/O object 647 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 648 * @token: Token of DPSW object 649 * @if_id: interface id 650 * @cfg: Link configuration 651 * 652 * Return: '0' on Success; Error code otherwise. 653 */ 654 int dpdmux_if_set_link_cfg(struct fsl_mc_io *mc_io, 655 uint32_t cmd_flags, 656 uint16_t token, 657 uint16_t if_id, 658 struct dpdmux_link_cfg *cfg) 659 { 660 struct mc_command cmd = { 0 }; 661 struct dpdmux_cmd_if_set_link_cfg *cmd_params; 662 663 /* prepare command */ 664 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_LINK_CFG, 665 cmd_flags, 666 token); 667 cmd_params = (struct dpdmux_cmd_if_set_link_cfg *)cmd.params; 668 cmd_params->if_id = cpu_to_le16(if_id); 669 cmd_params->rate = cpu_to_le32(cfg->rate); 670 cmd_params->options = cpu_to_le64(cfg->options); 671 cmd_params->advertising = cpu_to_le64(cfg->advertising); 672 673 /* send command to mc*/ 674 return mc_send_command(mc_io, &cmd); 675 } 676 677 /** 678 * dpdmux_if_get_link_state - Return the link state 679 * @mc_io: Pointer to MC portal's I/O object 680 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 681 * @token: Token of DPSW object 682 * @if_id: interface id 683 * @state: link state 684 * 685 * @returns '0' on Success; Error code otherwise. 686 */ 687 int dpdmux_if_get_link_state(struct fsl_mc_io *mc_io, 688 uint32_t cmd_flags, 689 uint16_t token, 690 uint16_t if_id, 691 struct dpdmux_link_state *state) 692 { 693 struct mc_command cmd = { 0 }; 694 struct dpdmux_cmd_if_get_link_state *cmd_params; 695 struct dpdmux_rsp_if_get_link_state *rsp_params; 696 int err; 697 698 /* prepare command */ 699 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_LINK_STATE, 700 cmd_flags, 701 token); 702 cmd_params = (struct dpdmux_cmd_if_get_link_state *)cmd.params; 703 cmd_params->if_id = cpu_to_le16(if_id); 704 705 /* send command to mc*/ 706 err = mc_send_command(mc_io, &cmd); 707 if (err) 708 return err; 709 710 /* retrieve response parameters */ 711 rsp_params = (struct dpdmux_rsp_if_get_link_state *)cmd.params; 712 state->rate = le32_to_cpu(rsp_params->rate); 713 state->options = le64_to_cpu(rsp_params->options); 714 state->up = dpdmux_get_field(rsp_params->up, UP); 715 state->state_valid = dpdmux_get_field(rsp_params->up, STATE_VALID); 716 state->supported = le64_to_cpu(rsp_params->supported); 717 state->advertising = le64_to_cpu(rsp_params->advertising); 718 719 return 0; 720 } 721 722 /** 723 * dpdmux_if_set_default - Set default interface 724 * @mc_io: Pointer to MC portal's I/O object 725 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 726 * @token: Token of DPSW object 727 * @if_id: interface id 728 * 729 * @returns '0' on Success; Error code otherwise. 730 */ 731 int dpdmux_if_set_default(struct fsl_mc_io *mc_io, 732 uint32_t cmd_flags, 733 uint16_t token, 734 uint16_t if_id) 735 { 736 struct dpdmux_cmd_if *cmd_params; 737 struct mc_command cmd = { 0 }; 738 739 /* prepare command */ 740 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_DEFAULT, 741 cmd_flags, 742 token); 743 cmd_params = (struct dpdmux_cmd_if *)cmd.params; 744 cmd_params->if_id = cpu_to_le16(if_id); 745 746 /* send command to mc*/ 747 return mc_send_command(mc_io, &cmd); 748 } 749 750 /** 751 * dpdmux_if_get_default - Get default interface 752 * @mc_io: Pointer to MC portal's I/O object 753 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 754 * @token: Token of DPSW object 755 * @if_id: interface id 756 * 757 * @returns '0' on Success; Error code otherwise. 758 */ 759 int dpdmux_if_get_default(struct fsl_mc_io *mc_io, 760 uint32_t cmd_flags, 761 uint16_t token, 762 uint16_t *if_id) 763 { 764 struct dpdmux_cmd_if *rsp_params; 765 struct mc_command cmd = { 0 }; 766 int err; 767 768 /* prepare command */ 769 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_DEFAULT, 770 cmd_flags, 771 token); 772 773 /* send command to mc*/ 774 err = mc_send_command(mc_io, &cmd); 775 if (err) 776 return err; 777 778 /* retrieve response parameters */ 779 rsp_params = (struct dpdmux_cmd_if *)cmd.params; 780 *if_id = le16_to_cpu(rsp_params->if_id); 781 782 return 0; 783 } 784 785 /** 786 * dpdmux_set_custom_key - Set a custom classification key. 787 * 788 * This API is only available for DPDMUX instance created with 789 * DPDMUX_METHOD_CUSTOM. This API must be called before populating the 790 * classification table using dpdmux_add_custom_cls_entry. 791 * 792 * Calls to dpdmux_set_custom_key remove all existing classification entries 793 * that may have been added previously using dpdmux_add_custom_cls_entry. 794 * 795 * @mc_io: Pointer to MC portal's I/O object 796 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 797 * @token: Token of DPSW object 798 * @if_id: Interface id 799 * @key_cfg_iova: DMA address of a configuration structure set up using 800 * dpkg_prepare_key_cfg. Maximum key size is 24 bytes 801 * 802 * @returns '0' on Success; Error code otherwise. 803 */ 804 int dpdmux_set_custom_key(struct fsl_mc_io *mc_io, 805 uint32_t cmd_flags, 806 uint16_t token, 807 uint64_t key_cfg_iova) 808 { 809 struct dpdmux_set_custom_key *cmd_params; 810 struct mc_command cmd = { 0 }; 811 812 /* prepare command */ 813 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_CUSTOM_KEY, 814 cmd_flags, 815 token); 816 cmd_params = (struct dpdmux_set_custom_key *)cmd.params; 817 cmd_params->key_cfg_iova = cpu_to_le64(key_cfg_iova); 818 819 /* send command to mc*/ 820 return mc_send_command(mc_io, &cmd); 821 } 822 823 /** 824 * dpdmux_add_custom_cls_entry - Adds a custom classification entry. 825 * 826 * This API is only available for DPDMUX instances created with 827 * DPDMUX_METHOD_CUSTOM. Before calling this function a classification key 828 * composition rule must be set up using dpdmux_set_custom_key. 829 * 830 * @mc_io: Pointer to MC portal's I/O object 831 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 832 * @token: Token of DPSW object 833 * @rule: Classification rule to insert. Rules cannot be duplicated, if a 834 * matching rule already exists, the action will be replaced. 835 * @action: Action to perform for matching traffic. 836 * 837 * @returns '0' on Success; Error code otherwise. 838 */ 839 int dpdmux_add_custom_cls_entry(struct fsl_mc_io *mc_io, 840 uint32_t cmd_flags, 841 uint16_t token, 842 struct dpdmux_rule_cfg *rule, 843 struct dpdmux_cls_action *action) 844 { 845 struct dpdmux_cmd_add_custom_cls_entry *cmd_params; 846 struct mc_command cmd = { 0 }; 847 848 /* prepare command */ 849 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_ADD_CUSTOM_CLS_ENTRY, 850 cmd_flags, 851 token); 852 853 cmd_params = (struct dpdmux_cmd_add_custom_cls_entry *)cmd.params; 854 cmd_params->key_size = rule->key_size; 855 cmd_params->dest_if = cpu_to_le16(action->dest_if); 856 cmd_params->key_iova = cpu_to_le64(rule->key_iova); 857 cmd_params->mask_iova = cpu_to_le64(rule->mask_iova); 858 859 /* send command to mc*/ 860 return mc_send_command(mc_io, &cmd); 861 } 862 863 /** 864 * dpdmux_remove_custom_cls_entry - Removes a custom classification entry. 865 * 866 * This API is only available for DPDMUX instances created with 867 * DPDMUX_METHOD_CUSTOM. The API can be used to remove classification 868 * entries previously inserted using dpdmux_add_custom_cls_entry. 869 * 870 * @mc_io: Pointer to MC portal's I/O object 871 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 872 * @token: Token of DPSW object 873 * @rule: Classification rule to remove 874 * 875 * @returns '0' on Success; Error code otherwise. 876 */ 877 int dpdmux_remove_custom_cls_entry(struct fsl_mc_io *mc_io, 878 uint32_t cmd_flags, 879 uint16_t token, 880 struct dpdmux_rule_cfg *rule) 881 { 882 struct dpdmux_cmd_remove_custom_cls_entry *cmd_params; 883 struct mc_command cmd = { 0 }; 884 885 /* prepare command */ 886 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_REMOVE_CUSTOM_CLS_ENTRY, 887 cmd_flags, 888 token); 889 cmd_params = (struct dpdmux_cmd_remove_custom_cls_entry *)cmd.params; 890 cmd_params->key_size = rule->key_size; 891 cmd_params->key_iova = cpu_to_le64(rule->key_iova); 892 cmd_params->mask_iova = cpu_to_le64(rule->mask_iova); 893 894 /* send command to mc*/ 895 return mc_send_command(mc_io, &cmd); 896 } 897 898 /** 899 * dpdmux_get_api_version() - Get Data Path Demux API version 900 * @mc_io: Pointer to MC portal's I/O object 901 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 902 * @major_ver: Major version of data path demux API 903 * @minor_ver: Minor version of data path demux API 904 * 905 * Return: '0' on Success; Error code otherwise. 906 */ 907 int dpdmux_get_api_version(struct fsl_mc_io *mc_io, 908 uint32_t cmd_flags, 909 uint16_t *major_ver, 910 uint16_t *minor_ver) 911 { 912 struct mc_command cmd = { 0 }; 913 struct dpdmux_rsp_get_api_version *rsp_params; 914 int err; 915 916 cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_API_VERSION, 917 cmd_flags, 918 0); 919 920 err = mc_send_command(mc_io, &cmd); 921 if (err) 922 return err; 923 924 rsp_params = (struct dpdmux_rsp_get_api_version *)cmd.params; 925 *major_ver = le16_to_cpu(rsp_params->major); 926 *minor_ver = le16_to_cpu(rsp_params->minor); 927 928 return 0; 929 } 930