1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright 2014-2016 Freescale Semiconductor Inc. 4 * Copyright 2017-2021 NXP 5 * 6 */ 7 8#include <linux/fsl/mc.h> 9#include "dpsw.h" 10#include "dpsw-cmd.h" 11 12static void build_if_id_bitmap(__le64 *bmap, const u16 *id, const u16 num_ifs) 13{ 14 int i; 15 16 for (i = 0; (i < num_ifs) && (i < DPSW_MAX_IF); i++) { 17 if (id[i] < DPSW_MAX_IF) 18 bmap[id[i] / 64] |= cpu_to_le64(BIT_MASK(id[i] % 64)); 19 } 20} 21 22/** 23 * dpsw_open() - Open a control session for the specified object 24 * @mc_io: Pointer to MC portal's I/O object 25 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 26 * @dpsw_id: DPSW unique ID 27 * @token: Returned token; use in subsequent API calls 28 * 29 * This function can be used to open a control session for an 30 * already created object; an object may have been declared in 31 * the DPL or by calling the dpsw_create() function. 32 * This function returns a unique authentication token, 33 * associated with the specific object ID and the specific MC 34 * portal; this token must be used in all subsequent commands for 35 * this specific object 36 * 37 * Return: '0' on Success; Error code otherwise. 38 */ 39int dpsw_open(struct fsl_mc_io *mc_io, u32 cmd_flags, int dpsw_id, u16 *token) 40{ 41 struct fsl_mc_command cmd = { 0 }; 42 struct dpsw_cmd_open *cmd_params; 43 int err; 44 45 /* prepare command */ 46 cmd.header = mc_encode_cmd_header(DPSW_CMDID_OPEN, 47 cmd_flags, 48 0); 49 cmd_params = (struct dpsw_cmd_open *)cmd.params; 50 cmd_params->dpsw_id = cpu_to_le32(dpsw_id); 51 52 /* send command to mc*/ 53 err = mc_send_command(mc_io, &cmd); 54 if (err) 55 return err; 56 57 /* retrieve response parameters */ 58 *token = mc_cmd_hdr_read_token(&cmd); 59 60 return 0; 61} 62 63/** 64 * dpsw_close() - Close the control session of the object 65 * @mc_io: Pointer to MC portal's I/O object 66 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 67 * @token: Token of DPSW object 68 * 69 * After this function is called, no further operations are 70 * allowed on the object without opening a new control session. 71 * 72 * Return: '0' on Success; Error code otherwise. 73 */ 74int dpsw_close(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token) 75{ 76 struct fsl_mc_command cmd = { 0 }; 77 78 /* prepare command */ 79 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CLOSE, 80 cmd_flags, 81 token); 82 83 /* send command to mc*/ 84 return mc_send_command(mc_io, &cmd); 85} 86 87/** 88 * dpsw_enable() - Enable DPSW functionality 89 * @mc_io: Pointer to MC portal's I/O object 90 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 91 * @token: Token of DPSW object 92 * 93 * Return: Completion status. '0' on Success; Error code otherwise. 94 */ 95int dpsw_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token) 96{ 97 struct fsl_mc_command cmd = { 0 }; 98 99 /* prepare command */ 100 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ENABLE, 101 cmd_flags, 102 token); 103 104 /* send command to mc*/ 105 return mc_send_command(mc_io, &cmd); 106} 107 108/** 109 * dpsw_disable() - Disable DPSW functionality 110 * @mc_io: Pointer to MC portal's I/O object 111 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 112 * @token: Token of DPSW object 113 * 114 * Return: Completion status. '0' on Success; Error code otherwise. 115 */ 116int dpsw_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token) 117{ 118 struct fsl_mc_command cmd = { 0 }; 119 120 /* prepare command */ 121 cmd.header = mc_encode_cmd_header(DPSW_CMDID_DISABLE, 122 cmd_flags, 123 token); 124 125 /* send command to mc*/ 126 return mc_send_command(mc_io, &cmd); 127} 128 129/** 130 * dpsw_reset() - Reset the DPSW, returns the object to initial state. 131 * @mc_io: Pointer to MC portal's I/O object 132 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 133 * @token: Token of DPSW object 134 * 135 * Return: '0' on Success; Error code otherwise. 136 */ 137int dpsw_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token) 138{ 139 struct fsl_mc_command cmd = { 0 }; 140 141 /* prepare command */ 142 cmd.header = mc_encode_cmd_header(DPSW_CMDID_RESET, 143 cmd_flags, 144 token); 145 146 /* send command to mc*/ 147 return mc_send_command(mc_io, &cmd); 148} 149 150/** 151 * dpsw_set_irq_enable() - Set overall interrupt state. 152 * @mc_io: Pointer to MC portal's I/O object 153 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 154 * @token: Token of DPCI object 155 * @irq_index: The interrupt index to configure 156 * @en: Interrupt state - enable = 1, disable = 0 157 * 158 * Allows GPP software to control when interrupts are generated. 159 * Each interrupt can have up to 32 causes. The enable/disable control's the 160 * overall interrupt state. if the interrupt is disabled no causes will cause 161 * an interrupt 162 * 163 * Return: '0' on Success; Error code otherwise. 164 */ 165int dpsw_set_irq_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 166 u8 irq_index, u8 en) 167{ 168 struct fsl_mc_command cmd = { 0 }; 169 struct dpsw_cmd_set_irq_enable *cmd_params; 170 171 /* prepare command */ 172 cmd.header = mc_encode_cmd_header(DPSW_CMDID_SET_IRQ_ENABLE, 173 cmd_flags, 174 token); 175 cmd_params = (struct dpsw_cmd_set_irq_enable *)cmd.params; 176 dpsw_set_field(cmd_params->enable_state, ENABLE, en); 177 cmd_params->irq_index = irq_index; 178 179 /* send command to mc*/ 180 return mc_send_command(mc_io, &cmd); 181} 182 183/** 184 * dpsw_set_irq_mask() - Set interrupt mask. 185 * @mc_io: Pointer to MC portal's I/O object 186 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 187 * @token: Token of DPCI object 188 * @irq_index: The interrupt index to configure 189 * @mask: Event mask to trigger interrupt; 190 * each bit: 191 * 0 = ignore event 192 * 1 = consider event for asserting IRQ 193 * 194 * Every interrupt can have up to 32 causes and the interrupt model supports 195 * masking/unmasking each cause independently 196 * 197 * Return: '0' on Success; Error code otherwise. 198 */ 199int dpsw_set_irq_mask(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 200 u8 irq_index, u32 mask) 201{ 202 struct fsl_mc_command cmd = { 0 }; 203 struct dpsw_cmd_set_irq_mask *cmd_params; 204 205 /* prepare command */ 206 cmd.header = mc_encode_cmd_header(DPSW_CMDID_SET_IRQ_MASK, 207 cmd_flags, 208 token); 209 cmd_params = (struct dpsw_cmd_set_irq_mask *)cmd.params; 210 cmd_params->mask = cpu_to_le32(mask); 211 cmd_params->irq_index = irq_index; 212 213 /* send command to mc*/ 214 return mc_send_command(mc_io, &cmd); 215} 216 217/** 218 * dpsw_get_irq_status() - Get the current status of any pending interrupts 219 * @mc_io: Pointer to MC portal's I/O object 220 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 221 * @token: Token of DPSW object 222 * @irq_index: The interrupt index to configure 223 * @status: Returned interrupts status - one bit per cause: 224 * 0 = no interrupt pending 225 * 1 = interrupt pending 226 * 227 * Return: '0' on Success; Error code otherwise. 228 */ 229int dpsw_get_irq_status(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 230 u8 irq_index, u32 *status) 231{ 232 struct fsl_mc_command cmd = { 0 }; 233 struct dpsw_cmd_get_irq_status *cmd_params; 234 struct dpsw_rsp_get_irq_status *rsp_params; 235 int err; 236 237 /* prepare command */ 238 cmd.header = mc_encode_cmd_header(DPSW_CMDID_GET_IRQ_STATUS, 239 cmd_flags, 240 token); 241 cmd_params = (struct dpsw_cmd_get_irq_status *)cmd.params; 242 cmd_params->status = cpu_to_le32(*status); 243 cmd_params->irq_index = irq_index; 244 245 /* send command to mc*/ 246 err = mc_send_command(mc_io, &cmd); 247 if (err) 248 return err; 249 250 /* retrieve response parameters */ 251 rsp_params = (struct dpsw_rsp_get_irq_status *)cmd.params; 252 *status = le32_to_cpu(rsp_params->status); 253 254 return 0; 255} 256 257/** 258 * dpsw_clear_irq_status() - Clear a pending interrupt's status 259 * @mc_io: Pointer to MC portal's I/O object 260 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 261 * @token: Token of DPCI object 262 * @irq_index: The interrupt index to configure 263 * @status: bits to clear (W1C) - one bit per cause: 264 * 0 = don't change 265 * 1 = clear status bit 266 * 267 * Return: '0' on Success; Error code otherwise. 268 */ 269int dpsw_clear_irq_status(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 270 u8 irq_index, u32 status) 271{ 272 struct fsl_mc_command cmd = { 0 }; 273 struct dpsw_cmd_clear_irq_status *cmd_params; 274 275 /* prepare command */ 276 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CLEAR_IRQ_STATUS, 277 cmd_flags, 278 token); 279 cmd_params = (struct dpsw_cmd_clear_irq_status *)cmd.params; 280 cmd_params->status = cpu_to_le32(status); 281 cmd_params->irq_index = irq_index; 282 283 /* send command to mc*/ 284 return mc_send_command(mc_io, &cmd); 285} 286 287/** 288 * dpsw_get_attributes() - Retrieve DPSW attributes 289 * @mc_io: Pointer to MC portal's I/O object 290 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 291 * @token: Token of DPSW object 292 * @attr: Returned DPSW attributes 293 * 294 * Return: Completion status. '0' on Success; Error code otherwise. 295 */ 296int dpsw_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 297 struct dpsw_attr *attr) 298{ 299 struct fsl_mc_command cmd = { 0 }; 300 struct dpsw_rsp_get_attr *rsp_params; 301 int err; 302 303 /* prepare command */ 304 cmd.header = mc_encode_cmd_header(DPSW_CMDID_GET_ATTR, 305 cmd_flags, 306 token); 307 308 /* send command to mc*/ 309 err = mc_send_command(mc_io, &cmd); 310 if (err) 311 return err; 312 313 /* retrieve response parameters */ 314 rsp_params = (struct dpsw_rsp_get_attr *)cmd.params; 315 attr->num_ifs = le16_to_cpu(rsp_params->num_ifs); 316 attr->max_fdbs = rsp_params->max_fdbs; 317 attr->num_fdbs = rsp_params->num_fdbs; 318 attr->max_vlans = le16_to_cpu(rsp_params->max_vlans); 319 attr->num_vlans = le16_to_cpu(rsp_params->num_vlans); 320 attr->max_fdb_entries = le16_to_cpu(rsp_params->max_fdb_entries); 321 attr->fdb_aging_time = le16_to_cpu(rsp_params->fdb_aging_time); 322 attr->id = le32_to_cpu(rsp_params->dpsw_id); 323 attr->mem_size = le16_to_cpu(rsp_params->mem_size); 324 attr->max_fdb_mc_groups = le16_to_cpu(rsp_params->max_fdb_mc_groups); 325 attr->max_meters_per_if = rsp_params->max_meters_per_if; 326 attr->options = le64_to_cpu(rsp_params->options); 327 attr->component_type = dpsw_get_field(rsp_params->component_type, COMPONENT_TYPE); 328 attr->flooding_cfg = dpsw_get_field(rsp_params->repl_cfg, FLOODING_CFG); 329 attr->broadcast_cfg = dpsw_get_field(rsp_params->repl_cfg, BROADCAST_CFG); 330 return 0; 331} 332 333/** 334 * dpsw_if_set_link_cfg() - Set the link configuration. 335 * @mc_io: Pointer to MC portal's I/O object 336 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 337 * @token: Token of DPSW object 338 * @if_id: Interface id 339 * @cfg: Link configuration 340 * 341 * Return: '0' on Success; Error code otherwise. 342 */ 343int dpsw_if_set_link_cfg(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 if_id, 344 struct dpsw_link_cfg *cfg) 345{ 346 struct fsl_mc_command cmd = { 0 }; 347 struct dpsw_cmd_if_set_link_cfg *cmd_params; 348 349 /* prepare command */ 350 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_SET_LINK_CFG, 351 cmd_flags, 352 token); 353 cmd_params = (struct dpsw_cmd_if_set_link_cfg *)cmd.params; 354 cmd_params->if_id = cpu_to_le16(if_id); 355 cmd_params->rate = cpu_to_le32(cfg->rate); 356 cmd_params->options = cpu_to_le64(cfg->options); 357 358 /* send command to mc*/ 359 return mc_send_command(mc_io, &cmd); 360} 361 362/** 363 * dpsw_if_get_link_state - Return the link state 364 * @mc_io: Pointer to MC portal's I/O object 365 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 366 * @token: Token of DPSW object 367 * @if_id: Interface id 368 * @state: Link state 1 - linkup, 0 - link down or disconnected 369 * 370 * Return: '0' on Success; Error code otherwise. 371 */ 372int dpsw_if_get_link_state(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 373 u16 if_id, struct dpsw_link_state *state) 374{ 375 struct fsl_mc_command cmd = { 0 }; 376 struct dpsw_cmd_if_get_link_state *cmd_params; 377 struct dpsw_rsp_if_get_link_state *rsp_params; 378 int err; 379 380 /* prepare command */ 381 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_GET_LINK_STATE, 382 cmd_flags, 383 token); 384 cmd_params = (struct dpsw_cmd_if_get_link_state *)cmd.params; 385 cmd_params->if_id = cpu_to_le16(if_id); 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 dpsw_rsp_if_get_link_state *)cmd.params; 394 state->rate = le32_to_cpu(rsp_params->rate); 395 state->options = le64_to_cpu(rsp_params->options); 396 state->up = dpsw_get_field(rsp_params->up, UP); 397 398 return 0; 399} 400 401/** 402 * dpsw_if_set_tci() - Set default VLAN Tag Control Information (TCI) 403 * @mc_io: Pointer to MC portal's I/O object 404 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 405 * @token: Token of DPSW object 406 * @if_id: Interface Identifier 407 * @cfg: Tag Control Information Configuration 408 * 409 * Return: Completion status. '0' on Success; Error code otherwise. 410 */ 411int dpsw_if_set_tci(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 if_id, 412 const struct dpsw_tci_cfg *cfg) 413{ 414 struct fsl_mc_command cmd = { 0 }; 415 struct dpsw_cmd_if_set_tci *cmd_params; 416 u16 tmp_conf = 0; 417 418 /* prepare command */ 419 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_SET_TCI, 420 cmd_flags, 421 token); 422 cmd_params = (struct dpsw_cmd_if_set_tci *)cmd.params; 423 cmd_params->if_id = cpu_to_le16(if_id); 424 dpsw_set_field(tmp_conf, VLAN_ID, cfg->vlan_id); 425 dpsw_set_field(tmp_conf, DEI, cfg->dei); 426 dpsw_set_field(tmp_conf, PCP, cfg->pcp); 427 cmd_params->conf = cpu_to_le16(tmp_conf); 428 429 /* send command to mc*/ 430 return mc_send_command(mc_io, &cmd); 431} 432 433/** 434 * dpsw_if_get_tci() - Get default VLAN Tag Control Information (TCI) 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 DPSW object 438 * @if_id: Interface Identifier 439 * @cfg: Tag Control Information Configuration 440 * 441 * Return: Completion status. '0' on Success; Error code otherwise. 442 */ 443int dpsw_if_get_tci(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 if_id, 444 struct dpsw_tci_cfg *cfg) 445{ 446 struct fsl_mc_command cmd = { 0 }; 447 struct dpsw_cmd_if_get_tci *cmd_params; 448 struct dpsw_rsp_if_get_tci *rsp_params; 449 int err; 450 451 /* prepare command */ 452 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_GET_TCI, 453 cmd_flags, 454 token); 455 cmd_params = (struct dpsw_cmd_if_get_tci *)cmd.params; 456 cmd_params->if_id = cpu_to_le16(if_id); 457 458 /* send command to mc*/ 459 err = mc_send_command(mc_io, &cmd); 460 if (err) 461 return err; 462 463 /* retrieve response parameters */ 464 rsp_params = (struct dpsw_rsp_if_get_tci *)cmd.params; 465 cfg->pcp = rsp_params->pcp; 466 cfg->dei = rsp_params->dei; 467 cfg->vlan_id = le16_to_cpu(rsp_params->vlan_id); 468 469 return 0; 470} 471 472/** 473 * dpsw_if_set_stp() - Function sets Spanning Tree Protocol (STP) state. 474 * @mc_io: Pointer to MC portal's I/O object 475 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 476 * @token: Token of DPSW object 477 * @if_id: Interface Identifier 478 * @cfg: STP State configuration parameters 479 * 480 * The following STP states are supported - 481 * blocking, listening, learning, forwarding and disabled. 482 * 483 * Return: Completion status. '0' on Success; Error code otherwise. 484 */ 485int dpsw_if_set_stp(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 if_id, 486 const struct dpsw_stp_cfg *cfg) 487{ 488 struct fsl_mc_command cmd = { 0 }; 489 struct dpsw_cmd_if_set_stp *cmd_params; 490 491 /* prepare command */ 492 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_SET_STP, 493 cmd_flags, 494 token); 495 cmd_params = (struct dpsw_cmd_if_set_stp *)cmd.params; 496 cmd_params->if_id = cpu_to_le16(if_id); 497 cmd_params->vlan_id = cpu_to_le16(cfg->vlan_id); 498 dpsw_set_field(cmd_params->state, STATE, cfg->state); 499 500 /* send command to mc*/ 501 return mc_send_command(mc_io, &cmd); 502} 503 504/** 505 * dpsw_if_get_counter() - Get specific counter of particular interface 506 * @mc_io: Pointer to MC portal's I/O object 507 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 508 * @token: Token of DPSW object 509 * @if_id: Interface Identifier 510 * @type: Counter type 511 * @counter: return value 512 * 513 * Return: Completion status. '0' on Success; Error code otherwise. 514 */ 515int dpsw_if_get_counter(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 516 u16 if_id, enum dpsw_counter type, u64 *counter) 517{ 518 struct fsl_mc_command cmd = { 0 }; 519 struct dpsw_cmd_if_get_counter *cmd_params; 520 struct dpsw_rsp_if_get_counter *rsp_params; 521 int err; 522 523 /* prepare command */ 524 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_GET_COUNTER, 525 cmd_flags, 526 token); 527 cmd_params = (struct dpsw_cmd_if_get_counter *)cmd.params; 528 cmd_params->if_id = cpu_to_le16(if_id); 529 dpsw_set_field(cmd_params->type, COUNTER_TYPE, type); 530 531 /* send command to mc*/ 532 err = mc_send_command(mc_io, &cmd); 533 if (err) 534 return err; 535 536 /* retrieve response parameters */ 537 rsp_params = (struct dpsw_rsp_if_get_counter *)cmd.params; 538 *counter = le64_to_cpu(rsp_params->counter); 539 540 return 0; 541} 542 543/** 544 * dpsw_if_enable() - Enable Interface 545 * @mc_io: Pointer to MC portal's I/O object 546 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 547 * @token: Token of DPSW object 548 * @if_id: Interface Identifier 549 * 550 * Return: Completion status. '0' on Success; Error code otherwise. 551 */ 552int dpsw_if_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 if_id) 553{ 554 struct fsl_mc_command cmd = { 0 }; 555 struct dpsw_cmd_if *cmd_params; 556 557 /* prepare command */ 558 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_ENABLE, 559 cmd_flags, 560 token); 561 cmd_params = (struct dpsw_cmd_if *)cmd.params; 562 cmd_params->if_id = cpu_to_le16(if_id); 563 564 /* send command to mc*/ 565 return mc_send_command(mc_io, &cmd); 566} 567 568/** 569 * dpsw_if_disable() - Disable Interface 570 * @mc_io: Pointer to MC portal's I/O object 571 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 572 * @token: Token of DPSW object 573 * @if_id: Interface Identifier 574 * 575 * Return: Completion status. '0' on Success; Error code otherwise. 576 */ 577int dpsw_if_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 if_id) 578{ 579 struct fsl_mc_command cmd = { 0 }; 580 struct dpsw_cmd_if *cmd_params; 581 582 /* prepare command */ 583 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_DISABLE, 584 cmd_flags, 585 token); 586 cmd_params = (struct dpsw_cmd_if *)cmd.params; 587 cmd_params->if_id = cpu_to_le16(if_id); 588 589 /* send command to mc*/ 590 return mc_send_command(mc_io, &cmd); 591} 592 593/** 594 * dpsw_if_get_attributes() - Function obtains attributes of interface 595 * @mc_io: Pointer to MC portal's I/O object 596 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 597 * @token: Token of DPSW object 598 * @if_id: Interface Identifier 599 * @attr: Returned interface attributes 600 * 601 * Return: Completion status. '0' on Success; Error code otherwise. 602 */ 603int dpsw_if_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 604 u16 if_id, struct dpsw_if_attr *attr) 605{ 606 struct dpsw_rsp_if_get_attr *rsp_params; 607 struct fsl_mc_command cmd = { 0 }; 608 struct dpsw_cmd_if *cmd_params; 609 int err; 610 611 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_GET_ATTR, cmd_flags, 612 token); 613 cmd_params = (struct dpsw_cmd_if *)cmd.params; 614 cmd_params->if_id = cpu_to_le16(if_id); 615 616 err = mc_send_command(mc_io, &cmd); 617 if (err) 618 return err; 619 620 rsp_params = (struct dpsw_rsp_if_get_attr *)cmd.params; 621 attr->num_tcs = rsp_params->num_tcs; 622 attr->rate = le32_to_cpu(rsp_params->rate); 623 attr->options = le32_to_cpu(rsp_params->options); 624 attr->qdid = le16_to_cpu(rsp_params->qdid); 625 attr->enabled = dpsw_get_field(rsp_params->conf, ENABLED); 626 attr->accept_all_vlan = dpsw_get_field(rsp_params->conf, 627 ACCEPT_ALL_VLAN); 628 attr->admit_untagged = dpsw_get_field(rsp_params->conf, 629 ADMIT_UNTAGGED); 630 631 return 0; 632} 633 634/** 635 * dpsw_if_set_max_frame_length() - Set Maximum Receive frame length. 636 * @mc_io: Pointer to MC portal's I/O object 637 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 638 * @token: Token of DPSW object 639 * @if_id: Interface Identifier 640 * @frame_length: Maximum Frame Length 641 * 642 * Return: Completion status. '0' on Success; Error code otherwise. 643 */ 644int dpsw_if_set_max_frame_length(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 645 u16 if_id, u16 frame_length) 646{ 647 struct fsl_mc_command cmd = { 0 }; 648 struct dpsw_cmd_if_set_max_frame_length *cmd_params; 649 650 /* prepare command */ 651 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_SET_MAX_FRAME_LENGTH, 652 cmd_flags, 653 token); 654 cmd_params = (struct dpsw_cmd_if_set_max_frame_length *)cmd.params; 655 cmd_params->if_id = cpu_to_le16(if_id); 656 cmd_params->frame_length = cpu_to_le16(frame_length); 657 658 /* send command to mc*/ 659 return mc_send_command(mc_io, &cmd); 660} 661 662/** 663 * dpsw_vlan_add() - Adding new VLAN to DPSW. 664 * @mc_io: Pointer to MC portal's I/O object 665 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 666 * @token: Token of DPSW object 667 * @vlan_id: VLAN Identifier 668 * @cfg: VLAN configuration 669 * 670 * Only VLAN ID and FDB ID are required parameters here. 671 * 12 bit VLAN ID is defined in IEEE802.1Q. 672 * Adding a duplicate VLAN ID is not allowed. 673 * FDB ID can be shared across multiple VLANs. Shared learning 674 * is obtained by calling dpsw_vlan_add for multiple VLAN IDs 675 * with same fdb_id 676 * 677 * Return: Completion status. '0' on Success; Error code otherwise. 678 */ 679int dpsw_vlan_add(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 680 u16 vlan_id, const struct dpsw_vlan_cfg *cfg) 681{ 682 struct fsl_mc_command cmd = { 0 }; 683 struct dpsw_vlan_add *cmd_params; 684 685 /* prepare command */ 686 cmd.header = mc_encode_cmd_header(DPSW_CMDID_VLAN_ADD, 687 cmd_flags, 688 token); 689 cmd_params = (struct dpsw_vlan_add *)cmd.params; 690 cmd_params->fdb_id = cpu_to_le16(cfg->fdb_id); 691 cmd_params->vlan_id = cpu_to_le16(vlan_id); 692 693 /* send command to mc*/ 694 return mc_send_command(mc_io, &cmd); 695} 696 697/** 698 * dpsw_vlan_add_if() - Adding a set of interfaces to an existing VLAN. 699 * @mc_io: Pointer to MC portal's I/O object 700 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 701 * @token: Token of DPSW object 702 * @vlan_id: VLAN Identifier 703 * @cfg: Set of interfaces to add 704 * 705 * It adds only interfaces not belonging to this VLAN yet, 706 * otherwise an error is generated and an entire command is 707 * ignored. This function can be called numerous times always 708 * providing required interfaces delta. 709 * 710 * Return: Completion status. '0' on Success; Error code otherwise. 711 */ 712int dpsw_vlan_add_if(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 713 u16 vlan_id, const struct dpsw_vlan_if_cfg *cfg) 714{ 715 struct dpsw_cmd_vlan_add_if *cmd_params; 716 struct fsl_mc_command cmd = { 0 }; 717 718 /* prepare command */ 719 cmd.header = mc_encode_cmd_header(DPSW_CMDID_VLAN_ADD_IF, 720 cmd_flags, 721 token); 722 cmd_params = (struct dpsw_cmd_vlan_add_if *)cmd.params; 723 cmd_params->vlan_id = cpu_to_le16(vlan_id); 724 cmd_params->options = cpu_to_le16(cfg->options); 725 cmd_params->fdb_id = cpu_to_le16(cfg->fdb_id); 726 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 727 728 /* send command to mc*/ 729 return mc_send_command(mc_io, &cmd); 730} 731 732/** 733 * dpsw_vlan_add_if_untagged() - Defining a set of interfaces that should be 734 * transmitted as untagged. 735 * @mc_io: Pointer to MC portal's I/O object 736 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 737 * @token: Token of DPSW object 738 * @vlan_id: VLAN Identifier 739 * @cfg: Set of interfaces that should be transmitted as untagged 740 * 741 * These interfaces should already belong to this VLAN. 742 * By default all interfaces are transmitted as tagged. 743 * Providing un-existing interface or untagged interface that is 744 * configured untagged already generates an error and the entire 745 * command is ignored. 746 * 747 * Return: Completion status. '0' on Success; Error code otherwise. 748 */ 749int dpsw_vlan_add_if_untagged(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 750 u16 vlan_id, const struct dpsw_vlan_if_cfg *cfg) 751{ 752 struct fsl_mc_command cmd = { 0 }; 753 struct dpsw_cmd_vlan_manage_if *cmd_params; 754 755 /* prepare command */ 756 cmd.header = mc_encode_cmd_header(DPSW_CMDID_VLAN_ADD_IF_UNTAGGED, 757 cmd_flags, 758 token); 759 cmd_params = (struct dpsw_cmd_vlan_manage_if *)cmd.params; 760 cmd_params->vlan_id = cpu_to_le16(vlan_id); 761 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 762 763 /* send command to mc*/ 764 return mc_send_command(mc_io, &cmd); 765} 766 767/** 768 * dpsw_vlan_remove_if() - Remove interfaces from an existing VLAN. 769 * @mc_io: Pointer to MC portal's I/O object 770 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 771 * @token: Token of DPSW object 772 * @vlan_id: VLAN Identifier 773 * @cfg: Set of interfaces that should be removed 774 * 775 * Interfaces must belong to this VLAN, otherwise an error 776 * is returned and an the command is ignored 777 * 778 * Return: Completion status. '0' on Success; Error code otherwise. 779 */ 780int dpsw_vlan_remove_if(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 781 u16 vlan_id, const struct dpsw_vlan_if_cfg *cfg) 782{ 783 struct fsl_mc_command cmd = { 0 }; 784 struct dpsw_cmd_vlan_manage_if *cmd_params; 785 786 /* prepare command */ 787 cmd.header = mc_encode_cmd_header(DPSW_CMDID_VLAN_REMOVE_IF, 788 cmd_flags, 789 token); 790 cmd_params = (struct dpsw_cmd_vlan_manage_if *)cmd.params; 791 cmd_params->vlan_id = cpu_to_le16(vlan_id); 792 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 793 794 /* send command to mc*/ 795 return mc_send_command(mc_io, &cmd); 796} 797 798/** 799 * dpsw_vlan_remove_if_untagged() - Define a set of interfaces that should be 800 * converted from transmitted as untagged to transmit as tagged. 801 * @mc_io: Pointer to MC portal's I/O object 802 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 803 * @token: Token of DPSW object 804 * @vlan_id: VLAN Identifier 805 * @cfg: Set of interfaces that should be removed 806 * 807 * Interfaces provided by API have to belong to this VLAN and 808 * configured untagged, otherwise an error is returned and the 809 * command is ignored 810 * 811 * Return: Completion status. '0' on Success; Error code otherwise. 812 */ 813int dpsw_vlan_remove_if_untagged(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 814 u16 vlan_id, const struct dpsw_vlan_if_cfg *cfg) 815{ 816 struct fsl_mc_command cmd = { 0 }; 817 struct dpsw_cmd_vlan_manage_if *cmd_params; 818 819 /* prepare command */ 820 cmd.header = mc_encode_cmd_header(DPSW_CMDID_VLAN_REMOVE_IF_UNTAGGED, 821 cmd_flags, 822 token); 823 cmd_params = (struct dpsw_cmd_vlan_manage_if *)cmd.params; 824 cmd_params->vlan_id = cpu_to_le16(vlan_id); 825 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 826 827 /* send command to mc*/ 828 return mc_send_command(mc_io, &cmd); 829} 830 831/** 832 * dpsw_vlan_remove() - Remove an entire VLAN 833 * @mc_io: Pointer to MC portal's I/O object 834 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 835 * @token: Token of DPSW object 836 * @vlan_id: VLAN Identifier 837 * 838 * Return: Completion status. '0' on Success; Error code otherwise. 839 */ 840int dpsw_vlan_remove(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 841 u16 vlan_id) 842{ 843 struct fsl_mc_command cmd = { 0 }; 844 struct dpsw_cmd_vlan_remove *cmd_params; 845 846 /* prepare command */ 847 cmd.header = mc_encode_cmd_header(DPSW_CMDID_VLAN_REMOVE, 848 cmd_flags, 849 token); 850 cmd_params = (struct dpsw_cmd_vlan_remove *)cmd.params; 851 cmd_params->vlan_id = cpu_to_le16(vlan_id); 852 853 /* send command to mc*/ 854 return mc_send_command(mc_io, &cmd); 855} 856 857/** 858 * dpsw_fdb_add() - Add FDB to switch and Returns handle to FDB table for 859 * the reference 860 * @mc_io: Pointer to MC portal's I/O object 861 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 862 * @token: Token of DPSW object 863 * @fdb_id: Returned Forwarding Database Identifier 864 * @cfg: FDB Configuration 865 * 866 * Return: Completion status. '0' on Success; Error code otherwise. 867 */ 868int dpsw_fdb_add(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 *fdb_id, 869 const struct dpsw_fdb_cfg *cfg) 870{ 871 struct dpsw_cmd_fdb_add *cmd_params; 872 struct dpsw_rsp_fdb_add *rsp_params; 873 struct fsl_mc_command cmd = { 0 }; 874 int err; 875 876 cmd.header = mc_encode_cmd_header(DPSW_CMDID_FDB_ADD, 877 cmd_flags, 878 token); 879 cmd_params = (struct dpsw_cmd_fdb_add *)cmd.params; 880 cmd_params->fdb_ageing_time = cpu_to_le16(cfg->fdb_ageing_time); 881 cmd_params->num_fdb_entries = cpu_to_le16(cfg->num_fdb_entries); 882 883 err = mc_send_command(mc_io, &cmd); 884 if (err) 885 return err; 886 887 rsp_params = (struct dpsw_rsp_fdb_add *)cmd.params; 888 *fdb_id = le16_to_cpu(rsp_params->fdb_id); 889 890 return 0; 891} 892 893/** 894 * dpsw_fdb_remove() - Remove FDB from switch 895 * @mc_io: Pointer to MC portal's I/O object 896 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 897 * @token: Token of DPSW object 898 * @fdb_id: Forwarding Database Identifier 899 * 900 * Return: Completion status. '0' on Success; Error code otherwise. 901 */ 902int dpsw_fdb_remove(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 fdb_id) 903{ 904 struct dpsw_cmd_fdb_remove *cmd_params; 905 struct fsl_mc_command cmd = { 0 }; 906 907 /* prepare command */ 908 cmd.header = mc_encode_cmd_header(DPSW_CMDID_FDB_REMOVE, 909 cmd_flags, 910 token); 911 cmd_params = (struct dpsw_cmd_fdb_remove *)cmd.params; 912 cmd_params->fdb_id = cpu_to_le16(fdb_id); 913 914 return mc_send_command(mc_io, &cmd); 915} 916 917/** 918 * dpsw_fdb_add_unicast() - Function adds an unicast entry into MAC lookup table 919 * @mc_io: Pointer to MC portal's I/O object 920 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 921 * @token: Token of DPSW object 922 * @fdb_id: Forwarding Database Identifier 923 * @cfg: Unicast entry configuration 924 * 925 * Return: Completion status. '0' on Success; Error code otherwise. 926 */ 927int dpsw_fdb_add_unicast(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 928 u16 fdb_id, const struct dpsw_fdb_unicast_cfg *cfg) 929{ 930 struct fsl_mc_command cmd = { 0 }; 931 struct dpsw_cmd_fdb_unicast_op *cmd_params; 932 int i; 933 934 /* prepare command */ 935 cmd.header = mc_encode_cmd_header(DPSW_CMDID_FDB_ADD_UNICAST, 936 cmd_flags, 937 token); 938 cmd_params = (struct dpsw_cmd_fdb_unicast_op *)cmd.params; 939 cmd_params->fdb_id = cpu_to_le16(fdb_id); 940 cmd_params->if_egress = cpu_to_le16(cfg->if_egress); 941 for (i = 0; i < 6; i++) 942 cmd_params->mac_addr[i] = cfg->mac_addr[5 - i]; 943 dpsw_set_field(cmd_params->type, ENTRY_TYPE, cfg->type); 944 945 /* send command to mc*/ 946 return mc_send_command(mc_io, &cmd); 947} 948 949/** 950 * dpsw_fdb_dump() - Dump the content of FDB table into memory. 951 * @mc_io: Pointer to MC portal's I/O object 952 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 953 * @token: Token of DPSW object 954 * @fdb_id: Forwarding Database Identifier 955 * @iova_addr: Data will be stored here as an array of struct fdb_dump_entry 956 * @iova_size: Memory size allocated at iova_addr 957 * @num_entries:Number of entries written at iova_addr 958 * 959 * Return: Completion status. '0' on Success; Error code otherwise. 960 * 961 * The memory allocated at iova_addr must be initialized with zero before 962 * command execution. If the FDB table does not fit into memory MC will stop 963 * after the memory is filled up. 964 * The struct fdb_dump_entry array must be parsed until the end of memory 965 * area or until an entry with mac_addr set to zero is found. 966 */ 967int dpsw_fdb_dump(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 fdb_id, 968 u64 iova_addr, u32 iova_size, u16 *num_entries) 969{ 970 struct dpsw_cmd_fdb_dump *cmd_params; 971 struct dpsw_rsp_fdb_dump *rsp_params; 972 struct fsl_mc_command cmd = { 0 }; 973 int err; 974 975 /* prepare command */ 976 cmd.header = mc_encode_cmd_header(DPSW_CMDID_FDB_DUMP, 977 cmd_flags, 978 token); 979 cmd_params = (struct dpsw_cmd_fdb_dump *)cmd.params; 980 cmd_params->fdb_id = cpu_to_le16(fdb_id); 981 cmd_params->iova_addr = cpu_to_le64(iova_addr); 982 cmd_params->iova_size = cpu_to_le32(iova_size); 983 984 /* send command to mc */ 985 err = mc_send_command(mc_io, &cmd); 986 if (err) 987 return err; 988 989 rsp_params = (struct dpsw_rsp_fdb_dump *)cmd.params; 990 *num_entries = le16_to_cpu(rsp_params->num_entries); 991 992 return 0; 993} 994 995/** 996 * dpsw_fdb_remove_unicast() - removes an entry from MAC lookup table 997 * @mc_io: Pointer to MC portal's I/O object 998 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 999 * @token: Token of DPSW object 1000 * @fdb_id: Forwarding Database Identifier 1001 * @cfg: Unicast entry configuration 1002 * 1003 * Return: Completion status. '0' on Success; Error code otherwise. 1004 */ 1005int dpsw_fdb_remove_unicast(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1006 u16 fdb_id, const struct dpsw_fdb_unicast_cfg *cfg) 1007{ 1008 struct fsl_mc_command cmd = { 0 }; 1009 struct dpsw_cmd_fdb_unicast_op *cmd_params; 1010 int i; 1011 1012 /* prepare command */ 1013 cmd.header = mc_encode_cmd_header(DPSW_CMDID_FDB_REMOVE_UNICAST, 1014 cmd_flags, 1015 token); 1016 cmd_params = (struct dpsw_cmd_fdb_unicast_op *)cmd.params; 1017 cmd_params->fdb_id = cpu_to_le16(fdb_id); 1018 for (i = 0; i < 6; i++) 1019 cmd_params->mac_addr[i] = cfg->mac_addr[5 - i]; 1020 cmd_params->if_egress = cpu_to_le16(cfg->if_egress); 1021 dpsw_set_field(cmd_params->type, ENTRY_TYPE, cfg->type); 1022 1023 /* send command to mc*/ 1024 return mc_send_command(mc_io, &cmd); 1025} 1026 1027/** 1028 * dpsw_fdb_add_multicast() - Add a set of egress interfaces to multi-cast group 1029 * @mc_io: Pointer to MC portal's I/O object 1030 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1031 * @token: Token of DPSW object 1032 * @fdb_id: Forwarding Database Identifier 1033 * @cfg: Multicast entry configuration 1034 * 1035 * If group doesn't exist, it will be created. 1036 * It adds only interfaces not belonging to this multicast group 1037 * yet, otherwise error will be generated and the command is 1038 * ignored. 1039 * This function may be called numerous times always providing 1040 * required interfaces delta. 1041 * 1042 * Return: Completion status. '0' on Success; Error code otherwise. 1043 */ 1044int dpsw_fdb_add_multicast(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1045 u16 fdb_id, const struct dpsw_fdb_multicast_cfg *cfg) 1046{ 1047 struct fsl_mc_command cmd = { 0 }; 1048 struct dpsw_cmd_fdb_multicast_op *cmd_params; 1049 int i; 1050 1051 /* prepare command */ 1052 cmd.header = mc_encode_cmd_header(DPSW_CMDID_FDB_ADD_MULTICAST, 1053 cmd_flags, 1054 token); 1055 cmd_params = (struct dpsw_cmd_fdb_multicast_op *)cmd.params; 1056 cmd_params->fdb_id = cpu_to_le16(fdb_id); 1057 cmd_params->num_ifs = cpu_to_le16(cfg->num_ifs); 1058 dpsw_set_field(cmd_params->type, ENTRY_TYPE, cfg->type); 1059 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 1060 for (i = 0; i < 6; i++) 1061 cmd_params->mac_addr[i] = cfg->mac_addr[5 - i]; 1062 1063 /* send command to mc*/ 1064 return mc_send_command(mc_io, &cmd); 1065} 1066 1067/** 1068 * dpsw_fdb_remove_multicast() - Removing interfaces from an existing multicast 1069 * group. 1070 * @mc_io: Pointer to MC portal's I/O object 1071 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1072 * @token: Token of DPSW object 1073 * @fdb_id: Forwarding Database Identifier 1074 * @cfg: Multicast entry configuration 1075 * 1076 * Interfaces provided by this API have to exist in the group, 1077 * otherwise an error will be returned and an entire command 1078 * ignored. If there is no interface left in the group, 1079 * an entire group is deleted 1080 * 1081 * Return: Completion status. '0' on Success; Error code otherwise. 1082 */ 1083int dpsw_fdb_remove_multicast(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1084 u16 fdb_id, const struct dpsw_fdb_multicast_cfg *cfg) 1085{ 1086 struct fsl_mc_command cmd = { 0 }; 1087 struct dpsw_cmd_fdb_multicast_op *cmd_params; 1088 int i; 1089 1090 /* prepare command */ 1091 cmd.header = mc_encode_cmd_header(DPSW_CMDID_FDB_REMOVE_MULTICAST, 1092 cmd_flags, 1093 token); 1094 cmd_params = (struct dpsw_cmd_fdb_multicast_op *)cmd.params; 1095 cmd_params->fdb_id = cpu_to_le16(fdb_id); 1096 cmd_params->num_ifs = cpu_to_le16(cfg->num_ifs); 1097 dpsw_set_field(cmd_params->type, ENTRY_TYPE, cfg->type); 1098 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 1099 for (i = 0; i < 6; i++) 1100 cmd_params->mac_addr[i] = cfg->mac_addr[5 - i]; 1101 1102 /* send command to mc*/ 1103 return mc_send_command(mc_io, &cmd); 1104} 1105 1106/** 1107 * dpsw_ctrl_if_get_attributes() - Obtain control interface attributes 1108 * @mc_io: Pointer to MC portal's I/O object 1109 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1110 * @token: Token of DPSW object 1111 * @attr: Returned control interface attributes 1112 * 1113 * Return: '0' on Success; Error code otherwise. 1114 */ 1115int dpsw_ctrl_if_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags, 1116 u16 token, struct dpsw_ctrl_if_attr *attr) 1117{ 1118 struct dpsw_rsp_ctrl_if_get_attr *rsp_params; 1119 struct fsl_mc_command cmd = { 0 }; 1120 int err; 1121 1122 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CTRL_IF_GET_ATTR, 1123 cmd_flags, token); 1124 1125 err = mc_send_command(mc_io, &cmd); 1126 if (err) 1127 return err; 1128 1129 rsp_params = (struct dpsw_rsp_ctrl_if_get_attr *)cmd.params; 1130 attr->rx_fqid = le32_to_cpu(rsp_params->rx_fqid); 1131 attr->rx_err_fqid = le32_to_cpu(rsp_params->rx_err_fqid); 1132 attr->tx_err_conf_fqid = le32_to_cpu(rsp_params->tx_err_conf_fqid); 1133 1134 return 0; 1135} 1136 1137/** 1138 * dpsw_ctrl_if_set_pools() - Set control interface buffer pools 1139 * @mc_io: Pointer to MC portal's I/O object 1140 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1141 * @token: Token of DPSW object 1142 * @cfg: Buffer pools configuration 1143 * 1144 * Return: '0' on Success; Error code otherwise. 1145 */ 1146int dpsw_ctrl_if_set_pools(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1147 const struct dpsw_ctrl_if_pools_cfg *cfg) 1148{ 1149 struct dpsw_cmd_ctrl_if_set_pools *cmd_params; 1150 struct fsl_mc_command cmd = { 0 }; 1151 int i; 1152 1153 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CTRL_IF_SET_POOLS, 1154 cmd_flags, token); 1155 cmd_params = (struct dpsw_cmd_ctrl_if_set_pools *)cmd.params; 1156 cmd_params->num_dpbp = cfg->num_dpbp; 1157 for (i = 0; i < DPSW_MAX_DPBP; i++) { 1158 cmd_params->dpbp_id[i] = cpu_to_le32(cfg->pools[i].dpbp_id); 1159 cmd_params->buffer_size[i] = 1160 cpu_to_le16(cfg->pools[i].buffer_size); 1161 cmd_params->backup_pool_mask |= 1162 DPSW_BACKUP_POOL(cfg->pools[i].backup_pool, i); 1163 } 1164 1165 return mc_send_command(mc_io, &cmd); 1166} 1167 1168/** 1169 * dpsw_ctrl_if_set_queue() - Set Rx queue configuration 1170 * @mc_io: Pointer to MC portal's I/O object 1171 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1172 * @token: Token of dpsw object 1173 * @qtype: dpsw_queue_type of the targeted queue 1174 * @cfg: Rx queue configuration 1175 * 1176 * Return: '0' on Success; Error code otherwise. 1177 */ 1178int dpsw_ctrl_if_set_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1179 enum dpsw_queue_type qtype, 1180 const struct dpsw_ctrl_if_queue_cfg *cfg) 1181{ 1182 struct dpsw_cmd_ctrl_if_set_queue *cmd_params; 1183 struct fsl_mc_command cmd = { 0 }; 1184 1185 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CTRL_IF_SET_QUEUE, 1186 cmd_flags, 1187 token); 1188 cmd_params = (struct dpsw_cmd_ctrl_if_set_queue *)cmd.params; 1189 cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id); 1190 cmd_params->dest_priority = cfg->dest_cfg.priority; 1191 cmd_params->qtype = qtype; 1192 cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx); 1193 cmd_params->options = cpu_to_le32(cfg->options); 1194 dpsw_set_field(cmd_params->dest_type, 1195 DEST_TYPE, 1196 cfg->dest_cfg.dest_type); 1197 1198 return mc_send_command(mc_io, &cmd); 1199} 1200 1201/** 1202 * dpsw_get_api_version() - Get Data Path Switch API version 1203 * @mc_io: Pointer to MC portal's I/O object 1204 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1205 * @major_ver: Major version of data path switch API 1206 * @minor_ver: Minor version of data path switch API 1207 * 1208 * Return: '0' on Success; Error code otherwise. 1209 */ 1210int dpsw_get_api_version(struct fsl_mc_io *mc_io, u32 cmd_flags, 1211 u16 *major_ver, u16 *minor_ver) 1212{ 1213 struct fsl_mc_command cmd = { 0 }; 1214 struct dpsw_rsp_get_api_version *rsp_params; 1215 int err; 1216 1217 cmd.header = mc_encode_cmd_header(DPSW_CMDID_GET_API_VERSION, 1218 cmd_flags, 1219 0); 1220 1221 err = mc_send_command(mc_io, &cmd); 1222 if (err) 1223 return err; 1224 1225 rsp_params = (struct dpsw_rsp_get_api_version *)cmd.params; 1226 *major_ver = le16_to_cpu(rsp_params->version_major); 1227 *minor_ver = le16_to_cpu(rsp_params->version_minor); 1228 1229 return 0; 1230} 1231 1232/** 1233 * dpsw_if_get_port_mac_addr() - Retrieve MAC address associated to the physical port 1234 * @mc_io: Pointer to MC portal's I/O object 1235 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1236 * @token: Token of DPSW object 1237 * @if_id: Interface Identifier 1238 * @mac_addr: MAC address of the physical port, if any, otherwise 0 1239 * 1240 * Return: Completion status. '0' on Success; Error code otherwise. 1241 */ 1242int dpsw_if_get_port_mac_addr(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1243 u16 if_id, u8 mac_addr[6]) 1244{ 1245 struct dpsw_rsp_if_get_mac_addr *rsp_params; 1246 struct fsl_mc_command cmd = { 0 }; 1247 struct dpsw_cmd_if *cmd_params; 1248 int err, i; 1249 1250 /* prepare command */ 1251 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_GET_PORT_MAC_ADDR, 1252 cmd_flags, 1253 token); 1254 cmd_params = (struct dpsw_cmd_if *)cmd.params; 1255 cmd_params->if_id = cpu_to_le16(if_id); 1256 1257 /* send command to mc*/ 1258 err = mc_send_command(mc_io, &cmd); 1259 if (err) 1260 return err; 1261 1262 /* retrieve response parameters */ 1263 rsp_params = (struct dpsw_rsp_if_get_mac_addr *)cmd.params; 1264 for (i = 0; i < 6; i++) 1265 mac_addr[5 - i] = rsp_params->mac_addr[i]; 1266 1267 return 0; 1268} 1269 1270/** 1271 * dpsw_ctrl_if_enable() - Enable control interface 1272 * @mc_io: Pointer to MC portal's I/O object 1273 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1274 * @token: Token of DPSW object 1275 * 1276 * Return: '0' on Success; Error code otherwise. 1277 */ 1278int dpsw_ctrl_if_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token) 1279{ 1280 struct fsl_mc_command cmd = { 0 }; 1281 1282 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CTRL_IF_ENABLE, cmd_flags, 1283 token); 1284 1285 return mc_send_command(mc_io, &cmd); 1286} 1287 1288/** 1289 * dpsw_ctrl_if_disable() - Function disables control interface 1290 * @mc_io: Pointer to MC portal's I/O object 1291 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1292 * @token: Token of DPSW object 1293 * 1294 * Return: '0' on Success; Error code otherwise. 1295 */ 1296int dpsw_ctrl_if_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token) 1297{ 1298 struct fsl_mc_command cmd = { 0 }; 1299 1300 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CTRL_IF_DISABLE, 1301 cmd_flags, 1302 token); 1303 1304 return mc_send_command(mc_io, &cmd); 1305} 1306 1307/** 1308 * dpsw_set_egress_flood() - Set egress parameters associated with an FDB ID 1309 * @mc_io: Pointer to MC portal's I/O object 1310 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1311 * @token: Token of DPSW object 1312 * @cfg: Egress flooding configuration 1313 * 1314 * Return: '0' on Success; Error code otherwise. 1315 */ 1316int dpsw_set_egress_flood(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1317 const struct dpsw_egress_flood_cfg *cfg) 1318{ 1319 struct dpsw_cmd_set_egress_flood *cmd_params; 1320 struct fsl_mc_command cmd = { 0 }; 1321 1322 cmd.header = mc_encode_cmd_header(DPSW_CMDID_SET_EGRESS_FLOOD, cmd_flags, token); 1323 cmd_params = (struct dpsw_cmd_set_egress_flood *)cmd.params; 1324 cmd_params->fdb_id = cpu_to_le16(cfg->fdb_id); 1325 cmd_params->flood_type = cfg->flood_type; 1326 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 1327 1328 return mc_send_command(mc_io, &cmd); 1329} 1330 1331/** 1332 * dpsw_if_set_learning_mode() - Configure the learning mode on an interface. 1333 * If this API is used, it will take precedence over the FDB configuration. 1334 * @mc_io: Pointer to MC portal's I/O object 1335 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1336 * @token: Token of DPSW object 1337 * @if_id: InterfaceID 1338 * @mode: Learning mode 1339 * 1340 * Return: Completion status. '0' on Success; Error code otherwise. 1341 */ 1342int dpsw_if_set_learning_mode(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1343 u16 if_id, enum dpsw_learning_mode mode) 1344{ 1345 struct dpsw_cmd_if_set_learning_mode *cmd_params; 1346 struct fsl_mc_command cmd = { 0 }; 1347 1348 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_SET_LEARNING_MODE, 1349 cmd_flags, 1350 token); 1351 cmd_params = (struct dpsw_cmd_if_set_learning_mode *)cmd.params; 1352 cmd_params->if_id = cpu_to_le16(if_id); 1353 dpsw_set_field(cmd_params->mode, LEARNING_MODE, mode); 1354 1355 return mc_send_command(mc_io, &cmd); 1356} 1357 1358/** 1359 * dpsw_acl_add() - Create an ACL table 1360 * @mc_io: Pointer to MC portal's I/O object 1361 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1362 * @token: Token of DPSW object 1363 * @acl_id: Returned ACL ID, for future references 1364 * @cfg: ACL configuration 1365 * 1366 * Create Access Control List table. Multiple ACLs can be created and 1367 * co-exist in L2 switch 1368 * 1369 * Return: '0' on Success; Error code otherwise. 1370 */ 1371int dpsw_acl_add(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, u16 *acl_id, 1372 const struct dpsw_acl_cfg *cfg) 1373{ 1374 struct dpsw_cmd_acl_add *cmd_params; 1375 struct dpsw_rsp_acl_add *rsp_params; 1376 struct fsl_mc_command cmd = { 0 }; 1377 int err; 1378 1379 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ACL_ADD, cmd_flags, token); 1380 cmd_params = (struct dpsw_cmd_acl_add *)cmd.params; 1381 cmd_params->max_entries = cpu_to_le16(cfg->max_entries); 1382 1383 err = mc_send_command(mc_io, &cmd); 1384 if (err) 1385 return err; 1386 1387 rsp_params = (struct dpsw_rsp_acl_add *)cmd.params; 1388 *acl_id = le16_to_cpu(rsp_params->acl_id); 1389 1390 return 0; 1391} 1392 1393/** 1394 * dpsw_acl_remove() - Remove an ACL table from L2 switch. 1395 * @mc_io: Pointer to MC portal's I/O object 1396 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1397 * @token: Token of DPSW object 1398 * @acl_id: ACL ID 1399 * 1400 * Return: '0' on Success; Error code otherwise. 1401 */ 1402int dpsw_acl_remove(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1403 u16 acl_id) 1404{ 1405 struct dpsw_cmd_acl_remove *cmd_params; 1406 struct fsl_mc_command cmd = { 0 }; 1407 1408 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ACL_REMOVE, cmd_flags, 1409 token); 1410 cmd_params = (struct dpsw_cmd_acl_remove *)cmd.params; 1411 cmd_params->acl_id = cpu_to_le16(acl_id); 1412 1413 return mc_send_command(mc_io, &cmd); 1414} 1415 1416/** 1417 * dpsw_acl_add_if() - Associate interface/interfaces with an ACL table. 1418 * @mc_io: Pointer to MC portal's I/O object 1419 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1420 * @token: Token of DPSW object 1421 * @acl_id: ACL ID 1422 * @cfg: Interfaces list 1423 * 1424 * Return: '0' on Success; Error code otherwise. 1425 */ 1426int dpsw_acl_add_if(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1427 u16 acl_id, const struct dpsw_acl_if_cfg *cfg) 1428{ 1429 struct dpsw_cmd_acl_if *cmd_params; 1430 struct fsl_mc_command cmd = { 0 }; 1431 1432 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ACL_ADD_IF, cmd_flags, 1433 token); 1434 cmd_params = (struct dpsw_cmd_acl_if *)cmd.params; 1435 cmd_params->acl_id = cpu_to_le16(acl_id); 1436 cmd_params->num_ifs = cpu_to_le16(cfg->num_ifs); 1437 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 1438 1439 return mc_send_command(mc_io, &cmd); 1440} 1441 1442/** 1443 * dpsw_acl_remove_if() - De-associate interface/interfaces from an ACL table 1444 * @mc_io: Pointer to MC portal's I/O object 1445 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1446 * @token: Token of DPSW object 1447 * @acl_id: ACL ID 1448 * @cfg: Interfaces list 1449 * 1450 * Return: '0' on Success; Error code otherwise. 1451 */ 1452int dpsw_acl_remove_if(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1453 u16 acl_id, const struct dpsw_acl_if_cfg *cfg) 1454{ 1455 struct dpsw_cmd_acl_if *cmd_params; 1456 struct fsl_mc_command cmd = { 0 }; 1457 1458 /* prepare command */ 1459 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ACL_REMOVE_IF, cmd_flags, 1460 token); 1461 cmd_params = (struct dpsw_cmd_acl_if *)cmd.params; 1462 cmd_params->acl_id = cpu_to_le16(acl_id); 1463 cmd_params->num_ifs = cpu_to_le16(cfg->num_ifs); 1464 build_if_id_bitmap(&cmd_params->if_id, cfg->if_id, cfg->num_ifs); 1465 1466 /* send command to mc*/ 1467 return mc_send_command(mc_io, &cmd); 1468} 1469 1470/** 1471 * dpsw_acl_prepare_entry_cfg() - Setup an ACL entry 1472 * @key: Key 1473 * @entry_cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA 1474 * 1475 * This function has to be called before adding or removing acl_entry 1476 * 1477 */ 1478void dpsw_acl_prepare_entry_cfg(const struct dpsw_acl_key *key, 1479 u8 *entry_cfg_buf) 1480{ 1481 struct dpsw_prep_acl_entry *ext_params; 1482 int i; 1483 1484 ext_params = (struct dpsw_prep_acl_entry *)entry_cfg_buf; 1485 1486 for (i = 0; i < 6; i++) { 1487 ext_params->match_l2_dest_mac[i] = key->match.l2_dest_mac[5 - i]; 1488 ext_params->match_l2_source_mac[i] = key->match.l2_source_mac[5 - i]; 1489 ext_params->mask_l2_dest_mac[i] = key->mask.l2_dest_mac[5 - i]; 1490 ext_params->mask_l2_source_mac[i] = key->mask.l2_source_mac[5 - i]; 1491 } 1492 1493 ext_params->match_l2_tpid = cpu_to_le16(key->match.l2_tpid); 1494 ext_params->match_l2_vlan_id = cpu_to_le16(key->match.l2_vlan_id); 1495 ext_params->match_l3_dest_ip = cpu_to_le32(key->match.l3_dest_ip); 1496 ext_params->match_l3_source_ip = cpu_to_le32(key->match.l3_source_ip); 1497 ext_params->match_l4_dest_port = cpu_to_le16(key->match.l4_dest_port); 1498 ext_params->match_l4_source_port = cpu_to_le16(key->match.l4_source_port); 1499 ext_params->match_l2_ether_type = cpu_to_le16(key->match.l2_ether_type); 1500 ext_params->match_l2_pcp_dei = key->match.l2_pcp_dei; 1501 ext_params->match_l3_dscp = key->match.l3_dscp; 1502 1503 ext_params->mask_l2_tpid = cpu_to_le16(key->mask.l2_tpid); 1504 ext_params->mask_l2_vlan_id = cpu_to_le16(key->mask.l2_vlan_id); 1505 ext_params->mask_l3_dest_ip = cpu_to_le32(key->mask.l3_dest_ip); 1506 ext_params->mask_l3_source_ip = cpu_to_le32(key->mask.l3_source_ip); 1507 ext_params->mask_l4_dest_port = cpu_to_le16(key->mask.l4_dest_port); 1508 ext_params->mask_l4_source_port = cpu_to_le16(key->mask.l4_source_port); 1509 ext_params->mask_l2_ether_type = cpu_to_le16(key->mask.l2_ether_type); 1510 ext_params->mask_l2_pcp_dei = key->mask.l2_pcp_dei; 1511 ext_params->mask_l3_dscp = key->mask.l3_dscp; 1512 ext_params->match_l3_protocol = key->match.l3_protocol; 1513 ext_params->mask_l3_protocol = key->mask.l3_protocol; 1514} 1515 1516/** 1517 * dpsw_acl_add_entry() - Add a rule to the ACL table. 1518 * @mc_io: Pointer to MC portal's I/O object 1519 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1520 * @token: Token of DPSW object 1521 * @acl_id: ACL ID 1522 * @cfg: Entry configuration 1523 * 1524 * warning: This function has to be called after dpsw_acl_prepare_entry_cfg() 1525 * 1526 * Return: '0' on Success; Error code otherwise. 1527 */ 1528int dpsw_acl_add_entry(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1529 u16 acl_id, const struct dpsw_acl_entry_cfg *cfg) 1530{ 1531 struct dpsw_cmd_acl_entry *cmd_params; 1532 struct fsl_mc_command cmd = { 0 }; 1533 1534 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ACL_ADD_ENTRY, cmd_flags, 1535 token); 1536 cmd_params = (struct dpsw_cmd_acl_entry *)cmd.params; 1537 cmd_params->acl_id = cpu_to_le16(acl_id); 1538 cmd_params->result_if_id = cpu_to_le16(cfg->result.if_id); 1539 cmd_params->precedence = cpu_to_le32(cfg->precedence); 1540 cmd_params->key_iova = cpu_to_le64(cfg->key_iova); 1541 dpsw_set_field(cmd_params->result_action, 1542 RESULT_ACTION, 1543 cfg->result.action); 1544 1545 return mc_send_command(mc_io, &cmd); 1546} 1547 1548/** 1549 * dpsw_acl_remove_entry() - Removes an entry from ACL. 1550 * @mc_io: Pointer to MC portal's I/O object 1551 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1552 * @token: Token of DPSW object 1553 * @acl_id: ACL ID 1554 * @cfg: Entry configuration 1555 * 1556 * warning: This function has to be called after dpsw_acl_set_entry_cfg() 1557 * 1558 * Return: '0' on Success; Error code otherwise. 1559 */ 1560int dpsw_acl_remove_entry(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1561 u16 acl_id, const struct dpsw_acl_entry_cfg *cfg) 1562{ 1563 struct dpsw_cmd_acl_entry *cmd_params; 1564 struct fsl_mc_command cmd = { 0 }; 1565 1566 /* prepare command */ 1567 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ACL_REMOVE_ENTRY, 1568 cmd_flags, 1569 token); 1570 cmd_params = (struct dpsw_cmd_acl_entry *)cmd.params; 1571 cmd_params->acl_id = cpu_to_le16(acl_id); 1572 cmd_params->result_if_id = cpu_to_le16(cfg->result.if_id); 1573 cmd_params->precedence = cpu_to_le32(cfg->precedence); 1574 cmd_params->key_iova = cpu_to_le64(cfg->key_iova); 1575 dpsw_set_field(cmd_params->result_action, 1576 RESULT_ACTION, 1577 cfg->result.action); 1578 1579 /* send command to mc*/ 1580 return mc_send_command(mc_io, &cmd); 1581} 1582 1583/** 1584 * dpsw_set_reflection_if() - Set target interface for traffic mirrored 1585 * @mc_io: Pointer to MC portal's I/O object 1586 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1587 * @token: Token of DPSW object 1588 * @if_id: Interface Id 1589 * 1590 * Only one mirroring destination is allowed per switch 1591 * 1592 * Return: Completion status. '0' on Success; Error code otherwise. 1593 */ 1594int dpsw_set_reflection_if(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1595 u16 if_id) 1596{ 1597 struct dpsw_cmd_set_reflection_if *cmd_params; 1598 struct fsl_mc_command cmd = { 0 }; 1599 1600 cmd.header = mc_encode_cmd_header(DPSW_CMDID_SET_REFLECTION_IF, 1601 cmd_flags, 1602 token); 1603 cmd_params = (struct dpsw_cmd_set_reflection_if *)cmd.params; 1604 cmd_params->if_id = cpu_to_le16(if_id); 1605 1606 return mc_send_command(mc_io, &cmd); 1607} 1608 1609/** 1610 * dpsw_if_add_reflection() - Setup mirroring rule 1611 * @mc_io: Pointer to MC portal's I/O object 1612 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1613 * @token: Token of DPSW object 1614 * @if_id: Interface Identifier 1615 * @cfg: Reflection configuration 1616 * 1617 * Return: Completion status. '0' on Success; Error code otherwise. 1618 */ 1619int dpsw_if_add_reflection(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1620 u16 if_id, const struct dpsw_reflection_cfg *cfg) 1621{ 1622 struct dpsw_cmd_if_reflection *cmd_params; 1623 struct fsl_mc_command cmd = { 0 }; 1624 1625 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_ADD_REFLECTION, 1626 cmd_flags, 1627 token); 1628 cmd_params = (struct dpsw_cmd_if_reflection *)cmd.params; 1629 cmd_params->if_id = cpu_to_le16(if_id); 1630 cmd_params->vlan_id = cpu_to_le16(cfg->vlan_id); 1631 dpsw_set_field(cmd_params->filter, FILTER, cfg->filter); 1632 1633 return mc_send_command(mc_io, &cmd); 1634} 1635 1636/** 1637 * dpsw_if_remove_reflection() - Remove mirroring rule 1638 * @mc_io: Pointer to MC portal's I/O object 1639 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 1640 * @token: Token of DPSW object 1641 * @if_id: Interface Identifier 1642 * @cfg: Reflection configuration 1643 * 1644 * Return: Completion status. '0' on Success; Error code otherwise. 1645 */ 1646int dpsw_if_remove_reflection(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token, 1647 u16 if_id, const struct dpsw_reflection_cfg *cfg) 1648{ 1649 struct dpsw_cmd_if_reflection *cmd_params; 1650 struct fsl_mc_command cmd = { 0 }; 1651 1652 cmd.header = mc_encode_cmd_header(DPSW_CMDID_IF_REMOVE_REFLECTION, 1653 cmd_flags, 1654 token); 1655 cmd_params = (struct dpsw_cmd_if_reflection *)cmd.params; 1656 cmd_params->if_id = cpu_to_le16(if_id); 1657 cmd_params->vlan_id = cpu_to_le16(cfg->vlan_id); 1658 dpsw_set_field(cmd_params->filter, FILTER, cfg->filter); 1659 1660 return mc_send_command(mc_io, &cmd); 1661} 1662