1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2019-2021, Intel Corporation. */ 3 4 #include "ice_vsi_vlan_lib.h" 5 #include "ice_lib.h" 6 #include "ice_fltr.h" 7 #include "ice.h" 8 9 static void print_invalid_tpid(struct ice_vsi *vsi, u16 tpid) 10 { 11 dev_err(ice_pf_to_dev(vsi->back), "%s %d specified invalid VLAN tpid 0x%04x\n", 12 ice_vsi_type_str(vsi->type), vsi->idx, tpid); 13 } 14 15 /** 16 * validate_vlan - check if the ice_vlan passed in is valid 17 * @vsi: VSI used for printing error message 18 * @vlan: ice_vlan structure to validate 19 * 20 * Return true if the VLAN TPID is valid or if the VLAN TPID is 0 and the VLAN 21 * VID is 0, which allows for non-zero VLAN filters with the specified VLAN TPID 22 * and untagged VLAN 0 filters to be added to the prune list respectively. 23 */ 24 static bool validate_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan) 25 { 26 if (vlan->tpid != ETH_P_8021Q && vlan->tpid != ETH_P_8021AD && 27 vlan->tpid != ETH_P_QINQ1 && (vlan->tpid || vlan->vid)) { 28 print_invalid_tpid(vsi, vlan->tpid); 29 return false; 30 } 31 32 return true; 33 } 34 35 /** 36 * ice_vsi_add_vlan - default add VLAN implementation for all VSI types 37 * @vsi: VSI being configured 38 * @vlan: VLAN filter to add 39 */ 40 int ice_vsi_add_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan) 41 { 42 int err; 43 44 if (!validate_vlan(vsi, vlan)) 45 return -EINVAL; 46 47 err = ice_fltr_add_vlan(vsi, vlan); 48 if (err && err != -EEXIST) { 49 dev_err(ice_pf_to_dev(vsi->back), "Failure Adding VLAN %d on VSI %i, status %d\n", 50 vlan->vid, vsi->vsi_num, err); 51 return err; 52 } 53 54 vsi->num_vlan++; 55 return 0; 56 } 57 58 /** 59 * ice_vsi_del_vlan - default del VLAN implementation for all VSI types 60 * @vsi: VSI being configured 61 * @vlan: VLAN filter to delete 62 */ 63 int ice_vsi_del_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan) 64 { 65 struct ice_pf *pf = vsi->back; 66 struct device *dev; 67 int err; 68 69 if (!validate_vlan(vsi, vlan)) 70 return -EINVAL; 71 72 dev = ice_pf_to_dev(pf); 73 74 err = ice_fltr_remove_vlan(vsi, vlan); 75 if (!err) 76 vsi->num_vlan--; 77 else if (err == -ENOENT || err == -EBUSY) 78 err = 0; 79 else 80 dev_err(dev, "Error removing VLAN %d on VSI %i error: %d\n", 81 vlan->vid, vsi->vsi_num, err); 82 83 return err; 84 } 85 86 /** 87 * ice_vsi_manage_vlan_insertion - Manage VLAN insertion for the VSI for Tx 88 * @vsi: the VSI being changed 89 */ 90 static int ice_vsi_manage_vlan_insertion(struct ice_vsi *vsi) 91 { 92 struct ice_hw *hw = &vsi->back->hw; 93 struct ice_vsi_ctx *ctxt; 94 int err; 95 96 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 97 if (!ctxt) 98 return -ENOMEM; 99 100 /* Here we are configuring the VSI to let the driver add VLAN tags by 101 * setting inner_vlan_flags to ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL. The actual VLAN tag 102 * insertion happens in the Tx hot path, in ice_tx_map. 103 */ 104 ctxt->info.inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL; 105 106 /* Preserve existing VLAN strip setting */ 107 ctxt->info.inner_vlan_flags |= (vsi->info.inner_vlan_flags & 108 ICE_AQ_VSI_INNER_VLAN_EMODE_M); 109 110 ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID); 111 112 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 113 if (err) { 114 dev_err(ice_pf_to_dev(vsi->back), "update VSI for VLAN insert failed, err %d aq_err %s\n", 115 err, ice_aq_str(hw->adminq.sq_last_status)); 116 goto out; 117 } 118 119 vsi->info.inner_vlan_flags = ctxt->info.inner_vlan_flags; 120 out: 121 kfree(ctxt); 122 return err; 123 } 124 125 /** 126 * ice_vsi_manage_vlan_stripping - Manage VLAN stripping for the VSI for Rx 127 * @vsi: the VSI being changed 128 * @ena: boolean value indicating if this is a enable or disable request 129 */ 130 static int ice_vsi_manage_vlan_stripping(struct ice_vsi *vsi, bool ena) 131 { 132 struct ice_hw *hw = &vsi->back->hw; 133 struct ice_vsi_ctx *ctxt; 134 int err; 135 136 /* do not allow modifying VLAN stripping when a port VLAN is configured 137 * on this VSI 138 */ 139 if (vsi->info.port_based_inner_vlan) 140 return 0; 141 142 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 143 if (!ctxt) 144 return -ENOMEM; 145 146 /* Here we are configuring what the VSI should do with the VLAN tag in 147 * the Rx packet. We can either leave the tag in the packet or put it in 148 * the Rx descriptor. 149 */ 150 if (ena) 151 /* Strip VLAN tag from Rx packet and put it in the desc */ 152 ctxt->info.inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_EMODE_STR_BOTH; 153 else 154 /* Disable stripping. Leave tag in packet */ 155 ctxt->info.inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING; 156 157 /* Allow all packets untagged/tagged */ 158 ctxt->info.inner_vlan_flags |= ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL; 159 160 ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID); 161 162 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 163 if (err) { 164 dev_err(ice_pf_to_dev(vsi->back), "update VSI for VLAN strip failed, ena = %d err %d aq_err %s\n", 165 ena, err, ice_aq_str(hw->adminq.sq_last_status)); 166 goto out; 167 } 168 169 vsi->info.inner_vlan_flags = ctxt->info.inner_vlan_flags; 170 out: 171 kfree(ctxt); 172 return err; 173 } 174 175 int ice_vsi_ena_inner_stripping(struct ice_vsi *vsi, const u16 tpid) 176 { 177 if (tpid != ETH_P_8021Q) { 178 print_invalid_tpid(vsi, tpid); 179 return -EINVAL; 180 } 181 182 return ice_vsi_manage_vlan_stripping(vsi, true); 183 } 184 185 int ice_vsi_dis_inner_stripping(struct ice_vsi *vsi) 186 { 187 return ice_vsi_manage_vlan_stripping(vsi, false); 188 } 189 190 int ice_vsi_ena_inner_insertion(struct ice_vsi *vsi, const u16 tpid) 191 { 192 if (tpid != ETH_P_8021Q) { 193 print_invalid_tpid(vsi, tpid); 194 return -EINVAL; 195 } 196 197 return ice_vsi_manage_vlan_insertion(vsi); 198 } 199 200 int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi) 201 { 202 return ice_vsi_manage_vlan_insertion(vsi); 203 } 204 205 static void 206 ice_save_vlan_info(struct ice_aqc_vsi_props *info, 207 struct ice_vsi_vlan_info *vlan) 208 { 209 vlan->sw_flags2 = info->sw_flags2; 210 vlan->inner_vlan_flags = info->inner_vlan_flags; 211 vlan->outer_vlan_flags = info->outer_vlan_flags; 212 } 213 214 static void 215 ice_restore_vlan_info(struct ice_aqc_vsi_props *info, 216 struct ice_vsi_vlan_info *vlan) 217 { 218 info->sw_flags2 = vlan->sw_flags2; 219 info->inner_vlan_flags = vlan->inner_vlan_flags; 220 info->outer_vlan_flags = vlan->outer_vlan_flags; 221 } 222 223 /** 224 * __ice_vsi_set_inner_port_vlan - set port VLAN VSI context settings to enable a port VLAN 225 * @vsi: the VSI to update 226 * @pvid_info: VLAN ID and QoS used to set the PVID VSI context field 227 */ 228 static int __ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, u16 pvid_info) 229 { 230 struct ice_hw *hw = &vsi->back->hw; 231 struct ice_aqc_vsi_props *info; 232 struct ice_vsi_ctx *ctxt; 233 int ret; 234 235 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 236 if (!ctxt) 237 return -ENOMEM; 238 239 ice_save_vlan_info(&vsi->info, &vsi->vlan_info); 240 ctxt->info = vsi->info; 241 info = &ctxt->info; 242 info->inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTUNTAGGED | 243 ICE_AQ_VSI_INNER_VLAN_INSERT_PVID | 244 ICE_AQ_VSI_INNER_VLAN_EMODE_STR; 245 info->sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; 246 247 info->port_based_inner_vlan = cpu_to_le16(pvid_info); 248 info->valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID | 249 ICE_AQ_VSI_PROP_SW_VALID); 250 251 ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 252 if (ret) { 253 dev_info(ice_hw_to_dev(hw), "update VSI for port VLAN failed, err %d aq_err %s\n", 254 ret, ice_aq_str(hw->adminq.sq_last_status)); 255 goto out; 256 } 257 258 vsi->info.inner_vlan_flags = info->inner_vlan_flags; 259 vsi->info.sw_flags2 = info->sw_flags2; 260 vsi->info.port_based_inner_vlan = info->port_based_inner_vlan; 261 out: 262 kfree(ctxt); 263 return ret; 264 } 265 266 int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan) 267 { 268 u16 port_vlan_info; 269 270 if (vlan->tpid != ETH_P_8021Q) 271 return -EINVAL; 272 273 if (vlan->prio > 7) 274 return -EINVAL; 275 276 port_vlan_info = vlan->vid | (vlan->prio << VLAN_PRIO_SHIFT); 277 278 return __ice_vsi_set_inner_port_vlan(vsi, port_vlan_info); 279 } 280 281 int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi) 282 { 283 struct ice_hw *hw = &vsi->back->hw; 284 struct ice_aqc_vsi_props *info; 285 struct ice_vsi_ctx *ctxt; 286 int ret; 287 288 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 289 if (!ctxt) 290 return -ENOMEM; 291 292 ice_restore_vlan_info(&vsi->info, &vsi->vlan_info); 293 vsi->info.port_based_inner_vlan = 0; 294 ctxt->info = vsi->info; 295 info = &ctxt->info; 296 info->valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID | 297 ICE_AQ_VSI_PROP_SW_VALID); 298 299 ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 300 if (ret) 301 dev_err(ice_hw_to_dev(hw), "update VSI for port VLAN failed, err %d aq_err %s\n", 302 ret, ice_aq_str(hw->adminq.sq_last_status)); 303 304 kfree(ctxt); 305 return ret; 306 } 307 308 /** 309 * ice_cfg_vlan_pruning - enable or disable VLAN pruning on the VSI 310 * @vsi: VSI to enable or disable VLAN pruning on 311 * @ena: set to true to enable VLAN pruning and false to disable it 312 * 313 * returns 0 if VSI is updated, negative otherwise 314 */ 315 static int ice_cfg_vlan_pruning(struct ice_vsi *vsi, bool ena) 316 { 317 struct ice_vsi_ctx *ctxt; 318 struct ice_pf *pf; 319 int status; 320 321 if (!vsi) 322 return -EINVAL; 323 324 /* Don't enable VLAN pruning if the netdev is currently in promiscuous 325 * mode. VLAN pruning will be enabled when the interface exits 326 * promiscuous mode if any VLAN filters are active. 327 */ 328 if (vsi->netdev && vsi->netdev->flags & IFF_PROMISC && ena) 329 return 0; 330 331 pf = vsi->back; 332 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 333 if (!ctxt) 334 return -ENOMEM; 335 336 ctxt->info = vsi->info; 337 338 if (ena) 339 ctxt->info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; 340 else 341 ctxt->info.sw_flags2 &= ~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; 342 343 ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID); 344 345 status = ice_update_vsi(&pf->hw, vsi->idx, ctxt, NULL); 346 if (status) { 347 netdev_err(vsi->netdev, "%sabling VLAN pruning on VSI handle: %d, VSI HW ID: %d failed, err = %d, aq_err = %s\n", 348 ena ? "En" : "Dis", vsi->idx, vsi->vsi_num, status, 349 ice_aq_str(pf->hw.adminq.sq_last_status)); 350 goto err_out; 351 } 352 353 vsi->info.sw_flags2 = ctxt->info.sw_flags2; 354 355 kfree(ctxt); 356 return 0; 357 358 err_out: 359 kfree(ctxt); 360 return status; 361 } 362 363 int ice_vsi_ena_rx_vlan_filtering(struct ice_vsi *vsi) 364 { 365 return ice_cfg_vlan_pruning(vsi, true); 366 } 367 368 int ice_vsi_dis_rx_vlan_filtering(struct ice_vsi *vsi) 369 { 370 return ice_cfg_vlan_pruning(vsi, false); 371 } 372 373 static int ice_cfg_vlan_antispoof(struct ice_vsi *vsi, bool enable) 374 { 375 struct ice_vsi_ctx *ctx; 376 int err; 377 378 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 379 if (!ctx) 380 return -ENOMEM; 381 382 ctx->info.sec_flags = vsi->info.sec_flags; 383 ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID); 384 385 if (enable) 386 ctx->info.sec_flags |= ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA << 387 ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S; 388 else 389 ctx->info.sec_flags &= ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA << 390 ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S); 391 392 err = ice_update_vsi(&vsi->back->hw, vsi->idx, ctx, NULL); 393 if (err) 394 dev_err(ice_pf_to_dev(vsi->back), "Failed to configure Tx VLAN anti-spoof %s for VSI %d, error %d\n", 395 enable ? "ON" : "OFF", vsi->vsi_num, err); 396 else 397 vsi->info.sec_flags = ctx->info.sec_flags; 398 399 kfree(ctx); 400 401 return err; 402 } 403 404 int ice_vsi_ena_tx_vlan_filtering(struct ice_vsi *vsi) 405 { 406 return ice_cfg_vlan_antispoof(vsi, true); 407 } 408 409 int ice_vsi_dis_tx_vlan_filtering(struct ice_vsi *vsi) 410 { 411 return ice_cfg_vlan_antispoof(vsi, false); 412 } 413 414 /** 415 * tpid_to_vsi_outer_vlan_type - convert from TPID to VSI context based tag_type 416 * @tpid: tpid used to translate into VSI context based tag_type 417 * @tag_type: output variable to hold the VSI context based tag type 418 */ 419 static int tpid_to_vsi_outer_vlan_type(u16 tpid, u8 *tag_type) 420 { 421 switch (tpid) { 422 case ETH_P_8021Q: 423 *tag_type = ICE_AQ_VSI_OUTER_TAG_VLAN_8100; 424 break; 425 case ETH_P_8021AD: 426 *tag_type = ICE_AQ_VSI_OUTER_TAG_STAG; 427 break; 428 case ETH_P_QINQ1: 429 *tag_type = ICE_AQ_VSI_OUTER_TAG_VLAN_9100; 430 break; 431 default: 432 *tag_type = 0; 433 return -EINVAL; 434 } 435 436 return 0; 437 } 438 439 /** 440 * ice_vsi_ena_outer_stripping - enable outer VLAN stripping 441 * @vsi: VSI to configure 442 * @tpid: TPID to enable outer VLAN stripping for 443 * 444 * Enable outer VLAN stripping via VSI context. This function should only be 445 * used if DVM is supported. Also, this function should never be called directly 446 * as it should be part of ice_vsi_vlan_ops if it's needed. 447 * 448 * Since the VSI context only supports a single TPID for insertion and 449 * stripping, setting the TPID for stripping will affect the TPID for insertion. 450 * Callers need to be aware of this limitation. 451 * 452 * Only modify outer VLAN stripping settings and the VLAN TPID. Outer VLAN 453 * insertion settings are unmodified. 454 * 455 * This enables hardware to strip a VLAN tag with the specified TPID to be 456 * stripped from the packet and placed in the receive descriptor. 457 */ 458 int ice_vsi_ena_outer_stripping(struct ice_vsi *vsi, u16 tpid) 459 { 460 struct ice_hw *hw = &vsi->back->hw; 461 struct ice_vsi_ctx *ctxt; 462 u8 tag_type; 463 int err; 464 465 /* do not allow modifying VLAN stripping when a port VLAN is configured 466 * on this VSI 467 */ 468 if (vsi->info.port_based_outer_vlan) 469 return 0; 470 471 if (tpid_to_vsi_outer_vlan_type(tpid, &tag_type)) 472 return -EINVAL; 473 474 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 475 if (!ctxt) 476 return -ENOMEM; 477 478 ctxt->info.valid_sections = 479 cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); 480 /* clear current outer VLAN strip settings */ 481 ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags & 482 ~(ICE_AQ_VSI_OUTER_VLAN_EMODE_M | ICE_AQ_VSI_OUTER_TAG_TYPE_M); 483 ctxt->info.outer_vlan_flags |= 484 ((ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW_BOTH << 485 ICE_AQ_VSI_OUTER_VLAN_EMODE_S) | 486 ((tag_type << ICE_AQ_VSI_OUTER_TAG_TYPE_S) & 487 ICE_AQ_VSI_OUTER_TAG_TYPE_M)); 488 489 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 490 if (err) 491 dev_err(ice_pf_to_dev(vsi->back), "update VSI for enabling outer VLAN stripping failed, err %d aq_err %s\n", 492 err, ice_aq_str(hw->adminq.sq_last_status)); 493 else 494 vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags; 495 496 kfree(ctxt); 497 return err; 498 } 499 500 /** 501 * ice_vsi_dis_outer_stripping - disable outer VLAN stripping 502 * @vsi: VSI to configure 503 * 504 * Disable outer VLAN stripping via VSI context. This function should only be 505 * used if DVM is supported. Also, this function should never be called directly 506 * as it should be part of ice_vsi_vlan_ops if it's needed. 507 * 508 * Only modify the outer VLAN stripping settings. The VLAN TPID and outer VLAN 509 * insertion settings are unmodified. 510 * 511 * This tells the hardware to not strip any VLAN tagged packets, thus leaving 512 * them in the packet. This enables software offloaded VLAN stripping and 513 * disables hardware offloaded VLAN stripping. 514 */ 515 int ice_vsi_dis_outer_stripping(struct ice_vsi *vsi) 516 { 517 struct ice_hw *hw = &vsi->back->hw; 518 struct ice_vsi_ctx *ctxt; 519 int err; 520 521 if (vsi->info.port_based_outer_vlan) 522 return 0; 523 524 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 525 if (!ctxt) 526 return -ENOMEM; 527 528 ctxt->info.valid_sections = 529 cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); 530 /* clear current outer VLAN strip settings */ 531 ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags & 532 ~ICE_AQ_VSI_OUTER_VLAN_EMODE_M; 533 ctxt->info.outer_vlan_flags |= ICE_AQ_VSI_OUTER_VLAN_EMODE_NOTHING << 534 ICE_AQ_VSI_OUTER_VLAN_EMODE_S; 535 536 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 537 if (err) 538 dev_err(ice_pf_to_dev(vsi->back), "update VSI for disabling outer VLAN stripping failed, err %d aq_err %s\n", 539 err, ice_aq_str(hw->adminq.sq_last_status)); 540 else 541 vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags; 542 543 kfree(ctxt); 544 return err; 545 } 546 547 /** 548 * ice_vsi_ena_outer_insertion - enable outer VLAN insertion 549 * @vsi: VSI to configure 550 * @tpid: TPID to enable outer VLAN insertion for 551 * 552 * Enable outer VLAN insertion via VSI context. This function should only be 553 * used if DVM is supported. Also, this function should never be called directly 554 * as it should be part of ice_vsi_vlan_ops if it's needed. 555 * 556 * Since the VSI context only supports a single TPID for insertion and 557 * stripping, setting the TPID for insertion will affect the TPID for stripping. 558 * Callers need to be aware of this limitation. 559 * 560 * Only modify outer VLAN insertion settings and the VLAN TPID. Outer VLAN 561 * stripping settings are unmodified. 562 * 563 * This allows a VLAN tag with the specified TPID to be inserted in the transmit 564 * descriptor. 565 */ 566 int ice_vsi_ena_outer_insertion(struct ice_vsi *vsi, u16 tpid) 567 { 568 struct ice_hw *hw = &vsi->back->hw; 569 struct ice_vsi_ctx *ctxt; 570 u8 tag_type; 571 int err; 572 573 if (vsi->info.port_based_outer_vlan) 574 return 0; 575 576 if (tpid_to_vsi_outer_vlan_type(tpid, &tag_type)) 577 return -EINVAL; 578 579 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 580 if (!ctxt) 581 return -ENOMEM; 582 583 ctxt->info.valid_sections = 584 cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); 585 /* clear current outer VLAN insertion settings */ 586 ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags & 587 ~(ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_INSERT | 588 ICE_AQ_VSI_OUTER_VLAN_BLOCK_TX_DESC | 589 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M | 590 ICE_AQ_VSI_OUTER_TAG_TYPE_M); 591 ctxt->info.outer_vlan_flags |= 592 ((ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ALL << 593 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_S) & 594 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M) | 595 ((tag_type << ICE_AQ_VSI_OUTER_TAG_TYPE_S) & 596 ICE_AQ_VSI_OUTER_TAG_TYPE_M); 597 598 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 599 if (err) 600 dev_err(ice_pf_to_dev(vsi->back), "update VSI for enabling outer VLAN insertion failed, err %d aq_err %s\n", 601 err, ice_aq_str(hw->adminq.sq_last_status)); 602 else 603 vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags; 604 605 kfree(ctxt); 606 return err; 607 } 608 609 /** 610 * ice_vsi_dis_outer_insertion - disable outer VLAN insertion 611 * @vsi: VSI to configure 612 * 613 * Disable outer VLAN insertion via VSI context. This function should only be 614 * used if DVM is supported. Also, this function should never be called directly 615 * as it should be part of ice_vsi_vlan_ops if it's needed. 616 * 617 * Only modify the outer VLAN insertion settings. The VLAN TPID and outer VLAN 618 * settings are unmodified. 619 * 620 * This tells the hardware to not allow any VLAN tagged packets in the transmit 621 * descriptor. This enables software offloaded VLAN insertion and disables 622 * hardware offloaded VLAN insertion. 623 */ 624 int ice_vsi_dis_outer_insertion(struct ice_vsi *vsi) 625 { 626 struct ice_hw *hw = &vsi->back->hw; 627 struct ice_vsi_ctx *ctxt; 628 int err; 629 630 if (vsi->info.port_based_outer_vlan) 631 return 0; 632 633 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 634 if (!ctxt) 635 return -ENOMEM; 636 637 ctxt->info.valid_sections = 638 cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); 639 /* clear current outer VLAN insertion settings */ 640 ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags & 641 ~(ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_INSERT | 642 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M); 643 ctxt->info.outer_vlan_flags |= 644 ICE_AQ_VSI_OUTER_VLAN_BLOCK_TX_DESC | 645 ((ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ALL << 646 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_S) & 647 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M); 648 649 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 650 if (err) 651 dev_err(ice_pf_to_dev(vsi->back), "update VSI for disabling outer VLAN insertion failed, err %d aq_err %s\n", 652 err, ice_aq_str(hw->adminq.sq_last_status)); 653 else 654 vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags; 655 656 kfree(ctxt); 657 return err; 658 } 659 660 /** 661 * __ice_vsi_set_outer_port_vlan - set the outer port VLAN and related settings 662 * @vsi: VSI to configure 663 * @vlan_info: packed u16 that contains the VLAN prio and ID 664 * @tpid: TPID of the port VLAN 665 * 666 * Set the port VLAN prio, ID, and TPID. 667 * 668 * Enable VLAN pruning so the VSI doesn't receive any traffic that doesn't match 669 * a VLAN prune rule. The caller should take care to add a VLAN prune rule that 670 * matches the port VLAN ID and TPID. 671 * 672 * Tell hardware to strip outer VLAN tagged packets on receive and don't put 673 * them in the receive descriptor. VSI(s) in port VLANs should not be aware of 674 * the port VLAN ID or TPID they are assigned to. 675 * 676 * Tell hardware to prevent outer VLAN tag insertion on transmit and only allow 677 * untagged outer packets from the transmit descriptor. 678 * 679 * Also, tell the hardware to insert the port VLAN on transmit. 680 */ 681 static int 682 __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid) 683 { 684 struct ice_hw *hw = &vsi->back->hw; 685 struct ice_vsi_ctx *ctxt; 686 u8 tag_type; 687 int err; 688 689 if (tpid_to_vsi_outer_vlan_type(tpid, &tag_type)) 690 return -EINVAL; 691 692 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 693 if (!ctxt) 694 return -ENOMEM; 695 696 ice_save_vlan_info(&vsi->info, &vsi->vlan_info); 697 ctxt->info = vsi->info; 698 699 ctxt->info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; 700 701 ctxt->info.port_based_outer_vlan = cpu_to_le16(vlan_info); 702 ctxt->info.outer_vlan_flags = 703 (ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW << 704 ICE_AQ_VSI_OUTER_VLAN_EMODE_S) | 705 ((tag_type << ICE_AQ_VSI_OUTER_TAG_TYPE_S) & 706 ICE_AQ_VSI_OUTER_TAG_TYPE_M) | 707 ICE_AQ_VSI_OUTER_VLAN_BLOCK_TX_DESC | 708 (ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ACCEPTUNTAGGED << 709 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_S) | 710 ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_INSERT; 711 712 ctxt->info.valid_sections = 713 cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID | 714 ICE_AQ_VSI_PROP_SW_VALID); 715 716 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 717 if (err) { 718 dev_err(ice_pf_to_dev(vsi->back), "update VSI for setting outer port based VLAN failed, err %d aq_err %s\n", 719 err, ice_aq_str(hw->adminq.sq_last_status)); 720 } else { 721 vsi->info.port_based_outer_vlan = ctxt->info.port_based_outer_vlan; 722 vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags; 723 vsi->info.sw_flags2 = ctxt->info.sw_flags2; 724 } 725 726 kfree(ctxt); 727 return err; 728 } 729 730 /** 731 * ice_vsi_set_outer_port_vlan - public version of __ice_vsi_set_outer_port_vlan 732 * @vsi: VSI to configure 733 * @vlan: ice_vlan structure used to set the port VLAN 734 * 735 * Set the outer port VLAN via VSI context. This function should only be 736 * used if DVM is supported. Also, this function should never be called directly 737 * as it should be part of ice_vsi_vlan_ops if it's needed. 738 * 739 * Use the ice_vlan structure passed in to set this VSI in a port VLAN. 740 */ 741 int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan) 742 { 743 u16 port_vlan_info; 744 745 if (vlan->prio > (VLAN_PRIO_MASK >> VLAN_PRIO_SHIFT)) 746 return -EINVAL; 747 748 port_vlan_info = vlan->vid | (vlan->prio << VLAN_PRIO_SHIFT); 749 750 return __ice_vsi_set_outer_port_vlan(vsi, port_vlan_info, vlan->tpid); 751 } 752 753 /** 754 * ice_vsi_clear_outer_port_vlan - clear outer port vlan 755 * @vsi: VSI to configure 756 * 757 * The function is restoring previously set vlan config (saved in 758 * vsi->vlan_info). Setting happens in port vlan configuration. 759 */ 760 int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi) 761 { 762 struct ice_hw *hw = &vsi->back->hw; 763 struct ice_vsi_ctx *ctxt; 764 int err; 765 766 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 767 if (!ctxt) 768 return -ENOMEM; 769 770 ice_restore_vlan_info(&vsi->info, &vsi->vlan_info); 771 vsi->info.port_based_outer_vlan = 0; 772 ctxt->info = vsi->info; 773 774 ctxt->info.valid_sections = 775 cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID | 776 ICE_AQ_VSI_PROP_SW_VALID); 777 778 err = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 779 if (err) 780 dev_err(ice_pf_to_dev(vsi->back), "update VSI for clearing outer port based VLAN failed, err %d aq_err %s\n", 781 err, ice_aq_str(hw->adminq.sq_last_status)); 782 783 kfree(ctxt); 784 return err; 785 } 786