3970 lines · c
1// SPDX-License-Identifier: GPL-2.02/* Copyright (c) 2018, Intel Corporation. */3 4#include "ice.h"5#include "ice_base.h"6#include "ice_flow.h"7#include "ice_lib.h"8#include "ice_fltr.h"9#include "ice_dcb_lib.h"10#include "ice_type.h"11#include "ice_vsi_vlan_ops.h"12 13/**14 * ice_vsi_type_str - maps VSI type enum to string equivalents15 * @vsi_type: VSI type enum16 */17const char *ice_vsi_type_str(enum ice_vsi_type vsi_type)18{19 switch (vsi_type) {20 case ICE_VSI_PF:21 return "ICE_VSI_PF";22 case ICE_VSI_VF:23 return "ICE_VSI_VF";24 case ICE_VSI_SF:25 return "ICE_VSI_SF";26 case ICE_VSI_CTRL:27 return "ICE_VSI_CTRL";28 case ICE_VSI_CHNL:29 return "ICE_VSI_CHNL";30 case ICE_VSI_LB:31 return "ICE_VSI_LB";32 default:33 return "unknown";34 }35}36 37/**38 * ice_vsi_ctrl_all_rx_rings - Start or stop a VSI's Rx rings39 * @vsi: the VSI being configured40 * @ena: start or stop the Rx rings41 *42 * First enable/disable all of the Rx rings, flush any remaining writes, and43 * then verify that they have all been enabled/disabled successfully. This will44 * let all of the register writes complete when enabling/disabling the Rx rings45 * before waiting for the change in hardware to complete.46 */47static int ice_vsi_ctrl_all_rx_rings(struct ice_vsi *vsi, bool ena)48{49 int ret = 0;50 u16 i;51 52 ice_for_each_rxq(vsi, i)53 ice_vsi_ctrl_one_rx_ring(vsi, ena, i, false);54 55 ice_flush(&vsi->back->hw);56 57 ice_for_each_rxq(vsi, i) {58 ret = ice_vsi_wait_one_rx_ring(vsi, ena, i);59 if (ret)60 break;61 }62 63 return ret;64}65 66/**67 * ice_vsi_alloc_arrays - Allocate queue and vector pointer arrays for the VSI68 * @vsi: VSI pointer69 *70 * On error: returns error code (negative)71 * On success: returns 072 */73static int ice_vsi_alloc_arrays(struct ice_vsi *vsi)74{75 struct ice_pf *pf = vsi->back;76 struct device *dev;77 78 dev = ice_pf_to_dev(pf);79 if (vsi->type == ICE_VSI_CHNL)80 return 0;81 82 /* allocate memory for both Tx and Rx ring pointers */83 vsi->tx_rings = devm_kcalloc(dev, vsi->alloc_txq,84 sizeof(*vsi->tx_rings), GFP_KERNEL);85 if (!vsi->tx_rings)86 return -ENOMEM;87 88 vsi->rx_rings = devm_kcalloc(dev, vsi->alloc_rxq,89 sizeof(*vsi->rx_rings), GFP_KERNEL);90 if (!vsi->rx_rings)91 goto err_rings;92 93 /* txq_map needs to have enough space to track both Tx (stack) rings94 * and XDP rings; at this point vsi->num_xdp_txq might not be set,95 * so use num_possible_cpus() as we want to always provide XDP ring96 * per CPU, regardless of queue count settings from user that might97 * have come from ethtool's set_channels() callback;98 */99 vsi->txq_map = devm_kcalloc(dev, (vsi->alloc_txq + num_possible_cpus()),100 sizeof(*vsi->txq_map), GFP_KERNEL);101 102 if (!vsi->txq_map)103 goto err_txq_map;104 105 vsi->rxq_map = devm_kcalloc(dev, vsi->alloc_rxq,106 sizeof(*vsi->rxq_map), GFP_KERNEL);107 if (!vsi->rxq_map)108 goto err_rxq_map;109 110 /* There is no need to allocate q_vectors for a loopback VSI. */111 if (vsi->type == ICE_VSI_LB)112 return 0;113 114 /* allocate memory for q_vector pointers */115 vsi->q_vectors = devm_kcalloc(dev, vsi->num_q_vectors,116 sizeof(*vsi->q_vectors), GFP_KERNEL);117 if (!vsi->q_vectors)118 goto err_vectors;119 120 return 0;121 122err_vectors:123 devm_kfree(dev, vsi->rxq_map);124err_rxq_map:125 devm_kfree(dev, vsi->txq_map);126err_txq_map:127 devm_kfree(dev, vsi->rx_rings);128err_rings:129 devm_kfree(dev, vsi->tx_rings);130 return -ENOMEM;131}132 133/**134 * ice_vsi_set_num_desc - Set number of descriptors for queues on this VSI135 * @vsi: the VSI being configured136 */137static void ice_vsi_set_num_desc(struct ice_vsi *vsi)138{139 switch (vsi->type) {140 case ICE_VSI_PF:141 case ICE_VSI_SF:142 case ICE_VSI_CTRL:143 case ICE_VSI_LB:144 /* a user could change the values of num_[tr]x_desc using145 * ethtool -G so we should keep those values instead of146 * overwriting them with the defaults.147 */148 if (!vsi->num_rx_desc)149 vsi->num_rx_desc = ICE_DFLT_NUM_RX_DESC;150 if (!vsi->num_tx_desc)151 vsi->num_tx_desc = ICE_DFLT_NUM_TX_DESC;152 break;153 default:154 dev_dbg(ice_pf_to_dev(vsi->back), "Not setting number of Tx/Rx descriptors for VSI type %d\n",155 vsi->type);156 break;157 }158}159 160/**161 * ice_vsi_set_num_qs - Set number of queues, descriptors and vectors for a VSI162 * @vsi: the VSI being configured163 *164 * Return 0 on success and a negative value on error165 */166static void ice_vsi_set_num_qs(struct ice_vsi *vsi)167{168 enum ice_vsi_type vsi_type = vsi->type;169 struct ice_pf *pf = vsi->back;170 struct ice_vf *vf = vsi->vf;171 172 if (WARN_ON(vsi_type == ICE_VSI_VF && !vf))173 return;174 175 switch (vsi_type) {176 case ICE_VSI_PF:177 if (vsi->req_txq) {178 vsi->alloc_txq = vsi->req_txq;179 vsi->num_txq = vsi->req_txq;180 } else {181 vsi->alloc_txq = min3(pf->num_lan_msix,182 ice_get_avail_txq_count(pf),183 (u16)num_online_cpus());184 }185 186 pf->num_lan_tx = vsi->alloc_txq;187 188 /* only 1 Rx queue unless RSS is enabled */189 if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {190 vsi->alloc_rxq = 1;191 } else {192 if (vsi->req_rxq) {193 vsi->alloc_rxq = vsi->req_rxq;194 vsi->num_rxq = vsi->req_rxq;195 } else {196 vsi->alloc_rxq = min3(pf->num_lan_msix,197 ice_get_avail_rxq_count(pf),198 (u16)num_online_cpus());199 }200 }201 202 pf->num_lan_rx = vsi->alloc_rxq;203 204 vsi->num_q_vectors = min_t(int, pf->num_lan_msix,205 max_t(int, vsi->alloc_rxq,206 vsi->alloc_txq));207 break;208 case ICE_VSI_SF:209 vsi->alloc_txq = 1;210 vsi->alloc_rxq = 1;211 vsi->num_q_vectors = 1;212 vsi->irq_dyn_alloc = true;213 break;214 case ICE_VSI_VF:215 if (vf->num_req_qs)216 vf->num_vf_qs = vf->num_req_qs;217 vsi->alloc_txq = vf->num_vf_qs;218 vsi->alloc_rxq = vf->num_vf_qs;219 /* pf->vfs.num_msix_per includes (VF miscellaneous vector +220 * data queue interrupts). Since vsi->num_q_vectors is number221 * of queues vectors, subtract 1 (ICE_NONQ_VECS_VF) from the222 * original vector count223 */224 vsi->num_q_vectors = vf->num_msix - ICE_NONQ_VECS_VF;225 break;226 case ICE_VSI_CTRL:227 vsi->alloc_txq = 1;228 vsi->alloc_rxq = 1;229 vsi->num_q_vectors = 1;230 break;231 case ICE_VSI_CHNL:232 vsi->alloc_txq = 0;233 vsi->alloc_rxq = 0;234 break;235 case ICE_VSI_LB:236 vsi->alloc_txq = 1;237 vsi->alloc_rxq = 1;238 break;239 default:240 dev_warn(ice_pf_to_dev(pf), "Unknown VSI type %d\n", vsi_type);241 break;242 }243 244 ice_vsi_set_num_desc(vsi);245}246 247/**248 * ice_get_free_slot - get the next non-NULL location index in array249 * @array: array to search250 * @size: size of the array251 * @curr: last known occupied index to be used as a search hint252 *253 * void * is being used to keep the functionality generic. This lets us use this254 * function on any array of pointers.255 */256static int ice_get_free_slot(void *array, int size, int curr)257{258 int **tmp_array = (int **)array;259 int next;260 261 if (curr < (size - 1) && !tmp_array[curr + 1]) {262 next = curr + 1;263 } else {264 int i = 0;265 266 while ((i < size) && (tmp_array[i]))267 i++;268 if (i == size)269 next = ICE_NO_VSI;270 else271 next = i;272 }273 return next;274}275 276/**277 * ice_vsi_delete_from_hw - delete a VSI from the switch278 * @vsi: pointer to VSI being removed279 */280static void ice_vsi_delete_from_hw(struct ice_vsi *vsi)281{282 struct ice_pf *pf = vsi->back;283 struct ice_vsi_ctx *ctxt;284 int status;285 286 ice_fltr_remove_all(vsi);287 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);288 if (!ctxt)289 return;290 291 if (vsi->type == ICE_VSI_VF)292 ctxt->vf_num = vsi->vf->vf_id;293 ctxt->vsi_num = vsi->vsi_num;294 295 memcpy(&ctxt->info, &vsi->info, sizeof(ctxt->info));296 297 status = ice_free_vsi(&pf->hw, vsi->idx, ctxt, false, NULL);298 if (status)299 dev_err(ice_pf_to_dev(pf), "Failed to delete VSI %i in FW - error: %d\n",300 vsi->vsi_num, status);301 302 kfree(ctxt);303}304 305/**306 * ice_vsi_free_arrays - De-allocate queue and vector pointer arrays for the VSI307 * @vsi: pointer to VSI being cleared308 */309static void ice_vsi_free_arrays(struct ice_vsi *vsi)310{311 struct ice_pf *pf = vsi->back;312 struct device *dev;313 314 dev = ice_pf_to_dev(pf);315 316 /* free the ring and vector containers */317 devm_kfree(dev, vsi->q_vectors);318 vsi->q_vectors = NULL;319 devm_kfree(dev, vsi->tx_rings);320 vsi->tx_rings = NULL;321 devm_kfree(dev, vsi->rx_rings);322 vsi->rx_rings = NULL;323 devm_kfree(dev, vsi->txq_map);324 vsi->txq_map = NULL;325 devm_kfree(dev, vsi->rxq_map);326 vsi->rxq_map = NULL;327}328 329/**330 * ice_vsi_free_stats - Free the ring statistics structures331 * @vsi: VSI pointer332 */333static void ice_vsi_free_stats(struct ice_vsi *vsi)334{335 struct ice_vsi_stats *vsi_stat;336 struct ice_pf *pf = vsi->back;337 int i;338 339 if (vsi->type == ICE_VSI_CHNL)340 return;341 if (!pf->vsi_stats)342 return;343 344 vsi_stat = pf->vsi_stats[vsi->idx];345 if (!vsi_stat)346 return;347 348 ice_for_each_alloc_txq(vsi, i) {349 if (vsi_stat->tx_ring_stats[i]) {350 kfree_rcu(vsi_stat->tx_ring_stats[i], rcu);351 WRITE_ONCE(vsi_stat->tx_ring_stats[i], NULL);352 }353 }354 355 ice_for_each_alloc_rxq(vsi, i) {356 if (vsi_stat->rx_ring_stats[i]) {357 kfree_rcu(vsi_stat->rx_ring_stats[i], rcu);358 WRITE_ONCE(vsi_stat->rx_ring_stats[i], NULL);359 }360 }361 362 kfree(vsi_stat->tx_ring_stats);363 kfree(vsi_stat->rx_ring_stats);364 kfree(vsi_stat);365 pf->vsi_stats[vsi->idx] = NULL;366}367 368/**369 * ice_vsi_alloc_ring_stats - Allocates Tx and Rx ring stats for the VSI370 * @vsi: VSI which is having stats allocated371 */372static int ice_vsi_alloc_ring_stats(struct ice_vsi *vsi)373{374 struct ice_ring_stats **tx_ring_stats;375 struct ice_ring_stats **rx_ring_stats;376 struct ice_vsi_stats *vsi_stats;377 struct ice_pf *pf = vsi->back;378 u16 i;379 380 vsi_stats = pf->vsi_stats[vsi->idx];381 tx_ring_stats = vsi_stats->tx_ring_stats;382 rx_ring_stats = vsi_stats->rx_ring_stats;383 384 /* Allocate Tx ring stats */385 ice_for_each_alloc_txq(vsi, i) {386 struct ice_ring_stats *ring_stats;387 struct ice_tx_ring *ring;388 389 ring = vsi->tx_rings[i];390 ring_stats = tx_ring_stats[i];391 392 if (!ring_stats) {393 ring_stats = kzalloc(sizeof(*ring_stats), GFP_KERNEL);394 if (!ring_stats)395 goto err_out;396 397 WRITE_ONCE(tx_ring_stats[i], ring_stats);398 }399 400 ring->ring_stats = ring_stats;401 }402 403 /* Allocate Rx ring stats */404 ice_for_each_alloc_rxq(vsi, i) {405 struct ice_ring_stats *ring_stats;406 struct ice_rx_ring *ring;407 408 ring = vsi->rx_rings[i];409 ring_stats = rx_ring_stats[i];410 411 if (!ring_stats) {412 ring_stats = kzalloc(sizeof(*ring_stats), GFP_KERNEL);413 if (!ring_stats)414 goto err_out;415 416 WRITE_ONCE(rx_ring_stats[i], ring_stats);417 }418 419 ring->ring_stats = ring_stats;420 }421 422 return 0;423 424err_out:425 ice_vsi_free_stats(vsi);426 return -ENOMEM;427}428 429/**430 * ice_vsi_free - clean up and deallocate the provided VSI431 * @vsi: pointer to VSI being cleared432 *433 * This deallocates the VSI's queue resources, removes it from the PF's434 * VSI array if necessary, and deallocates the VSI435 */436void ice_vsi_free(struct ice_vsi *vsi)437{438 struct ice_pf *pf = NULL;439 struct device *dev;440 441 if (!vsi || !vsi->back)442 return;443 444 pf = vsi->back;445 dev = ice_pf_to_dev(pf);446 447 if (!pf->vsi[vsi->idx] || pf->vsi[vsi->idx] != vsi) {448 dev_dbg(dev, "vsi does not exist at pf->vsi[%d]\n", vsi->idx);449 return;450 }451 452 mutex_lock(&pf->sw_mutex);453 /* updates the PF for this cleared VSI */454 455 pf->vsi[vsi->idx] = NULL;456 pf->next_vsi = vsi->idx;457 458 ice_vsi_free_stats(vsi);459 ice_vsi_free_arrays(vsi);460 mutex_destroy(&vsi->xdp_state_lock);461 mutex_unlock(&pf->sw_mutex);462 devm_kfree(dev, vsi);463}464 465void ice_vsi_delete(struct ice_vsi *vsi)466{467 ice_vsi_delete_from_hw(vsi);468 ice_vsi_free(vsi);469}470 471/**472 * ice_msix_clean_ctrl_vsi - MSIX mode interrupt handler for ctrl VSI473 * @irq: interrupt number474 * @data: pointer to a q_vector475 */476static irqreturn_t ice_msix_clean_ctrl_vsi(int __always_unused irq, void *data)477{478 struct ice_q_vector *q_vector = (struct ice_q_vector *)data;479 480 if (!q_vector->tx.tx_ring)481 return IRQ_HANDLED;482 483#define FDIR_RX_DESC_CLEAN_BUDGET 64484 ice_clean_rx_irq(q_vector->rx.rx_ring, FDIR_RX_DESC_CLEAN_BUDGET);485 ice_clean_ctrl_tx_irq(q_vector->tx.tx_ring);486 487 return IRQ_HANDLED;488}489 490/**491 * ice_msix_clean_rings - MSIX mode Interrupt Handler492 * @irq: interrupt number493 * @data: pointer to a q_vector494 */495static irqreturn_t ice_msix_clean_rings(int __always_unused irq, void *data)496{497 struct ice_q_vector *q_vector = (struct ice_q_vector *)data;498 499 if (!q_vector->tx.tx_ring && !q_vector->rx.rx_ring)500 return IRQ_HANDLED;501 502 q_vector->total_events++;503 504 napi_schedule(&q_vector->napi);505 506 return IRQ_HANDLED;507}508 509/**510 * ice_vsi_alloc_stat_arrays - Allocate statistics arrays511 * @vsi: VSI pointer512 */513static int ice_vsi_alloc_stat_arrays(struct ice_vsi *vsi)514{515 struct ice_vsi_stats *vsi_stat;516 struct ice_pf *pf = vsi->back;517 518 if (vsi->type == ICE_VSI_CHNL)519 return 0;520 if (!pf->vsi_stats)521 return -ENOENT;522 523 if (pf->vsi_stats[vsi->idx])524 /* realloc will happen in rebuild path */525 return 0;526 527 vsi_stat = kzalloc(sizeof(*vsi_stat), GFP_KERNEL);528 if (!vsi_stat)529 return -ENOMEM;530 531 vsi_stat->tx_ring_stats =532 kcalloc(vsi->alloc_txq, sizeof(*vsi_stat->tx_ring_stats),533 GFP_KERNEL);534 if (!vsi_stat->tx_ring_stats)535 goto err_alloc_tx;536 537 vsi_stat->rx_ring_stats =538 kcalloc(vsi->alloc_rxq, sizeof(*vsi_stat->rx_ring_stats),539 GFP_KERNEL);540 if (!vsi_stat->rx_ring_stats)541 goto err_alloc_rx;542 543 pf->vsi_stats[vsi->idx] = vsi_stat;544 545 return 0;546 547err_alloc_rx:548 kfree(vsi_stat->rx_ring_stats);549err_alloc_tx:550 kfree(vsi_stat->tx_ring_stats);551 kfree(vsi_stat);552 pf->vsi_stats[vsi->idx] = NULL;553 return -ENOMEM;554}555 556/**557 * ice_vsi_alloc_def - set default values for already allocated VSI558 * @vsi: ptr to VSI559 * @ch: ptr to channel560 */561static int562ice_vsi_alloc_def(struct ice_vsi *vsi, struct ice_channel *ch)563{564 if (vsi->type != ICE_VSI_CHNL) {565 ice_vsi_set_num_qs(vsi);566 if (ice_vsi_alloc_arrays(vsi))567 return -ENOMEM;568 }569 570 switch (vsi->type) {571 case ICE_VSI_PF:572 case ICE_VSI_SF:573 /* Setup default MSIX irq handler for VSI */574 vsi->irq_handler = ice_msix_clean_rings;575 break;576 case ICE_VSI_CTRL:577 /* Setup ctrl VSI MSIX irq handler */578 vsi->irq_handler = ice_msix_clean_ctrl_vsi;579 break;580 case ICE_VSI_CHNL:581 if (!ch)582 return -EINVAL;583 584 vsi->num_rxq = ch->num_rxq;585 vsi->num_txq = ch->num_txq;586 vsi->next_base_q = ch->base_q;587 break;588 case ICE_VSI_VF:589 case ICE_VSI_LB:590 break;591 default:592 ice_vsi_free_arrays(vsi);593 return -EINVAL;594 }595 596 return 0;597}598 599/**600 * ice_vsi_alloc - Allocates the next available struct VSI in the PF601 * @pf: board private structure602 *603 * Reserves a VSI index from the PF and allocates an empty VSI structure604 * without a type. The VSI structure must later be initialized by calling605 * ice_vsi_cfg().606 *607 * returns a pointer to a VSI on success, NULL on failure.608 */609struct ice_vsi *ice_vsi_alloc(struct ice_pf *pf)610{611 struct device *dev = ice_pf_to_dev(pf);612 struct ice_vsi *vsi = NULL;613 614 /* Need to protect the allocation of the VSIs at the PF level */615 mutex_lock(&pf->sw_mutex);616 617 /* If we have already allocated our maximum number of VSIs,618 * pf->next_vsi will be ICE_NO_VSI. If not, pf->next_vsi index619 * is available to be populated620 */621 if (pf->next_vsi == ICE_NO_VSI) {622 dev_dbg(dev, "out of VSI slots!\n");623 goto unlock_pf;624 }625 626 vsi = devm_kzalloc(dev, sizeof(*vsi), GFP_KERNEL);627 if (!vsi)628 goto unlock_pf;629 630 vsi->back = pf;631 set_bit(ICE_VSI_DOWN, vsi->state);632 633 /* fill slot and make note of the index */634 vsi->idx = pf->next_vsi;635 pf->vsi[pf->next_vsi] = vsi;636 637 /* prepare pf->next_vsi for next use */638 pf->next_vsi = ice_get_free_slot(pf->vsi, pf->num_alloc_vsi,639 pf->next_vsi);640 641 mutex_init(&vsi->xdp_state_lock);642 643unlock_pf:644 mutex_unlock(&pf->sw_mutex);645 return vsi;646}647 648/**649 * ice_alloc_fd_res - Allocate FD resource for a VSI650 * @vsi: pointer to the ice_vsi651 *652 * This allocates the FD resources653 *654 * Returns 0 on success, -EPERM on no-op or -EIO on failure655 */656static int ice_alloc_fd_res(struct ice_vsi *vsi)657{658 struct ice_pf *pf = vsi->back;659 u32 g_val, b_val;660 661 /* Flow Director filters are only allocated/assigned to the PF VSI or662 * CHNL VSI which passes the traffic. The CTRL VSI is only used to663 * add/delete filters so resources are not allocated to it664 */665 if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))666 return -EPERM;667 668 if (!(vsi->type == ICE_VSI_PF || vsi->type == ICE_VSI_VF ||669 vsi->type == ICE_VSI_CHNL))670 return -EPERM;671 672 /* FD filters from guaranteed pool per VSI */673 g_val = pf->hw.func_caps.fd_fltr_guar;674 if (!g_val)675 return -EPERM;676 677 /* FD filters from best effort pool */678 b_val = pf->hw.func_caps.fd_fltr_best_effort;679 if (!b_val)680 return -EPERM;681 682 /* PF main VSI gets only 64 FD resources from guaranteed pool683 * when ADQ is configured.684 */685#define ICE_PF_VSI_GFLTR 64686 687 /* determine FD filter resources per VSI from shared(best effort) and688 * dedicated pool689 */690 if (vsi->type == ICE_VSI_PF) {691 vsi->num_gfltr = g_val;692 /* if MQPRIO is configured, main VSI doesn't get all FD693 * resources from guaranteed pool. PF VSI gets 64 FD resources694 */695 if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) {696 if (g_val < ICE_PF_VSI_GFLTR)697 return -EPERM;698 /* allow bare minimum entries for PF VSI */699 vsi->num_gfltr = ICE_PF_VSI_GFLTR;700 }701 702 /* each VSI gets same "best_effort" quota */703 vsi->num_bfltr = b_val;704 } else if (vsi->type == ICE_VSI_VF) {705 vsi->num_gfltr = 0;706 707 /* each VSI gets same "best_effort" quota */708 vsi->num_bfltr = b_val;709 } else {710 struct ice_vsi *main_vsi;711 int numtc;712 713 main_vsi = ice_get_main_vsi(pf);714 if (!main_vsi)715 return -EPERM;716 717 if (!main_vsi->all_numtc)718 return -EINVAL;719 720 /* figure out ADQ numtc */721 numtc = main_vsi->all_numtc - ICE_CHNL_START_TC;722 723 /* only one TC but still asking resources for channels,724 * invalid config725 */726 if (numtc < ICE_CHNL_START_TC)727 return -EPERM;728 729 g_val -= ICE_PF_VSI_GFLTR;730 /* channel VSIs gets equal share from guaranteed pool */731 vsi->num_gfltr = g_val / numtc;732 733 /* each VSI gets same "best_effort" quota */734 vsi->num_bfltr = b_val;735 }736 737 return 0;738}739 740/**741 * ice_vsi_get_qs - Assign queues from PF to VSI742 * @vsi: the VSI to assign queues to743 *744 * Returns 0 on success and a negative value on error745 */746static int ice_vsi_get_qs(struct ice_vsi *vsi)747{748 struct ice_pf *pf = vsi->back;749 struct ice_qs_cfg tx_qs_cfg = {750 .qs_mutex = &pf->avail_q_mutex,751 .pf_map = pf->avail_txqs,752 .pf_map_size = pf->max_pf_txqs,753 .q_count = vsi->alloc_txq,754 .scatter_count = ICE_MAX_SCATTER_TXQS,755 .vsi_map = vsi->txq_map,756 .vsi_map_offset = 0,757 .mapping_mode = ICE_VSI_MAP_CONTIG758 };759 struct ice_qs_cfg rx_qs_cfg = {760 .qs_mutex = &pf->avail_q_mutex,761 .pf_map = pf->avail_rxqs,762 .pf_map_size = pf->max_pf_rxqs,763 .q_count = vsi->alloc_rxq,764 .scatter_count = ICE_MAX_SCATTER_RXQS,765 .vsi_map = vsi->rxq_map,766 .vsi_map_offset = 0,767 .mapping_mode = ICE_VSI_MAP_CONTIG768 };769 int ret;770 771 if (vsi->type == ICE_VSI_CHNL)772 return 0;773 774 ret = __ice_vsi_get_qs(&tx_qs_cfg);775 if (ret)776 return ret;777 vsi->tx_mapping_mode = tx_qs_cfg.mapping_mode;778 779 ret = __ice_vsi_get_qs(&rx_qs_cfg);780 if (ret)781 return ret;782 vsi->rx_mapping_mode = rx_qs_cfg.mapping_mode;783 784 return 0;785}786 787/**788 * ice_vsi_put_qs - Release queues from VSI to PF789 * @vsi: the VSI that is going to release queues790 */791static void ice_vsi_put_qs(struct ice_vsi *vsi)792{793 struct ice_pf *pf = vsi->back;794 int i;795 796 mutex_lock(&pf->avail_q_mutex);797 798 ice_for_each_alloc_txq(vsi, i) {799 clear_bit(vsi->txq_map[i], pf->avail_txqs);800 vsi->txq_map[i] = ICE_INVAL_Q_INDEX;801 }802 803 ice_for_each_alloc_rxq(vsi, i) {804 clear_bit(vsi->rxq_map[i], pf->avail_rxqs);805 vsi->rxq_map[i] = ICE_INVAL_Q_INDEX;806 }807 808 mutex_unlock(&pf->avail_q_mutex);809}810 811/**812 * ice_is_safe_mode813 * @pf: pointer to the PF struct814 *815 * returns true if driver is in safe mode, false otherwise816 */817bool ice_is_safe_mode(struct ice_pf *pf)818{819 return !test_bit(ICE_FLAG_ADV_FEATURES, pf->flags);820}821 822/**823 * ice_is_rdma_ena824 * @pf: pointer to the PF struct825 *826 * returns true if RDMA is currently supported, false otherwise827 */828bool ice_is_rdma_ena(struct ice_pf *pf)829{830 return test_bit(ICE_FLAG_RDMA_ENA, pf->flags);831}832 833/**834 * ice_vsi_clean_rss_flow_fld - Delete RSS configuration835 * @vsi: the VSI being cleaned up836 *837 * This function deletes RSS input set for all flows that were configured838 * for this VSI839 */840static void ice_vsi_clean_rss_flow_fld(struct ice_vsi *vsi)841{842 struct ice_pf *pf = vsi->back;843 int status;844 845 if (ice_is_safe_mode(pf))846 return;847 848 status = ice_rem_vsi_rss_cfg(&pf->hw, vsi->idx);849 if (status)850 dev_dbg(ice_pf_to_dev(pf), "ice_rem_vsi_rss_cfg failed for vsi = %d, error = %d\n",851 vsi->vsi_num, status);852}853 854/**855 * ice_rss_clean - Delete RSS related VSI structures and configuration856 * @vsi: the VSI being removed857 */858static void ice_rss_clean(struct ice_vsi *vsi)859{860 struct ice_pf *pf = vsi->back;861 struct device *dev;862 863 dev = ice_pf_to_dev(pf);864 865 devm_kfree(dev, vsi->rss_hkey_user);866 devm_kfree(dev, vsi->rss_lut_user);867 868 ice_vsi_clean_rss_flow_fld(vsi);869 /* remove RSS replay list */870 if (!ice_is_safe_mode(pf))871 ice_rem_vsi_rss_list(&pf->hw, vsi->idx);872}873 874/**875 * ice_vsi_set_rss_params - Setup RSS capabilities per VSI type876 * @vsi: the VSI being configured877 */878static void ice_vsi_set_rss_params(struct ice_vsi *vsi)879{880 struct ice_hw_common_caps *cap;881 struct ice_pf *pf = vsi->back;882 u16 max_rss_size;883 884 if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {885 vsi->rss_size = 1;886 return;887 }888 889 cap = &pf->hw.func_caps.common_cap;890 max_rss_size = BIT(cap->rss_table_entry_width);891 switch (vsi->type) {892 case ICE_VSI_CHNL:893 case ICE_VSI_PF:894 /* PF VSI will inherit RSS instance of PF */895 vsi->rss_table_size = (u16)cap->rss_table_size;896 if (vsi->type == ICE_VSI_CHNL)897 vsi->rss_size = min_t(u16, vsi->num_rxq, max_rss_size);898 else899 vsi->rss_size = min_t(u16, num_online_cpus(),900 max_rss_size);901 vsi->rss_lut_type = ICE_LUT_PF;902 break;903 case ICE_VSI_SF:904 vsi->rss_table_size = ICE_LUT_VSI_SIZE;905 vsi->rss_size = min_t(u16, num_online_cpus(), max_rss_size);906 vsi->rss_lut_type = ICE_LUT_VSI;907 break;908 case ICE_VSI_VF:909 /* VF VSI will get a small RSS table.910 * For VSI_LUT, LUT size should be set to 64 bytes.911 */912 vsi->rss_table_size = ICE_LUT_VSI_SIZE;913 vsi->rss_size = ICE_MAX_RSS_QS_PER_VF;914 vsi->rss_lut_type = ICE_LUT_VSI;915 break;916 case ICE_VSI_LB:917 break;918 default:919 dev_dbg(ice_pf_to_dev(pf), "Unsupported VSI type %s\n",920 ice_vsi_type_str(vsi->type));921 break;922 }923}924 925/**926 * ice_set_dflt_vsi_ctx - Set default VSI context before adding a VSI927 * @hw: HW structure used to determine the VLAN mode of the device928 * @ctxt: the VSI context being set929 *930 * This initializes a default VSI context for all sections except the Queues.931 */932static void ice_set_dflt_vsi_ctx(struct ice_hw *hw, struct ice_vsi_ctx *ctxt)933{934 u32 table = 0;935 936 memset(&ctxt->info, 0, sizeof(ctxt->info));937 /* VSI's should be allocated from shared pool */938 ctxt->alloc_from_pool = true;939 /* Src pruning enabled by default */940 ctxt->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE;941 /* Traffic from VSI can be sent to LAN */942 ctxt->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA;943 /* allow all untagged/tagged packets by default on Tx */944 ctxt->info.inner_vlan_flags = FIELD_PREP(ICE_AQ_VSI_INNER_VLAN_TX_MODE_M,945 ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL);946 /* SVM - by default bits 3 and 4 in inner_vlan_flags are 0's which947 * results in legacy behavior (show VLAN, DEI, and UP) in descriptor.948 *949 * DVM - leave inner VLAN in packet by default950 */951 if (ice_is_dvm_ena(hw)) {952 ctxt->info.inner_vlan_flags |=953 FIELD_PREP(ICE_AQ_VSI_INNER_VLAN_EMODE_M,954 ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING);955 ctxt->info.outer_vlan_flags =956 FIELD_PREP(ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M,957 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ALL);958 ctxt->info.outer_vlan_flags |=959 FIELD_PREP(ICE_AQ_VSI_OUTER_TAG_TYPE_M,960 ICE_AQ_VSI_OUTER_TAG_VLAN_8100);961 ctxt->info.outer_vlan_flags |=962 FIELD_PREP(ICE_AQ_VSI_OUTER_VLAN_EMODE_M,963 ICE_AQ_VSI_OUTER_VLAN_EMODE_NOTHING);964 }965 /* Have 1:1 UP mapping for both ingress/egress tables */966 table |= ICE_UP_TABLE_TRANSLATE(0, 0);967 table |= ICE_UP_TABLE_TRANSLATE(1, 1);968 table |= ICE_UP_TABLE_TRANSLATE(2, 2);969 table |= ICE_UP_TABLE_TRANSLATE(3, 3);970 table |= ICE_UP_TABLE_TRANSLATE(4, 4);971 table |= ICE_UP_TABLE_TRANSLATE(5, 5);972 table |= ICE_UP_TABLE_TRANSLATE(6, 6);973 table |= ICE_UP_TABLE_TRANSLATE(7, 7);974 ctxt->info.ingress_table = cpu_to_le32(table);975 ctxt->info.egress_table = cpu_to_le32(table);976 /* Have 1:1 UP mapping for outer to inner UP table */977 ctxt->info.outer_up_table = cpu_to_le32(table);978 /* No Outer tag support outer_tag_flags remains to zero */979}980 981/**982 * ice_vsi_setup_q_map - Setup a VSI queue map983 * @vsi: the VSI being configured984 * @ctxt: VSI context structure985 */986static int ice_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt)987{988 u16 offset = 0, qmap = 0, tx_count = 0, rx_count = 0, pow = 0;989 u16 num_txq_per_tc, num_rxq_per_tc;990 u16 qcount_tx = vsi->alloc_txq;991 u16 qcount_rx = vsi->alloc_rxq;992 u8 netdev_tc = 0;993 int i;994 995 if (!vsi->tc_cfg.numtc) {996 /* at least TC0 should be enabled by default */997 vsi->tc_cfg.numtc = 1;998 vsi->tc_cfg.ena_tc = 1;999 }1000 1001 num_rxq_per_tc = min_t(u16, qcount_rx / vsi->tc_cfg.numtc, ICE_MAX_RXQS_PER_TC);1002 if (!num_rxq_per_tc)1003 num_rxq_per_tc = 1;1004 num_txq_per_tc = qcount_tx / vsi->tc_cfg.numtc;1005 if (!num_txq_per_tc)1006 num_txq_per_tc = 1;1007 1008 /* find the (rounded up) power-of-2 of qcount */1009 pow = (u16)order_base_2(num_rxq_per_tc);1010 1011 /* TC mapping is a function of the number of Rx queues assigned to the1012 * VSI for each traffic class and the offset of these queues.1013 * The first 10 bits are for queue offset for TC0, next 4 bits for no:of1014 * queues allocated to TC0. No:of queues is a power-of-2.1015 *1016 * If TC is not enabled, the queue offset is set to 0, and allocate one1017 * queue, this way, traffic for the given TC will be sent to the default1018 * queue.1019 *1020 * Setup number and offset of Rx queues for all TCs for the VSI1021 */1022 ice_for_each_traffic_class(i) {1023 if (!(vsi->tc_cfg.ena_tc & BIT(i))) {1024 /* TC is not enabled */1025 vsi->tc_cfg.tc_info[i].qoffset = 0;1026 vsi->tc_cfg.tc_info[i].qcount_rx = 1;1027 vsi->tc_cfg.tc_info[i].qcount_tx = 1;1028 vsi->tc_cfg.tc_info[i].netdev_tc = 0;1029 ctxt->info.tc_mapping[i] = 0;1030 continue;1031 }1032 1033 /* TC is enabled */1034 vsi->tc_cfg.tc_info[i].qoffset = offset;1035 vsi->tc_cfg.tc_info[i].qcount_rx = num_rxq_per_tc;1036 vsi->tc_cfg.tc_info[i].qcount_tx = num_txq_per_tc;1037 vsi->tc_cfg.tc_info[i].netdev_tc = netdev_tc++;1038 1039 qmap = FIELD_PREP(ICE_AQ_VSI_TC_Q_OFFSET_M, offset);1040 qmap |= FIELD_PREP(ICE_AQ_VSI_TC_Q_NUM_M, pow);1041 offset += num_rxq_per_tc;1042 tx_count += num_txq_per_tc;1043 ctxt->info.tc_mapping[i] = cpu_to_le16(qmap);1044 }1045 1046 /* if offset is non-zero, means it is calculated correctly based on1047 * enabled TCs for a given VSI otherwise qcount_rx will always1048 * be correct and non-zero because it is based off - VSI's1049 * allocated Rx queues which is at least 1 (hence qcount_tx will be1050 * at least 1)1051 */1052 if (offset)1053 rx_count = offset;1054 else1055 rx_count = num_rxq_per_tc;1056 1057 if (rx_count > vsi->alloc_rxq) {1058 dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Rx queues (%u), than were allocated (%u)!\n",1059 rx_count, vsi->alloc_rxq);1060 return -EINVAL;1061 }1062 1063 if (tx_count > vsi->alloc_txq) {1064 dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Tx queues (%u), than were allocated (%u)!\n",1065 tx_count, vsi->alloc_txq);1066 return -EINVAL;1067 }1068 1069 vsi->num_txq = tx_count;1070 vsi->num_rxq = rx_count;1071 1072 if (vsi->type == ICE_VSI_VF && vsi->num_txq != vsi->num_rxq) {1073 dev_dbg(ice_pf_to_dev(vsi->back), "VF VSI should have same number of Tx and Rx queues. Hence making them equal\n");1074 /* since there is a chance that num_rxq could have been changed1075 * in the above for loop, make num_txq equal to num_rxq.1076 */1077 vsi->num_txq = vsi->num_rxq;1078 }1079 1080 /* Rx queue mapping */1081 ctxt->info.mapping_flags |= cpu_to_le16(ICE_AQ_VSI_Q_MAP_CONTIG);1082 /* q_mapping buffer holds the info for the first queue allocated for1083 * this VSI in the PF space and also the number of queues associated1084 * with this VSI.1085 */1086 ctxt->info.q_mapping[0] = cpu_to_le16(vsi->rxq_map[0]);1087 ctxt->info.q_mapping[1] = cpu_to_le16(vsi->num_rxq);1088 1089 return 0;1090}1091 1092/**1093 * ice_set_fd_vsi_ctx - Set FD VSI context before adding a VSI1094 * @ctxt: the VSI context being set1095 * @vsi: the VSI being configured1096 */1097static void ice_set_fd_vsi_ctx(struct ice_vsi_ctx *ctxt, struct ice_vsi *vsi)1098{1099 u8 dflt_q_group, dflt_q_prio;1100 u16 dflt_q, report_q, val;1101 1102 if (vsi->type != ICE_VSI_PF && vsi->type != ICE_VSI_CTRL &&1103 vsi->type != ICE_VSI_VF && vsi->type != ICE_VSI_CHNL)1104 return;1105 1106 val = ICE_AQ_VSI_PROP_FLOW_DIR_VALID;1107 ctxt->info.valid_sections |= cpu_to_le16(val);1108 dflt_q = 0;1109 dflt_q_group = 0;1110 report_q = 0;1111 dflt_q_prio = 0;1112 1113 /* enable flow director filtering/programming */1114 val = ICE_AQ_VSI_FD_ENABLE | ICE_AQ_VSI_FD_PROG_ENABLE;1115 ctxt->info.fd_options = cpu_to_le16(val);1116 /* max of allocated flow director filters */1117 ctxt->info.max_fd_fltr_dedicated =1118 cpu_to_le16(vsi->num_gfltr);1119 /* max of shared flow director filters any VSI may program */1120 ctxt->info.max_fd_fltr_shared =1121 cpu_to_le16(vsi->num_bfltr);1122 /* default queue index within the VSI of the default FD */1123 val = FIELD_PREP(ICE_AQ_VSI_FD_DEF_Q_M, dflt_q);1124 /* target queue or queue group to the FD filter */1125 val |= FIELD_PREP(ICE_AQ_VSI_FD_DEF_GRP_M, dflt_q_group);1126 ctxt->info.fd_def_q = cpu_to_le16(val);1127 /* queue index on which FD filter completion is reported */1128 val = FIELD_PREP(ICE_AQ_VSI_FD_REPORT_Q_M, report_q);1129 /* priority of the default qindex action */1130 val |= FIELD_PREP(ICE_AQ_VSI_FD_DEF_PRIORITY_M, dflt_q_prio);1131 ctxt->info.fd_report_opt = cpu_to_le16(val);1132}1133 1134/**1135 * ice_set_rss_vsi_ctx - Set RSS VSI context before adding a VSI1136 * @ctxt: the VSI context being set1137 * @vsi: the VSI being configured1138 */1139static void ice_set_rss_vsi_ctx(struct ice_vsi_ctx *ctxt, struct ice_vsi *vsi)1140{1141 u8 lut_type, hash_type;1142 struct device *dev;1143 struct ice_pf *pf;1144 1145 pf = vsi->back;1146 dev = ice_pf_to_dev(pf);1147 1148 switch (vsi->type) {1149 case ICE_VSI_CHNL:1150 case ICE_VSI_PF:1151 /* PF VSI will inherit RSS instance of PF */1152 lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_PF;1153 break;1154 case ICE_VSI_VF:1155 case ICE_VSI_SF:1156 /* VF VSI will gets a small RSS table which is a VSI LUT type */1157 lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_VSI;1158 break;1159 default:1160 dev_dbg(dev, "Unsupported VSI type %s\n",1161 ice_vsi_type_str(vsi->type));1162 return;1163 }1164 1165 hash_type = ICE_AQ_VSI_Q_OPT_RSS_HASH_TPLZ;1166 vsi->rss_hfunc = hash_type;1167 1168 ctxt->info.q_opt_rss =1169 FIELD_PREP(ICE_AQ_VSI_Q_OPT_RSS_LUT_M, lut_type) |1170 FIELD_PREP(ICE_AQ_VSI_Q_OPT_RSS_HASH_M, hash_type);1171}1172 1173static void1174ice_chnl_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt)1175{1176 struct ice_pf *pf = vsi->back;1177 u16 qcount, qmap;1178 u8 offset = 0;1179 int pow;1180 1181 qcount = min_t(int, vsi->num_rxq, pf->num_lan_msix);1182 1183 pow = order_base_2(qcount);1184 qmap = FIELD_PREP(ICE_AQ_VSI_TC_Q_OFFSET_M, offset);1185 qmap |= FIELD_PREP(ICE_AQ_VSI_TC_Q_NUM_M, pow);1186 1187 ctxt->info.tc_mapping[0] = cpu_to_le16(qmap);1188 ctxt->info.mapping_flags |= cpu_to_le16(ICE_AQ_VSI_Q_MAP_CONTIG);1189 ctxt->info.q_mapping[0] = cpu_to_le16(vsi->next_base_q);1190 ctxt->info.q_mapping[1] = cpu_to_le16(qcount);1191}1192 1193/**1194 * ice_vsi_is_vlan_pruning_ena - check if VLAN pruning is enabled or not1195 * @vsi: VSI to check whether or not VLAN pruning is enabled.1196 *1197 * returns true if Rx VLAN pruning is enabled and false otherwise.1198 */1199static bool ice_vsi_is_vlan_pruning_ena(struct ice_vsi *vsi)1200{1201 return vsi->info.sw_flags2 & ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;1202}1203 1204/**1205 * ice_vsi_init - Create and initialize a VSI1206 * @vsi: the VSI being configured1207 * @vsi_flags: VSI configuration flags1208 *1209 * Set ICE_FLAG_VSI_INIT to initialize a new VSI context, clear it to1210 * reconfigure an existing context.1211 *1212 * This initializes a VSI context depending on the VSI type to be added and1213 * passes it down to the add_vsi aq command to create a new VSI.1214 */1215static int ice_vsi_init(struct ice_vsi *vsi, u32 vsi_flags)1216{1217 struct ice_pf *pf = vsi->back;1218 struct ice_hw *hw = &pf->hw;1219 struct ice_vsi_ctx *ctxt;1220 struct device *dev;1221 int ret = 0;1222 1223 dev = ice_pf_to_dev(pf);1224 ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);1225 if (!ctxt)1226 return -ENOMEM;1227 1228 switch (vsi->type) {1229 case ICE_VSI_CTRL:1230 case ICE_VSI_LB:1231 case ICE_VSI_PF:1232 ctxt->flags = ICE_AQ_VSI_TYPE_PF;1233 break;1234 case ICE_VSI_SF:1235 case ICE_VSI_CHNL:1236 ctxt->flags = ICE_AQ_VSI_TYPE_VMDQ2;1237 break;1238 case ICE_VSI_VF:1239 ctxt->flags = ICE_AQ_VSI_TYPE_VF;1240 /* VF number here is the absolute VF number (0-255) */1241 ctxt->vf_num = vsi->vf->vf_id + hw->func_caps.vf_base_id;1242 break;1243 default:1244 ret = -ENODEV;1245 goto out;1246 }1247 1248 /* Handle VLAN pruning for channel VSI if main VSI has VLAN1249 * prune enabled1250 */1251 if (vsi->type == ICE_VSI_CHNL) {1252 struct ice_vsi *main_vsi;1253 1254 main_vsi = ice_get_main_vsi(pf);1255 if (main_vsi && ice_vsi_is_vlan_pruning_ena(main_vsi))1256 ctxt->info.sw_flags2 |=1257 ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;1258 else1259 ctxt->info.sw_flags2 &=1260 ~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;1261 }1262 1263 ice_set_dflt_vsi_ctx(hw, ctxt);1264 if (test_bit(ICE_FLAG_FD_ENA, pf->flags))1265 ice_set_fd_vsi_ctx(ctxt, vsi);1266 /* if the switch is in VEB mode, allow VSI loopback */1267 if (vsi->vsw->bridge_mode == BRIDGE_MODE_VEB)1268 ctxt->info.sw_flags |= ICE_AQ_VSI_SW_FLAG_ALLOW_LB;1269 1270 /* Set LUT type and HASH type if RSS is enabled */1271 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags) &&1272 vsi->type != ICE_VSI_CTRL) {1273 ice_set_rss_vsi_ctx(ctxt, vsi);1274 /* if updating VSI context, make sure to set valid_section:1275 * to indicate which section of VSI context being updated1276 */1277 if (!(vsi_flags & ICE_VSI_FLAG_INIT))1278 ctxt->info.valid_sections |=1279 cpu_to_le16(ICE_AQ_VSI_PROP_Q_OPT_VALID);1280 }1281 1282 ctxt->info.sw_id = vsi->port_info->sw_id;1283 if (vsi->type == ICE_VSI_CHNL) {1284 ice_chnl_vsi_setup_q_map(vsi, ctxt);1285 } else {1286 ret = ice_vsi_setup_q_map(vsi, ctxt);1287 if (ret)1288 goto out;1289 1290 if (!(vsi_flags & ICE_VSI_FLAG_INIT))1291 /* means VSI being updated */1292 /* must to indicate which section of VSI context are1293 * being modified1294 */1295 ctxt->info.valid_sections |=1296 cpu_to_le16(ICE_AQ_VSI_PROP_RXQ_MAP_VALID);1297 }1298 1299 /* Allow control frames out of main VSI */1300 if (vsi->type == ICE_VSI_PF) {1301 ctxt->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD;1302 ctxt->info.valid_sections |=1303 cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);1304 }1305 1306 if (vsi_flags & ICE_VSI_FLAG_INIT) {1307 ret = ice_add_vsi(hw, vsi->idx, ctxt, NULL);1308 if (ret) {1309 dev_err(dev, "Add VSI failed, err %d\n", ret);1310 ret = -EIO;1311 goto out;1312 }1313 } else {1314 ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL);1315 if (ret) {1316 dev_err(dev, "Update VSI failed, err %d\n", ret);1317 ret = -EIO;1318 goto out;1319 }1320 }1321 1322 /* keep context for update VSI operations */1323 vsi->info = ctxt->info;1324 1325 /* record VSI number returned */1326 vsi->vsi_num = ctxt->vsi_num;1327 1328out:1329 kfree(ctxt);1330 return ret;1331}1332 1333/**1334 * ice_vsi_clear_rings - Deallocates the Tx and Rx rings for VSI1335 * @vsi: the VSI having rings deallocated1336 */1337static void ice_vsi_clear_rings(struct ice_vsi *vsi)1338{1339 int i;1340 1341 /* Avoid stale references by clearing map from vector to ring */1342 if (vsi->q_vectors) {1343 ice_for_each_q_vector(vsi, i) {1344 struct ice_q_vector *q_vector = vsi->q_vectors[i];1345 1346 if (q_vector) {1347 q_vector->tx.tx_ring = NULL;1348 q_vector->rx.rx_ring = NULL;1349 }1350 }1351 }1352 1353 if (vsi->tx_rings) {1354 ice_for_each_alloc_txq(vsi, i) {1355 if (vsi->tx_rings[i]) {1356 kfree_rcu(vsi->tx_rings[i], rcu);1357 WRITE_ONCE(vsi->tx_rings[i], NULL);1358 }1359 }1360 }1361 if (vsi->rx_rings) {1362 ice_for_each_alloc_rxq(vsi, i) {1363 if (vsi->rx_rings[i]) {1364 kfree_rcu(vsi->rx_rings[i], rcu);1365 WRITE_ONCE(vsi->rx_rings[i], NULL);1366 }1367 }1368 }1369}1370 1371/**1372 * ice_vsi_alloc_rings - Allocates Tx and Rx rings for the VSI1373 * @vsi: VSI which is having rings allocated1374 */1375static int ice_vsi_alloc_rings(struct ice_vsi *vsi)1376{1377 bool dvm_ena = ice_is_dvm_ena(&vsi->back->hw);1378 struct ice_pf *pf = vsi->back;1379 struct device *dev;1380 u16 i;1381 1382 dev = ice_pf_to_dev(pf);1383 /* Allocate Tx rings */1384 ice_for_each_alloc_txq(vsi, i) {1385 struct ice_tx_ring *ring;1386 1387 /* allocate with kzalloc(), free with kfree_rcu() */1388 ring = kzalloc(sizeof(*ring), GFP_KERNEL);1389 1390 if (!ring)1391 goto err_out;1392 1393 ring->q_index = i;1394 ring->reg_idx = vsi->txq_map[i];1395 ring->vsi = vsi;1396 ring->tx_tstamps = &pf->ptp.port.tx;1397 ring->dev = dev;1398 ring->count = vsi->num_tx_desc;1399 ring->txq_teid = ICE_INVAL_TEID;1400 if (dvm_ena)1401 ring->flags |= ICE_TX_FLAGS_RING_VLAN_L2TAG2;1402 else1403 ring->flags |= ICE_TX_FLAGS_RING_VLAN_L2TAG1;1404 WRITE_ONCE(vsi->tx_rings[i], ring);1405 }1406 1407 /* Allocate Rx rings */1408 ice_for_each_alloc_rxq(vsi, i) {1409 struct ice_rx_ring *ring;1410 1411 /* allocate with kzalloc(), free with kfree_rcu() */1412 ring = kzalloc(sizeof(*ring), GFP_KERNEL);1413 if (!ring)1414 goto err_out;1415 1416 ring->q_index = i;1417 ring->reg_idx = vsi->rxq_map[i];1418 ring->vsi = vsi;1419 ring->netdev = vsi->netdev;1420 ring->dev = dev;1421 ring->count = vsi->num_rx_desc;1422 ring->cached_phctime = pf->ptp.cached_phc_time;1423 WRITE_ONCE(vsi->rx_rings[i], ring);1424 }1425 1426 return 0;1427 1428err_out:1429 ice_vsi_clear_rings(vsi);1430 return -ENOMEM;1431}1432 1433/**1434 * ice_vsi_manage_rss_lut - disable/enable RSS1435 * @vsi: the VSI being changed1436 * @ena: boolean value indicating if this is an enable or disable request1437 *1438 * In the event of disable request for RSS, this function will zero out RSS1439 * LUT, while in the event of enable request for RSS, it will reconfigure RSS1440 * LUT.1441 */1442void ice_vsi_manage_rss_lut(struct ice_vsi *vsi, bool ena)1443{1444 u8 *lut;1445 1446 lut = kzalloc(vsi->rss_table_size, GFP_KERNEL);1447 if (!lut)1448 return;1449 1450 if (ena) {1451 if (vsi->rss_lut_user)1452 memcpy(lut, vsi->rss_lut_user, vsi->rss_table_size);1453 else1454 ice_fill_rss_lut(lut, vsi->rss_table_size,1455 vsi->rss_size);1456 }1457 1458 ice_set_rss_lut(vsi, lut, vsi->rss_table_size);1459 kfree(lut);1460}1461 1462/**1463 * ice_vsi_cfg_crc_strip - Configure CRC stripping for a VSI1464 * @vsi: VSI to be configured1465 * @disable: set to true to have FCS / CRC in the frame data1466 */1467void ice_vsi_cfg_crc_strip(struct ice_vsi *vsi, bool disable)1468{1469 int i;1470 1471 ice_for_each_rxq(vsi, i)1472 if (disable)1473 vsi->rx_rings[i]->flags |= ICE_RX_FLAGS_CRC_STRIP_DIS;1474 else1475 vsi->rx_rings[i]->flags &= ~ICE_RX_FLAGS_CRC_STRIP_DIS;1476}1477 1478/**1479 * ice_vsi_cfg_rss_lut_key - Configure RSS params for a VSI1480 * @vsi: VSI to be configured1481 */1482int ice_vsi_cfg_rss_lut_key(struct ice_vsi *vsi)1483{1484 struct ice_pf *pf = vsi->back;1485 struct device *dev;1486 u8 *lut, *key;1487 int err;1488 1489 dev = ice_pf_to_dev(pf);1490 if (vsi->type == ICE_VSI_PF && vsi->ch_rss_size &&1491 (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))) {1492 vsi->rss_size = min_t(u16, vsi->rss_size, vsi->ch_rss_size);1493 } else {1494 vsi->rss_size = min_t(u16, vsi->rss_size, vsi->num_rxq);1495 1496 /* If orig_rss_size is valid and it is less than determined1497 * main VSI's rss_size, update main VSI's rss_size to be1498 * orig_rss_size so that when tc-qdisc is deleted, main VSI1499 * RSS table gets programmed to be correct (whatever it was1500 * to begin with (prior to setup-tc for ADQ config)1501 */1502 if (vsi->orig_rss_size && vsi->rss_size < vsi->orig_rss_size &&1503 vsi->orig_rss_size <= vsi->num_rxq) {1504 vsi->rss_size = vsi->orig_rss_size;1505 /* now orig_rss_size is used, reset it to zero */1506 vsi->orig_rss_size = 0;1507 }1508 }1509 1510 lut = kzalloc(vsi->rss_table_size, GFP_KERNEL);1511 if (!lut)1512 return -ENOMEM;1513 1514 if (vsi->rss_lut_user)1515 memcpy(lut, vsi->rss_lut_user, vsi->rss_table_size);1516 else1517 ice_fill_rss_lut(lut, vsi->rss_table_size, vsi->rss_size);1518 1519 err = ice_set_rss_lut(vsi, lut, vsi->rss_table_size);1520 if (err) {1521 dev_err(dev, "set_rss_lut failed, error %d\n", err);1522 goto ice_vsi_cfg_rss_exit;1523 }1524 1525 key = kzalloc(ICE_GET_SET_RSS_KEY_EXTEND_KEY_SIZE, GFP_KERNEL);1526 if (!key) {1527 err = -ENOMEM;1528 goto ice_vsi_cfg_rss_exit;1529 }1530 1531 if (vsi->rss_hkey_user)1532 memcpy(key, vsi->rss_hkey_user, ICE_GET_SET_RSS_KEY_EXTEND_KEY_SIZE);1533 else1534 netdev_rss_key_fill((void *)key, ICE_GET_SET_RSS_KEY_EXTEND_KEY_SIZE);1535 1536 err = ice_set_rss_key(vsi, key);1537 if (err)1538 dev_err(dev, "set_rss_key failed, error %d\n", err);1539 1540 kfree(key);1541ice_vsi_cfg_rss_exit:1542 kfree(lut);1543 return err;1544}1545 1546/**1547 * ice_vsi_set_vf_rss_flow_fld - Sets VF VSI RSS input set for different flows1548 * @vsi: VSI to be configured1549 *1550 * This function will only be called during the VF VSI setup. Upon successful1551 * completion of package download, this function will configure default RSS1552 * input sets for VF VSI.1553 */1554static void ice_vsi_set_vf_rss_flow_fld(struct ice_vsi *vsi)1555{1556 struct ice_pf *pf = vsi->back;1557 struct device *dev;1558 int status;1559 1560 dev = ice_pf_to_dev(pf);1561 if (ice_is_safe_mode(pf)) {1562 dev_dbg(dev, "Advanced RSS disabled. Package download failed, vsi num = %d\n",1563 vsi->vsi_num);1564 return;1565 }1566 1567 status = ice_add_avf_rss_cfg(&pf->hw, vsi, ICE_DEFAULT_RSS_HENA);1568 if (status)1569 dev_dbg(dev, "ice_add_avf_rss_cfg failed for vsi = %d, error = %d\n",1570 vsi->vsi_num, status);1571}1572 1573static const struct ice_rss_hash_cfg default_rss_cfgs[] = {1574 /* configure RSS for IPv4 with input set IP src/dst */1575 {ICE_FLOW_SEG_HDR_IPV4, ICE_FLOW_HASH_IPV4, ICE_RSS_ANY_HEADERS, false},1576 /* configure RSS for IPv6 with input set IPv6 src/dst */1577 {ICE_FLOW_SEG_HDR_IPV6, ICE_FLOW_HASH_IPV6, ICE_RSS_ANY_HEADERS, false},1578 /* configure RSS for tcp4 with input set IP src/dst, TCP src/dst */1579 {ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV4,1580 ICE_HASH_TCP_IPV4, ICE_RSS_ANY_HEADERS, false},1581 /* configure RSS for udp4 with input set IP src/dst, UDP src/dst */1582 {ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV4,1583 ICE_HASH_UDP_IPV4, ICE_RSS_ANY_HEADERS, false},1584 /* configure RSS for sctp4 with input set IP src/dst - only support1585 * RSS on SCTPv4 on outer headers (non-tunneled)1586 */1587 {ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV4,1588 ICE_HASH_SCTP_IPV4, ICE_RSS_OUTER_HEADERS, false},1589 /* configure RSS for gtpc4 with input set IPv4 src/dst */1590 {ICE_FLOW_SEG_HDR_GTPC | ICE_FLOW_SEG_HDR_IPV4,1591 ICE_FLOW_HASH_IPV4, ICE_RSS_OUTER_HEADERS, false},1592 /* configure RSS for gtpc4t with input set IPv4 src/dst */1593 {ICE_FLOW_SEG_HDR_GTPC_TEID | ICE_FLOW_SEG_HDR_IPV4,1594 ICE_FLOW_HASH_GTP_C_IPV4_TEID, ICE_RSS_OUTER_HEADERS, false},1595 /* configure RSS for gtpu4 with input set IPv4 src/dst */1596 {ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4,1597 ICE_FLOW_HASH_GTP_U_IPV4_TEID, ICE_RSS_OUTER_HEADERS, false},1598 /* configure RSS for gtpu4e with input set IPv4 src/dst */1599 {ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4,1600 ICE_FLOW_HASH_GTP_U_IPV4_EH, ICE_RSS_OUTER_HEADERS, false},1601 /* configure RSS for gtpu4u with input set IPv4 src/dst */1602 { ICE_FLOW_SEG_HDR_GTPU_UP | ICE_FLOW_SEG_HDR_IPV4,1603 ICE_FLOW_HASH_GTP_U_IPV4_UP, ICE_RSS_OUTER_HEADERS, false},1604 /* configure RSS for gtpu4d with input set IPv4 src/dst */1605 {ICE_FLOW_SEG_HDR_GTPU_DWN | ICE_FLOW_SEG_HDR_IPV4,1606 ICE_FLOW_HASH_GTP_U_IPV4_DWN, ICE_RSS_OUTER_HEADERS, false},1607 1608 /* configure RSS for tcp6 with input set IPv6 src/dst, TCP src/dst */1609 {ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV6,1610 ICE_HASH_TCP_IPV6, ICE_RSS_ANY_HEADERS, false},1611 /* configure RSS for udp6 with input set IPv6 src/dst, UDP src/dst */1612 {ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV6,1613 ICE_HASH_UDP_IPV6, ICE_RSS_ANY_HEADERS, false},1614 /* configure RSS for sctp6 with input set IPv6 src/dst - only support1615 * RSS on SCTPv6 on outer headers (non-tunneled)1616 */1617 {ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV6,1618 ICE_HASH_SCTP_IPV6, ICE_RSS_OUTER_HEADERS, false},1619 /* configure RSS for IPSEC ESP SPI with input set MAC_IPV4_SPI */1620 {ICE_FLOW_SEG_HDR_ESP,1621 ICE_FLOW_HASH_ESP_SPI, ICE_RSS_OUTER_HEADERS, false},1622 /* configure RSS for gtpc6 with input set IPv6 src/dst */1623 {ICE_FLOW_SEG_HDR_GTPC | ICE_FLOW_SEG_HDR_IPV6,1624 ICE_FLOW_HASH_IPV6, ICE_RSS_OUTER_HEADERS, false},1625 /* configure RSS for gtpc6t with input set IPv6 src/dst */1626 {ICE_FLOW_SEG_HDR_GTPC_TEID | ICE_FLOW_SEG_HDR_IPV6,1627 ICE_FLOW_HASH_GTP_C_IPV6_TEID, ICE_RSS_OUTER_HEADERS, false},1628 /* configure RSS for gtpu6 with input set IPv6 src/dst */1629 {ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6,1630 ICE_FLOW_HASH_GTP_U_IPV6_TEID, ICE_RSS_OUTER_HEADERS, false},1631 /* configure RSS for gtpu6e with input set IPv6 src/dst */1632 {ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6,1633 ICE_FLOW_HASH_GTP_U_IPV6_EH, ICE_RSS_OUTER_HEADERS, false},1634 /* configure RSS for gtpu6u with input set IPv6 src/dst */1635 { ICE_FLOW_SEG_HDR_GTPU_UP | ICE_FLOW_SEG_HDR_IPV6,1636 ICE_FLOW_HASH_GTP_U_IPV6_UP, ICE_RSS_OUTER_HEADERS, false},1637 /* configure RSS for gtpu6d with input set IPv6 src/dst */1638 {ICE_FLOW_SEG_HDR_GTPU_DWN | ICE_FLOW_SEG_HDR_IPV6,1639 ICE_FLOW_HASH_GTP_U_IPV6_DWN, ICE_RSS_OUTER_HEADERS, false},1640};1641 1642/**1643 * ice_vsi_set_rss_flow_fld - Sets RSS input set for different flows1644 * @vsi: VSI to be configured1645 *1646 * This function will only be called after successful download package call1647 * during initialization of PF. Since the downloaded package will erase the1648 * RSS section, this function will configure RSS input sets for different1649 * flow types. The last profile added has the highest priority, therefore 21650 * tuple profiles (i.e. IPv4 src/dst) are added before 4 tuple profiles1651 * (i.e. IPv4 src/dst TCP src/dst port).1652 */1653static void ice_vsi_set_rss_flow_fld(struct ice_vsi *vsi)1654{1655 u16 vsi_num = vsi->vsi_num;1656 struct ice_pf *pf = vsi->back;1657 struct ice_hw *hw = &pf->hw;1658 struct device *dev;1659 int status;1660 u32 i;1661 1662 dev = ice_pf_to_dev(pf);1663 if (ice_is_safe_mode(pf)) {1664 dev_dbg(dev, "Advanced RSS disabled. Package download failed, vsi num = %d\n",1665 vsi_num);1666 return;1667 }1668 for (i = 0; i < ARRAY_SIZE(default_rss_cfgs); i++) {1669 const struct ice_rss_hash_cfg *cfg = &default_rss_cfgs[i];1670 1671 status = ice_add_rss_cfg(hw, vsi, cfg);1672 if (status)1673 dev_dbg(dev, "ice_add_rss_cfg failed, addl_hdrs = %x, hash_flds = %llx, hdr_type = %d, symm = %d\n",1674 cfg->addl_hdrs, cfg->hash_flds,1675 cfg->hdr_type, cfg->symm);1676 }1677}1678 1679/**1680 * ice_pf_state_is_nominal - checks the PF for nominal state1681 * @pf: pointer to PF to check1682 *1683 * Check the PF's state for a collection of bits that would indicate1684 * the PF is in a state that would inhibit normal operation for1685 * driver functionality.1686 *1687 * Returns true if PF is in a nominal state, false otherwise1688 */1689bool ice_pf_state_is_nominal(struct ice_pf *pf)1690{1691 DECLARE_BITMAP(check_bits, ICE_STATE_NBITS) = { 0 };1692 1693 if (!pf)1694 return false;1695 1696 bitmap_set(check_bits, 0, ICE_STATE_NOMINAL_CHECK_BITS);1697 if (bitmap_intersects(pf->state, check_bits, ICE_STATE_NBITS))1698 return false;1699 1700 return true;1701}1702 1703/**1704 * ice_update_eth_stats - Update VSI-specific ethernet statistics counters1705 * @vsi: the VSI to be updated1706 */1707void ice_update_eth_stats(struct ice_vsi *vsi)1708{1709 struct ice_eth_stats *prev_es, *cur_es;1710 struct ice_hw *hw = &vsi->back->hw;1711 struct ice_pf *pf = vsi->back;1712 u16 vsi_num = vsi->vsi_num; /* HW absolute index of a VSI */1713 1714 prev_es = &vsi->eth_stats_prev;1715 cur_es = &vsi->eth_stats;1716 1717 if (ice_is_reset_in_progress(pf->state))1718 vsi->stat_offsets_loaded = false;1719 1720 ice_stat_update40(hw, GLV_GORCL(vsi_num), vsi->stat_offsets_loaded,1721 &prev_es->rx_bytes, &cur_es->rx_bytes);1722 1723 ice_stat_update40(hw, GLV_UPRCL(vsi_num), vsi->stat_offsets_loaded,1724 &prev_es->rx_unicast, &cur_es->rx_unicast);1725 1726 ice_stat_update40(hw, GLV_MPRCL(vsi_num), vsi->stat_offsets_loaded,1727 &prev_es->rx_multicast, &cur_es->rx_multicast);1728 1729 ice_stat_update40(hw, GLV_BPRCL(vsi_num), vsi->stat_offsets_loaded,1730 &prev_es->rx_broadcast, &cur_es->rx_broadcast);1731 1732 ice_stat_update32(hw, GLV_RDPC(vsi_num), vsi->stat_offsets_loaded,1733 &prev_es->rx_discards, &cur_es->rx_discards);1734 1735 ice_stat_update40(hw, GLV_GOTCL(vsi_num), vsi->stat_offsets_loaded,1736 &prev_es->tx_bytes, &cur_es->tx_bytes);1737 1738 ice_stat_update40(hw, GLV_UPTCL(vsi_num), vsi->stat_offsets_loaded,1739 &prev_es->tx_unicast, &cur_es->tx_unicast);1740 1741 ice_stat_update40(hw, GLV_MPTCL(vsi_num), vsi->stat_offsets_loaded,1742 &prev_es->tx_multicast, &cur_es->tx_multicast);1743 1744 ice_stat_update40(hw, GLV_BPTCL(vsi_num), vsi->stat_offsets_loaded,1745 &prev_es->tx_broadcast, &cur_es->tx_broadcast);1746 1747 ice_stat_update32(hw, GLV_TEPC(vsi_num), vsi->stat_offsets_loaded,1748 &prev_es->tx_errors, &cur_es->tx_errors);1749 1750 vsi->stat_offsets_loaded = true;1751}1752 1753/**1754 * ice_write_qrxflxp_cntxt - write/configure QRXFLXP_CNTXT register1755 * @hw: HW pointer1756 * @pf_q: index of the Rx queue in the PF's queue space1757 * @rxdid: flexible descriptor RXDID1758 * @prio: priority for the RXDID for this queue1759 * @ena_ts: true to enable timestamp and false to disable timestamp1760 */1761void1762ice_write_qrxflxp_cntxt(struct ice_hw *hw, u16 pf_q, u32 rxdid, u32 prio,1763 bool ena_ts)1764{1765 int regval = rd32(hw, QRXFLXP_CNTXT(pf_q));1766 1767 /* clear any previous values */1768 regval &= ~(QRXFLXP_CNTXT_RXDID_IDX_M |1769 QRXFLXP_CNTXT_RXDID_PRIO_M |1770 QRXFLXP_CNTXT_TS_M);1771 1772 regval |= FIELD_PREP(QRXFLXP_CNTXT_RXDID_IDX_M, rxdid);1773 regval |= FIELD_PREP(QRXFLXP_CNTXT_RXDID_PRIO_M, prio);1774 1775 if (ena_ts)1776 /* Enable TimeSync on this queue */1777 regval |= QRXFLXP_CNTXT_TS_M;1778 1779 wr32(hw, QRXFLXP_CNTXT(pf_q), regval);1780}1781 1782/**1783 * ice_intrl_usec_to_reg - convert interrupt rate limit to register value1784 * @intrl: interrupt rate limit in usecs1785 * @gran: interrupt rate limit granularity in usecs1786 *1787 * This function converts a decimal interrupt rate limit in usecs to the format1788 * expected by firmware.1789 */1790static u32 ice_intrl_usec_to_reg(u8 intrl, u8 gran)1791{1792 u32 val = intrl / gran;1793 1794 if (val)1795 return val | GLINT_RATE_INTRL_ENA_M;1796 return 0;1797}1798 1799/**1800 * ice_write_intrl - write throttle rate limit to interrupt specific register1801 * @q_vector: pointer to interrupt specific structure1802 * @intrl: throttle rate limit in microseconds to write1803 */1804void ice_write_intrl(struct ice_q_vector *q_vector, u8 intrl)1805{1806 struct ice_hw *hw = &q_vector->vsi->back->hw;1807 1808 wr32(hw, GLINT_RATE(q_vector->reg_idx),1809 ice_intrl_usec_to_reg(intrl, ICE_INTRL_GRAN_ABOVE_25));1810}1811 1812static struct ice_q_vector *ice_pull_qvec_from_rc(struct ice_ring_container *rc)1813{1814 switch (rc->type) {1815 case ICE_RX_CONTAINER:1816 if (rc->rx_ring)1817 return rc->rx_ring->q_vector;1818 break;1819 case ICE_TX_CONTAINER:1820 if (rc->tx_ring)1821 return rc->tx_ring->q_vector;1822 break;1823 default:1824 break;1825 }1826 1827 return NULL;1828}1829 1830/**1831 * __ice_write_itr - write throttle rate to register1832 * @q_vector: pointer to interrupt data structure1833 * @rc: pointer to ring container1834 * @itr: throttle rate in microseconds to write1835 */1836static void __ice_write_itr(struct ice_q_vector *q_vector,1837 struct ice_ring_container *rc, u16 itr)1838{1839 struct ice_hw *hw = &q_vector->vsi->back->hw;1840 1841 wr32(hw, GLINT_ITR(rc->itr_idx, q_vector->reg_idx),1842 ITR_REG_ALIGN(itr) >> ICE_ITR_GRAN_S);1843}1844 1845/**1846 * ice_write_itr - write throttle rate to queue specific register1847 * @rc: pointer to ring container1848 * @itr: throttle rate in microseconds to write1849 */1850void ice_write_itr(struct ice_ring_container *rc, u16 itr)1851{1852 struct ice_q_vector *q_vector;1853 1854 q_vector = ice_pull_qvec_from_rc(rc);1855 if (!q_vector)1856 return;1857 1858 __ice_write_itr(q_vector, rc, itr);1859}1860 1861/**1862 * ice_set_q_vector_intrl - set up interrupt rate limiting1863 * @q_vector: the vector to be configured1864 *1865 * Interrupt rate limiting is local to the vector, not per-queue so we must1866 * detect if either ring container has dynamic moderation enabled to decide1867 * what to set the interrupt rate limit to via INTRL settings. In the case that1868 * dynamic moderation is disabled on both, write the value with the cached1869 * setting to make sure INTRL register matches the user visible value.1870 */1871void ice_set_q_vector_intrl(struct ice_q_vector *q_vector)1872{1873 if (ITR_IS_DYNAMIC(&q_vector->tx) || ITR_IS_DYNAMIC(&q_vector->rx)) {1874 /* in the case of dynamic enabled, cap each vector to no more1875 * than (4 us) 250,000 ints/sec, which allows low latency1876 * but still less than 500,000 interrupts per second, which1877 * reduces CPU a bit in the case of the lowest latency1878 * setting. The 4 here is a value in microseconds.1879 */1880 ice_write_intrl(q_vector, 4);1881 } else {1882 ice_write_intrl(q_vector, q_vector->intrl);1883 }1884}1885 1886/**1887 * ice_vsi_cfg_msix - MSIX mode Interrupt Config in the HW1888 * @vsi: the VSI being configured1889 *1890 * This configures MSIX mode interrupts for the PF VSI, and should not be used1891 * for the VF VSI.1892 */1893void ice_vsi_cfg_msix(struct ice_vsi *vsi)1894{1895 struct ice_pf *pf = vsi->back;1896 struct ice_hw *hw = &pf->hw;1897 u16 txq = 0, rxq = 0;1898 int i, q;1899 1900 ice_for_each_q_vector(vsi, i) {1901 struct ice_q_vector *q_vector = vsi->q_vectors[i];1902 u16 reg_idx = q_vector->reg_idx;1903 1904 ice_cfg_itr(hw, q_vector);1905 1906 /* Both Transmit Queue Interrupt Cause Control register1907 * and Receive Queue Interrupt Cause control register1908 * expects MSIX_INDX field to be the vector index1909 * within the function space and not the absolute1910 * vector index across PF or across device.1911 * For SR-IOV VF VSIs queue vector index always starts1912 * with 1 since first vector index(0) is used for OICR1913 * in VF space. Since VMDq and other PF VSIs are within1914 * the PF function space, use the vector index that is1915 * tracked for this PF.1916 */1917 for (q = 0; q < q_vector->num_ring_tx; q++) {1918 ice_cfg_txq_interrupt(vsi, txq, reg_idx,1919 q_vector->tx.itr_idx);1920 txq++;1921 }1922 1923 for (q = 0; q < q_vector->num_ring_rx; q++) {1924 ice_cfg_rxq_interrupt(vsi, rxq, reg_idx,1925 q_vector->rx.itr_idx);1926 rxq++;1927 }1928 }1929}1930 1931/**1932 * ice_vsi_start_all_rx_rings - start/enable all of a VSI's Rx rings1933 * @vsi: the VSI whose rings are to be enabled1934 *1935 * Returns 0 on success and a negative value on error1936 */1937int ice_vsi_start_all_rx_rings(struct ice_vsi *vsi)1938{1939 return ice_vsi_ctrl_all_rx_rings(vsi, true);1940}1941 1942/**1943 * ice_vsi_stop_all_rx_rings - stop/disable all of a VSI's Rx rings1944 * @vsi: the VSI whose rings are to be disabled1945 *1946 * Returns 0 on success and a negative value on error1947 */1948int ice_vsi_stop_all_rx_rings(struct ice_vsi *vsi)1949{1950 return ice_vsi_ctrl_all_rx_rings(vsi, false);1951}1952 1953/**1954 * ice_vsi_stop_tx_rings - Disable Tx rings1955 * @vsi: the VSI being configured1956 * @rst_src: reset source1957 * @rel_vmvf_num: Relative ID of VF/VM1958 * @rings: Tx ring array to be stopped1959 * @count: number of Tx ring array elements1960 */1961static int1962ice_vsi_stop_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,1963 u16 rel_vmvf_num, struct ice_tx_ring **rings, u16 count)1964{1965 u16 q_idx;1966 1967 if (vsi->num_txq > ICE_LAN_TXQ_MAX_QDIS)1968 return -EINVAL;1969 1970 for (q_idx = 0; q_idx < count; q_idx++) {1971 struct ice_txq_meta txq_meta = { };1972 int status;1973 1974 if (!rings || !rings[q_idx])1975 return -EINVAL;1976 1977 ice_fill_txq_meta(vsi, rings[q_idx], &txq_meta);1978 status = ice_vsi_stop_tx_ring(vsi, rst_src, rel_vmvf_num,1979 rings[q_idx], &txq_meta);1980 1981 if (status)1982 return status;1983 }1984 1985 return 0;1986}1987 1988/**1989 * ice_vsi_stop_lan_tx_rings - Disable LAN Tx rings1990 * @vsi: the VSI being configured1991 * @rst_src: reset source1992 * @rel_vmvf_num: Relative ID of VF/VM1993 */1994int1995ice_vsi_stop_lan_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,1996 u16 rel_vmvf_num)1997{1998 return ice_vsi_stop_tx_rings(vsi, rst_src, rel_vmvf_num, vsi->tx_rings, vsi->num_txq);1999}2000 2001/**2002 * ice_vsi_stop_xdp_tx_rings - Disable XDP Tx rings2003 * @vsi: the VSI being configured2004 */2005int ice_vsi_stop_xdp_tx_rings(struct ice_vsi *vsi)2006{2007 return ice_vsi_stop_tx_rings(vsi, ICE_NO_RESET, 0, vsi->xdp_rings, vsi->num_xdp_txq);2008}2009 2010/**2011 * ice_vsi_is_rx_queue_active2012 * @vsi: the VSI being configured2013 *2014 * Return true if at least one queue is active.2015 */2016bool ice_vsi_is_rx_queue_active(struct ice_vsi *vsi)2017{2018 struct ice_pf *pf = vsi->back;2019 struct ice_hw *hw = &pf->hw;2020 int i;2021 2022 ice_for_each_rxq(vsi, i) {2023 u32 rx_reg;2024 int pf_q;2025 2026 pf_q = vsi->rxq_map[i];2027 rx_reg = rd32(hw, QRX_CTRL(pf_q));2028 if (rx_reg & QRX_CTRL_QENA_STAT_M)2029 return true;2030 }2031 2032 return false;2033}2034 2035static void ice_vsi_set_tc_cfg(struct ice_vsi *vsi)2036{2037 if (!test_bit(ICE_FLAG_DCB_ENA, vsi->back->flags)) {2038 vsi->tc_cfg.ena_tc = ICE_DFLT_TRAFFIC_CLASS;2039 vsi->tc_cfg.numtc = 1;2040 return;2041 }2042 2043 /* set VSI TC information based on DCB config */2044 ice_vsi_set_dcb_tc_cfg(vsi);2045}2046 2047/**2048 * ice_cfg_sw_lldp - Config switch rules for LLDP packet handling2049 * @vsi: the VSI being configured2050 * @tx: bool to determine Tx or Rx rule2051 * @create: bool to determine create or remove Rule2052 */2053void ice_cfg_sw_lldp(struct ice_vsi *vsi, bool tx, bool create)2054{2055 int (*eth_fltr)(struct ice_vsi *v, u16 type, u16 flag,2056 enum ice_sw_fwd_act_type act);2057 struct ice_pf *pf = vsi->back;2058 struct device *dev;2059 int status;2060 2061 dev = ice_pf_to_dev(pf);2062 eth_fltr = create ? ice_fltr_add_eth : ice_fltr_remove_eth;2063 2064 if (tx) {2065 status = eth_fltr(vsi, ETH_P_LLDP, ICE_FLTR_TX,2066 ICE_DROP_PACKET);2067 } else {2068 if (ice_fw_supports_lldp_fltr_ctrl(&pf->hw)) {2069 status = ice_lldp_fltr_add_remove(&pf->hw, vsi->vsi_num,2070 create);2071 } else {2072 status = eth_fltr(vsi, ETH_P_LLDP, ICE_FLTR_RX,2073 ICE_FWD_TO_VSI);2074 }2075 }2076 2077 if (status)2078 dev_dbg(dev, "Fail %s %s LLDP rule on VSI %i error: %d\n",2079 create ? "adding" : "removing", tx ? "TX" : "RX",2080 vsi->vsi_num, status);2081}2082 2083/**2084 * ice_set_agg_vsi - sets up scheduler aggregator node and move VSI into it2085 * @vsi: pointer to the VSI2086 *2087 * This function will allocate new scheduler aggregator now if needed and will2088 * move specified VSI into it.2089 */2090static void ice_set_agg_vsi(struct ice_vsi *vsi)2091{2092 struct device *dev = ice_pf_to_dev(vsi->back);2093 struct ice_agg_node *agg_node_iter = NULL;2094 u32 agg_id = ICE_INVALID_AGG_NODE_ID;2095 struct ice_agg_node *agg_node = NULL;2096 int node_offset, max_agg_nodes = 0;2097 struct ice_port_info *port_info;2098 struct ice_pf *pf = vsi->back;2099 u32 agg_node_id_start = 0;2100 int status;2101 2102 /* create (as needed) scheduler aggregator node and move VSI into2103 * corresponding aggregator node2104 * - PF aggregator node to contains VSIs of type _PF and _CTRL2105 * - VF aggregator nodes will contain VF VSI2106 */2107 port_info = pf->hw.port_info;2108 if (!port_info)2109 return;2110 2111 switch (vsi->type) {2112 case ICE_VSI_CTRL:2113 case ICE_VSI_CHNL:2114 case ICE_VSI_LB:2115 case ICE_VSI_PF:2116 case ICE_VSI_SF:2117 max_agg_nodes = ICE_MAX_PF_AGG_NODES;2118 agg_node_id_start = ICE_PF_AGG_NODE_ID_START;2119 agg_node_iter = &pf->pf_agg_node[0];2120 break;2121 case ICE_VSI_VF:2122 /* user can create 'n' VFs on a given PF, but since max children2123 * per aggregator node can be only 64. Following code handles2124 * aggregator(s) for VF VSIs, either selects a agg_node which2125 * was already created provided num_vsis < 64, otherwise2126 * select next available node, which will be created2127 */2128 max_agg_nodes = ICE_MAX_VF_AGG_NODES;2129 agg_node_id_start = ICE_VF_AGG_NODE_ID_START;2130 agg_node_iter = &pf->vf_agg_node[0];2131 break;2132 default:2133 /* other VSI type, handle later if needed */2134 dev_dbg(dev, "unexpected VSI type %s\n",2135 ice_vsi_type_str(vsi->type));2136 return;2137 }2138 2139 /* find the appropriate aggregator node */2140 for (node_offset = 0; node_offset < max_agg_nodes; node_offset++) {2141 /* see if we can find space in previously created2142 * node if num_vsis < 64, otherwise skip2143 */2144 if (agg_node_iter->num_vsis &&2145 agg_node_iter->num_vsis == ICE_MAX_VSIS_IN_AGG_NODE) {2146 agg_node_iter++;2147 continue;2148 }2149 2150 if (agg_node_iter->valid &&2151 agg_node_iter->agg_id != ICE_INVALID_AGG_NODE_ID) {2152 agg_id = agg_node_iter->agg_id;2153 agg_node = agg_node_iter;2154 break;2155 }2156 2157 /* find unclaimed agg_id */2158 if (agg_node_iter->agg_id == ICE_INVALID_AGG_NODE_ID) {2159 agg_id = node_offset + agg_node_id_start;2160 agg_node = agg_node_iter;2161 break;2162 }2163 /* move to next agg_node */2164 agg_node_iter++;2165 }2166 2167 if (!agg_node)2168 return;2169 2170 /* if selected aggregator node was not created, create it */2171 if (!agg_node->valid) {2172 status = ice_cfg_agg(port_info, agg_id, ICE_AGG_TYPE_AGG,2173 (u8)vsi->tc_cfg.ena_tc);2174 if (status) {2175 dev_err(dev, "unable to create aggregator node with agg_id %u\n",2176 agg_id);2177 return;2178 }2179 /* aggregator node is created, store the needed info */2180 agg_node->valid = true;2181 agg_node->agg_id = agg_id;2182 }2183 2184 /* move VSI to corresponding aggregator node */2185 status = ice_move_vsi_to_agg(port_info, agg_id, vsi->idx,2186 (u8)vsi->tc_cfg.ena_tc);2187 if (status) {2188 dev_err(dev, "unable to move VSI idx %u into aggregator %u node",2189 vsi->idx, agg_id);2190 return;2191 }2192 2193 /* keep active children count for aggregator node */2194 agg_node->num_vsis++;2195 2196 /* cache the 'agg_id' in VSI, so that after reset - VSI will be moved2197 * to aggregator node2198 */2199 vsi->agg_node = agg_node;2200 dev_dbg(dev, "successfully moved VSI idx %u tc_bitmap 0x%x) into aggregator node %d which has num_vsis %u\n",2201 vsi->idx, vsi->tc_cfg.ena_tc, vsi->agg_node->agg_id,2202 vsi->agg_node->num_vsis);2203}2204 2205static int ice_vsi_cfg_tc_lan(struct ice_pf *pf, struct ice_vsi *vsi)2206{2207 u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };2208 struct device *dev = ice_pf_to_dev(pf);2209 int ret, i;2210 2211 /* configure VSI nodes based on number of queues and TC's */2212 ice_for_each_traffic_class(i) {2213 if (!(vsi->tc_cfg.ena_tc & BIT(i)))2214 continue;2215 2216 if (vsi->type == ICE_VSI_CHNL) {2217 if (!vsi->alloc_txq && vsi->num_txq)2218 max_txqs[i] = vsi->num_txq;2219 else2220 max_txqs[i] = pf->num_lan_tx;2221 } else {2222 max_txqs[i] = vsi->alloc_txq;2223 }2224 2225 if (vsi->type == ICE_VSI_PF)2226 max_txqs[i] += vsi->num_xdp_txq;2227 }2228 2229 dev_dbg(dev, "vsi->tc_cfg.ena_tc = %d\n", vsi->tc_cfg.ena_tc);2230 ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc,2231 max_txqs);2232 if (ret) {2233 dev_err(dev, "VSI %d failed lan queue config, error %d\n",2234 vsi->vsi_num, ret);2235 return ret;2236 }2237 2238 return 0;2239}2240 2241/**2242 * ice_vsi_cfg_def - configure default VSI based on the type2243 * @vsi: pointer to VSI2244 */2245static int ice_vsi_cfg_def(struct ice_vsi *vsi)2246{2247 struct device *dev = ice_pf_to_dev(vsi->back);2248 struct ice_pf *pf = vsi->back;2249 int ret;2250 2251 vsi->vsw = pf->first_sw;2252 2253 ret = ice_vsi_alloc_def(vsi, vsi->ch);2254 if (ret)2255 return ret;2256 2257 /* allocate memory for Tx/Rx ring stat pointers */2258 ret = ice_vsi_alloc_stat_arrays(vsi);2259 if (ret)2260 goto unroll_vsi_alloc;2261 2262 ice_alloc_fd_res(vsi);2263 2264 ret = ice_vsi_get_qs(vsi);2265 if (ret) {2266 dev_err(dev, "Failed to allocate queues. vsi->idx = %d\n",2267 vsi->idx);2268 goto unroll_vsi_alloc_stat;2269 }2270 2271 /* set RSS capabilities */2272 ice_vsi_set_rss_params(vsi);2273 2274 /* set TC configuration */2275 ice_vsi_set_tc_cfg(vsi);2276 2277 /* create the VSI */2278 ret = ice_vsi_init(vsi, vsi->flags);2279 if (ret)2280 goto unroll_get_qs;2281 2282 ice_vsi_init_vlan_ops(vsi);2283 2284 switch (vsi->type) {2285 case ICE_VSI_CTRL:2286 case ICE_VSI_SF:2287 case ICE_VSI_PF:2288 ret = ice_vsi_alloc_q_vectors(vsi);2289 if (ret)2290 goto unroll_vsi_init;2291 2292 ret = ice_vsi_alloc_rings(vsi);2293 if (ret)2294 goto unroll_vector_base;2295 2296 ret = ice_vsi_alloc_ring_stats(vsi);2297 if (ret)2298 goto unroll_vector_base;2299 2300 if (ice_is_xdp_ena_vsi(vsi)) {2301 ret = ice_vsi_determine_xdp_res(vsi);2302 if (ret)2303 goto unroll_vector_base;2304 ret = ice_prepare_xdp_rings(vsi, vsi->xdp_prog,2305 ICE_XDP_CFG_PART);2306 if (ret)2307 goto unroll_vector_base;2308 }2309 2310 ice_vsi_map_rings_to_vectors(vsi);2311 2312 vsi->stat_offsets_loaded = false;2313 2314 /* ICE_VSI_CTRL does not need RSS so skip RSS processing */2315 if (vsi->type != ICE_VSI_CTRL)2316 /* Do not exit if configuring RSS had an issue, at2317 * least receive traffic on first queue. Hence no2318 * need to capture return value2319 */2320 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {2321 ice_vsi_cfg_rss_lut_key(vsi);2322 ice_vsi_set_rss_flow_fld(vsi);2323 }2324 ice_init_arfs(vsi);2325 break;2326 case ICE_VSI_CHNL:2327 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {2328 ice_vsi_cfg_rss_lut_key(vsi);2329 ice_vsi_set_rss_flow_fld(vsi);2330 }2331 break;2332 case ICE_VSI_VF:2333 /* VF driver will take care of creating netdev for this type and2334 * map queues to vectors through Virtchnl, PF driver only2335 * creates a VSI and corresponding structures for bookkeeping2336 * purpose2337 */2338 ret = ice_vsi_alloc_q_vectors(vsi);2339 if (ret)2340 goto unroll_vsi_init;2341 2342 ret = ice_vsi_alloc_rings(vsi);2343 if (ret)2344 goto unroll_alloc_q_vector;2345 2346 ret = ice_vsi_alloc_ring_stats(vsi);2347 if (ret)2348 goto unroll_vector_base;2349 2350 vsi->stat_offsets_loaded = false;2351 2352 /* Do not exit if configuring RSS had an issue, at least2353 * receive traffic on first queue. Hence no need to capture2354 * return value2355 */2356 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {2357 ice_vsi_cfg_rss_lut_key(vsi);2358 ice_vsi_set_vf_rss_flow_fld(vsi);2359 }2360 break;2361 case ICE_VSI_LB:2362 ret = ice_vsi_alloc_rings(vsi);2363 if (ret)2364 goto unroll_vsi_init;2365 2366 ret = ice_vsi_alloc_ring_stats(vsi);2367 if (ret)2368 goto unroll_vector_base;2369 2370 break;2371 default:2372 /* clean up the resources and exit */2373 ret = -EINVAL;2374 goto unroll_vsi_init;2375 }2376 2377 return 0;2378 2379unroll_vector_base:2380 /* reclaim SW interrupts back to the common pool */2381unroll_alloc_q_vector:2382 ice_vsi_free_q_vectors(vsi);2383unroll_vsi_init:2384 ice_vsi_delete_from_hw(vsi);2385unroll_get_qs:2386 ice_vsi_put_qs(vsi);2387unroll_vsi_alloc_stat:2388 ice_vsi_free_stats(vsi);2389unroll_vsi_alloc:2390 ice_vsi_free_arrays(vsi);2391 return ret;2392}2393 2394/**2395 * ice_vsi_cfg - configure a previously allocated VSI2396 * @vsi: pointer to VSI2397 */2398int ice_vsi_cfg(struct ice_vsi *vsi)2399{2400 struct ice_pf *pf = vsi->back;2401 int ret;2402 2403 if (WARN_ON(vsi->type == ICE_VSI_VF && !vsi->vf))2404 return -EINVAL;2405 2406 ret = ice_vsi_cfg_def(vsi);2407 if (ret)2408 return ret;2409 2410 ret = ice_vsi_cfg_tc_lan(vsi->back, vsi);2411 if (ret)2412 ice_vsi_decfg(vsi);2413 2414 if (vsi->type == ICE_VSI_CTRL) {2415 if (vsi->vf) {2416 WARN_ON(vsi->vf->ctrl_vsi_idx != ICE_NO_VSI);2417 vsi->vf->ctrl_vsi_idx = vsi->idx;2418 } else {2419 WARN_ON(pf->ctrl_vsi_idx != ICE_NO_VSI);2420 pf->ctrl_vsi_idx = vsi->idx;2421 }2422 }2423 2424 return ret;2425}2426 2427/**2428 * ice_vsi_decfg - remove all VSI configuration2429 * @vsi: pointer to VSI2430 */2431void ice_vsi_decfg(struct ice_vsi *vsi)2432{2433 struct ice_pf *pf = vsi->back;2434 int err;2435 2436 ice_rm_vsi_lan_cfg(vsi->port_info, vsi->idx);2437 err = ice_rm_vsi_rdma_cfg(vsi->port_info, vsi->idx);2438 if (err)2439 dev_err(ice_pf_to_dev(pf), "Failed to remove RDMA scheduler config for VSI %u, err %d\n",2440 vsi->vsi_num, err);2441 2442 if (vsi->xdp_rings)2443 /* return value check can be skipped here, it always returns2444 * 0 if reset is in progress2445 */2446 ice_destroy_xdp_rings(vsi, ICE_XDP_CFG_PART);2447 2448 ice_vsi_clear_rings(vsi);2449 ice_vsi_free_q_vectors(vsi);2450 ice_vsi_put_qs(vsi);2451 ice_vsi_free_arrays(vsi);2452 2453 /* SR-IOV determines needed MSIX resources all at once instead of per2454 * VSI since when VFs are spawned we know how many VFs there are and how2455 * many interrupts each VF needs. SR-IOV MSIX resources are also2456 * cleared in the same manner.2457 */2458 2459 if (vsi->type == ICE_VSI_VF &&2460 vsi->agg_node && vsi->agg_node->valid)2461 vsi->agg_node->num_vsis--;2462}2463 2464/**2465 * ice_vsi_setup - Set up a VSI by a given type2466 * @pf: board private structure2467 * @params: parameters to use when creating the VSI2468 *2469 * This allocates the sw VSI structure and its queue resources.2470 *2471 * Returns pointer to the successfully allocated and configured VSI sw struct on2472 * success, NULL on failure.2473 */2474struct ice_vsi *2475ice_vsi_setup(struct ice_pf *pf, struct ice_vsi_cfg_params *params)2476{2477 struct device *dev = ice_pf_to_dev(pf);2478 struct ice_vsi *vsi;2479 int ret;2480 2481 /* ice_vsi_setup can only initialize a new VSI, and we must have2482 * a port_info structure for it.2483 */2484 if (WARN_ON(!(params->flags & ICE_VSI_FLAG_INIT)) ||2485 WARN_ON(!params->port_info))2486 return NULL;2487 2488 vsi = ice_vsi_alloc(pf);2489 if (!vsi) {2490 dev_err(dev, "could not allocate VSI\n");2491 return NULL;2492 }2493 2494 vsi->params = *params;2495 ret = ice_vsi_cfg(vsi);2496 if (ret)2497 goto err_vsi_cfg;2498 2499 /* Add switch rule to drop all Tx Flow Control Frames, of look up2500 * type ETHERTYPE from VSIs, and restrict malicious VF from sending2501 * out PAUSE or PFC frames. If enabled, FW can still send FC frames.2502 * The rule is added once for PF VSI in order to create appropriate2503 * recipe, since VSI/VSI list is ignored with drop action...2504 * Also add rules to handle LLDP Tx packets. Tx LLDP packets need to2505 * be dropped so that VFs cannot send LLDP packets to reconfig DCB2506 * settings in the HW.2507 */2508 if (!ice_is_safe_mode(pf) && vsi->type == ICE_VSI_PF) {2509 ice_fltr_add_eth(vsi, ETH_P_PAUSE, ICE_FLTR_TX,2510 ICE_DROP_PACKET);2511 ice_cfg_sw_lldp(vsi, true, true);2512 }2513 2514 if (!vsi->agg_node)2515 ice_set_agg_vsi(vsi);2516 2517 return vsi;2518 2519err_vsi_cfg:2520 ice_vsi_free(vsi);2521 2522 return NULL;2523}2524 2525/**2526 * ice_vsi_release_msix - Clear the queue to Interrupt mapping in HW2527 * @vsi: the VSI being cleaned up2528 */2529static void ice_vsi_release_msix(struct ice_vsi *vsi)2530{2531 struct ice_pf *pf = vsi->back;2532 struct ice_hw *hw = &pf->hw;2533 u32 txq = 0;2534 u32 rxq = 0;2535 int i, q;2536 2537 ice_for_each_q_vector(vsi, i) {2538 struct ice_q_vector *q_vector = vsi->q_vectors[i];2539 2540 ice_write_intrl(q_vector, 0);2541 for (q = 0; q < q_vector->num_ring_tx; q++) {2542 ice_write_itr(&q_vector->tx, 0);2543 wr32(hw, QINT_TQCTL(vsi->txq_map[txq]), 0);2544 if (vsi->xdp_rings) {2545 u32 xdp_txq = txq + vsi->num_xdp_txq;2546 2547 wr32(hw, QINT_TQCTL(vsi->txq_map[xdp_txq]), 0);2548 }2549 txq++;2550 }2551 2552 for (q = 0; q < q_vector->num_ring_rx; q++) {2553 ice_write_itr(&q_vector->rx, 0);2554 wr32(hw, QINT_RQCTL(vsi->rxq_map[rxq]), 0);2555 rxq++;2556 }2557 }2558 2559 ice_flush(hw);2560}2561 2562/**2563 * ice_vsi_free_irq - Free the IRQ association with the OS2564 * @vsi: the VSI being configured2565 */2566void ice_vsi_free_irq(struct ice_vsi *vsi)2567{2568 struct ice_pf *pf = vsi->back;2569 int i;2570 2571 if (!vsi->q_vectors || !vsi->irqs_ready)2572 return;2573 2574 ice_vsi_release_msix(vsi);2575 if (vsi->type == ICE_VSI_VF)2576 return;2577 2578 vsi->irqs_ready = false;2579 ice_free_cpu_rx_rmap(vsi);2580 2581 ice_for_each_q_vector(vsi, i) {2582 int irq_num;2583 2584 irq_num = vsi->q_vectors[i]->irq.virq;2585 2586 /* free only the irqs that were actually requested */2587 if (!vsi->q_vectors[i] ||2588 !(vsi->q_vectors[i]->num_ring_tx ||2589 vsi->q_vectors[i]->num_ring_rx))2590 continue;2591 2592 /* clear the affinity notifier in the IRQ descriptor */2593 if (!IS_ENABLED(CONFIG_RFS_ACCEL))2594 irq_set_affinity_notifier(irq_num, NULL);2595 2596 /* clear the affinity_hint in the IRQ descriptor */2597 irq_update_affinity_hint(irq_num, NULL);2598 synchronize_irq(irq_num);2599 devm_free_irq(ice_pf_to_dev(pf), irq_num, vsi->q_vectors[i]);2600 }2601}2602 2603/**2604 * ice_vsi_free_tx_rings - Free Tx resources for VSI queues2605 * @vsi: the VSI having resources freed2606 */2607void ice_vsi_free_tx_rings(struct ice_vsi *vsi)2608{2609 int i;2610 2611 if (!vsi->tx_rings)2612 return;2613 2614 ice_for_each_txq(vsi, i)2615 if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc)2616 ice_free_tx_ring(vsi->tx_rings[i]);2617}2618 2619/**2620 * ice_vsi_free_rx_rings - Free Rx resources for VSI queues2621 * @vsi: the VSI having resources freed2622 */2623void ice_vsi_free_rx_rings(struct ice_vsi *vsi)2624{2625 int i;2626 2627 if (!vsi->rx_rings)2628 return;2629 2630 ice_for_each_rxq(vsi, i)2631 if (vsi->rx_rings[i] && vsi->rx_rings[i]->desc)2632 ice_free_rx_ring(vsi->rx_rings[i]);2633}2634 2635/**2636 * ice_vsi_close - Shut down a VSI2637 * @vsi: the VSI being shut down2638 */2639void ice_vsi_close(struct ice_vsi *vsi)2640{2641 if (!test_and_set_bit(ICE_VSI_DOWN, vsi->state))2642 ice_down(vsi);2643 2644 ice_vsi_clear_napi_queues(vsi);2645 ice_vsi_free_irq(vsi);2646 ice_vsi_free_tx_rings(vsi);2647 ice_vsi_free_rx_rings(vsi);2648}2649 2650/**2651 * ice_ena_vsi - resume a VSI2652 * @vsi: the VSI being resume2653 * @locked: is the rtnl_lock already held2654 */2655int ice_ena_vsi(struct ice_vsi *vsi, bool locked)2656{2657 int err = 0;2658 2659 if (!test_bit(ICE_VSI_NEEDS_RESTART, vsi->state))2660 return 0;2661 2662 clear_bit(ICE_VSI_NEEDS_RESTART, vsi->state);2663 2664 if (vsi->netdev && (vsi->type == ICE_VSI_PF ||2665 vsi->type == ICE_VSI_SF)) {2666 if (netif_running(vsi->netdev)) {2667 if (!locked)2668 rtnl_lock();2669 2670 err = ice_open_internal(vsi->netdev);2671 2672 if (!locked)2673 rtnl_unlock();2674 }2675 } else if (vsi->type == ICE_VSI_CTRL) {2676 err = ice_vsi_open_ctrl(vsi);2677 }2678 2679 return err;2680}2681 2682/**2683 * ice_dis_vsi - pause a VSI2684 * @vsi: the VSI being paused2685 * @locked: is the rtnl_lock already held2686 */2687void ice_dis_vsi(struct ice_vsi *vsi, bool locked)2688{2689 bool already_down = test_bit(ICE_VSI_DOWN, vsi->state);2690 2691 set_bit(ICE_VSI_NEEDS_RESTART, vsi->state);2692 2693 if (vsi->netdev && (vsi->type == ICE_VSI_PF ||2694 vsi->type == ICE_VSI_SF)) {2695 if (netif_running(vsi->netdev)) {2696 if (!locked)2697 rtnl_lock();2698 already_down = test_bit(ICE_VSI_DOWN, vsi->state);2699 if (!already_down)2700 ice_vsi_close(vsi);2701 2702 if (!locked)2703 rtnl_unlock();2704 } else if (!already_down) {2705 ice_vsi_close(vsi);2706 }2707 } else if (vsi->type == ICE_VSI_CTRL && !already_down) {2708 ice_vsi_close(vsi);2709 }2710}2711 2712/**2713 * ice_vsi_set_napi_queues - associate netdev queues with napi2714 * @vsi: VSI pointer2715 *2716 * Associate queue[s] with napi for all vectors.2717 * The caller must hold rtnl_lock.2718 */2719void ice_vsi_set_napi_queues(struct ice_vsi *vsi)2720{2721 struct net_device *netdev = vsi->netdev;2722 int q_idx, v_idx;2723 2724 if (!netdev)2725 return;2726 2727 ice_for_each_rxq(vsi, q_idx)2728 netif_queue_set_napi(netdev, q_idx, NETDEV_QUEUE_TYPE_RX,2729 &vsi->rx_rings[q_idx]->q_vector->napi);2730 2731 ice_for_each_txq(vsi, q_idx)2732 netif_queue_set_napi(netdev, q_idx, NETDEV_QUEUE_TYPE_TX,2733 &vsi->tx_rings[q_idx]->q_vector->napi);2734 /* Also set the interrupt number for the NAPI */2735 ice_for_each_q_vector(vsi, v_idx) {2736 struct ice_q_vector *q_vector = vsi->q_vectors[v_idx];2737 2738 netif_napi_set_irq(&q_vector->napi, q_vector->irq.virq);2739 }2740}2741 2742/**2743 * ice_vsi_clear_napi_queues - dissociate netdev queues from napi2744 * @vsi: VSI pointer2745 *2746 * Clear the association between all VSI queues queue[s] and napi.2747 * The caller must hold rtnl_lock.2748 */2749void ice_vsi_clear_napi_queues(struct ice_vsi *vsi)2750{2751 struct net_device *netdev = vsi->netdev;2752 int q_idx;2753 2754 if (!netdev)2755 return;2756 2757 ice_for_each_txq(vsi, q_idx)2758 netif_queue_set_napi(netdev, q_idx, NETDEV_QUEUE_TYPE_TX, NULL);2759 2760 ice_for_each_rxq(vsi, q_idx)2761 netif_queue_set_napi(netdev, q_idx, NETDEV_QUEUE_TYPE_RX, NULL);2762}2763 2764/**2765 * ice_napi_add - register NAPI handler for the VSI2766 * @vsi: VSI for which NAPI handler is to be registered2767 *2768 * This function is only called in the driver's load path. Registering the NAPI2769 * handler is done in ice_vsi_alloc_q_vector() for all other cases (i.e. resume,2770 * reset/rebuild, etc.)2771 */2772void ice_napi_add(struct ice_vsi *vsi)2773{2774 int v_idx;2775 2776 if (!vsi->netdev)2777 return;2778 2779 ice_for_each_q_vector(vsi, v_idx)2780 netif_napi_add(vsi->netdev, &vsi->q_vectors[v_idx]->napi,2781 ice_napi_poll);2782}2783 2784/**2785 * ice_vsi_release - Delete a VSI and free its resources2786 * @vsi: the VSI being removed2787 *2788 * Returns 0 on success or < 0 on error2789 */2790int ice_vsi_release(struct ice_vsi *vsi)2791{2792 struct ice_pf *pf;2793 2794 if (!vsi->back)2795 return -ENODEV;2796 pf = vsi->back;2797 2798 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags))2799 ice_rss_clean(vsi);2800 2801 ice_vsi_close(vsi);2802 2803 /* The Rx rule will only exist to remove if the LLDP FW2804 * engine is currently stopped2805 */2806 if (!ice_is_safe_mode(pf) && vsi->type == ICE_VSI_PF &&2807 !test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags))2808 ice_cfg_sw_lldp(vsi, false, false);2809 2810 ice_vsi_decfg(vsi);2811 2812 /* retain SW VSI data structure since it is needed to unregister and2813 * free VSI netdev when PF is not in reset recovery pending state,\2814 * for ex: during rmmod.2815 */2816 if (!ice_is_reset_in_progress(pf->state))2817 ice_vsi_delete(vsi);2818 2819 return 0;2820}2821 2822/**2823 * ice_vsi_rebuild_get_coalesce - get coalesce from all q_vectors2824 * @vsi: VSI connected with q_vectors2825 * @coalesce: array of struct with stored coalesce2826 *2827 * Returns array size.2828 */2829static int2830ice_vsi_rebuild_get_coalesce(struct ice_vsi *vsi,2831 struct ice_coalesce_stored *coalesce)2832{2833 int i;2834 2835 ice_for_each_q_vector(vsi, i) {2836 struct ice_q_vector *q_vector = vsi->q_vectors[i];2837 2838 coalesce[i].itr_tx = q_vector->tx.itr_settings;2839 coalesce[i].itr_rx = q_vector->rx.itr_settings;2840 coalesce[i].intrl = q_vector->intrl;2841 2842 if (i < vsi->num_txq)2843 coalesce[i].tx_valid = true;2844 if (i < vsi->num_rxq)2845 coalesce[i].rx_valid = true;2846 }2847 2848 return vsi->num_q_vectors;2849}2850 2851/**2852 * ice_vsi_rebuild_set_coalesce - set coalesce from earlier saved arrays2853 * @vsi: VSI connected with q_vectors2854 * @coalesce: pointer to array of struct with stored coalesce2855 * @size: size of coalesce array2856 *2857 * Before this function, ice_vsi_rebuild_get_coalesce should be called to save2858 * ITR params in arrays. If size is 0 or coalesce wasn't stored set coalesce2859 * to default value.2860 */2861static void2862ice_vsi_rebuild_set_coalesce(struct ice_vsi *vsi,2863 struct ice_coalesce_stored *coalesce, int size)2864{2865 struct ice_ring_container *rc;2866 int i;2867 2868 if ((size && !coalesce) || !vsi)2869 return;2870 2871 /* There are a couple of cases that have to be handled here:2872 * 1. The case where the number of queue vectors stays the same, but2873 * the number of Tx or Rx rings changes (the first for loop)2874 * 2. The case where the number of queue vectors increased (the2875 * second for loop)2876 */2877 for (i = 0; i < size && i < vsi->num_q_vectors; i++) {2878 /* There are 2 cases to handle here and they are the same for2879 * both Tx and Rx:2880 * if the entry was valid previously (coalesce[i].[tr]x_valid2881 * and the loop variable is less than the number of rings2882 * allocated, then write the previous values2883 *2884 * if the entry was not valid previously, but the number of2885 * rings is less than are allocated (this means the number of2886 * rings increased from previously), then write out the2887 * values in the first element2888 *2889 * Also, always write the ITR, even if in ITR_IS_DYNAMIC2890 * as there is no harm because the dynamic algorithm2891 * will just overwrite.2892 */2893 if (i < vsi->alloc_rxq && coalesce[i].rx_valid) {2894 rc = &vsi->q_vectors[i]->rx;2895 rc->itr_settings = coalesce[i].itr_rx;2896 ice_write_itr(rc, rc->itr_setting);2897 } else if (i < vsi->alloc_rxq) {2898 rc = &vsi->q_vectors[i]->rx;2899 rc->itr_settings = coalesce[0].itr_rx;2900 ice_write_itr(rc, rc->itr_setting);2901 }2902 2903 if (i < vsi->alloc_txq && coalesce[i].tx_valid) {2904 rc = &vsi->q_vectors[i]->tx;2905 rc->itr_settings = coalesce[i].itr_tx;2906 ice_write_itr(rc, rc->itr_setting);2907 } else if (i < vsi->alloc_txq) {2908 rc = &vsi->q_vectors[i]->tx;2909 rc->itr_settings = coalesce[0].itr_tx;2910 ice_write_itr(rc, rc->itr_setting);2911 }2912 2913 vsi->q_vectors[i]->intrl = coalesce[i].intrl;2914 ice_set_q_vector_intrl(vsi->q_vectors[i]);2915 }2916 2917 /* the number of queue vectors increased so write whatever is in2918 * the first element2919 */2920 for (; i < vsi->num_q_vectors; i++) {2921 /* transmit */2922 rc = &vsi->q_vectors[i]->tx;2923 rc->itr_settings = coalesce[0].itr_tx;2924 ice_write_itr(rc, rc->itr_setting);2925 2926 /* receive */2927 rc = &vsi->q_vectors[i]->rx;2928 rc->itr_settings = coalesce[0].itr_rx;2929 ice_write_itr(rc, rc->itr_setting);2930 2931 vsi->q_vectors[i]->intrl = coalesce[0].intrl;2932 ice_set_q_vector_intrl(vsi->q_vectors[i]);2933 }2934}2935 2936/**2937 * ice_vsi_realloc_stat_arrays - Frees unused stat structures or alloc new ones2938 * @vsi: VSI pointer2939 */2940static int2941ice_vsi_realloc_stat_arrays(struct ice_vsi *vsi)2942{2943 u16 req_txq = vsi->req_txq ? vsi->req_txq : vsi->alloc_txq;2944 u16 req_rxq = vsi->req_rxq ? vsi->req_rxq : vsi->alloc_rxq;2945 struct ice_ring_stats **tx_ring_stats;2946 struct ice_ring_stats **rx_ring_stats;2947 struct ice_vsi_stats *vsi_stat;2948 struct ice_pf *pf = vsi->back;2949 u16 prev_txq = vsi->alloc_txq;2950 u16 prev_rxq = vsi->alloc_rxq;2951 int i;2952 2953 vsi_stat = pf->vsi_stats[vsi->idx];2954 2955 if (req_txq < prev_txq) {2956 for (i = req_txq; i < prev_txq; i++) {2957 if (vsi_stat->tx_ring_stats[i]) {2958 kfree_rcu(vsi_stat->tx_ring_stats[i], rcu);2959 WRITE_ONCE(vsi_stat->tx_ring_stats[i], NULL);2960 }2961 }2962 }2963 2964 tx_ring_stats = vsi_stat->tx_ring_stats;2965 vsi_stat->tx_ring_stats =2966 krealloc_array(vsi_stat->tx_ring_stats, req_txq,2967 sizeof(*vsi_stat->tx_ring_stats),2968 GFP_KERNEL | __GFP_ZERO);2969 if (!vsi_stat->tx_ring_stats) {2970 vsi_stat->tx_ring_stats = tx_ring_stats;2971 return -ENOMEM;2972 }2973 2974 if (req_rxq < prev_rxq) {2975 for (i = req_rxq; i < prev_rxq; i++) {2976 if (vsi_stat->rx_ring_stats[i]) {2977 kfree_rcu(vsi_stat->rx_ring_stats[i], rcu);2978 WRITE_ONCE(vsi_stat->rx_ring_stats[i], NULL);2979 }2980 }2981 }2982 2983 rx_ring_stats = vsi_stat->rx_ring_stats;2984 vsi_stat->rx_ring_stats =2985 krealloc_array(vsi_stat->rx_ring_stats, req_rxq,2986 sizeof(*vsi_stat->rx_ring_stats),2987 GFP_KERNEL | __GFP_ZERO);2988 if (!vsi_stat->rx_ring_stats) {2989 vsi_stat->rx_ring_stats = rx_ring_stats;2990 return -ENOMEM;2991 }2992 2993 return 0;2994}2995 2996/**2997 * ice_vsi_rebuild - Rebuild VSI after reset2998 * @vsi: VSI to be rebuild2999 * @vsi_flags: flags used for VSI rebuild flow3000 *3001 * Set vsi_flags to ICE_VSI_FLAG_INIT to initialize a new VSI, or3002 * ICE_VSI_FLAG_NO_INIT to rebuild an existing VSI in hardware.3003 *3004 * Returns 0 on success and negative value on failure3005 */3006int ice_vsi_rebuild(struct ice_vsi *vsi, u32 vsi_flags)3007{3008 struct ice_coalesce_stored *coalesce;3009 int prev_num_q_vectors;3010 struct ice_pf *pf;3011 int ret;3012 3013 if (!vsi)3014 return -EINVAL;3015 3016 vsi->flags = vsi_flags;3017 pf = vsi->back;3018 if (WARN_ON(vsi->type == ICE_VSI_VF && !vsi->vf))3019 return -EINVAL;3020 3021 mutex_lock(&vsi->xdp_state_lock);3022 3023 ret = ice_vsi_realloc_stat_arrays(vsi);3024 if (ret)3025 goto unlock;3026 3027 ice_vsi_decfg(vsi);3028 ret = ice_vsi_cfg_def(vsi);3029 if (ret)3030 goto unlock;3031 3032 coalesce = kcalloc(vsi->num_q_vectors,3033 sizeof(struct ice_coalesce_stored), GFP_KERNEL);3034 if (!coalesce) {3035 ret = -ENOMEM;3036 goto decfg;3037 }3038 3039 prev_num_q_vectors = ice_vsi_rebuild_get_coalesce(vsi, coalesce);3040 3041 ret = ice_vsi_cfg_tc_lan(pf, vsi);3042 if (ret) {3043 if (vsi_flags & ICE_VSI_FLAG_INIT) {3044 ret = -EIO;3045 goto free_coalesce;3046 }3047 3048 ret = ice_schedule_reset(pf, ICE_RESET_PFR);3049 goto free_coalesce;3050 }3051 3052 ice_vsi_rebuild_set_coalesce(vsi, coalesce, prev_num_q_vectors);3053 clear_bit(ICE_VSI_REBUILD_PENDING, vsi->state);3054 3055free_coalesce:3056 kfree(coalesce);3057decfg:3058 if (ret)3059 ice_vsi_decfg(vsi);3060unlock:3061 mutex_unlock(&vsi->xdp_state_lock);3062 return ret;3063}3064 3065/**3066 * ice_is_reset_in_progress - check for a reset in progress3067 * @state: PF state field3068 */3069bool ice_is_reset_in_progress(unsigned long *state)3070{3071 return test_bit(ICE_RESET_OICR_RECV, state) ||3072 test_bit(ICE_PFR_REQ, state) ||3073 test_bit(ICE_CORER_REQ, state) ||3074 test_bit(ICE_GLOBR_REQ, state);3075}3076 3077/**3078 * ice_wait_for_reset - Wait for driver to finish reset and rebuild3079 * @pf: pointer to the PF structure3080 * @timeout: length of time to wait, in jiffies3081 *3082 * Wait (sleep) for a short time until the driver finishes cleaning up from3083 * a device reset. The caller must be able to sleep. Use this to delay3084 * operations that could fail while the driver is cleaning up after a device3085 * reset.3086 *3087 * Returns 0 on success, -EBUSY if the reset is not finished within the3088 * timeout, and -ERESTARTSYS if the thread was interrupted.3089 */3090int ice_wait_for_reset(struct ice_pf *pf, unsigned long timeout)3091{3092 long ret;3093 3094 ret = wait_event_interruptible_timeout(pf->reset_wait_queue,3095 !ice_is_reset_in_progress(pf->state),3096 timeout);3097 if (ret < 0)3098 return ret;3099 else if (!ret)3100 return -EBUSY;3101 else3102 return 0;3103}3104 3105/**3106 * ice_vsi_update_q_map - update our copy of the VSI info with new queue map3107 * @vsi: VSI being configured3108 * @ctx: the context buffer returned from AQ VSI update command3109 */3110static void ice_vsi_update_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctx)3111{3112 vsi->info.mapping_flags = ctx->info.mapping_flags;3113 memcpy(&vsi->info.q_mapping, &ctx->info.q_mapping,3114 sizeof(vsi->info.q_mapping));3115 memcpy(&vsi->info.tc_mapping, ctx->info.tc_mapping,3116 sizeof(vsi->info.tc_mapping));3117}3118 3119/**3120 * ice_vsi_cfg_netdev_tc - Setup the netdev TC configuration3121 * @vsi: the VSI being configured3122 * @ena_tc: TC map to be enabled3123 */3124void ice_vsi_cfg_netdev_tc(struct ice_vsi *vsi, u8 ena_tc)3125{3126 struct net_device *netdev = vsi->netdev;3127 struct ice_pf *pf = vsi->back;3128 int numtc = vsi->tc_cfg.numtc;3129 struct ice_dcbx_cfg *dcbcfg;3130 u8 netdev_tc;3131 int i;3132 3133 if (!netdev)3134 return;3135 3136 /* CHNL VSI doesn't have it's own netdev, hence, no netdev_tc */3137 if (vsi->type == ICE_VSI_CHNL)3138 return;3139 3140 if (!ena_tc) {3141 netdev_reset_tc(netdev);3142 return;3143 }3144 3145 if (vsi->type == ICE_VSI_PF && ice_is_adq_active(pf))3146 numtc = vsi->all_numtc;3147 3148 if (netdev_set_num_tc(netdev, numtc))3149 return;3150 3151 dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;3152 3153 ice_for_each_traffic_class(i)3154 if (vsi->tc_cfg.ena_tc & BIT(i))3155 netdev_set_tc_queue(netdev,3156 vsi->tc_cfg.tc_info[i].netdev_tc,3157 vsi->tc_cfg.tc_info[i].qcount_tx,3158 vsi->tc_cfg.tc_info[i].qoffset);3159 /* setup TC queue map for CHNL TCs */3160 ice_for_each_chnl_tc(i) {3161 if (!(vsi->all_enatc & BIT(i)))3162 break;3163 if (!vsi->mqprio_qopt.qopt.count[i])3164 break;3165 netdev_set_tc_queue(netdev, i,3166 vsi->mqprio_qopt.qopt.count[i],3167 vsi->mqprio_qopt.qopt.offset[i]);3168 }3169 3170 if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))3171 return;3172 3173 for (i = 0; i < ICE_MAX_USER_PRIORITY; i++) {3174 u8 ets_tc = dcbcfg->etscfg.prio_table[i];3175 3176 /* Get the mapped netdev TC# for the UP */3177 netdev_tc = vsi->tc_cfg.tc_info[ets_tc].netdev_tc;3178 netdev_set_prio_tc_map(netdev, i, netdev_tc);3179 }3180}3181 3182/**3183 * ice_vsi_setup_q_map_mqprio - Prepares mqprio based tc_config3184 * @vsi: the VSI being configured,3185 * @ctxt: VSI context structure3186 * @ena_tc: number of traffic classes to enable3187 *3188 * Prepares VSI tc_config to have queue configurations based on MQPRIO options.3189 */3190static int3191ice_vsi_setup_q_map_mqprio(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt,3192 u8 ena_tc)3193{3194 u16 pow, offset = 0, qcount_tx = 0, qcount_rx = 0, qmap;3195 u16 tc0_offset = vsi->mqprio_qopt.qopt.offset[0];3196 int tc0_qcount = vsi->mqprio_qopt.qopt.count[0];3197 u16 new_txq, new_rxq;3198 u8 netdev_tc = 0;3199 int i;3200 3201 vsi->tc_cfg.ena_tc = ena_tc ? ena_tc : 1;3202 3203 pow = order_base_2(tc0_qcount);3204 qmap = FIELD_PREP(ICE_AQ_VSI_TC_Q_OFFSET_M, tc0_offset);3205 qmap |= FIELD_PREP(ICE_AQ_VSI_TC_Q_NUM_M, pow);3206 3207 ice_for_each_traffic_class(i) {3208 if (!(vsi->tc_cfg.ena_tc & BIT(i))) {3209 /* TC is not enabled */3210 vsi->tc_cfg.tc_info[i].qoffset = 0;3211 vsi->tc_cfg.tc_info[i].qcount_rx = 1;3212 vsi->tc_cfg.tc_info[i].qcount_tx = 1;3213 vsi->tc_cfg.tc_info[i].netdev_tc = 0;3214 ctxt->info.tc_mapping[i] = 0;3215 continue;3216 }3217 3218 offset = vsi->mqprio_qopt.qopt.offset[i];3219 qcount_rx = vsi->mqprio_qopt.qopt.count[i];3220 qcount_tx = vsi->mqprio_qopt.qopt.count[i];3221 vsi->tc_cfg.tc_info[i].qoffset = offset;3222 vsi->tc_cfg.tc_info[i].qcount_rx = qcount_rx;3223 vsi->tc_cfg.tc_info[i].qcount_tx = qcount_tx;3224 vsi->tc_cfg.tc_info[i].netdev_tc = netdev_tc++;3225 }3226 3227 if (vsi->all_numtc && vsi->all_numtc != vsi->tc_cfg.numtc) {3228 ice_for_each_chnl_tc(i) {3229 if (!(vsi->all_enatc & BIT(i)))3230 continue;3231 offset = vsi->mqprio_qopt.qopt.offset[i];3232 qcount_rx = vsi->mqprio_qopt.qopt.count[i];3233 qcount_tx = vsi->mqprio_qopt.qopt.count[i];3234 }3235 }3236 3237 new_txq = offset + qcount_tx;3238 if (new_txq > vsi->alloc_txq) {3239 dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Tx queues (%u), than were allocated (%u)!\n",3240 new_txq, vsi->alloc_txq);3241 return -EINVAL;3242 }3243 3244 new_rxq = offset + qcount_rx;3245 if (new_rxq > vsi->alloc_rxq) {3246 dev_err(ice_pf_to_dev(vsi->back), "Trying to use more Rx queues (%u), than were allocated (%u)!\n",3247 new_rxq, vsi->alloc_rxq);3248 return -EINVAL;3249 }3250 3251 /* Set actual Tx/Rx queue pairs */3252 vsi->num_txq = new_txq;3253 vsi->num_rxq = new_rxq;3254 3255 /* Setup queue TC[0].qmap for given VSI context */3256 ctxt->info.tc_mapping[0] = cpu_to_le16(qmap);3257 ctxt->info.q_mapping[0] = cpu_to_le16(vsi->rxq_map[0]);3258 ctxt->info.q_mapping[1] = cpu_to_le16(tc0_qcount);3259 3260 /* Find queue count available for channel VSIs and starting offset3261 * for channel VSIs3262 */3263 if (tc0_qcount && tc0_qcount < vsi->num_rxq) {3264 vsi->cnt_q_avail = vsi->num_rxq - tc0_qcount;3265 vsi->next_base_q = tc0_qcount;3266 }3267 dev_dbg(ice_pf_to_dev(vsi->back), "vsi->num_txq = %d\n", vsi->num_txq);3268 dev_dbg(ice_pf_to_dev(vsi->back), "vsi->num_rxq = %d\n", vsi->num_rxq);3269 dev_dbg(ice_pf_to_dev(vsi->back), "all_numtc %u, all_enatc: 0x%04x, tc_cfg.numtc %u\n",3270 vsi->all_numtc, vsi->all_enatc, vsi->tc_cfg.numtc);3271 3272 return 0;3273}3274 3275/**3276 * ice_vsi_cfg_tc - Configure VSI Tx Sched for given TC map3277 * @vsi: VSI to be configured3278 * @ena_tc: TC bitmap3279 *3280 * VSI queues expected to be quiesced before calling this function3281 */3282int ice_vsi_cfg_tc(struct ice_vsi *vsi, u8 ena_tc)3283{3284 u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };3285 struct ice_pf *pf = vsi->back;3286 struct ice_tc_cfg old_tc_cfg;3287 struct ice_vsi_ctx *ctx;3288 struct device *dev;3289 int i, ret = 0;3290 u8 num_tc = 0;3291 3292 dev = ice_pf_to_dev(pf);3293 if (vsi->tc_cfg.ena_tc == ena_tc &&3294 vsi->mqprio_qopt.mode != TC_MQPRIO_MODE_CHANNEL)3295 return 0;3296 3297 ice_for_each_traffic_class(i) {3298 /* build bitmap of enabled TCs */3299 if (ena_tc & BIT(i))3300 num_tc++;3301 /* populate max_txqs per TC */3302 max_txqs[i] = vsi->alloc_txq;3303 /* Update max_txqs if it is CHNL VSI, because alloc_t[r]xq are3304 * zero for CHNL VSI, hence use num_txq instead as max_txqs3305 */3306 if (vsi->type == ICE_VSI_CHNL &&3307 test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))3308 max_txqs[i] = vsi->num_txq;3309 }3310 3311 memcpy(&old_tc_cfg, &vsi->tc_cfg, sizeof(old_tc_cfg));3312 vsi->tc_cfg.ena_tc = ena_tc;3313 vsi->tc_cfg.numtc = num_tc;3314 3315 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);3316 if (!ctx)3317 return -ENOMEM;3318 3319 ctx->vf_num = 0;3320 ctx->info = vsi->info;3321 3322 if (vsi->type == ICE_VSI_PF &&3323 test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))3324 ret = ice_vsi_setup_q_map_mqprio(vsi, ctx, ena_tc);3325 else3326 ret = ice_vsi_setup_q_map(vsi, ctx);3327 3328 if (ret) {3329 memcpy(&vsi->tc_cfg, &old_tc_cfg, sizeof(vsi->tc_cfg));3330 goto out;3331 }3332 3333 /* must to indicate which section of VSI context are being modified */3334 ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_RXQ_MAP_VALID);3335 ret = ice_update_vsi(&pf->hw, vsi->idx, ctx, NULL);3336 if (ret) {3337 dev_info(dev, "Failed VSI Update\n");3338 goto out;3339 }3340 3341 if (vsi->type == ICE_VSI_PF &&3342 test_bit(ICE_FLAG_TC_MQPRIO, pf->flags))3343 ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, 1, max_txqs);3344 else3345 ret = ice_cfg_vsi_lan(vsi->port_info, vsi->idx,3346 vsi->tc_cfg.ena_tc, max_txqs);3347 3348 if (ret) {3349 dev_err(dev, "VSI %d failed TC config, error %d\n",3350 vsi->vsi_num, ret);3351 goto out;3352 }3353 ice_vsi_update_q_map(vsi, ctx);3354 vsi->info.valid_sections = 0;3355 3356 ice_vsi_cfg_netdev_tc(vsi, ena_tc);3357out:3358 kfree(ctx);3359 return ret;3360}3361 3362/**3363 * ice_update_ring_stats - Update ring statistics3364 * @stats: stats to be updated3365 * @pkts: number of processed packets3366 * @bytes: number of processed bytes3367 *3368 * This function assumes that caller has acquired a u64_stats_sync lock.3369 */3370static void ice_update_ring_stats(struct ice_q_stats *stats, u64 pkts, u64 bytes)3371{3372 stats->bytes += bytes;3373 stats->pkts += pkts;3374}3375 3376/**3377 * ice_update_tx_ring_stats - Update Tx ring specific counters3378 * @tx_ring: ring to update3379 * @pkts: number of processed packets3380 * @bytes: number of processed bytes3381 */3382void ice_update_tx_ring_stats(struct ice_tx_ring *tx_ring, u64 pkts, u64 bytes)3383{3384 u64_stats_update_begin(&tx_ring->ring_stats->syncp);3385 ice_update_ring_stats(&tx_ring->ring_stats->stats, pkts, bytes);3386 u64_stats_update_end(&tx_ring->ring_stats->syncp);3387}3388 3389/**3390 * ice_update_rx_ring_stats - Update Rx ring specific counters3391 * @rx_ring: ring to update3392 * @pkts: number of processed packets3393 * @bytes: number of processed bytes3394 */3395void ice_update_rx_ring_stats(struct ice_rx_ring *rx_ring, u64 pkts, u64 bytes)3396{3397 u64_stats_update_begin(&rx_ring->ring_stats->syncp);3398 ice_update_ring_stats(&rx_ring->ring_stats->stats, pkts, bytes);3399 u64_stats_update_end(&rx_ring->ring_stats->syncp);3400}3401 3402/**3403 * ice_is_dflt_vsi_in_use - check if the default forwarding VSI is being used3404 * @pi: port info of the switch with default VSI3405 *3406 * Return true if the there is a single VSI in default forwarding VSI list3407 */3408bool ice_is_dflt_vsi_in_use(struct ice_port_info *pi)3409{3410 bool exists = false;3411 3412 ice_check_if_dflt_vsi(pi, 0, &exists);3413 return exists;3414}3415 3416/**3417 * ice_is_vsi_dflt_vsi - check if the VSI passed in is the default VSI3418 * @vsi: VSI to compare against default forwarding VSI3419 *3420 * If this VSI passed in is the default forwarding VSI then return true, else3421 * return false3422 */3423bool ice_is_vsi_dflt_vsi(struct ice_vsi *vsi)3424{3425 return ice_check_if_dflt_vsi(vsi->port_info, vsi->idx, NULL);3426}3427 3428/**3429 * ice_set_dflt_vsi - set the default forwarding VSI3430 * @vsi: VSI getting set as the default forwarding VSI on the switch3431 *3432 * If the VSI passed in is already the default VSI and it's enabled just return3433 * success.3434 *3435 * Otherwise try to set the VSI passed in as the switch's default VSI and3436 * return the result.3437 */3438int ice_set_dflt_vsi(struct ice_vsi *vsi)3439{3440 struct device *dev;3441 int status;3442 3443 if (!vsi)3444 return -EINVAL;3445 3446 dev = ice_pf_to_dev(vsi->back);3447 3448 if (ice_lag_is_switchdev_running(vsi->back)) {3449 dev_dbg(dev, "VSI %d passed is a part of LAG containing interfaces in switchdev mode, nothing to do\n",3450 vsi->vsi_num);3451 return 0;3452 }3453 3454 /* the VSI passed in is already the default VSI */3455 if (ice_is_vsi_dflt_vsi(vsi)) {3456 dev_dbg(dev, "VSI %d passed in is already the default forwarding VSI, nothing to do\n",3457 vsi->vsi_num);3458 return 0;3459 }3460 3461 status = ice_cfg_dflt_vsi(vsi->port_info, vsi->idx, true, ICE_FLTR_RX);3462 if (status) {3463 dev_err(dev, "Failed to set VSI %d as the default forwarding VSI, error %d\n",3464 vsi->vsi_num, status);3465 return status;3466 }3467 3468 return 0;3469}3470 3471/**3472 * ice_clear_dflt_vsi - clear the default forwarding VSI3473 * @vsi: VSI to remove from filter list3474 *3475 * If the switch has no default VSI or it's not enabled then return error.3476 *3477 * Otherwise try to clear the default VSI and return the result.3478 */3479int ice_clear_dflt_vsi(struct ice_vsi *vsi)3480{3481 struct device *dev;3482 int status;3483 3484 if (!vsi)3485 return -EINVAL;3486 3487 dev = ice_pf_to_dev(vsi->back);3488 3489 /* there is no default VSI configured */3490 if (!ice_is_dflt_vsi_in_use(vsi->port_info))3491 return -ENODEV;3492 3493 status = ice_cfg_dflt_vsi(vsi->port_info, vsi->idx, false,3494 ICE_FLTR_RX);3495 if (status) {3496 dev_err(dev, "Failed to clear the default forwarding VSI %d, error %d\n",3497 vsi->vsi_num, status);3498 return -EIO;3499 }3500 3501 return 0;3502}3503 3504/**3505 * ice_get_link_speed_mbps - get link speed in Mbps3506 * @vsi: the VSI whose link speed is being queried3507 *3508 * Return current VSI link speed and 0 if the speed is unknown.3509 */3510int ice_get_link_speed_mbps(struct ice_vsi *vsi)3511{3512 unsigned int link_speed;3513 3514 link_speed = vsi->port_info->phy.link_info.link_speed;3515 3516 return (int)ice_get_link_speed(fls(link_speed) - 1);3517}3518 3519/**3520 * ice_get_link_speed_kbps - get link speed in Kbps3521 * @vsi: the VSI whose link speed is being queried3522 *3523 * Return current VSI link speed and 0 if the speed is unknown.3524 */3525int ice_get_link_speed_kbps(struct ice_vsi *vsi)3526{3527 int speed_mbps;3528 3529 speed_mbps = ice_get_link_speed_mbps(vsi);3530 3531 return speed_mbps * 1000;3532}3533 3534/**3535 * ice_set_min_bw_limit - setup minimum BW limit for Tx based on min_tx_rate3536 * @vsi: VSI to be configured3537 * @min_tx_rate: min Tx rate in Kbps to be configured as BW limit3538 *3539 * If the min_tx_rate is specified as 0 that means to clear the minimum BW limit3540 * profile, otherwise a non-zero value will force a minimum BW limit for the VSI3541 * on TC 0.3542 */3543int ice_set_min_bw_limit(struct ice_vsi *vsi, u64 min_tx_rate)3544{3545 struct ice_pf *pf = vsi->back;3546 struct device *dev;3547 int status;3548 int speed;3549 3550 dev = ice_pf_to_dev(pf);3551 if (!vsi->port_info) {3552 dev_dbg(dev, "VSI %d, type %u specified doesn't have valid port_info\n",3553 vsi->idx, vsi->type);3554 return -EINVAL;3555 }3556 3557 speed = ice_get_link_speed_kbps(vsi);3558 if (min_tx_rate > (u64)speed) {3559 dev_err(dev, "invalid min Tx rate %llu Kbps specified for %s %d is greater than current link speed %u Kbps\n",3560 min_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx,3561 speed);3562 return -EINVAL;3563 }3564 3565 /* Configure min BW for VSI limit */3566 if (min_tx_rate) {3567 status = ice_cfg_vsi_bw_lmt_per_tc(vsi->port_info, vsi->idx, 0,3568 ICE_MIN_BW, min_tx_rate);3569 if (status) {3570 dev_err(dev, "failed to set min Tx rate(%llu Kbps) for %s %d\n",3571 min_tx_rate, ice_vsi_type_str(vsi->type),3572 vsi->idx);3573 return status;3574 }3575 3576 dev_dbg(dev, "set min Tx rate(%llu Kbps) for %s\n",3577 min_tx_rate, ice_vsi_type_str(vsi->type));3578 } else {3579 status = ice_cfg_vsi_bw_dflt_lmt_per_tc(vsi->port_info,3580 vsi->idx, 0,3581 ICE_MIN_BW);3582 if (status) {3583 dev_err(dev, "failed to clear min Tx rate configuration for %s %d\n",3584 ice_vsi_type_str(vsi->type), vsi->idx);3585 return status;3586 }3587 3588 dev_dbg(dev, "cleared min Tx rate configuration for %s %d\n",3589 ice_vsi_type_str(vsi->type), vsi->idx);3590 }3591 3592 return 0;3593}3594 3595/**3596 * ice_set_max_bw_limit - setup maximum BW limit for Tx based on max_tx_rate3597 * @vsi: VSI to be configured3598 * @max_tx_rate: max Tx rate in Kbps to be configured as BW limit3599 *3600 * If the max_tx_rate is specified as 0 that means to clear the maximum BW limit3601 * profile, otherwise a non-zero value will force a maximum BW limit for the VSI3602 * on TC 0.3603 */3604int ice_set_max_bw_limit(struct ice_vsi *vsi, u64 max_tx_rate)3605{3606 struct ice_pf *pf = vsi->back;3607 struct device *dev;3608 int status;3609 int speed;3610 3611 dev = ice_pf_to_dev(pf);3612 if (!vsi->port_info) {3613 dev_dbg(dev, "VSI %d, type %u specified doesn't have valid port_info\n",3614 vsi->idx, vsi->type);3615 return -EINVAL;3616 }3617 3618 speed = ice_get_link_speed_kbps(vsi);3619 if (max_tx_rate > (u64)speed) {3620 dev_err(dev, "invalid max Tx rate %llu Kbps specified for %s %d is greater than current link speed %u Kbps\n",3621 max_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx,3622 speed);3623 return -EINVAL;3624 }3625 3626 /* Configure max BW for VSI limit */3627 if (max_tx_rate) {3628 status = ice_cfg_vsi_bw_lmt_per_tc(vsi->port_info, vsi->idx, 0,3629 ICE_MAX_BW, max_tx_rate);3630 if (status) {3631 dev_err(dev, "failed setting max Tx rate(%llu Kbps) for %s %d\n",3632 max_tx_rate, ice_vsi_type_str(vsi->type),3633 vsi->idx);3634 return status;3635 }3636 3637 dev_dbg(dev, "set max Tx rate(%llu Kbps) for %s %d\n",3638 max_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx);3639 } else {3640 status = ice_cfg_vsi_bw_dflt_lmt_per_tc(vsi->port_info,3641 vsi->idx, 0,3642 ICE_MAX_BW);3643 if (status) {3644 dev_err(dev, "failed clearing max Tx rate configuration for %s %d\n",3645 ice_vsi_type_str(vsi->type), vsi->idx);3646 return status;3647 }3648 3649 dev_dbg(dev, "cleared max Tx rate configuration for %s %d\n",3650 ice_vsi_type_str(vsi->type), vsi->idx);3651 }3652 3653 return 0;3654}3655 3656/**3657 * ice_set_link - turn on/off physical link3658 * @vsi: VSI to modify physical link on3659 * @ena: turn on/off physical link3660 */3661int ice_set_link(struct ice_vsi *vsi, bool ena)3662{3663 struct device *dev = ice_pf_to_dev(vsi->back);3664 struct ice_port_info *pi = vsi->port_info;3665 struct ice_hw *hw = pi->hw;3666 int status;3667 3668 if (vsi->type != ICE_VSI_PF)3669 return -EINVAL;3670 3671 status = ice_aq_set_link_restart_an(pi, ena, NULL);3672 3673 /* if link is owned by manageability, FW will return ICE_AQ_RC_EMODE.3674 * this is not a fatal error, so print a warning message and return3675 * a success code. Return an error if FW returns an error code other3676 * than ICE_AQ_RC_EMODE3677 */3678 if (status == -EIO) {3679 if (hw->adminq.sq_last_status == ICE_AQ_RC_EMODE)3680 dev_dbg(dev, "can't set link to %s, err %d aq_err %s. not fatal, continuing\n",3681 (ena ? "ON" : "OFF"), status,3682 ice_aq_str(hw->adminq.sq_last_status));3683 } else if (status) {3684 dev_err(dev, "can't set link to %s, err %d aq_err %s\n",3685 (ena ? "ON" : "OFF"), status,3686 ice_aq_str(hw->adminq.sq_last_status));3687 return status;3688 }3689 3690 return 0;3691}3692 3693/**3694 * ice_vsi_add_vlan_zero - add VLAN 0 filter(s) for this VSI3695 * @vsi: VSI used to add VLAN filters3696 *3697 * In Single VLAN Mode (SVM), single VLAN filters via ICE_SW_LKUP_VLAN are based3698 * on the inner VLAN ID, so the VLAN TPID (i.e. 0x8100 or 0x888a8) doesn't3699 * matter. In Double VLAN Mode (DVM), outer/single VLAN filters via3700 * ICE_SW_LKUP_VLAN are based on the outer/single VLAN ID + VLAN TPID.3701 *3702 * For both modes add a VLAN 0 + no VLAN TPID filter to handle untagged traffic3703 * when VLAN pruning is enabled. Also, this handles VLAN 0 priority tagged3704 * traffic in SVM, since the VLAN TPID isn't part of filtering.3705 *3706 * If DVM is enabled then an explicit VLAN 0 + VLAN TPID filter needs to be3707 * added to allow VLAN 0 priority tagged traffic in DVM, since the VLAN TPID is3708 * part of filtering.3709 */3710int ice_vsi_add_vlan_zero(struct ice_vsi *vsi)3711{3712 struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);3713 struct ice_vlan vlan;3714 int err;3715 3716 vlan = ICE_VLAN(0, 0, 0);3717 err = vlan_ops->add_vlan(vsi, &vlan);3718 if (err && err != -EEXIST)3719 return err;3720 3721 /* in SVM both VLAN 0 filters are identical */3722 if (!ice_is_dvm_ena(&vsi->back->hw))3723 return 0;3724 3725 vlan = ICE_VLAN(ETH_P_8021Q, 0, 0);3726 err = vlan_ops->add_vlan(vsi, &vlan);3727 if (err && err != -EEXIST)3728 return err;3729 3730 return 0;3731}3732 3733/**3734 * ice_vsi_del_vlan_zero - delete VLAN 0 filter(s) for this VSI3735 * @vsi: VSI used to add VLAN filters3736 *3737 * Delete the VLAN 0 filters in the same manner that they were added in3738 * ice_vsi_add_vlan_zero.3739 */3740int ice_vsi_del_vlan_zero(struct ice_vsi *vsi)3741{3742 struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);3743 struct ice_vlan vlan;3744 int err;3745 3746 vlan = ICE_VLAN(0, 0, 0);3747 err = vlan_ops->del_vlan(vsi, &vlan);3748 if (err && err != -EEXIST)3749 return err;3750 3751 /* in SVM both VLAN 0 filters are identical */3752 if (!ice_is_dvm_ena(&vsi->back->hw))3753 return 0;3754 3755 vlan = ICE_VLAN(ETH_P_8021Q, 0, 0);3756 err = vlan_ops->del_vlan(vsi, &vlan);3757 if (err && err != -EEXIST)3758 return err;3759 3760 /* when deleting the last VLAN filter, make sure to disable the VLAN3761 * promisc mode so the filter isn't left by accident3762 */3763 return ice_clear_vsi_promisc(&vsi->back->hw, vsi->idx,3764 ICE_MCAST_VLAN_PROMISC_BITS, 0);3765}3766 3767/**3768 * ice_vsi_num_zero_vlans - get number of VLAN 0 filters based on VLAN mode3769 * @vsi: VSI used to get the VLAN mode3770 *3771 * If DVM is enabled then 2 VLAN 0 filters are added, else if SVM is enabled3772 * then 1 VLAN 0 filter is added. See ice_vsi_add_vlan_zero for more details.3773 */3774static u16 ice_vsi_num_zero_vlans(struct ice_vsi *vsi)3775{3776#define ICE_DVM_NUM_ZERO_VLAN_FLTRS 23777#define ICE_SVM_NUM_ZERO_VLAN_FLTRS 13778 /* no VLAN 0 filter is created when a port VLAN is active */3779 if (vsi->type == ICE_VSI_VF) {3780 if (WARN_ON(!vsi->vf))3781 return 0;3782 3783 if (ice_vf_is_port_vlan_ena(vsi->vf))3784 return 0;3785 }3786 3787 if (ice_is_dvm_ena(&vsi->back->hw))3788 return ICE_DVM_NUM_ZERO_VLAN_FLTRS;3789 else3790 return ICE_SVM_NUM_ZERO_VLAN_FLTRS;3791}3792 3793/**3794 * ice_vsi_has_non_zero_vlans - check if VSI has any non-zero VLANs3795 * @vsi: VSI used to determine if any non-zero VLANs have been added3796 */3797bool ice_vsi_has_non_zero_vlans(struct ice_vsi *vsi)3798{3799 return (vsi->num_vlan > ice_vsi_num_zero_vlans(vsi));3800}3801 3802/**3803 * ice_vsi_num_non_zero_vlans - get the number of non-zero VLANs for this VSI3804 * @vsi: VSI used to get the number of non-zero VLANs added3805 */3806u16 ice_vsi_num_non_zero_vlans(struct ice_vsi *vsi)3807{3808 return (vsi->num_vlan - ice_vsi_num_zero_vlans(vsi));3809}3810 3811/**3812 * ice_is_feature_supported3813 * @pf: pointer to the struct ice_pf instance3814 * @f: feature enum to be checked3815 *3816 * returns true if feature is supported, false otherwise3817 */3818bool ice_is_feature_supported(struct ice_pf *pf, enum ice_feature f)3819{3820 if (f < 0 || f >= ICE_F_MAX)3821 return false;3822 3823 return test_bit(f, pf->features);3824}3825 3826/**3827 * ice_set_feature_support3828 * @pf: pointer to the struct ice_pf instance3829 * @f: feature enum to set3830 */3831void ice_set_feature_support(struct ice_pf *pf, enum ice_feature f)3832{3833 if (f < 0 || f >= ICE_F_MAX)3834 return;3835 3836 set_bit(f, pf->features);3837}3838 3839/**3840 * ice_clear_feature_support3841 * @pf: pointer to the struct ice_pf instance3842 * @f: feature enum to clear3843 */3844void ice_clear_feature_support(struct ice_pf *pf, enum ice_feature f)3845{3846 if (f < 0 || f >= ICE_F_MAX)3847 return;3848 3849 clear_bit(f, pf->features);3850}3851 3852/**3853 * ice_init_feature_support3854 * @pf: pointer to the struct ice_pf instance3855 *3856 * called during init to setup supported feature3857 */3858void ice_init_feature_support(struct ice_pf *pf)3859{3860 switch (pf->hw.device_id) {3861 case ICE_DEV_ID_E810C_BACKPLANE:3862 case ICE_DEV_ID_E810C_QSFP:3863 case ICE_DEV_ID_E810C_SFP:3864 case ICE_DEV_ID_E810_XXV_BACKPLANE:3865 case ICE_DEV_ID_E810_XXV_QSFP:3866 case ICE_DEV_ID_E810_XXV_SFP:3867 ice_set_feature_support(pf, ICE_F_DSCP);3868 if (ice_is_phy_rclk_in_netlist(&pf->hw))3869 ice_set_feature_support(pf, ICE_F_PHY_RCLK);3870 /* If we don't own the timer - don't enable other caps */3871 if (!ice_pf_src_tmr_owned(pf))3872 break;3873 if (ice_is_cgu_in_netlist(&pf->hw))3874 ice_set_feature_support(pf, ICE_F_CGU);3875 if (ice_is_clock_mux_in_netlist(&pf->hw))3876 ice_set_feature_support(pf, ICE_F_SMA_CTRL);3877 if (ice_gnss_is_gps_present(&pf->hw))3878 ice_set_feature_support(pf, ICE_F_GNSS);3879 break;3880 default:3881 break;3882 }3883}3884 3885/**3886 * ice_vsi_update_security - update security block in VSI3887 * @vsi: pointer to VSI structure3888 * @fill: function pointer to fill ctx3889 */3890int3891ice_vsi_update_security(struct ice_vsi *vsi, void (*fill)(struct ice_vsi_ctx *))3892{3893 struct ice_vsi_ctx ctx = { 0 };3894 3895 ctx.info = vsi->info;3896 ctx.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);3897 fill(&ctx);3898 3899 if (ice_update_vsi(&vsi->back->hw, vsi->idx, &ctx, NULL))3900 return -ENODEV;3901 3902 vsi->info = ctx.info;3903 return 0;3904}3905 3906/**3907 * ice_vsi_ctx_set_antispoof - set antispoof function in VSI ctx3908 * @ctx: pointer to VSI ctx structure3909 */3910void ice_vsi_ctx_set_antispoof(struct ice_vsi_ctx *ctx)3911{3912 ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF |3913 (ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA <<3914 ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S);3915}3916 3917/**3918 * ice_vsi_ctx_clear_antispoof - clear antispoof function in VSI ctx3919 * @ctx: pointer to VSI ctx structure3920 */3921void ice_vsi_ctx_clear_antispoof(struct ice_vsi_ctx *ctx)3922{3923 ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF &3924 ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA <<3925 ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S);3926}3927 3928/**3929 * ice_vsi_ctx_set_allow_override - allow destination override on VSI3930 * @ctx: pointer to VSI ctx structure3931 */3932void ice_vsi_ctx_set_allow_override(struct ice_vsi_ctx *ctx)3933{3934 ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD;3935}3936 3937/**3938 * ice_vsi_ctx_clear_allow_override - turn off destination override on VSI3939 * @ctx: pointer to VSI ctx structure3940 */3941void ice_vsi_ctx_clear_allow_override(struct ice_vsi_ctx *ctx)3942{3943 ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD;3944}3945 3946/**3947 * ice_vsi_update_local_lb - update sw block in VSI with local loopback bit3948 * @vsi: pointer to VSI structure3949 * @set: set or unset the bit3950 */3951int3952ice_vsi_update_local_lb(struct ice_vsi *vsi, bool set)3953{3954 struct ice_vsi_ctx ctx = {3955 .info = vsi->info,3956 };3957 3958 ctx.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID);3959 if (set)3960 ctx.info.sw_flags |= ICE_AQ_VSI_SW_FLAG_LOCAL_LB;3961 else3962 ctx.info.sw_flags &= ~ICE_AQ_VSI_SW_FLAG_LOCAL_LB;3963 3964 if (ice_update_vsi(&vsi->back->hw, vsi->idx, &ctx, NULL))3965 return -ENODEV;3966 3967 vsi->info = ctx.info;3968 return 0;3969}3970