1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2013 - 2018 Intel Corporation. */ 3 4 #include "i40e.h" 5 6 /*********************notification routines***********************/ 7 8 /** 9 * i40e_vc_vf_broadcast 10 * @pf: pointer to the PF structure 11 * @v_opcode: operation code 12 * @v_retval: return value 13 * @msg: pointer to the msg buffer 14 * @msglen: msg length 15 * 16 * send a message to all VFs on a given PF 17 **/ 18 static void i40e_vc_vf_broadcast(struct i40e_pf *pf, 19 enum virtchnl_ops v_opcode, 20 i40e_status v_retval, u8 *msg, 21 u16 msglen) 22 { 23 struct i40e_hw *hw = &pf->hw; 24 struct i40e_vf *vf = pf->vf; 25 int i; 26 27 for (i = 0; i < pf->num_alloc_vfs; i++, vf++) { 28 int abs_vf_id = vf->vf_id + (int)hw->func_caps.vf_base_id; 29 /* Not all vfs are enabled so skip the ones that are not */ 30 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states) && 31 !test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) 32 continue; 33 34 /* Ignore return value on purpose - a given VF may fail, but 35 * we need to keep going and send to all of them 36 */ 37 i40e_aq_send_msg_to_vf(hw, abs_vf_id, v_opcode, v_retval, 38 msg, msglen, NULL); 39 } 40 } 41 42 /** 43 * i40e_vc_notify_vf_link_state 44 * @vf: pointer to the VF structure 45 * 46 * send a link status message to a single VF 47 **/ 48 static void i40e_vc_notify_vf_link_state(struct i40e_vf *vf) 49 { 50 struct virtchnl_pf_event pfe; 51 struct i40e_pf *pf = vf->pf; 52 struct i40e_hw *hw = &pf->hw; 53 struct i40e_link_status *ls = &pf->hw.phy.link_info; 54 int abs_vf_id = vf->vf_id + (int)hw->func_caps.vf_base_id; 55 56 pfe.event = VIRTCHNL_EVENT_LINK_CHANGE; 57 pfe.severity = PF_EVENT_SEVERITY_INFO; 58 if (vf->link_forced) { 59 pfe.event_data.link_event.link_status = vf->link_up; 60 pfe.event_data.link_event.link_speed = 61 (vf->link_up ? VIRTCHNL_LINK_SPEED_40GB : 0); 62 } else { 63 pfe.event_data.link_event.link_status = 64 ls->link_info & I40E_AQ_LINK_UP; 65 pfe.event_data.link_event.link_speed = 66 i40e_virtchnl_link_speed(ls->link_speed); 67 } 68 i40e_aq_send_msg_to_vf(hw, abs_vf_id, VIRTCHNL_OP_EVENT, 69 0, (u8 *)&pfe, sizeof(pfe), NULL); 70 } 71 72 /** 73 * i40e_vc_notify_link_state 74 * @pf: pointer to the PF structure 75 * 76 * send a link status message to all VFs on a given PF 77 **/ 78 void i40e_vc_notify_link_state(struct i40e_pf *pf) 79 { 80 int i; 81 82 for (i = 0; i < pf->num_alloc_vfs; i++) 83 i40e_vc_notify_vf_link_state(&pf->vf[i]); 84 } 85 86 /** 87 * i40e_vc_notify_reset 88 * @pf: pointer to the PF structure 89 * 90 * indicate a pending reset to all VFs on a given PF 91 **/ 92 void i40e_vc_notify_reset(struct i40e_pf *pf) 93 { 94 struct virtchnl_pf_event pfe; 95 96 pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING; 97 pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM; 98 i40e_vc_vf_broadcast(pf, VIRTCHNL_OP_EVENT, 0, 99 (u8 *)&pfe, sizeof(struct virtchnl_pf_event)); 100 } 101 102 /** 103 * i40e_vc_notify_vf_reset 104 * @vf: pointer to the VF structure 105 * 106 * indicate a pending reset to the given VF 107 **/ 108 void i40e_vc_notify_vf_reset(struct i40e_vf *vf) 109 { 110 struct virtchnl_pf_event pfe; 111 int abs_vf_id; 112 113 /* validate the request */ 114 if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs) 115 return; 116 117 /* verify if the VF is in either init or active before proceeding */ 118 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states) && 119 !test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) 120 return; 121 122 abs_vf_id = vf->vf_id + (int)vf->pf->hw.func_caps.vf_base_id; 123 124 pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING; 125 pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM; 126 i40e_aq_send_msg_to_vf(&vf->pf->hw, abs_vf_id, VIRTCHNL_OP_EVENT, 127 0, (u8 *)&pfe, 128 sizeof(struct virtchnl_pf_event), NULL); 129 } 130 /***********************misc routines*****************************/ 131 132 /** 133 * i40e_vc_disable_vf 134 * @vf: pointer to the VF info 135 * 136 * Disable the VF through a SW reset. 137 **/ 138 static inline void i40e_vc_disable_vf(struct i40e_vf *vf) 139 { 140 int i; 141 142 i40e_vc_notify_vf_reset(vf); 143 144 /* We want to ensure that an actual reset occurs initiated after this 145 * function was called. However, we do not want to wait forever, so 146 * we'll give a reasonable time and print a message if we failed to 147 * ensure a reset. 148 */ 149 for (i = 0; i < 20; i++) { 150 if (i40e_reset_vf(vf, false)) 151 return; 152 usleep_range(10000, 20000); 153 } 154 155 dev_warn(&vf->pf->pdev->dev, 156 "Failed to initiate reset for VF %d after 200 milliseconds\n", 157 vf->vf_id); 158 } 159 160 /** 161 * i40e_vc_isvalid_vsi_id 162 * @vf: pointer to the VF info 163 * @vsi_id: VF relative VSI id 164 * 165 * check for the valid VSI id 166 **/ 167 static inline bool i40e_vc_isvalid_vsi_id(struct i40e_vf *vf, u16 vsi_id) 168 { 169 struct i40e_pf *pf = vf->pf; 170 struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id); 171 172 return (vsi && (vsi->vf_id == vf->vf_id)); 173 } 174 175 /** 176 * i40e_vc_isvalid_queue_id 177 * @vf: pointer to the VF info 178 * @vsi_id: vsi id 179 * @qid: vsi relative queue id 180 * 181 * check for the valid queue id 182 **/ 183 static inline bool i40e_vc_isvalid_queue_id(struct i40e_vf *vf, u16 vsi_id, 184 u8 qid) 185 { 186 struct i40e_pf *pf = vf->pf; 187 struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id); 188 189 return (vsi && (qid < vsi->alloc_queue_pairs)); 190 } 191 192 /** 193 * i40e_vc_isvalid_vector_id 194 * @vf: pointer to the VF info 195 * @vector_id: VF relative vector id 196 * 197 * check for the valid vector id 198 **/ 199 static inline bool i40e_vc_isvalid_vector_id(struct i40e_vf *vf, u8 vector_id) 200 { 201 struct i40e_pf *pf = vf->pf; 202 203 return vector_id < pf->hw.func_caps.num_msix_vectors_vf; 204 } 205 206 /***********************vf resource mgmt routines*****************/ 207 208 /** 209 * i40e_vc_get_pf_queue_id 210 * @vf: pointer to the VF info 211 * @vsi_id: id of VSI as provided by the FW 212 * @vsi_queue_id: vsi relative queue id 213 * 214 * return PF relative queue id 215 **/ 216 static u16 i40e_vc_get_pf_queue_id(struct i40e_vf *vf, u16 vsi_id, 217 u8 vsi_queue_id) 218 { 219 struct i40e_pf *pf = vf->pf; 220 struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id); 221 u16 pf_queue_id = I40E_QUEUE_END_OF_LIST; 222 223 if (!vsi) 224 return pf_queue_id; 225 226 if (le16_to_cpu(vsi->info.mapping_flags) & 227 I40E_AQ_VSI_QUE_MAP_NONCONTIG) 228 pf_queue_id = 229 le16_to_cpu(vsi->info.queue_mapping[vsi_queue_id]); 230 else 231 pf_queue_id = le16_to_cpu(vsi->info.queue_mapping[0]) + 232 vsi_queue_id; 233 234 return pf_queue_id; 235 } 236 237 /** 238 * i40e_get_real_pf_qid 239 * @vf: pointer to the VF info 240 * @vsi_id: vsi id 241 * @queue_id: queue number 242 * 243 * wrapper function to get pf_queue_id handling ADq code as well 244 **/ 245 static u16 i40e_get_real_pf_qid(struct i40e_vf *vf, u16 vsi_id, u16 queue_id) 246 { 247 int i; 248 249 if (vf->adq_enabled) { 250 /* Although VF considers all the queues(can be 1 to 16) as its 251 * own but they may actually belong to different VSIs(up to 4). 252 * We need to find which queues belongs to which VSI. 253 */ 254 for (i = 0; i < vf->num_tc; i++) { 255 if (queue_id < vf->ch[i].num_qps) { 256 vsi_id = vf->ch[i].vsi_id; 257 break; 258 } 259 /* find right queue id which is relative to a 260 * given VSI. 261 */ 262 queue_id -= vf->ch[i].num_qps; 263 } 264 } 265 266 return i40e_vc_get_pf_queue_id(vf, vsi_id, queue_id); 267 } 268 269 /** 270 * i40e_config_irq_link_list 271 * @vf: pointer to the VF info 272 * @vsi_id: id of VSI as given by the FW 273 * @vecmap: irq map info 274 * 275 * configure irq link list from the map 276 **/ 277 static void i40e_config_irq_link_list(struct i40e_vf *vf, u16 vsi_id, 278 struct virtchnl_vector_map *vecmap) 279 { 280 unsigned long linklistmap = 0, tempmap; 281 struct i40e_pf *pf = vf->pf; 282 struct i40e_hw *hw = &pf->hw; 283 u16 vsi_queue_id, pf_queue_id; 284 enum i40e_queue_type qtype; 285 u16 next_q, vector_id, size; 286 u32 reg, reg_idx; 287 u16 itr_idx = 0; 288 289 vector_id = vecmap->vector_id; 290 /* setup the head */ 291 if (0 == vector_id) 292 reg_idx = I40E_VPINT_LNKLST0(vf->vf_id); 293 else 294 reg_idx = I40E_VPINT_LNKLSTN( 295 ((pf->hw.func_caps.num_msix_vectors_vf - 1) * vf->vf_id) + 296 (vector_id - 1)); 297 298 if (vecmap->rxq_map == 0 && vecmap->txq_map == 0) { 299 /* Special case - No queues mapped on this vector */ 300 wr32(hw, reg_idx, I40E_VPINT_LNKLST0_FIRSTQ_INDX_MASK); 301 goto irq_list_done; 302 } 303 tempmap = vecmap->rxq_map; 304 for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) { 305 linklistmap |= (BIT(I40E_VIRTCHNL_SUPPORTED_QTYPES * 306 vsi_queue_id)); 307 } 308 309 tempmap = vecmap->txq_map; 310 for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) { 311 linklistmap |= (BIT(I40E_VIRTCHNL_SUPPORTED_QTYPES * 312 vsi_queue_id + 1)); 313 } 314 315 size = I40E_MAX_VSI_QP * I40E_VIRTCHNL_SUPPORTED_QTYPES; 316 next_q = find_first_bit(&linklistmap, size); 317 if (unlikely(next_q == size)) 318 goto irq_list_done; 319 320 vsi_queue_id = next_q / I40E_VIRTCHNL_SUPPORTED_QTYPES; 321 qtype = next_q % I40E_VIRTCHNL_SUPPORTED_QTYPES; 322 pf_queue_id = i40e_get_real_pf_qid(vf, vsi_id, vsi_queue_id); 323 reg = ((qtype << I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT) | pf_queue_id); 324 325 wr32(hw, reg_idx, reg); 326 327 while (next_q < size) { 328 switch (qtype) { 329 case I40E_QUEUE_TYPE_RX: 330 reg_idx = I40E_QINT_RQCTL(pf_queue_id); 331 itr_idx = vecmap->rxitr_idx; 332 break; 333 case I40E_QUEUE_TYPE_TX: 334 reg_idx = I40E_QINT_TQCTL(pf_queue_id); 335 itr_idx = vecmap->txitr_idx; 336 break; 337 default: 338 break; 339 } 340 341 next_q = find_next_bit(&linklistmap, size, next_q + 1); 342 if (next_q < size) { 343 vsi_queue_id = next_q / I40E_VIRTCHNL_SUPPORTED_QTYPES; 344 qtype = next_q % I40E_VIRTCHNL_SUPPORTED_QTYPES; 345 pf_queue_id = i40e_get_real_pf_qid(vf, 346 vsi_id, 347 vsi_queue_id); 348 } else { 349 pf_queue_id = I40E_QUEUE_END_OF_LIST; 350 qtype = 0; 351 } 352 353 /* format for the RQCTL & TQCTL regs is same */ 354 reg = (vector_id) | 355 (qtype << I40E_QINT_RQCTL_NEXTQ_TYPE_SHIFT) | 356 (pf_queue_id << I40E_QINT_RQCTL_NEXTQ_INDX_SHIFT) | 357 BIT(I40E_QINT_RQCTL_CAUSE_ENA_SHIFT) | 358 (itr_idx << I40E_QINT_RQCTL_ITR_INDX_SHIFT); 359 wr32(hw, reg_idx, reg); 360 } 361 362 /* if the vf is running in polling mode and using interrupt zero, 363 * need to disable auto-mask on enabling zero interrupt for VFs. 364 */ 365 if ((vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_POLLING) && 366 (vector_id == 0)) { 367 reg = rd32(hw, I40E_GLINT_CTL); 368 if (!(reg & I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK)) { 369 reg |= I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK; 370 wr32(hw, I40E_GLINT_CTL, reg); 371 } 372 } 373 374 irq_list_done: 375 i40e_flush(hw); 376 } 377 378 /** 379 * i40e_release_iwarp_qvlist 380 * @vf: pointer to the VF. 381 * 382 **/ 383 static void i40e_release_iwarp_qvlist(struct i40e_vf *vf) 384 { 385 struct i40e_pf *pf = vf->pf; 386 struct virtchnl_iwarp_qvlist_info *qvlist_info = vf->qvlist_info; 387 u32 msix_vf; 388 u32 i; 389 390 if (!vf->qvlist_info) 391 return; 392 393 msix_vf = pf->hw.func_caps.num_msix_vectors_vf; 394 for (i = 0; i < qvlist_info->num_vectors; i++) { 395 struct virtchnl_iwarp_qv_info *qv_info; 396 u32 next_q_index, next_q_type; 397 struct i40e_hw *hw = &pf->hw; 398 u32 v_idx, reg_idx, reg; 399 400 qv_info = &qvlist_info->qv_info[i]; 401 if (!qv_info) 402 continue; 403 v_idx = qv_info->v_idx; 404 if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) { 405 /* Figure out the queue after CEQ and make that the 406 * first queue. 407 */ 408 reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx; 409 reg = rd32(hw, I40E_VPINT_CEQCTL(reg_idx)); 410 next_q_index = (reg & I40E_VPINT_CEQCTL_NEXTQ_INDX_MASK) 411 >> I40E_VPINT_CEQCTL_NEXTQ_INDX_SHIFT; 412 next_q_type = (reg & I40E_VPINT_CEQCTL_NEXTQ_TYPE_MASK) 413 >> I40E_VPINT_CEQCTL_NEXTQ_TYPE_SHIFT; 414 415 reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1); 416 reg = (next_q_index & 417 I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) | 418 (next_q_type << 419 I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT); 420 421 wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg); 422 } 423 } 424 kfree(vf->qvlist_info); 425 vf->qvlist_info = NULL; 426 } 427 428 /** 429 * i40e_config_iwarp_qvlist 430 * @vf: pointer to the VF info 431 * @qvlist_info: queue and vector list 432 * 433 * Return 0 on success or < 0 on error 434 **/ 435 static int i40e_config_iwarp_qvlist(struct i40e_vf *vf, 436 struct virtchnl_iwarp_qvlist_info *qvlist_info) 437 { 438 struct i40e_pf *pf = vf->pf; 439 struct i40e_hw *hw = &pf->hw; 440 struct virtchnl_iwarp_qv_info *qv_info; 441 u32 v_idx, i, reg_idx, reg; 442 u32 next_q_idx, next_q_type; 443 u32 msix_vf, size; 444 445 size = sizeof(struct virtchnl_iwarp_qvlist_info) + 446 (sizeof(struct virtchnl_iwarp_qv_info) * 447 (qvlist_info->num_vectors - 1)); 448 vf->qvlist_info = kzalloc(size, GFP_KERNEL); 449 if (!vf->qvlist_info) 450 return -ENOMEM; 451 452 vf->qvlist_info->num_vectors = qvlist_info->num_vectors; 453 454 msix_vf = pf->hw.func_caps.num_msix_vectors_vf; 455 for (i = 0; i < qvlist_info->num_vectors; i++) { 456 qv_info = &qvlist_info->qv_info[i]; 457 if (!qv_info) 458 continue; 459 v_idx = qv_info->v_idx; 460 461 /* Validate vector id belongs to this vf */ 462 if (!i40e_vc_isvalid_vector_id(vf, v_idx)) 463 goto err; 464 465 vf->qvlist_info->qv_info[i] = *qv_info; 466 467 reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1); 468 /* We might be sharing the interrupt, so get the first queue 469 * index and type, push it down the list by adding the new 470 * queue on top. Also link it with the new queue in CEQCTL. 471 */ 472 reg = rd32(hw, I40E_VPINT_LNKLSTN(reg_idx)); 473 next_q_idx = ((reg & I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) >> 474 I40E_VPINT_LNKLSTN_FIRSTQ_INDX_SHIFT); 475 next_q_type = ((reg & I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK) >> 476 I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT); 477 478 if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) { 479 reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx; 480 reg = (I40E_VPINT_CEQCTL_CAUSE_ENA_MASK | 481 (v_idx << I40E_VPINT_CEQCTL_MSIX_INDX_SHIFT) | 482 (qv_info->itr_idx << I40E_VPINT_CEQCTL_ITR_INDX_SHIFT) | 483 (next_q_type << I40E_VPINT_CEQCTL_NEXTQ_TYPE_SHIFT) | 484 (next_q_idx << I40E_VPINT_CEQCTL_NEXTQ_INDX_SHIFT)); 485 wr32(hw, I40E_VPINT_CEQCTL(reg_idx), reg); 486 487 reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1); 488 reg = (qv_info->ceq_idx & 489 I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) | 490 (I40E_QUEUE_TYPE_PE_CEQ << 491 I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT); 492 wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg); 493 } 494 495 if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) { 496 reg = (I40E_VPINT_AEQCTL_CAUSE_ENA_MASK | 497 (v_idx << I40E_VPINT_AEQCTL_MSIX_INDX_SHIFT) | 498 (qv_info->itr_idx << I40E_VPINT_AEQCTL_ITR_INDX_SHIFT)); 499 500 wr32(hw, I40E_VPINT_AEQCTL(vf->vf_id), reg); 501 } 502 } 503 504 return 0; 505 err: 506 kfree(vf->qvlist_info); 507 vf->qvlist_info = NULL; 508 return -EINVAL; 509 } 510 511 /** 512 * i40e_config_vsi_tx_queue 513 * @vf: pointer to the VF info 514 * @vsi_id: id of VSI as provided by the FW 515 * @vsi_queue_id: vsi relative queue index 516 * @info: config. info 517 * 518 * configure tx queue 519 **/ 520 static int i40e_config_vsi_tx_queue(struct i40e_vf *vf, u16 vsi_id, 521 u16 vsi_queue_id, 522 struct virtchnl_txq_info *info) 523 { 524 struct i40e_pf *pf = vf->pf; 525 struct i40e_hw *hw = &pf->hw; 526 struct i40e_hmc_obj_txq tx_ctx; 527 struct i40e_vsi *vsi; 528 u16 pf_queue_id; 529 u32 qtx_ctl; 530 int ret = 0; 531 532 if (!i40e_vc_isvalid_vsi_id(vf, info->vsi_id)) { 533 ret = -ENOENT; 534 goto error_context; 535 } 536 pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_id, vsi_queue_id); 537 vsi = i40e_find_vsi_from_id(pf, vsi_id); 538 if (!vsi) { 539 ret = -ENOENT; 540 goto error_context; 541 } 542 543 /* clear the context structure first */ 544 memset(&tx_ctx, 0, sizeof(struct i40e_hmc_obj_txq)); 545 546 /* only set the required fields */ 547 tx_ctx.base = info->dma_ring_addr / 128; 548 tx_ctx.qlen = info->ring_len; 549 tx_ctx.rdylist = le16_to_cpu(vsi->info.qs_handle[0]); 550 tx_ctx.rdylist_act = 0; 551 tx_ctx.head_wb_ena = info->headwb_enabled; 552 tx_ctx.head_wb_addr = info->dma_headwb_addr; 553 554 /* clear the context in the HMC */ 555 ret = i40e_clear_lan_tx_queue_context(hw, pf_queue_id); 556 if (ret) { 557 dev_err(&pf->pdev->dev, 558 "Failed to clear VF LAN Tx queue context %d, error: %d\n", 559 pf_queue_id, ret); 560 ret = -ENOENT; 561 goto error_context; 562 } 563 564 /* set the context in the HMC */ 565 ret = i40e_set_lan_tx_queue_context(hw, pf_queue_id, &tx_ctx); 566 if (ret) { 567 dev_err(&pf->pdev->dev, 568 "Failed to set VF LAN Tx queue context %d error: %d\n", 569 pf_queue_id, ret); 570 ret = -ENOENT; 571 goto error_context; 572 } 573 574 /* associate this queue with the PCI VF function */ 575 qtx_ctl = I40E_QTX_CTL_VF_QUEUE; 576 qtx_ctl |= ((hw->pf_id << I40E_QTX_CTL_PF_INDX_SHIFT) 577 & I40E_QTX_CTL_PF_INDX_MASK); 578 qtx_ctl |= (((vf->vf_id + hw->func_caps.vf_base_id) 579 << I40E_QTX_CTL_VFVM_INDX_SHIFT) 580 & I40E_QTX_CTL_VFVM_INDX_MASK); 581 wr32(hw, I40E_QTX_CTL(pf_queue_id), qtx_ctl); 582 i40e_flush(hw); 583 584 error_context: 585 return ret; 586 } 587 588 /** 589 * i40e_config_vsi_rx_queue 590 * @vf: pointer to the VF info 591 * @vsi_id: id of VSI as provided by the FW 592 * @vsi_queue_id: vsi relative queue index 593 * @info: config. info 594 * 595 * configure rx queue 596 **/ 597 static int i40e_config_vsi_rx_queue(struct i40e_vf *vf, u16 vsi_id, 598 u16 vsi_queue_id, 599 struct virtchnl_rxq_info *info) 600 { 601 struct i40e_pf *pf = vf->pf; 602 struct i40e_hw *hw = &pf->hw; 603 struct i40e_hmc_obj_rxq rx_ctx; 604 u16 pf_queue_id; 605 int ret = 0; 606 607 pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_id, vsi_queue_id); 608 609 /* clear the context structure first */ 610 memset(&rx_ctx, 0, sizeof(struct i40e_hmc_obj_rxq)); 611 612 /* only set the required fields */ 613 rx_ctx.base = info->dma_ring_addr / 128; 614 rx_ctx.qlen = info->ring_len; 615 616 if (info->splithdr_enabled) { 617 rx_ctx.hsplit_0 = I40E_RX_SPLIT_L2 | 618 I40E_RX_SPLIT_IP | 619 I40E_RX_SPLIT_TCP_UDP | 620 I40E_RX_SPLIT_SCTP; 621 /* header length validation */ 622 if (info->hdr_size > ((2 * 1024) - 64)) { 623 ret = -EINVAL; 624 goto error_param; 625 } 626 rx_ctx.hbuff = info->hdr_size >> I40E_RXQ_CTX_HBUFF_SHIFT; 627 628 /* set split mode 10b */ 629 rx_ctx.dtype = I40E_RX_DTYPE_HEADER_SPLIT; 630 } 631 632 /* databuffer length validation */ 633 if (info->databuffer_size > ((16 * 1024) - 128)) { 634 ret = -EINVAL; 635 goto error_param; 636 } 637 rx_ctx.dbuff = info->databuffer_size >> I40E_RXQ_CTX_DBUFF_SHIFT; 638 639 /* max pkt. length validation */ 640 if (info->max_pkt_size >= (16 * 1024) || info->max_pkt_size < 64) { 641 ret = -EINVAL; 642 goto error_param; 643 } 644 rx_ctx.rxmax = info->max_pkt_size; 645 646 /* enable 32bytes desc always */ 647 rx_ctx.dsize = 1; 648 649 /* default values */ 650 rx_ctx.lrxqthresh = 1; 651 rx_ctx.crcstrip = 1; 652 rx_ctx.prefena = 1; 653 rx_ctx.l2tsel = 1; 654 655 /* clear the context in the HMC */ 656 ret = i40e_clear_lan_rx_queue_context(hw, pf_queue_id); 657 if (ret) { 658 dev_err(&pf->pdev->dev, 659 "Failed to clear VF LAN Rx queue context %d, error: %d\n", 660 pf_queue_id, ret); 661 ret = -ENOENT; 662 goto error_param; 663 } 664 665 /* set the context in the HMC */ 666 ret = i40e_set_lan_rx_queue_context(hw, pf_queue_id, &rx_ctx); 667 if (ret) { 668 dev_err(&pf->pdev->dev, 669 "Failed to set VF LAN Rx queue context %d error: %d\n", 670 pf_queue_id, ret); 671 ret = -ENOENT; 672 goto error_param; 673 } 674 675 error_param: 676 return ret; 677 } 678 679 /** 680 * i40e_alloc_vsi_res 681 * @vf: pointer to the VF info 682 * @idx: VSI index, applies only for ADq mode, zero otherwise 683 * 684 * alloc VF vsi context & resources 685 **/ 686 static int i40e_alloc_vsi_res(struct i40e_vf *vf, u8 idx) 687 { 688 struct i40e_mac_filter *f = NULL; 689 struct i40e_pf *pf = vf->pf; 690 struct i40e_vsi *vsi; 691 u64 max_tx_rate = 0; 692 int ret = 0; 693 694 vsi = i40e_vsi_setup(pf, I40E_VSI_SRIOV, pf->vsi[pf->lan_vsi]->seid, 695 vf->vf_id); 696 697 if (!vsi) { 698 dev_err(&pf->pdev->dev, 699 "add vsi failed for VF %d, aq_err %d\n", 700 vf->vf_id, pf->hw.aq.asq_last_status); 701 ret = -ENOENT; 702 goto error_alloc_vsi_res; 703 } 704 705 if (!idx) { 706 u64 hena = i40e_pf_get_default_rss_hena(pf); 707 u8 broadcast[ETH_ALEN]; 708 709 vf->lan_vsi_idx = vsi->idx; 710 vf->lan_vsi_id = vsi->id; 711 /* If the port VLAN has been configured and then the 712 * VF driver was removed then the VSI port VLAN 713 * configuration was destroyed. Check if there is 714 * a port VLAN and restore the VSI configuration if 715 * needed. 716 */ 717 if (vf->port_vlan_id) 718 i40e_vsi_add_pvid(vsi, vf->port_vlan_id); 719 720 spin_lock_bh(&vsi->mac_filter_hash_lock); 721 if (is_valid_ether_addr(vf->default_lan_addr.addr)) { 722 f = i40e_add_mac_filter(vsi, 723 vf->default_lan_addr.addr); 724 if (!f) 725 dev_info(&pf->pdev->dev, 726 "Could not add MAC filter %pM for VF %d\n", 727 vf->default_lan_addr.addr, vf->vf_id); 728 } 729 eth_broadcast_addr(broadcast); 730 f = i40e_add_mac_filter(vsi, broadcast); 731 if (!f) 732 dev_info(&pf->pdev->dev, 733 "Could not allocate VF broadcast filter\n"); 734 spin_unlock_bh(&vsi->mac_filter_hash_lock); 735 wr32(&pf->hw, I40E_VFQF_HENA1(0, vf->vf_id), (u32)hena); 736 wr32(&pf->hw, I40E_VFQF_HENA1(1, vf->vf_id), (u32)(hena >> 32)); 737 /* program mac filter only for VF VSI */ 738 ret = i40e_sync_vsi_filters(vsi); 739 if (ret) 740 dev_err(&pf->pdev->dev, "Unable to program ucast filters\n"); 741 } 742 743 /* storing VSI index and id for ADq and don't apply the mac filter */ 744 if (vf->adq_enabled) { 745 vf->ch[idx].vsi_idx = vsi->idx; 746 vf->ch[idx].vsi_id = vsi->id; 747 } 748 749 /* Set VF bandwidth if specified */ 750 if (vf->tx_rate) { 751 max_tx_rate = vf->tx_rate; 752 } else if (vf->ch[idx].max_tx_rate) { 753 max_tx_rate = vf->ch[idx].max_tx_rate; 754 } 755 756 if (max_tx_rate) { 757 max_tx_rate = div_u64(max_tx_rate, I40E_BW_CREDIT_DIVISOR); 758 ret = i40e_aq_config_vsi_bw_limit(&pf->hw, vsi->seid, 759 max_tx_rate, 0, NULL); 760 if (ret) 761 dev_err(&pf->pdev->dev, "Unable to set tx rate, VF %d, error code %d.\n", 762 vf->vf_id, ret); 763 } 764 765 error_alloc_vsi_res: 766 return ret; 767 } 768 769 /** 770 * i40e_map_pf_queues_to_vsi 771 * @vf: pointer to the VF info 772 * 773 * PF maps LQPs to a VF by programming VSILAN_QTABLE & VPLAN_QTABLE. This 774 * function takes care of first part VSILAN_QTABLE, mapping pf queues to VSI. 775 **/ 776 static void i40e_map_pf_queues_to_vsi(struct i40e_vf *vf) 777 { 778 struct i40e_pf *pf = vf->pf; 779 struct i40e_hw *hw = &pf->hw; 780 u32 reg, num_tc = 1; /* VF has at least one traffic class */ 781 u16 vsi_id, qps; 782 int i, j; 783 784 if (vf->adq_enabled) 785 num_tc = vf->num_tc; 786 787 for (i = 0; i < num_tc; i++) { 788 if (vf->adq_enabled) { 789 qps = vf->ch[i].num_qps; 790 vsi_id = vf->ch[i].vsi_id; 791 } else { 792 qps = pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs; 793 vsi_id = vf->lan_vsi_id; 794 } 795 796 for (j = 0; j < 7; j++) { 797 if (j * 2 >= qps) { 798 /* end of list */ 799 reg = 0x07FF07FF; 800 } else { 801 u16 qid = i40e_vc_get_pf_queue_id(vf, 802 vsi_id, 803 j * 2); 804 reg = qid; 805 qid = i40e_vc_get_pf_queue_id(vf, vsi_id, 806 (j * 2) + 1); 807 reg |= qid << 16; 808 } 809 i40e_write_rx_ctl(hw, 810 I40E_VSILAN_QTABLE(j, vsi_id), 811 reg); 812 } 813 } 814 } 815 816 /** 817 * i40e_map_pf_to_vf_queues 818 * @vf: pointer to the VF info 819 * 820 * PF maps LQPs to a VF by programming VSILAN_QTABLE & VPLAN_QTABLE. This 821 * function takes care of the second part VPLAN_QTABLE & completes VF mappings. 822 **/ 823 static void i40e_map_pf_to_vf_queues(struct i40e_vf *vf) 824 { 825 struct i40e_pf *pf = vf->pf; 826 struct i40e_hw *hw = &pf->hw; 827 u32 reg, total_qps = 0; 828 u32 qps, num_tc = 1; /* VF has at least one traffic class */ 829 u16 vsi_id, qid; 830 int i, j; 831 832 if (vf->adq_enabled) 833 num_tc = vf->num_tc; 834 835 for (i = 0; i < num_tc; i++) { 836 if (vf->adq_enabled) { 837 qps = vf->ch[i].num_qps; 838 vsi_id = vf->ch[i].vsi_id; 839 } else { 840 qps = pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs; 841 vsi_id = vf->lan_vsi_id; 842 } 843 844 for (j = 0; j < qps; j++) { 845 qid = i40e_vc_get_pf_queue_id(vf, vsi_id, j); 846 847 reg = (qid & I40E_VPLAN_QTABLE_QINDEX_MASK); 848 wr32(hw, I40E_VPLAN_QTABLE(total_qps, vf->vf_id), 849 reg); 850 total_qps++; 851 } 852 } 853 } 854 855 /** 856 * i40e_enable_vf_mappings 857 * @vf: pointer to the VF info 858 * 859 * enable VF mappings 860 **/ 861 static void i40e_enable_vf_mappings(struct i40e_vf *vf) 862 { 863 struct i40e_pf *pf = vf->pf; 864 struct i40e_hw *hw = &pf->hw; 865 u32 reg; 866 867 /* Tell the hardware we're using noncontiguous mapping. HW requires 868 * that VF queues be mapped using this method, even when they are 869 * contiguous in real life 870 */ 871 i40e_write_rx_ctl(hw, I40E_VSILAN_QBASE(vf->lan_vsi_id), 872 I40E_VSILAN_QBASE_VSIQTABLE_ENA_MASK); 873 874 /* enable VF vplan_qtable mappings */ 875 reg = I40E_VPLAN_MAPENA_TXRX_ENA_MASK; 876 wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), reg); 877 878 i40e_map_pf_to_vf_queues(vf); 879 i40e_map_pf_queues_to_vsi(vf); 880 881 i40e_flush(hw); 882 } 883 884 /** 885 * i40e_disable_vf_mappings 886 * @vf: pointer to the VF info 887 * 888 * disable VF mappings 889 **/ 890 static void i40e_disable_vf_mappings(struct i40e_vf *vf) 891 { 892 struct i40e_pf *pf = vf->pf; 893 struct i40e_hw *hw = &pf->hw; 894 int i; 895 896 /* disable qp mappings */ 897 wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), 0); 898 for (i = 0; i < I40E_MAX_VSI_QP; i++) 899 wr32(hw, I40E_VPLAN_QTABLE(i, vf->vf_id), 900 I40E_QUEUE_END_OF_LIST); 901 i40e_flush(hw); 902 } 903 904 /** 905 * i40e_free_vf_res 906 * @vf: pointer to the VF info 907 * 908 * free VF resources 909 **/ 910 static void i40e_free_vf_res(struct i40e_vf *vf) 911 { 912 struct i40e_pf *pf = vf->pf; 913 struct i40e_hw *hw = &pf->hw; 914 u32 reg_idx, reg; 915 int i, j, msix_vf; 916 917 /* Start by disabling VF's configuration API to prevent the OS from 918 * accessing the VF's VSI after it's freed / invalidated. 919 */ 920 clear_bit(I40E_VF_STATE_INIT, &vf->vf_states); 921 922 /* It's possible the VF had requeuested more queues than the default so 923 * do the accounting here when we're about to free them. 924 */ 925 if (vf->num_queue_pairs > I40E_DEFAULT_QUEUES_PER_VF) { 926 pf->queues_left += vf->num_queue_pairs - 927 I40E_DEFAULT_QUEUES_PER_VF; 928 } 929 930 /* free vsi & disconnect it from the parent uplink */ 931 if (vf->lan_vsi_idx) { 932 i40e_vsi_release(pf->vsi[vf->lan_vsi_idx]); 933 vf->lan_vsi_idx = 0; 934 vf->lan_vsi_id = 0; 935 vf->num_mac = 0; 936 } 937 938 /* do the accounting and remove additional ADq VSI's */ 939 if (vf->adq_enabled && vf->ch[0].vsi_idx) { 940 for (j = 0; j < vf->num_tc; j++) { 941 /* At this point VSI0 is already released so don't 942 * release it again and only clear their values in 943 * structure variables 944 */ 945 if (j) 946 i40e_vsi_release(pf->vsi[vf->ch[j].vsi_idx]); 947 vf->ch[j].vsi_idx = 0; 948 vf->ch[j].vsi_id = 0; 949 } 950 } 951 msix_vf = pf->hw.func_caps.num_msix_vectors_vf; 952 953 /* disable interrupts so the VF starts in a known state */ 954 for (i = 0; i < msix_vf; i++) { 955 /* format is same for both registers */ 956 if (0 == i) 957 reg_idx = I40E_VFINT_DYN_CTL0(vf->vf_id); 958 else 959 reg_idx = I40E_VFINT_DYN_CTLN(((msix_vf - 1) * 960 (vf->vf_id)) 961 + (i - 1)); 962 wr32(hw, reg_idx, I40E_VFINT_DYN_CTLN_CLEARPBA_MASK); 963 i40e_flush(hw); 964 } 965 966 /* clear the irq settings */ 967 for (i = 0; i < msix_vf; i++) { 968 /* format is same for both registers */ 969 if (0 == i) 970 reg_idx = I40E_VPINT_LNKLST0(vf->vf_id); 971 else 972 reg_idx = I40E_VPINT_LNKLSTN(((msix_vf - 1) * 973 (vf->vf_id)) 974 + (i - 1)); 975 reg = (I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK | 976 I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK); 977 wr32(hw, reg_idx, reg); 978 i40e_flush(hw); 979 } 980 /* reset some of the state variables keeping track of the resources */ 981 vf->num_queue_pairs = 0; 982 clear_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states); 983 clear_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states); 984 } 985 986 /** 987 * i40e_alloc_vf_res 988 * @vf: pointer to the VF info 989 * 990 * allocate VF resources 991 **/ 992 static int i40e_alloc_vf_res(struct i40e_vf *vf) 993 { 994 struct i40e_pf *pf = vf->pf; 995 int total_queue_pairs = 0; 996 int ret, idx; 997 998 if (vf->num_req_queues && 999 vf->num_req_queues <= pf->queues_left + I40E_DEFAULT_QUEUES_PER_VF) 1000 pf->num_vf_qps = vf->num_req_queues; 1001 else 1002 pf->num_vf_qps = I40E_DEFAULT_QUEUES_PER_VF; 1003 1004 /* allocate hw vsi context & associated resources */ 1005 ret = i40e_alloc_vsi_res(vf, 0); 1006 if (ret) 1007 goto error_alloc; 1008 total_queue_pairs += pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs; 1009 1010 /* allocate additional VSIs based on tc information for ADq */ 1011 if (vf->adq_enabled) { 1012 if (pf->queues_left >= 1013 (I40E_MAX_VF_QUEUES - I40E_DEFAULT_QUEUES_PER_VF)) { 1014 /* TC 0 always belongs to VF VSI */ 1015 for (idx = 1; idx < vf->num_tc; idx++) { 1016 ret = i40e_alloc_vsi_res(vf, idx); 1017 if (ret) 1018 goto error_alloc; 1019 } 1020 /* send correct number of queues */ 1021 total_queue_pairs = I40E_MAX_VF_QUEUES; 1022 } else { 1023 dev_info(&pf->pdev->dev, "VF %d: Not enough queues to allocate, disabling ADq\n", 1024 vf->vf_id); 1025 vf->adq_enabled = false; 1026 } 1027 } 1028 1029 /* We account for each VF to get a default number of queue pairs. If 1030 * the VF has now requested more, we need to account for that to make 1031 * certain we never request more queues than we actually have left in 1032 * HW. 1033 */ 1034 if (total_queue_pairs > I40E_DEFAULT_QUEUES_PER_VF) 1035 pf->queues_left -= 1036 total_queue_pairs - I40E_DEFAULT_QUEUES_PER_VF; 1037 1038 if (vf->trusted) 1039 set_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps); 1040 else 1041 clear_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps); 1042 1043 /* store the total qps number for the runtime 1044 * VF req validation 1045 */ 1046 vf->num_queue_pairs = total_queue_pairs; 1047 1048 /* VF is now completely initialized */ 1049 set_bit(I40E_VF_STATE_INIT, &vf->vf_states); 1050 1051 error_alloc: 1052 if (ret) 1053 i40e_free_vf_res(vf); 1054 1055 return ret; 1056 } 1057 1058 #define VF_DEVICE_STATUS 0xAA 1059 #define VF_TRANS_PENDING_MASK 0x20 1060 /** 1061 * i40e_quiesce_vf_pci 1062 * @vf: pointer to the VF structure 1063 * 1064 * Wait for VF PCI transactions to be cleared after reset. Returns -EIO 1065 * if the transactions never clear. 1066 **/ 1067 static int i40e_quiesce_vf_pci(struct i40e_vf *vf) 1068 { 1069 struct i40e_pf *pf = vf->pf; 1070 struct i40e_hw *hw = &pf->hw; 1071 int vf_abs_id, i; 1072 u32 reg; 1073 1074 vf_abs_id = vf->vf_id + hw->func_caps.vf_base_id; 1075 1076 wr32(hw, I40E_PF_PCI_CIAA, 1077 VF_DEVICE_STATUS | (vf_abs_id << I40E_PF_PCI_CIAA_VF_NUM_SHIFT)); 1078 for (i = 0; i < 100; i++) { 1079 reg = rd32(hw, I40E_PF_PCI_CIAD); 1080 if ((reg & VF_TRANS_PENDING_MASK) == 0) 1081 return 0; 1082 udelay(1); 1083 } 1084 return -EIO; 1085 } 1086 1087 /** 1088 * i40e_trigger_vf_reset 1089 * @vf: pointer to the VF structure 1090 * @flr: VFLR was issued or not 1091 * 1092 * Trigger hardware to start a reset for a particular VF. Expects the caller 1093 * to wait the proper amount of time to allow hardware to reset the VF before 1094 * it cleans up and restores VF functionality. 1095 **/ 1096 static void i40e_trigger_vf_reset(struct i40e_vf *vf, bool flr) 1097 { 1098 struct i40e_pf *pf = vf->pf; 1099 struct i40e_hw *hw = &pf->hw; 1100 u32 reg, reg_idx, bit_idx; 1101 1102 /* warn the VF */ 1103 clear_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states); 1104 1105 /* Disable VF's configuration API during reset. The flag is re-enabled 1106 * in i40e_alloc_vf_res(), when it's safe again to access VF's VSI. 1107 * It's normally disabled in i40e_free_vf_res(), but it's safer 1108 * to do it earlier to give some time to finish to any VF config 1109 * functions that may still be running at this point. 1110 */ 1111 clear_bit(I40E_VF_STATE_INIT, &vf->vf_states); 1112 1113 /* In the case of a VFLR, the HW has already reset the VF and we 1114 * just need to clean up, so don't hit the VFRTRIG register. 1115 */ 1116 if (!flr) { 1117 /* reset VF using VPGEN_VFRTRIG reg */ 1118 reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id)); 1119 reg |= I40E_VPGEN_VFRTRIG_VFSWR_MASK; 1120 wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg); 1121 i40e_flush(hw); 1122 } 1123 /* clear the VFLR bit in GLGEN_VFLRSTAT */ 1124 reg_idx = (hw->func_caps.vf_base_id + vf->vf_id) / 32; 1125 bit_idx = (hw->func_caps.vf_base_id + vf->vf_id) % 32; 1126 wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx)); 1127 i40e_flush(hw); 1128 1129 if (i40e_quiesce_vf_pci(vf)) 1130 dev_err(&pf->pdev->dev, "VF %d PCI transactions stuck\n", 1131 vf->vf_id); 1132 } 1133 1134 /** 1135 * i40e_cleanup_reset_vf 1136 * @vf: pointer to the VF structure 1137 * 1138 * Cleanup a VF after the hardware reset is finished. Expects the caller to 1139 * have verified whether the reset is finished properly, and ensure the 1140 * minimum amount of wait time has passed. 1141 **/ 1142 static void i40e_cleanup_reset_vf(struct i40e_vf *vf) 1143 { 1144 struct i40e_pf *pf = vf->pf; 1145 struct i40e_hw *hw = &pf->hw; 1146 u32 reg; 1147 1148 /* free VF resources to begin resetting the VSI state */ 1149 i40e_free_vf_res(vf); 1150 1151 /* Enable hardware by clearing the reset bit in the VPGEN_VFRTRIG reg. 1152 * By doing this we allow HW to access VF memory at any point. If we 1153 * did it any sooner, HW could access memory while it was being freed 1154 * in i40e_free_vf_res(), causing an IOMMU fault. 1155 * 1156 * On the other hand, this needs to be done ASAP, because the VF driver 1157 * is waiting for this to happen and may report a timeout. It's 1158 * harmless, but it gets logged into Guest OS kernel log, so best avoid 1159 * it. 1160 */ 1161 reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id)); 1162 reg &= ~I40E_VPGEN_VFRTRIG_VFSWR_MASK; 1163 wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg); 1164 1165 /* reallocate VF resources to finish resetting the VSI state */ 1166 if (!i40e_alloc_vf_res(vf)) { 1167 int abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id; 1168 i40e_enable_vf_mappings(vf); 1169 set_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states); 1170 clear_bit(I40E_VF_STATE_DISABLED, &vf->vf_states); 1171 /* Do not notify the client during VF init */ 1172 if (!test_and_clear_bit(I40E_VF_STATE_PRE_ENABLE, 1173 &vf->vf_states)) 1174 i40e_notify_client_of_vf_reset(pf, abs_vf_id); 1175 vf->num_vlan = 0; 1176 } 1177 1178 /* Tell the VF driver the reset is done. This needs to be done only 1179 * after VF has been fully initialized, because the VF driver may 1180 * request resources immediately after setting this flag. 1181 */ 1182 wr32(hw, I40E_VFGEN_RSTAT1(vf->vf_id), VIRTCHNL_VFR_VFACTIVE); 1183 } 1184 1185 /** 1186 * i40e_reset_vf 1187 * @vf: pointer to the VF structure 1188 * @flr: VFLR was issued or not 1189 * 1190 * Returns true if the VF is reset, false otherwise. 1191 **/ 1192 bool i40e_reset_vf(struct i40e_vf *vf, bool flr) 1193 { 1194 struct i40e_pf *pf = vf->pf; 1195 struct i40e_hw *hw = &pf->hw; 1196 bool rsd = false; 1197 u32 reg; 1198 int i; 1199 1200 /* If the VFs have been disabled, this means something else is 1201 * resetting the VF, so we shouldn't continue. 1202 */ 1203 if (test_and_set_bit(__I40E_VF_DISABLE, pf->state)) 1204 return false; 1205 1206 i40e_trigger_vf_reset(vf, flr); 1207 1208 /* poll VPGEN_VFRSTAT reg to make sure 1209 * that reset is complete 1210 */ 1211 for (i = 0; i < 10; i++) { 1212 /* VF reset requires driver to first reset the VF and then 1213 * poll the status register to make sure that the reset 1214 * completed successfully. Due to internal HW FIFO flushes, 1215 * we must wait 10ms before the register will be valid. 1216 */ 1217 usleep_range(10000, 20000); 1218 reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id)); 1219 if (reg & I40E_VPGEN_VFRSTAT_VFRD_MASK) { 1220 rsd = true; 1221 break; 1222 } 1223 } 1224 1225 if (flr) 1226 usleep_range(10000, 20000); 1227 1228 if (!rsd) 1229 dev_err(&pf->pdev->dev, "VF reset check timeout on VF %d\n", 1230 vf->vf_id); 1231 usleep_range(10000, 20000); 1232 1233 /* On initial reset, we don't have any queues to disable */ 1234 if (vf->lan_vsi_idx != 0) 1235 i40e_vsi_stop_rings(pf->vsi[vf->lan_vsi_idx]); 1236 1237 i40e_cleanup_reset_vf(vf); 1238 1239 i40e_flush(hw); 1240 clear_bit(__I40E_VF_DISABLE, pf->state); 1241 1242 return true; 1243 } 1244 1245 /** 1246 * i40e_reset_all_vfs 1247 * @pf: pointer to the PF structure 1248 * @flr: VFLR was issued or not 1249 * 1250 * Reset all allocated VFs in one go. First, tell the hardware to reset each 1251 * VF, then do all the waiting in one chunk, and finally finish restoring each 1252 * VF after the wait. This is useful during PF routines which need to reset 1253 * all VFs, as otherwise it must perform these resets in a serialized fashion. 1254 * 1255 * Returns true if any VFs were reset, and false otherwise. 1256 **/ 1257 bool i40e_reset_all_vfs(struct i40e_pf *pf, bool flr) 1258 { 1259 struct i40e_hw *hw = &pf->hw; 1260 struct i40e_vf *vf; 1261 int i, v; 1262 u32 reg; 1263 1264 /* If we don't have any VFs, then there is nothing to reset */ 1265 if (!pf->num_alloc_vfs) 1266 return false; 1267 1268 /* If VFs have been disabled, there is no need to reset */ 1269 if (test_and_set_bit(__I40E_VF_DISABLE, pf->state)) 1270 return false; 1271 1272 /* Begin reset on all VFs at once */ 1273 for (v = 0; v < pf->num_alloc_vfs; v++) 1274 i40e_trigger_vf_reset(&pf->vf[v], flr); 1275 1276 /* HW requires some time to make sure it can flush the FIFO for a VF 1277 * when it resets it. Poll the VPGEN_VFRSTAT register for each VF in 1278 * sequence to make sure that it has completed. We'll keep track of 1279 * the VFs using a simple iterator that increments once that VF has 1280 * finished resetting. 1281 */ 1282 for (i = 0, v = 0; i < 10 && v < pf->num_alloc_vfs; i++) { 1283 usleep_range(10000, 20000); 1284 1285 /* Check each VF in sequence, beginning with the VF to fail 1286 * the previous check. 1287 */ 1288 while (v < pf->num_alloc_vfs) { 1289 vf = &pf->vf[v]; 1290 reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id)); 1291 if (!(reg & I40E_VPGEN_VFRSTAT_VFRD_MASK)) 1292 break; 1293 1294 /* If the current VF has finished resetting, move on 1295 * to the next VF in sequence. 1296 */ 1297 v++; 1298 } 1299 } 1300 1301 if (flr) 1302 usleep_range(10000, 20000); 1303 1304 /* Display a warning if at least one VF didn't manage to reset in 1305 * time, but continue on with the operation. 1306 */ 1307 if (v < pf->num_alloc_vfs) 1308 dev_err(&pf->pdev->dev, "VF reset check timeout on VF %d\n", 1309 pf->vf[v].vf_id); 1310 usleep_range(10000, 20000); 1311 1312 /* Begin disabling all the rings associated with VFs, but do not wait 1313 * between each VF. 1314 */ 1315 for (v = 0; v < pf->num_alloc_vfs; v++) { 1316 /* On initial reset, we don't have any queues to disable */ 1317 if (pf->vf[v].lan_vsi_idx == 0) 1318 continue; 1319 1320 i40e_vsi_stop_rings_no_wait(pf->vsi[pf->vf[v].lan_vsi_idx]); 1321 } 1322 1323 /* Now that we've notified HW to disable all of the VF rings, wait 1324 * until they finish. 1325 */ 1326 for (v = 0; v < pf->num_alloc_vfs; v++) { 1327 /* On initial reset, we don't have any queues to disable */ 1328 if (pf->vf[v].lan_vsi_idx == 0) 1329 continue; 1330 1331 i40e_vsi_wait_queues_disabled(pf->vsi[pf->vf[v].lan_vsi_idx]); 1332 } 1333 1334 /* Hw may need up to 50ms to finish disabling the RX queues. We 1335 * minimize the wait by delaying only once for all VFs. 1336 */ 1337 mdelay(50); 1338 1339 /* Finish the reset on each VF */ 1340 for (v = 0; v < pf->num_alloc_vfs; v++) 1341 i40e_cleanup_reset_vf(&pf->vf[v]); 1342 1343 i40e_flush(hw); 1344 clear_bit(__I40E_VF_DISABLE, pf->state); 1345 1346 return true; 1347 } 1348 1349 /** 1350 * i40e_free_vfs 1351 * @pf: pointer to the PF structure 1352 * 1353 * free VF resources 1354 **/ 1355 void i40e_free_vfs(struct i40e_pf *pf) 1356 { 1357 struct i40e_hw *hw = &pf->hw; 1358 u32 reg_idx, bit_idx; 1359 int i, tmp, vf_id; 1360 1361 if (!pf->vf) 1362 return; 1363 while (test_and_set_bit(__I40E_VF_DISABLE, pf->state)) 1364 usleep_range(1000, 2000); 1365 1366 i40e_notify_client_of_vf_enable(pf, 0); 1367 1368 /* Amortize wait time by stopping all VFs at the same time */ 1369 for (i = 0; i < pf->num_alloc_vfs; i++) { 1370 if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states)) 1371 continue; 1372 1373 i40e_vsi_stop_rings_no_wait(pf->vsi[pf->vf[i].lan_vsi_idx]); 1374 } 1375 1376 for (i = 0; i < pf->num_alloc_vfs; i++) { 1377 if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states)) 1378 continue; 1379 1380 i40e_vsi_wait_queues_disabled(pf->vsi[pf->vf[i].lan_vsi_idx]); 1381 } 1382 1383 /* Disable IOV before freeing resources. This lets any VF drivers 1384 * running in the host get themselves cleaned up before we yank 1385 * the carpet out from underneath their feet. 1386 */ 1387 if (!pci_vfs_assigned(pf->pdev)) 1388 pci_disable_sriov(pf->pdev); 1389 else 1390 dev_warn(&pf->pdev->dev, "VFs are assigned - not disabling SR-IOV\n"); 1391 1392 /* free up VF resources */ 1393 tmp = pf->num_alloc_vfs; 1394 pf->num_alloc_vfs = 0; 1395 for (i = 0; i < tmp; i++) { 1396 if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states)) 1397 i40e_free_vf_res(&pf->vf[i]); 1398 /* disable qp mappings */ 1399 i40e_disable_vf_mappings(&pf->vf[i]); 1400 } 1401 1402 kfree(pf->vf); 1403 pf->vf = NULL; 1404 1405 /* This check is for when the driver is unloaded while VFs are 1406 * assigned. Setting the number of VFs to 0 through sysfs is caught 1407 * before this function ever gets called. 1408 */ 1409 if (!pci_vfs_assigned(pf->pdev)) { 1410 /* Acknowledge VFLR for all VFS. Without this, VFs will fail to 1411 * work correctly when SR-IOV gets re-enabled. 1412 */ 1413 for (vf_id = 0; vf_id < tmp; vf_id++) { 1414 reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32; 1415 bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32; 1416 wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx)); 1417 } 1418 } 1419 clear_bit(__I40E_VF_DISABLE, pf->state); 1420 } 1421 1422 #ifdef CONFIG_PCI_IOV 1423 /** 1424 * i40e_alloc_vfs 1425 * @pf: pointer to the PF structure 1426 * @num_alloc_vfs: number of VFs to allocate 1427 * 1428 * allocate VF resources 1429 **/ 1430 int i40e_alloc_vfs(struct i40e_pf *pf, u16 num_alloc_vfs) 1431 { 1432 struct i40e_vf *vfs; 1433 int i, ret = 0; 1434 1435 /* Disable interrupt 0 so we don't try to handle the VFLR. */ 1436 i40e_irq_dynamic_disable_icr0(pf); 1437 1438 /* Check to see if we're just allocating resources for extant VFs */ 1439 if (pci_num_vf(pf->pdev) != num_alloc_vfs) { 1440 ret = pci_enable_sriov(pf->pdev, num_alloc_vfs); 1441 if (ret) { 1442 pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED; 1443 pf->num_alloc_vfs = 0; 1444 goto err_iov; 1445 } 1446 } 1447 /* allocate memory */ 1448 vfs = kcalloc(num_alloc_vfs, sizeof(struct i40e_vf), GFP_KERNEL); 1449 if (!vfs) { 1450 ret = -ENOMEM; 1451 goto err_alloc; 1452 } 1453 pf->vf = vfs; 1454 1455 /* apply default profile */ 1456 for (i = 0; i < num_alloc_vfs; i++) { 1457 vfs[i].pf = pf; 1458 vfs[i].parent_type = I40E_SWITCH_ELEMENT_TYPE_VEB; 1459 vfs[i].vf_id = i; 1460 1461 /* assign default capabilities */ 1462 set_bit(I40E_VIRTCHNL_VF_CAP_L2, &vfs[i].vf_caps); 1463 vfs[i].spoofchk = true; 1464 1465 set_bit(I40E_VF_STATE_PRE_ENABLE, &vfs[i].vf_states); 1466 1467 } 1468 pf->num_alloc_vfs = num_alloc_vfs; 1469 1470 /* VF resources get allocated during reset */ 1471 i40e_reset_all_vfs(pf, false); 1472 1473 i40e_notify_client_of_vf_enable(pf, num_alloc_vfs); 1474 1475 err_alloc: 1476 if (ret) 1477 i40e_free_vfs(pf); 1478 err_iov: 1479 /* Re-enable interrupt 0. */ 1480 i40e_irq_dynamic_enable_icr0(pf); 1481 return ret; 1482 } 1483 1484 #endif 1485 /** 1486 * i40e_pci_sriov_enable 1487 * @pdev: pointer to a pci_dev structure 1488 * @num_vfs: number of VFs to allocate 1489 * 1490 * Enable or change the number of VFs 1491 **/ 1492 static int i40e_pci_sriov_enable(struct pci_dev *pdev, int num_vfs) 1493 { 1494 #ifdef CONFIG_PCI_IOV 1495 struct i40e_pf *pf = pci_get_drvdata(pdev); 1496 int pre_existing_vfs = pci_num_vf(pdev); 1497 int err = 0; 1498 1499 if (test_bit(__I40E_TESTING, pf->state)) { 1500 dev_warn(&pdev->dev, 1501 "Cannot enable SR-IOV virtual functions while the device is undergoing diagnostic testing\n"); 1502 err = -EPERM; 1503 goto err_out; 1504 } 1505 1506 if (pre_existing_vfs && pre_existing_vfs != num_vfs) 1507 i40e_free_vfs(pf); 1508 else if (pre_existing_vfs && pre_existing_vfs == num_vfs) 1509 goto out; 1510 1511 if (num_vfs > pf->num_req_vfs) { 1512 dev_warn(&pdev->dev, "Unable to enable %d VFs. Limited to %d VFs due to device resource constraints.\n", 1513 num_vfs, pf->num_req_vfs); 1514 err = -EPERM; 1515 goto err_out; 1516 } 1517 1518 dev_info(&pdev->dev, "Allocating %d VFs.\n", num_vfs); 1519 err = i40e_alloc_vfs(pf, num_vfs); 1520 if (err) { 1521 dev_warn(&pdev->dev, "Failed to enable SR-IOV: %d\n", err); 1522 goto err_out; 1523 } 1524 1525 out: 1526 return num_vfs; 1527 1528 err_out: 1529 return err; 1530 #endif 1531 return 0; 1532 } 1533 1534 /** 1535 * i40e_pci_sriov_configure 1536 * @pdev: pointer to a pci_dev structure 1537 * @num_vfs: number of VFs to allocate 1538 * 1539 * Enable or change the number of VFs. Called when the user updates the number 1540 * of VFs in sysfs. 1541 **/ 1542 int i40e_pci_sriov_configure(struct pci_dev *pdev, int num_vfs) 1543 { 1544 struct i40e_pf *pf = pci_get_drvdata(pdev); 1545 1546 if (num_vfs) { 1547 if (!(pf->flags & I40E_FLAG_VEB_MODE_ENABLED)) { 1548 pf->flags |= I40E_FLAG_VEB_MODE_ENABLED; 1549 i40e_do_reset_safe(pf, I40E_PF_RESET_FLAG); 1550 } 1551 return i40e_pci_sriov_enable(pdev, num_vfs); 1552 } 1553 1554 if (!pci_vfs_assigned(pf->pdev)) { 1555 i40e_free_vfs(pf); 1556 pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED; 1557 i40e_do_reset_safe(pf, I40E_PF_RESET_FLAG); 1558 } else { 1559 dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs.\n"); 1560 return -EINVAL; 1561 } 1562 return 0; 1563 } 1564 1565 /***********************virtual channel routines******************/ 1566 1567 /** 1568 * i40e_vc_send_msg_to_vf 1569 * @vf: pointer to the VF info 1570 * @v_opcode: virtual channel opcode 1571 * @v_retval: virtual channel return value 1572 * @msg: pointer to the msg buffer 1573 * @msglen: msg length 1574 * 1575 * send msg to VF 1576 **/ 1577 static int i40e_vc_send_msg_to_vf(struct i40e_vf *vf, u32 v_opcode, 1578 u32 v_retval, u8 *msg, u16 msglen) 1579 { 1580 struct i40e_pf *pf; 1581 struct i40e_hw *hw; 1582 int abs_vf_id; 1583 i40e_status aq_ret; 1584 1585 /* validate the request */ 1586 if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs) 1587 return -EINVAL; 1588 1589 pf = vf->pf; 1590 hw = &pf->hw; 1591 abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id; 1592 1593 /* single place to detect unsuccessful return values */ 1594 if (v_retval) { 1595 vf->num_invalid_msgs++; 1596 dev_info(&pf->pdev->dev, "VF %d failed opcode %d, retval: %d\n", 1597 vf->vf_id, v_opcode, v_retval); 1598 if (vf->num_invalid_msgs > 1599 I40E_DEFAULT_NUM_INVALID_MSGS_ALLOWED) { 1600 dev_err(&pf->pdev->dev, 1601 "Number of invalid messages exceeded for VF %d\n", 1602 vf->vf_id); 1603 dev_err(&pf->pdev->dev, "Use PF Control I/F to enable the VF\n"); 1604 set_bit(I40E_VF_STATE_DISABLED, &vf->vf_states); 1605 } 1606 } else { 1607 vf->num_valid_msgs++; 1608 /* reset the invalid counter, if a valid message is received. */ 1609 vf->num_invalid_msgs = 0; 1610 } 1611 1612 aq_ret = i40e_aq_send_msg_to_vf(hw, abs_vf_id, v_opcode, v_retval, 1613 msg, msglen, NULL); 1614 if (aq_ret) { 1615 dev_info(&pf->pdev->dev, 1616 "Unable to send the message to VF %d aq_err %d\n", 1617 vf->vf_id, pf->hw.aq.asq_last_status); 1618 return -EIO; 1619 } 1620 1621 return 0; 1622 } 1623 1624 /** 1625 * i40e_vc_send_resp_to_vf 1626 * @vf: pointer to the VF info 1627 * @opcode: operation code 1628 * @retval: return value 1629 * 1630 * send resp msg to VF 1631 **/ 1632 static int i40e_vc_send_resp_to_vf(struct i40e_vf *vf, 1633 enum virtchnl_ops opcode, 1634 i40e_status retval) 1635 { 1636 return i40e_vc_send_msg_to_vf(vf, opcode, retval, NULL, 0); 1637 } 1638 1639 /** 1640 * i40e_vc_get_version_msg 1641 * @vf: pointer to the VF info 1642 * @msg: pointer to the msg buffer 1643 * 1644 * called from the VF to request the API version used by the PF 1645 **/ 1646 static int i40e_vc_get_version_msg(struct i40e_vf *vf, u8 *msg) 1647 { 1648 struct virtchnl_version_info info = { 1649 VIRTCHNL_VERSION_MAJOR, VIRTCHNL_VERSION_MINOR 1650 }; 1651 1652 vf->vf_ver = *(struct virtchnl_version_info *)msg; 1653 /* VFs running the 1.0 API expect to get 1.0 back or they will cry. */ 1654 if (VF_IS_V10(&vf->vf_ver)) 1655 info.minor = VIRTCHNL_VERSION_MINOR_NO_VF_CAPS; 1656 return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_VERSION, 1657 I40E_SUCCESS, (u8 *)&info, 1658 sizeof(struct virtchnl_version_info)); 1659 } 1660 1661 /** 1662 * i40e_del_qch - delete all the additional VSIs created as a part of ADq 1663 * @vf: pointer to VF structure 1664 **/ 1665 static void i40e_del_qch(struct i40e_vf *vf) 1666 { 1667 struct i40e_pf *pf = vf->pf; 1668 int i; 1669 1670 /* first element in the array belongs to primary VF VSI and we shouldn't 1671 * delete it. We should however delete the rest of the VSIs created 1672 */ 1673 for (i = 1; i < vf->num_tc; i++) { 1674 if (vf->ch[i].vsi_idx) { 1675 i40e_vsi_release(pf->vsi[vf->ch[i].vsi_idx]); 1676 vf->ch[i].vsi_idx = 0; 1677 vf->ch[i].vsi_id = 0; 1678 } 1679 } 1680 } 1681 1682 /** 1683 * i40e_vc_get_vf_resources_msg 1684 * @vf: pointer to the VF info 1685 * @msg: pointer to the msg buffer 1686 * 1687 * called from the VF to request its resources 1688 **/ 1689 static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf, u8 *msg) 1690 { 1691 struct virtchnl_vf_resource *vfres = NULL; 1692 struct i40e_pf *pf = vf->pf; 1693 i40e_status aq_ret = 0; 1694 struct i40e_vsi *vsi; 1695 int num_vsis = 1; 1696 int len = 0; 1697 int ret; 1698 1699 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) { 1700 aq_ret = I40E_ERR_PARAM; 1701 goto err; 1702 } 1703 1704 len = (sizeof(struct virtchnl_vf_resource) + 1705 sizeof(struct virtchnl_vsi_resource) * num_vsis); 1706 1707 vfres = kzalloc(len, GFP_KERNEL); 1708 if (!vfres) { 1709 aq_ret = I40E_ERR_NO_MEMORY; 1710 len = 0; 1711 goto err; 1712 } 1713 if (VF_IS_V11(&vf->vf_ver)) 1714 vf->driver_caps = *(u32 *)msg; 1715 else 1716 vf->driver_caps = VIRTCHNL_VF_OFFLOAD_L2 | 1717 VIRTCHNL_VF_OFFLOAD_RSS_REG | 1718 VIRTCHNL_VF_OFFLOAD_VLAN; 1719 1720 vfres->vf_cap_flags = VIRTCHNL_VF_OFFLOAD_L2; 1721 vsi = pf->vsi[vf->lan_vsi_idx]; 1722 if (!vsi->info.pvid) 1723 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_VLAN; 1724 1725 if (i40e_vf_client_capable(pf, vf->vf_id) && 1726 (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_IWARP)) { 1727 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_IWARP; 1728 set_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states); 1729 } else { 1730 clear_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states); 1731 } 1732 1733 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PF) { 1734 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_PF; 1735 } else { 1736 if ((pf->hw_features & I40E_HW_RSS_AQ_CAPABLE) && 1737 (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_AQ)) 1738 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_AQ; 1739 else 1740 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_REG; 1741 } 1742 1743 if (pf->hw_features & I40E_HW_MULTIPLE_TCP_UDP_RSS_PCTYPE) { 1744 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2) 1745 vfres->vf_cap_flags |= 1746 VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2; 1747 } 1748 1749 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP) 1750 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP; 1751 1752 if ((pf->hw_features & I40E_HW_OUTER_UDP_CSUM_CAPABLE) && 1753 (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM)) 1754 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM; 1755 1756 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_POLLING) { 1757 if (pf->flags & I40E_FLAG_MFP_ENABLED) { 1758 dev_err(&pf->pdev->dev, 1759 "VF %d requested polling mode: this feature is supported only when the device is running in single function per port (SFP) mode\n", 1760 vf->vf_id); 1761 aq_ret = I40E_ERR_PARAM; 1762 goto err; 1763 } 1764 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RX_POLLING; 1765 } 1766 1767 if (pf->hw_features & I40E_HW_WB_ON_ITR_CAPABLE) { 1768 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR) 1769 vfres->vf_cap_flags |= 1770 VIRTCHNL_VF_OFFLOAD_WB_ON_ITR; 1771 } 1772 1773 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_REQ_QUEUES) 1774 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_REQ_QUEUES; 1775 1776 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ADQ) 1777 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ADQ; 1778 1779 vfres->num_vsis = num_vsis; 1780 vfres->num_queue_pairs = vf->num_queue_pairs; 1781 vfres->max_vectors = pf->hw.func_caps.num_msix_vectors_vf; 1782 vfres->rss_key_size = I40E_HKEY_ARRAY_SIZE; 1783 vfres->rss_lut_size = I40E_VF_HLUT_ARRAY_SIZE; 1784 1785 if (vf->lan_vsi_idx) { 1786 vfres->vsi_res[0].vsi_id = vf->lan_vsi_id; 1787 vfres->vsi_res[0].vsi_type = VIRTCHNL_VSI_SRIOV; 1788 vfres->vsi_res[0].num_queue_pairs = vsi->alloc_queue_pairs; 1789 /* VFs only use TC 0 */ 1790 vfres->vsi_res[0].qset_handle 1791 = le16_to_cpu(vsi->info.qs_handle[0]); 1792 ether_addr_copy(vfres->vsi_res[0].default_mac_addr, 1793 vf->default_lan_addr.addr); 1794 } 1795 set_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states); 1796 1797 err: 1798 /* send the response back to the VF */ 1799 ret = i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_VF_RESOURCES, 1800 aq_ret, (u8 *)vfres, len); 1801 1802 kfree(vfres); 1803 return ret; 1804 } 1805 1806 /** 1807 * i40e_vc_reset_vf_msg 1808 * @vf: pointer to the VF info 1809 * 1810 * called from the VF to reset itself, 1811 * unlike other virtchnl messages, PF driver 1812 * doesn't send the response back to the VF 1813 **/ 1814 static void i40e_vc_reset_vf_msg(struct i40e_vf *vf) 1815 { 1816 if (test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) 1817 i40e_reset_vf(vf, false); 1818 } 1819 1820 /** 1821 * i40e_getnum_vf_vsi_vlan_filters 1822 * @vsi: pointer to the vsi 1823 * 1824 * called to get the number of VLANs offloaded on this VF 1825 **/ 1826 static inline int i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi *vsi) 1827 { 1828 struct i40e_mac_filter *f; 1829 int num_vlans = 0, bkt; 1830 1831 hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) { 1832 if (f->vlan >= 0 && f->vlan <= I40E_MAX_VLANID) 1833 num_vlans++; 1834 } 1835 1836 return num_vlans; 1837 } 1838 1839 /** 1840 * i40e_vc_config_promiscuous_mode_msg 1841 * @vf: pointer to the VF info 1842 * @msg: pointer to the msg buffer 1843 * @msglen: msg length 1844 * 1845 * called from the VF to configure the promiscuous mode of 1846 * VF vsis 1847 **/ 1848 static int i40e_vc_config_promiscuous_mode_msg(struct i40e_vf *vf, 1849 u8 *msg, u16 msglen) 1850 { 1851 struct virtchnl_promisc_info *info = 1852 (struct virtchnl_promisc_info *)msg; 1853 struct i40e_pf *pf = vf->pf; 1854 struct i40e_hw *hw = &pf->hw; 1855 struct i40e_mac_filter *f; 1856 i40e_status aq_ret = 0; 1857 bool allmulti = false; 1858 struct i40e_vsi *vsi; 1859 bool alluni = false; 1860 int aq_err = 0; 1861 int bkt; 1862 1863 vsi = i40e_find_vsi_from_id(pf, info->vsi_id); 1864 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 1865 !i40e_vc_isvalid_vsi_id(vf, info->vsi_id) || 1866 !vsi) { 1867 aq_ret = I40E_ERR_PARAM; 1868 goto error_param; 1869 } 1870 if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) { 1871 dev_err(&pf->pdev->dev, 1872 "Unprivileged VF %d is attempting to configure promiscuous mode\n", 1873 vf->vf_id); 1874 /* Lie to the VF on purpose. */ 1875 aq_ret = 0; 1876 goto error_param; 1877 } 1878 /* Multicast promiscuous handling*/ 1879 if (info->flags & FLAG_VF_MULTICAST_PROMISC) 1880 allmulti = true; 1881 1882 if (vf->port_vlan_id) { 1883 aq_ret = i40e_aq_set_vsi_mc_promisc_on_vlan(hw, vsi->seid, 1884 allmulti, 1885 vf->port_vlan_id, 1886 NULL); 1887 } else if (i40e_getnum_vf_vsi_vlan_filters(vsi)) { 1888 hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) { 1889 if (f->vlan < 0 || f->vlan > I40E_MAX_VLANID) 1890 continue; 1891 aq_ret = i40e_aq_set_vsi_mc_promisc_on_vlan(hw, 1892 vsi->seid, 1893 allmulti, 1894 f->vlan, 1895 NULL); 1896 aq_err = pf->hw.aq.asq_last_status; 1897 if (aq_ret) { 1898 dev_err(&pf->pdev->dev, 1899 "Could not add VLAN %d to multicast promiscuous domain err %s aq_err %s\n", 1900 f->vlan, 1901 i40e_stat_str(&pf->hw, aq_ret), 1902 i40e_aq_str(&pf->hw, aq_err)); 1903 break; 1904 } 1905 } 1906 } else { 1907 aq_ret = i40e_aq_set_vsi_multicast_promiscuous(hw, vsi->seid, 1908 allmulti, NULL); 1909 aq_err = pf->hw.aq.asq_last_status; 1910 if (aq_ret) { 1911 dev_err(&pf->pdev->dev, 1912 "VF %d failed to set multicast promiscuous mode err %s aq_err %s\n", 1913 vf->vf_id, 1914 i40e_stat_str(&pf->hw, aq_ret), 1915 i40e_aq_str(&pf->hw, aq_err)); 1916 goto error_param; 1917 } 1918 } 1919 1920 if (!aq_ret) { 1921 dev_info(&pf->pdev->dev, 1922 "VF %d successfully set multicast promiscuous mode\n", 1923 vf->vf_id); 1924 if (allmulti) 1925 set_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states); 1926 else 1927 clear_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states); 1928 } 1929 1930 if (info->flags & FLAG_VF_UNICAST_PROMISC) 1931 alluni = true; 1932 if (vf->port_vlan_id) { 1933 aq_ret = i40e_aq_set_vsi_uc_promisc_on_vlan(hw, vsi->seid, 1934 alluni, 1935 vf->port_vlan_id, 1936 NULL); 1937 } else if (i40e_getnum_vf_vsi_vlan_filters(vsi)) { 1938 hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) { 1939 if (f->vlan < 0 || f->vlan > I40E_MAX_VLANID) 1940 continue; 1941 aq_ret = i40e_aq_set_vsi_uc_promisc_on_vlan(hw, 1942 vsi->seid, 1943 alluni, 1944 f->vlan, 1945 NULL); 1946 aq_err = pf->hw.aq.asq_last_status; 1947 if (aq_ret) 1948 dev_err(&pf->pdev->dev, 1949 "Could not add VLAN %d to Unicast promiscuous domain err %s aq_err %s\n", 1950 f->vlan, 1951 i40e_stat_str(&pf->hw, aq_ret), 1952 i40e_aq_str(&pf->hw, aq_err)); 1953 } 1954 } else { 1955 aq_ret = i40e_aq_set_vsi_unicast_promiscuous(hw, vsi->seid, 1956 alluni, NULL, 1957 true); 1958 aq_err = pf->hw.aq.asq_last_status; 1959 if (aq_ret) { 1960 dev_err(&pf->pdev->dev, 1961 "VF %d failed to set unicast promiscuous mode %8.8x err %s aq_err %s\n", 1962 vf->vf_id, info->flags, 1963 i40e_stat_str(&pf->hw, aq_ret), 1964 i40e_aq_str(&pf->hw, aq_err)); 1965 goto error_param; 1966 } 1967 } 1968 1969 if (!aq_ret) { 1970 dev_info(&pf->pdev->dev, 1971 "VF %d successfully set unicast promiscuous mode\n", 1972 vf->vf_id); 1973 if (alluni) 1974 set_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states); 1975 else 1976 clear_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states); 1977 } 1978 1979 error_param: 1980 /* send the response to the VF */ 1981 return i40e_vc_send_resp_to_vf(vf, 1982 VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE, 1983 aq_ret); 1984 } 1985 1986 /** 1987 * i40e_vc_config_queues_msg 1988 * @vf: pointer to the VF info 1989 * @msg: pointer to the msg buffer 1990 * @msglen: msg length 1991 * 1992 * called from the VF to configure the rx/tx 1993 * queues 1994 **/ 1995 static int i40e_vc_config_queues_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 1996 { 1997 struct virtchnl_vsi_queue_config_info *qci = 1998 (struct virtchnl_vsi_queue_config_info *)msg; 1999 struct virtchnl_queue_pair_info *qpi; 2000 struct i40e_pf *pf = vf->pf; 2001 u16 vsi_id, vsi_queue_id = 0; 2002 i40e_status aq_ret = 0; 2003 int i, j = 0, idx = 0; 2004 2005 vsi_id = qci->vsi_id; 2006 2007 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2008 aq_ret = I40E_ERR_PARAM; 2009 goto error_param; 2010 } 2011 2012 if (!i40e_vc_isvalid_vsi_id(vf, vsi_id)) { 2013 aq_ret = I40E_ERR_PARAM; 2014 goto error_param; 2015 } 2016 2017 for (i = 0; i < qci->num_queue_pairs; i++) { 2018 qpi = &qci->qpair[i]; 2019 2020 if (!vf->adq_enabled) { 2021 vsi_queue_id = qpi->txq.queue_id; 2022 2023 if (qpi->txq.vsi_id != qci->vsi_id || 2024 qpi->rxq.vsi_id != qci->vsi_id || 2025 qpi->rxq.queue_id != vsi_queue_id) { 2026 aq_ret = I40E_ERR_PARAM; 2027 goto error_param; 2028 } 2029 } 2030 2031 if (!i40e_vc_isvalid_queue_id(vf, vsi_id, vsi_queue_id)) { 2032 aq_ret = I40E_ERR_PARAM; 2033 goto error_param; 2034 } 2035 2036 if (i40e_config_vsi_rx_queue(vf, vsi_id, vsi_queue_id, 2037 &qpi->rxq) || 2038 i40e_config_vsi_tx_queue(vf, vsi_id, vsi_queue_id, 2039 &qpi->txq)) { 2040 aq_ret = I40E_ERR_PARAM; 2041 goto error_param; 2042 } 2043 2044 /* For ADq there can be up to 4 VSIs with max 4 queues each. 2045 * VF does not know about these additional VSIs and all 2046 * it cares is about its own queues. PF configures these queues 2047 * to its appropriate VSIs based on TC mapping 2048 **/ 2049 if (vf->adq_enabled) { 2050 if (j == (vf->ch[idx].num_qps - 1)) { 2051 idx++; 2052 j = 0; /* resetting the queue count */ 2053 vsi_queue_id = 0; 2054 } else { 2055 j++; 2056 vsi_queue_id++; 2057 } 2058 vsi_id = vf->ch[idx].vsi_id; 2059 } 2060 } 2061 /* set vsi num_queue_pairs in use to num configured by VF */ 2062 if (!vf->adq_enabled) { 2063 pf->vsi[vf->lan_vsi_idx]->num_queue_pairs = 2064 qci->num_queue_pairs; 2065 } else { 2066 for (i = 0; i < vf->num_tc; i++) 2067 pf->vsi[vf->ch[i].vsi_idx]->num_queue_pairs = 2068 vf->ch[i].num_qps; 2069 } 2070 2071 error_param: 2072 /* send the response to the VF */ 2073 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_VSI_QUEUES, 2074 aq_ret); 2075 } 2076 2077 /** 2078 * i40e_validate_queue_map 2079 * @vsi_id: vsi id 2080 * @queuemap: Tx or Rx queue map 2081 * 2082 * check if Tx or Rx queue map is valid 2083 **/ 2084 static int i40e_validate_queue_map(struct i40e_vf *vf, u16 vsi_id, 2085 unsigned long queuemap) 2086 { 2087 u16 vsi_queue_id, queue_id; 2088 2089 for_each_set_bit(vsi_queue_id, &queuemap, I40E_MAX_VSI_QP) { 2090 if (vf->adq_enabled) { 2091 vsi_id = vf->ch[vsi_queue_id / I40E_MAX_VF_VSI].vsi_id; 2092 queue_id = (vsi_queue_id % I40E_DEFAULT_QUEUES_PER_VF); 2093 } else { 2094 queue_id = vsi_queue_id; 2095 } 2096 2097 if (!i40e_vc_isvalid_queue_id(vf, vsi_id, queue_id)) 2098 return -EINVAL; 2099 } 2100 2101 return 0; 2102 } 2103 2104 /** 2105 * i40e_vc_config_irq_map_msg 2106 * @vf: pointer to the VF info 2107 * @msg: pointer to the msg buffer 2108 * @msglen: msg length 2109 * 2110 * called from the VF to configure the irq to 2111 * queue map 2112 **/ 2113 static int i40e_vc_config_irq_map_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2114 { 2115 struct virtchnl_irq_map_info *irqmap_info = 2116 (struct virtchnl_irq_map_info *)msg; 2117 struct virtchnl_vector_map *map; 2118 u16 vsi_id, vector_id; 2119 i40e_status aq_ret = 0; 2120 int i; 2121 2122 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2123 aq_ret = I40E_ERR_PARAM; 2124 goto error_param; 2125 } 2126 2127 for (i = 0; i < irqmap_info->num_vectors; i++) { 2128 map = &irqmap_info->vecmap[i]; 2129 vector_id = map->vector_id; 2130 vsi_id = map->vsi_id; 2131 /* validate msg params */ 2132 if (!i40e_vc_isvalid_vector_id(vf, vector_id) || 2133 !i40e_vc_isvalid_vsi_id(vf, vsi_id)) { 2134 aq_ret = I40E_ERR_PARAM; 2135 goto error_param; 2136 } 2137 2138 if (i40e_validate_queue_map(vf, vsi_id, map->rxq_map)) { 2139 aq_ret = I40E_ERR_PARAM; 2140 goto error_param; 2141 } 2142 2143 if (i40e_validate_queue_map(vf, vsi_id, map->txq_map)) { 2144 aq_ret = I40E_ERR_PARAM; 2145 goto error_param; 2146 } 2147 2148 i40e_config_irq_link_list(vf, vsi_id, map); 2149 } 2150 error_param: 2151 /* send the response to the VF */ 2152 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_IRQ_MAP, 2153 aq_ret); 2154 } 2155 2156 /** 2157 * i40e_ctrl_vf_tx_rings 2158 * @vsi: the SRIOV VSI being configured 2159 * @q_map: bit map of the queues to be enabled 2160 * @enable: start or stop the queue 2161 **/ 2162 static int i40e_ctrl_vf_tx_rings(struct i40e_vsi *vsi, unsigned long q_map, 2163 bool enable) 2164 { 2165 struct i40e_pf *pf = vsi->back; 2166 int ret = 0; 2167 u16 q_id; 2168 2169 for_each_set_bit(q_id, &q_map, I40E_MAX_VF_QUEUES) { 2170 ret = i40e_control_wait_tx_q(vsi->seid, pf, 2171 vsi->base_queue + q_id, 2172 false /*is xdp*/, enable); 2173 if (ret) 2174 break; 2175 } 2176 return ret; 2177 } 2178 2179 /** 2180 * i40e_ctrl_vf_rx_rings 2181 * @vsi: the SRIOV VSI being configured 2182 * @q_map: bit map of the queues to be enabled 2183 * @enable: start or stop the queue 2184 **/ 2185 static int i40e_ctrl_vf_rx_rings(struct i40e_vsi *vsi, unsigned long q_map, 2186 bool enable) 2187 { 2188 struct i40e_pf *pf = vsi->back; 2189 int ret = 0; 2190 u16 q_id; 2191 2192 for_each_set_bit(q_id, &q_map, I40E_MAX_VF_QUEUES) { 2193 ret = i40e_control_wait_rx_q(pf, vsi->base_queue + q_id, 2194 enable); 2195 if (ret) 2196 break; 2197 } 2198 return ret; 2199 } 2200 2201 /** 2202 * i40e_vc_enable_queues_msg 2203 * @vf: pointer to the VF info 2204 * @msg: pointer to the msg buffer 2205 * @msglen: msg length 2206 * 2207 * called from the VF to enable all or specific queue(s) 2208 **/ 2209 static int i40e_vc_enable_queues_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2210 { 2211 struct virtchnl_queue_select *vqs = 2212 (struct virtchnl_queue_select *)msg; 2213 struct i40e_pf *pf = vf->pf; 2214 u16 vsi_id = vqs->vsi_id; 2215 i40e_status aq_ret = 0; 2216 int i; 2217 2218 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2219 aq_ret = I40E_ERR_PARAM; 2220 goto error_param; 2221 } 2222 2223 if (!i40e_vc_isvalid_vsi_id(vf, vsi_id)) { 2224 aq_ret = I40E_ERR_PARAM; 2225 goto error_param; 2226 } 2227 2228 if ((0 == vqs->rx_queues) && (0 == vqs->tx_queues)) { 2229 aq_ret = I40E_ERR_PARAM; 2230 goto error_param; 2231 } 2232 2233 /* Use the queue bit map sent by the VF */ 2234 if (i40e_ctrl_vf_rx_rings(pf->vsi[vf->lan_vsi_idx], vqs->rx_queues, 2235 true)) { 2236 aq_ret = I40E_ERR_TIMEOUT; 2237 goto error_param; 2238 } 2239 if (i40e_ctrl_vf_tx_rings(pf->vsi[vf->lan_vsi_idx], vqs->tx_queues, 2240 true)) { 2241 aq_ret = I40E_ERR_TIMEOUT; 2242 goto error_param; 2243 } 2244 2245 /* need to start the rings for additional ADq VSI's as well */ 2246 if (vf->adq_enabled) { 2247 /* zero belongs to LAN VSI */ 2248 for (i = 1; i < vf->num_tc; i++) { 2249 if (i40e_vsi_start_rings(pf->vsi[vf->ch[i].vsi_idx])) 2250 aq_ret = I40E_ERR_TIMEOUT; 2251 } 2252 } 2253 2254 error_param: 2255 /* send the response to the VF */ 2256 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_QUEUES, 2257 aq_ret); 2258 } 2259 2260 /** 2261 * i40e_vc_disable_queues_msg 2262 * @vf: pointer to the VF info 2263 * @msg: pointer to the msg buffer 2264 * @msglen: msg length 2265 * 2266 * called from the VF to disable all or specific 2267 * queue(s) 2268 **/ 2269 static int i40e_vc_disable_queues_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2270 { 2271 struct virtchnl_queue_select *vqs = 2272 (struct virtchnl_queue_select *)msg; 2273 struct i40e_pf *pf = vf->pf; 2274 i40e_status aq_ret = 0; 2275 2276 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2277 aq_ret = I40E_ERR_PARAM; 2278 goto error_param; 2279 } 2280 2281 if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) { 2282 aq_ret = I40E_ERR_PARAM; 2283 goto error_param; 2284 } 2285 2286 if ((0 == vqs->rx_queues) && (0 == vqs->tx_queues)) { 2287 aq_ret = I40E_ERR_PARAM; 2288 goto error_param; 2289 } 2290 2291 /* Use the queue bit map sent by the VF */ 2292 if (i40e_ctrl_vf_tx_rings(pf->vsi[vf->lan_vsi_idx], vqs->tx_queues, 2293 false)) { 2294 aq_ret = I40E_ERR_TIMEOUT; 2295 goto error_param; 2296 } 2297 if (i40e_ctrl_vf_rx_rings(pf->vsi[vf->lan_vsi_idx], vqs->rx_queues, 2298 false)) { 2299 aq_ret = I40E_ERR_TIMEOUT; 2300 goto error_param; 2301 } 2302 error_param: 2303 /* send the response to the VF */ 2304 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_QUEUES, 2305 aq_ret); 2306 } 2307 2308 /** 2309 * i40e_vc_request_queues_msg 2310 * @vf: pointer to the VF info 2311 * @msg: pointer to the msg buffer 2312 * @msglen: msg length 2313 * 2314 * VFs get a default number of queues but can use this message to request a 2315 * different number. If the request is successful, PF will reset the VF and 2316 * return 0. If unsuccessful, PF will send message informing VF of number of 2317 * available queues and return result of sending VF a message. 2318 **/ 2319 static int i40e_vc_request_queues_msg(struct i40e_vf *vf, u8 *msg, int msglen) 2320 { 2321 struct virtchnl_vf_res_request *vfres = 2322 (struct virtchnl_vf_res_request *)msg; 2323 int req_pairs = vfres->num_queue_pairs; 2324 int cur_pairs = vf->num_queue_pairs; 2325 struct i40e_pf *pf = vf->pf; 2326 2327 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) 2328 return -EINVAL; 2329 2330 if (req_pairs <= 0) { 2331 dev_err(&pf->pdev->dev, 2332 "VF %d tried to request %d queues. Ignoring.\n", 2333 vf->vf_id, req_pairs); 2334 } else if (req_pairs > I40E_MAX_VF_QUEUES) { 2335 dev_err(&pf->pdev->dev, 2336 "VF %d tried to request more than %d queues.\n", 2337 vf->vf_id, 2338 I40E_MAX_VF_QUEUES); 2339 vfres->num_queue_pairs = I40E_MAX_VF_QUEUES; 2340 } else if (req_pairs - cur_pairs > pf->queues_left) { 2341 dev_warn(&pf->pdev->dev, 2342 "VF %d requested %d more queues, but only %d left.\n", 2343 vf->vf_id, 2344 req_pairs - cur_pairs, 2345 pf->queues_left); 2346 vfres->num_queue_pairs = pf->queues_left + cur_pairs; 2347 } else { 2348 /* successful request */ 2349 vf->num_req_queues = req_pairs; 2350 i40e_vc_notify_vf_reset(vf); 2351 i40e_reset_vf(vf, false); 2352 return 0; 2353 } 2354 2355 return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_REQUEST_QUEUES, 0, 2356 (u8 *)vfres, sizeof(*vfres)); 2357 } 2358 2359 /** 2360 * i40e_vc_get_stats_msg 2361 * @vf: pointer to the VF info 2362 * @msg: pointer to the msg buffer 2363 * @msglen: msg length 2364 * 2365 * called from the VF to get vsi stats 2366 **/ 2367 static int i40e_vc_get_stats_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2368 { 2369 struct virtchnl_queue_select *vqs = 2370 (struct virtchnl_queue_select *)msg; 2371 struct i40e_pf *pf = vf->pf; 2372 struct i40e_eth_stats stats; 2373 i40e_status aq_ret = 0; 2374 struct i40e_vsi *vsi; 2375 2376 memset(&stats, 0, sizeof(struct i40e_eth_stats)); 2377 2378 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2379 aq_ret = I40E_ERR_PARAM; 2380 goto error_param; 2381 } 2382 2383 if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) { 2384 aq_ret = I40E_ERR_PARAM; 2385 goto error_param; 2386 } 2387 2388 vsi = pf->vsi[vf->lan_vsi_idx]; 2389 if (!vsi) { 2390 aq_ret = I40E_ERR_PARAM; 2391 goto error_param; 2392 } 2393 i40e_update_eth_stats(vsi); 2394 stats = vsi->eth_stats; 2395 2396 error_param: 2397 /* send the response back to the VF */ 2398 return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_STATS, aq_ret, 2399 (u8 *)&stats, sizeof(stats)); 2400 } 2401 2402 /* If the VF is not trusted restrict the number of MAC/VLAN it can program */ 2403 #define I40E_VC_MAX_MAC_ADDR_PER_VF 12 2404 #define I40E_VC_MAX_VLAN_PER_VF 8 2405 2406 /** 2407 * i40e_check_vf_permission 2408 * @vf: pointer to the VF info 2409 * @al: MAC address list from virtchnl 2410 * 2411 * Check that the given list of MAC addresses is allowed. Will return -EPERM 2412 * if any address in the list is not valid. Checks the following conditions: 2413 * 2414 * 1) broadcast and zero addresses are never valid 2415 * 2) unicast addresses are not allowed if the VMM has administratively set 2416 * the VF MAC address, unless the VF is marked as privileged. 2417 * 3) There is enough space to add all the addresses. 2418 * 2419 * Note that to guarantee consistency, it is expected this function be called 2420 * while holding the mac_filter_hash_lock, as otherwise the current number of 2421 * addresses might not be accurate. 2422 **/ 2423 static inline int i40e_check_vf_permission(struct i40e_vf *vf, 2424 struct virtchnl_ether_addr_list *al) 2425 { 2426 struct i40e_pf *pf = vf->pf; 2427 int i; 2428 2429 /* If this VF is not privileged, then we can't add more than a limited 2430 * number of addresses. Check to make sure that the additions do not 2431 * push us over the limit. 2432 */ 2433 if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) && 2434 (vf->num_mac + al->num_elements) > I40E_VC_MAX_MAC_ADDR_PER_VF) { 2435 dev_err(&pf->pdev->dev, 2436 "Cannot add more MAC addresses, VF is not trusted, switch the VF to trusted to add more functionality\n"); 2437 return -EPERM; 2438 } 2439 2440 for (i = 0; i < al->num_elements; i++) { 2441 u8 *addr = al->list[i].addr; 2442 2443 if (is_broadcast_ether_addr(addr) || 2444 is_zero_ether_addr(addr)) { 2445 dev_err(&pf->pdev->dev, "invalid VF MAC addr %pM\n", 2446 addr); 2447 return I40E_ERR_INVALID_MAC_ADDR; 2448 } 2449 2450 /* If the host VMM administrator has set the VF MAC address 2451 * administratively via the ndo_set_vf_mac command then deny 2452 * permission to the VF to add or delete unicast MAC addresses. 2453 * Unless the VF is privileged and then it can do whatever. 2454 * The VF may request to set the MAC address filter already 2455 * assigned to it so do not return an error in that case. 2456 */ 2457 if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) && 2458 !is_multicast_ether_addr(addr) && vf->pf_set_mac && 2459 !ether_addr_equal(addr, vf->default_lan_addr.addr)) { 2460 dev_err(&pf->pdev->dev, 2461 "VF attempting to override administratively set MAC address, reload the VF driver to resume normal operation\n"); 2462 return -EPERM; 2463 } 2464 } 2465 2466 return 0; 2467 } 2468 2469 /** 2470 * i40e_vc_add_mac_addr_msg 2471 * @vf: pointer to the VF info 2472 * @msg: pointer to the msg buffer 2473 * @msglen: msg length 2474 * 2475 * add guest mac address filter 2476 **/ 2477 static int i40e_vc_add_mac_addr_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2478 { 2479 struct virtchnl_ether_addr_list *al = 2480 (struct virtchnl_ether_addr_list *)msg; 2481 struct i40e_pf *pf = vf->pf; 2482 struct i40e_vsi *vsi = NULL; 2483 u16 vsi_id = al->vsi_id; 2484 i40e_status ret = 0; 2485 int i; 2486 2487 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2488 !i40e_vc_isvalid_vsi_id(vf, vsi_id)) { 2489 ret = I40E_ERR_PARAM; 2490 goto error_param; 2491 } 2492 2493 vsi = pf->vsi[vf->lan_vsi_idx]; 2494 2495 /* Lock once, because all function inside for loop accesses VSI's 2496 * MAC filter list which needs to be protected using same lock. 2497 */ 2498 spin_lock_bh(&vsi->mac_filter_hash_lock); 2499 2500 ret = i40e_check_vf_permission(vf, al); 2501 if (ret) { 2502 spin_unlock_bh(&vsi->mac_filter_hash_lock); 2503 goto error_param; 2504 } 2505 2506 /* add new addresses to the list */ 2507 for (i = 0; i < al->num_elements; i++) { 2508 struct i40e_mac_filter *f; 2509 2510 f = i40e_find_mac(vsi, al->list[i].addr); 2511 if (!f) { 2512 f = i40e_add_mac_filter(vsi, al->list[i].addr); 2513 2514 if (!f) { 2515 dev_err(&pf->pdev->dev, 2516 "Unable to add MAC filter %pM for VF %d\n", 2517 al->list[i].addr, vf->vf_id); 2518 ret = I40E_ERR_PARAM; 2519 spin_unlock_bh(&vsi->mac_filter_hash_lock); 2520 goto error_param; 2521 } else { 2522 vf->num_mac++; 2523 } 2524 } 2525 } 2526 spin_unlock_bh(&vsi->mac_filter_hash_lock); 2527 2528 /* program the updated filter list */ 2529 ret = i40e_sync_vsi_filters(vsi); 2530 if (ret) 2531 dev_err(&pf->pdev->dev, "Unable to program VF %d MAC filters, error %d\n", 2532 vf->vf_id, ret); 2533 2534 error_param: 2535 /* send the response to the VF */ 2536 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_ETH_ADDR, 2537 ret); 2538 } 2539 2540 /** 2541 * i40e_vc_del_mac_addr_msg 2542 * @vf: pointer to the VF info 2543 * @msg: pointer to the msg buffer 2544 * @msglen: msg length 2545 * 2546 * remove guest mac address filter 2547 **/ 2548 static int i40e_vc_del_mac_addr_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2549 { 2550 struct virtchnl_ether_addr_list *al = 2551 (struct virtchnl_ether_addr_list *)msg; 2552 struct i40e_pf *pf = vf->pf; 2553 struct i40e_vsi *vsi = NULL; 2554 u16 vsi_id = al->vsi_id; 2555 i40e_status ret = 0; 2556 int i; 2557 2558 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2559 !i40e_vc_isvalid_vsi_id(vf, vsi_id)) { 2560 ret = I40E_ERR_PARAM; 2561 goto error_param; 2562 } 2563 2564 for (i = 0; i < al->num_elements; i++) { 2565 if (is_broadcast_ether_addr(al->list[i].addr) || 2566 is_zero_ether_addr(al->list[i].addr)) { 2567 dev_err(&pf->pdev->dev, "Invalid MAC addr %pM for VF %d\n", 2568 al->list[i].addr, vf->vf_id); 2569 ret = I40E_ERR_INVALID_MAC_ADDR; 2570 goto error_param; 2571 } 2572 } 2573 vsi = pf->vsi[vf->lan_vsi_idx]; 2574 2575 spin_lock_bh(&vsi->mac_filter_hash_lock); 2576 /* delete addresses from the list */ 2577 for (i = 0; i < al->num_elements; i++) 2578 if (i40e_del_mac_filter(vsi, al->list[i].addr)) { 2579 ret = I40E_ERR_INVALID_MAC_ADDR; 2580 spin_unlock_bh(&vsi->mac_filter_hash_lock); 2581 goto error_param; 2582 } else { 2583 vf->num_mac--; 2584 } 2585 2586 spin_unlock_bh(&vsi->mac_filter_hash_lock); 2587 2588 /* program the updated filter list */ 2589 ret = i40e_sync_vsi_filters(vsi); 2590 if (ret) 2591 dev_err(&pf->pdev->dev, "Unable to program VF %d MAC filters, error %d\n", 2592 vf->vf_id, ret); 2593 2594 error_param: 2595 /* send the response to the VF */ 2596 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_ETH_ADDR, 2597 ret); 2598 } 2599 2600 /** 2601 * i40e_vc_add_vlan_msg 2602 * @vf: pointer to the VF info 2603 * @msg: pointer to the msg buffer 2604 * @msglen: msg length 2605 * 2606 * program guest vlan id 2607 **/ 2608 static int i40e_vc_add_vlan_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2609 { 2610 struct virtchnl_vlan_filter_list *vfl = 2611 (struct virtchnl_vlan_filter_list *)msg; 2612 struct i40e_pf *pf = vf->pf; 2613 struct i40e_vsi *vsi = NULL; 2614 u16 vsi_id = vfl->vsi_id; 2615 i40e_status aq_ret = 0; 2616 int i; 2617 2618 if ((vf->num_vlan >= I40E_VC_MAX_VLAN_PER_VF) && 2619 !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) { 2620 dev_err(&pf->pdev->dev, 2621 "VF is not trusted, switch the VF to trusted to add more VLAN addresses\n"); 2622 goto error_param; 2623 } 2624 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2625 !i40e_vc_isvalid_vsi_id(vf, vsi_id)) { 2626 aq_ret = I40E_ERR_PARAM; 2627 goto error_param; 2628 } 2629 2630 for (i = 0; i < vfl->num_elements; i++) { 2631 if (vfl->vlan_id[i] > I40E_MAX_VLANID) { 2632 aq_ret = I40E_ERR_PARAM; 2633 dev_err(&pf->pdev->dev, 2634 "invalid VF VLAN id %d\n", vfl->vlan_id[i]); 2635 goto error_param; 2636 } 2637 } 2638 vsi = pf->vsi[vf->lan_vsi_idx]; 2639 if (vsi->info.pvid) { 2640 aq_ret = I40E_ERR_PARAM; 2641 goto error_param; 2642 } 2643 2644 i40e_vlan_stripping_enable(vsi); 2645 for (i = 0; i < vfl->num_elements; i++) { 2646 /* add new VLAN filter */ 2647 int ret = i40e_vsi_add_vlan(vsi, vfl->vlan_id[i]); 2648 if (!ret) 2649 vf->num_vlan++; 2650 2651 if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states)) 2652 i40e_aq_set_vsi_uc_promisc_on_vlan(&pf->hw, vsi->seid, 2653 true, 2654 vfl->vlan_id[i], 2655 NULL); 2656 if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states)) 2657 i40e_aq_set_vsi_mc_promisc_on_vlan(&pf->hw, vsi->seid, 2658 true, 2659 vfl->vlan_id[i], 2660 NULL); 2661 2662 if (ret) 2663 dev_err(&pf->pdev->dev, 2664 "Unable to add VLAN filter %d for VF %d, error %d\n", 2665 vfl->vlan_id[i], vf->vf_id, ret); 2666 } 2667 2668 error_param: 2669 /* send the response to the VF */ 2670 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_VLAN, aq_ret); 2671 } 2672 2673 /** 2674 * i40e_vc_remove_vlan_msg 2675 * @vf: pointer to the VF info 2676 * @msg: pointer to the msg buffer 2677 * @msglen: msg length 2678 * 2679 * remove programmed guest vlan id 2680 **/ 2681 static int i40e_vc_remove_vlan_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2682 { 2683 struct virtchnl_vlan_filter_list *vfl = 2684 (struct virtchnl_vlan_filter_list *)msg; 2685 struct i40e_pf *pf = vf->pf; 2686 struct i40e_vsi *vsi = NULL; 2687 u16 vsi_id = vfl->vsi_id; 2688 i40e_status aq_ret = 0; 2689 int i; 2690 2691 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2692 !i40e_vc_isvalid_vsi_id(vf, vsi_id)) { 2693 aq_ret = I40E_ERR_PARAM; 2694 goto error_param; 2695 } 2696 2697 for (i = 0; i < vfl->num_elements; i++) { 2698 if (vfl->vlan_id[i] > I40E_MAX_VLANID) { 2699 aq_ret = I40E_ERR_PARAM; 2700 goto error_param; 2701 } 2702 } 2703 2704 vsi = pf->vsi[vf->lan_vsi_idx]; 2705 if (vsi->info.pvid) { 2706 aq_ret = I40E_ERR_PARAM; 2707 goto error_param; 2708 } 2709 2710 for (i = 0; i < vfl->num_elements; i++) { 2711 i40e_vsi_kill_vlan(vsi, vfl->vlan_id[i]); 2712 vf->num_vlan--; 2713 2714 if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states)) 2715 i40e_aq_set_vsi_uc_promisc_on_vlan(&pf->hw, vsi->seid, 2716 false, 2717 vfl->vlan_id[i], 2718 NULL); 2719 if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states)) 2720 i40e_aq_set_vsi_mc_promisc_on_vlan(&pf->hw, vsi->seid, 2721 false, 2722 vfl->vlan_id[i], 2723 NULL); 2724 } 2725 2726 error_param: 2727 /* send the response to the VF */ 2728 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_VLAN, aq_ret); 2729 } 2730 2731 /** 2732 * i40e_vc_iwarp_msg 2733 * @vf: pointer to the VF info 2734 * @msg: pointer to the msg buffer 2735 * @msglen: msg length 2736 * 2737 * called from the VF for the iwarp msgs 2738 **/ 2739 static int i40e_vc_iwarp_msg(struct i40e_vf *vf, u8 *msg, u16 msglen) 2740 { 2741 struct i40e_pf *pf = vf->pf; 2742 int abs_vf_id = vf->vf_id + pf->hw.func_caps.vf_base_id; 2743 i40e_status aq_ret = 0; 2744 2745 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2746 !test_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states)) { 2747 aq_ret = I40E_ERR_PARAM; 2748 goto error_param; 2749 } 2750 2751 i40e_notify_client_of_vf_msg(pf->vsi[pf->lan_vsi], abs_vf_id, 2752 msg, msglen); 2753 2754 error_param: 2755 /* send the response to the VF */ 2756 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_IWARP, 2757 aq_ret); 2758 } 2759 2760 /** 2761 * i40e_vc_iwarp_qvmap_msg 2762 * @vf: pointer to the VF info 2763 * @msg: pointer to the msg buffer 2764 * @msglen: msg length 2765 * @config: config qvmap or release it 2766 * 2767 * called from the VF for the iwarp msgs 2768 **/ 2769 static int i40e_vc_iwarp_qvmap_msg(struct i40e_vf *vf, u8 *msg, u16 msglen, 2770 bool config) 2771 { 2772 struct virtchnl_iwarp_qvlist_info *qvlist_info = 2773 (struct virtchnl_iwarp_qvlist_info *)msg; 2774 i40e_status aq_ret = 0; 2775 2776 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2777 !test_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states)) { 2778 aq_ret = I40E_ERR_PARAM; 2779 goto error_param; 2780 } 2781 2782 if (config) { 2783 if (i40e_config_iwarp_qvlist(vf, qvlist_info)) 2784 aq_ret = I40E_ERR_PARAM; 2785 } else { 2786 i40e_release_iwarp_qvlist(vf); 2787 } 2788 2789 error_param: 2790 /* send the response to the VF */ 2791 return i40e_vc_send_resp_to_vf(vf, 2792 config ? VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP : 2793 VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP, 2794 aq_ret); 2795 } 2796 2797 /** 2798 * i40e_vc_config_rss_key 2799 * @vf: pointer to the VF info 2800 * @msg: pointer to the msg buffer 2801 * @msglen: msg length 2802 * 2803 * Configure the VF's RSS key 2804 **/ 2805 static int i40e_vc_config_rss_key(struct i40e_vf *vf, u8 *msg, u16 msglen) 2806 { 2807 struct virtchnl_rss_key *vrk = 2808 (struct virtchnl_rss_key *)msg; 2809 struct i40e_pf *pf = vf->pf; 2810 struct i40e_vsi *vsi = NULL; 2811 u16 vsi_id = vrk->vsi_id; 2812 i40e_status aq_ret = 0; 2813 2814 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2815 !i40e_vc_isvalid_vsi_id(vf, vsi_id) || 2816 (vrk->key_len != I40E_HKEY_ARRAY_SIZE)) { 2817 aq_ret = I40E_ERR_PARAM; 2818 goto err; 2819 } 2820 2821 vsi = pf->vsi[vf->lan_vsi_idx]; 2822 aq_ret = i40e_config_rss(vsi, vrk->key, NULL, 0); 2823 err: 2824 /* send the response to the VF */ 2825 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_KEY, 2826 aq_ret); 2827 } 2828 2829 /** 2830 * i40e_vc_config_rss_lut 2831 * @vf: pointer to the VF info 2832 * @msg: pointer to the msg buffer 2833 * @msglen: msg length 2834 * 2835 * Configure the VF's RSS LUT 2836 **/ 2837 static int i40e_vc_config_rss_lut(struct i40e_vf *vf, u8 *msg, u16 msglen) 2838 { 2839 struct virtchnl_rss_lut *vrl = 2840 (struct virtchnl_rss_lut *)msg; 2841 struct i40e_pf *pf = vf->pf; 2842 struct i40e_vsi *vsi = NULL; 2843 u16 vsi_id = vrl->vsi_id; 2844 i40e_status aq_ret = 0; 2845 2846 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) || 2847 !i40e_vc_isvalid_vsi_id(vf, vsi_id) || 2848 (vrl->lut_entries != I40E_VF_HLUT_ARRAY_SIZE)) { 2849 aq_ret = I40E_ERR_PARAM; 2850 goto err; 2851 } 2852 2853 vsi = pf->vsi[vf->lan_vsi_idx]; 2854 aq_ret = i40e_config_rss(vsi, NULL, vrl->lut, I40E_VF_HLUT_ARRAY_SIZE); 2855 /* send the response to the VF */ 2856 err: 2857 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_LUT, 2858 aq_ret); 2859 } 2860 2861 /** 2862 * i40e_vc_get_rss_hena 2863 * @vf: pointer to the VF info 2864 * @msg: pointer to the msg buffer 2865 * @msglen: msg length 2866 * 2867 * Return the RSS HENA bits allowed by the hardware 2868 **/ 2869 static int i40e_vc_get_rss_hena(struct i40e_vf *vf, u8 *msg, u16 msglen) 2870 { 2871 struct virtchnl_rss_hena *vrh = NULL; 2872 struct i40e_pf *pf = vf->pf; 2873 i40e_status aq_ret = 0; 2874 int len = 0; 2875 2876 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2877 aq_ret = I40E_ERR_PARAM; 2878 goto err; 2879 } 2880 len = sizeof(struct virtchnl_rss_hena); 2881 2882 vrh = kzalloc(len, GFP_KERNEL); 2883 if (!vrh) { 2884 aq_ret = I40E_ERR_NO_MEMORY; 2885 len = 0; 2886 goto err; 2887 } 2888 vrh->hena = i40e_pf_get_default_rss_hena(pf); 2889 err: 2890 /* send the response back to the VF */ 2891 aq_ret = i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_RSS_HENA_CAPS, 2892 aq_ret, (u8 *)vrh, len); 2893 kfree(vrh); 2894 return aq_ret; 2895 } 2896 2897 /** 2898 * i40e_vc_set_rss_hena 2899 * @vf: pointer to the VF info 2900 * @msg: pointer to the msg buffer 2901 * @msglen: msg length 2902 * 2903 * Set the RSS HENA bits for the VF 2904 **/ 2905 static int i40e_vc_set_rss_hena(struct i40e_vf *vf, u8 *msg, u16 msglen) 2906 { 2907 struct virtchnl_rss_hena *vrh = 2908 (struct virtchnl_rss_hena *)msg; 2909 struct i40e_pf *pf = vf->pf; 2910 struct i40e_hw *hw = &pf->hw; 2911 i40e_status aq_ret = 0; 2912 2913 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2914 aq_ret = I40E_ERR_PARAM; 2915 goto err; 2916 } 2917 i40e_write_rx_ctl(hw, I40E_VFQF_HENA1(0, vf->vf_id), (u32)vrh->hena); 2918 i40e_write_rx_ctl(hw, I40E_VFQF_HENA1(1, vf->vf_id), 2919 (u32)(vrh->hena >> 32)); 2920 2921 /* send the response to the VF */ 2922 err: 2923 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_SET_RSS_HENA, aq_ret); 2924 } 2925 2926 /** 2927 * i40e_vc_enable_vlan_stripping 2928 * @vf: pointer to the VF info 2929 * @msg: pointer to the msg buffer 2930 * @msglen: msg length 2931 * 2932 * Enable vlan header stripping for the VF 2933 **/ 2934 static int i40e_vc_enable_vlan_stripping(struct i40e_vf *vf, u8 *msg, 2935 u16 msglen) 2936 { 2937 struct i40e_vsi *vsi = vf->pf->vsi[vf->lan_vsi_idx]; 2938 i40e_status aq_ret = 0; 2939 2940 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2941 aq_ret = I40E_ERR_PARAM; 2942 goto err; 2943 } 2944 2945 i40e_vlan_stripping_enable(vsi); 2946 2947 /* send the response to the VF */ 2948 err: 2949 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING, 2950 aq_ret); 2951 } 2952 2953 /** 2954 * i40e_vc_disable_vlan_stripping 2955 * @vf: pointer to the VF info 2956 * @msg: pointer to the msg buffer 2957 * @msglen: msg length 2958 * 2959 * Disable vlan header stripping for the VF 2960 **/ 2961 static int i40e_vc_disable_vlan_stripping(struct i40e_vf *vf, u8 *msg, 2962 u16 msglen) 2963 { 2964 struct i40e_vsi *vsi = vf->pf->vsi[vf->lan_vsi_idx]; 2965 i40e_status aq_ret = 0; 2966 2967 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 2968 aq_ret = I40E_ERR_PARAM; 2969 goto err; 2970 } 2971 2972 i40e_vlan_stripping_disable(vsi); 2973 2974 /* send the response to the VF */ 2975 err: 2976 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING, 2977 aq_ret); 2978 } 2979 2980 /** 2981 * i40e_validate_cloud_filter 2982 * @mask: mask for TC filter 2983 * @data: data for TC filter 2984 * 2985 * This function validates cloud filter programmed as TC filter for ADq 2986 **/ 2987 static int i40e_validate_cloud_filter(struct i40e_vf *vf, 2988 struct virtchnl_filter *tc_filter) 2989 { 2990 struct virtchnl_l4_spec mask = tc_filter->mask.tcp_spec; 2991 struct virtchnl_l4_spec data = tc_filter->data.tcp_spec; 2992 struct i40e_pf *pf = vf->pf; 2993 struct i40e_vsi *vsi = NULL; 2994 struct i40e_mac_filter *f; 2995 struct hlist_node *h; 2996 bool found = false; 2997 int bkt; 2998 2999 if (!tc_filter->action) { 3000 dev_info(&pf->pdev->dev, 3001 "VF %d: Currently ADq doesn't support Drop Action\n", 3002 vf->vf_id); 3003 goto err; 3004 } 3005 3006 /* action_meta is TC number here to which the filter is applied */ 3007 if (!tc_filter->action_meta || 3008 tc_filter->action_meta > I40E_MAX_VF_VSI) { 3009 dev_info(&pf->pdev->dev, "VF %d: Invalid TC number %u\n", 3010 vf->vf_id, tc_filter->action_meta); 3011 goto err; 3012 } 3013 3014 /* Check filter if it's programmed for advanced mode or basic mode. 3015 * There are two ADq modes (for VF only), 3016 * 1. Basic mode: intended to allow as many filter options as possible 3017 * to be added to a VF in Non-trusted mode. Main goal is 3018 * to add filters to its own MAC and VLAN id. 3019 * 2. Advanced mode: is for allowing filters to be applied other than 3020 * its own MAC or VLAN. This mode requires the VF to be 3021 * Trusted. 3022 */ 3023 if (mask.dst_mac[0] && !mask.dst_ip[0]) { 3024 vsi = pf->vsi[vf->lan_vsi_idx]; 3025 f = i40e_find_mac(vsi, data.dst_mac); 3026 3027 if (!f) { 3028 dev_info(&pf->pdev->dev, 3029 "Destination MAC %pM doesn't belong to VF %d\n", 3030 data.dst_mac, vf->vf_id); 3031 goto err; 3032 } 3033 3034 if (mask.vlan_id) { 3035 hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, 3036 hlist) { 3037 if (f->vlan == ntohs(data.vlan_id)) { 3038 found = true; 3039 break; 3040 } 3041 } 3042 if (!found) { 3043 dev_info(&pf->pdev->dev, 3044 "VF %d doesn't have any VLAN id %u\n", 3045 vf->vf_id, ntohs(data.vlan_id)); 3046 goto err; 3047 } 3048 } 3049 } else { 3050 /* Check if VF is trusted */ 3051 if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) { 3052 dev_err(&pf->pdev->dev, 3053 "VF %d not trusted, make VF trusted to add advanced mode ADq cloud filters\n", 3054 vf->vf_id); 3055 return I40E_ERR_CONFIG; 3056 } 3057 } 3058 3059 if (mask.dst_mac[0] & data.dst_mac[0]) { 3060 if (is_broadcast_ether_addr(data.dst_mac) || 3061 is_zero_ether_addr(data.dst_mac)) { 3062 dev_info(&pf->pdev->dev, "VF %d: Invalid Dest MAC addr %pM\n", 3063 vf->vf_id, data.dst_mac); 3064 goto err; 3065 } 3066 } 3067 3068 if (mask.src_mac[0] & data.src_mac[0]) { 3069 if (is_broadcast_ether_addr(data.src_mac) || 3070 is_zero_ether_addr(data.src_mac)) { 3071 dev_info(&pf->pdev->dev, "VF %d: Invalid Source MAC addr %pM\n", 3072 vf->vf_id, data.src_mac); 3073 goto err; 3074 } 3075 } 3076 3077 if (mask.dst_port & data.dst_port) { 3078 if (!data.dst_port || be16_to_cpu(data.dst_port) > 0xFFFF) { 3079 dev_info(&pf->pdev->dev, "VF %d: Invalid Dest port\n", 3080 vf->vf_id); 3081 goto err; 3082 } 3083 } 3084 3085 if (mask.src_port & data.src_port) { 3086 if (!data.src_port || be16_to_cpu(data.src_port) > 0xFFFF) { 3087 dev_info(&pf->pdev->dev, "VF %d: Invalid Source port\n", 3088 vf->vf_id); 3089 goto err; 3090 } 3091 } 3092 3093 if (tc_filter->flow_type != VIRTCHNL_TCP_V6_FLOW && 3094 tc_filter->flow_type != VIRTCHNL_TCP_V4_FLOW) { 3095 dev_info(&pf->pdev->dev, "VF %d: Invalid Flow type\n", 3096 vf->vf_id); 3097 goto err; 3098 } 3099 3100 if (mask.vlan_id & data.vlan_id) { 3101 if (ntohs(data.vlan_id) > I40E_MAX_VLANID) { 3102 dev_info(&pf->pdev->dev, "VF %d: invalid VLAN ID\n", 3103 vf->vf_id); 3104 goto err; 3105 } 3106 } 3107 3108 return I40E_SUCCESS; 3109 err: 3110 return I40E_ERR_CONFIG; 3111 } 3112 3113 /** 3114 * i40e_find_vsi_from_seid - searches for the vsi with the given seid 3115 * @vf: pointer to the VF info 3116 * @seid - seid of the vsi it is searching for 3117 **/ 3118 static struct i40e_vsi *i40e_find_vsi_from_seid(struct i40e_vf *vf, u16 seid) 3119 { 3120 struct i40e_pf *pf = vf->pf; 3121 struct i40e_vsi *vsi = NULL; 3122 int i; 3123 3124 for (i = 0; i < vf->num_tc ; i++) { 3125 vsi = i40e_find_vsi_from_id(pf, vf->ch[i].vsi_id); 3126 if (vsi && vsi->seid == seid) 3127 return vsi; 3128 } 3129 return NULL; 3130 } 3131 3132 /** 3133 * i40e_del_all_cloud_filters 3134 * @vf: pointer to the VF info 3135 * 3136 * This function deletes all cloud filters 3137 **/ 3138 static void i40e_del_all_cloud_filters(struct i40e_vf *vf) 3139 { 3140 struct i40e_cloud_filter *cfilter = NULL; 3141 struct i40e_pf *pf = vf->pf; 3142 struct i40e_vsi *vsi = NULL; 3143 struct hlist_node *node; 3144 int ret; 3145 3146 hlist_for_each_entry_safe(cfilter, node, 3147 &vf->cloud_filter_list, cloud_node) { 3148 vsi = i40e_find_vsi_from_seid(vf, cfilter->seid); 3149 3150 if (!vsi) { 3151 dev_err(&pf->pdev->dev, "VF %d: no VSI found for matching %u seid, can't delete cloud filter\n", 3152 vf->vf_id, cfilter->seid); 3153 continue; 3154 } 3155 3156 if (cfilter->dst_port) 3157 ret = i40e_add_del_cloud_filter_big_buf(vsi, cfilter, 3158 false); 3159 else 3160 ret = i40e_add_del_cloud_filter(vsi, cfilter, false); 3161 if (ret) 3162 dev_err(&pf->pdev->dev, 3163 "VF %d: Failed to delete cloud filter, err %s aq_err %s\n", 3164 vf->vf_id, i40e_stat_str(&pf->hw, ret), 3165 i40e_aq_str(&pf->hw, 3166 pf->hw.aq.asq_last_status)); 3167 3168 hlist_del(&cfilter->cloud_node); 3169 kfree(cfilter); 3170 vf->num_cloud_filters--; 3171 } 3172 } 3173 3174 /** 3175 * i40e_vc_del_cloud_filter 3176 * @vf: pointer to the VF info 3177 * @msg: pointer to the msg buffer 3178 * 3179 * This function deletes a cloud filter programmed as TC filter for ADq 3180 **/ 3181 static int i40e_vc_del_cloud_filter(struct i40e_vf *vf, u8 *msg) 3182 { 3183 struct virtchnl_filter *vcf = (struct virtchnl_filter *)msg; 3184 struct virtchnl_l4_spec mask = vcf->mask.tcp_spec; 3185 struct virtchnl_l4_spec tcf = vcf->data.tcp_spec; 3186 struct i40e_cloud_filter cfilter, *cf = NULL; 3187 struct i40e_pf *pf = vf->pf; 3188 struct i40e_vsi *vsi = NULL; 3189 struct hlist_node *node; 3190 i40e_status aq_ret = 0; 3191 int i, ret; 3192 3193 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 3194 aq_ret = I40E_ERR_PARAM; 3195 goto err; 3196 } 3197 3198 if (!vf->adq_enabled) { 3199 dev_info(&pf->pdev->dev, 3200 "VF %d: ADq not enabled, can't apply cloud filter\n", 3201 vf->vf_id); 3202 aq_ret = I40E_ERR_PARAM; 3203 goto err; 3204 } 3205 3206 if (i40e_validate_cloud_filter(vf, vcf)) { 3207 dev_info(&pf->pdev->dev, 3208 "VF %d: Invalid input, can't apply cloud filter\n", 3209 vf->vf_id); 3210 aq_ret = I40E_ERR_PARAM; 3211 goto err; 3212 } 3213 3214 memset(&cfilter, 0, sizeof(cfilter)); 3215 /* parse destination mac address */ 3216 for (i = 0; i < ETH_ALEN; i++) 3217 cfilter.dst_mac[i] = mask.dst_mac[i] & tcf.dst_mac[i]; 3218 3219 /* parse source mac address */ 3220 for (i = 0; i < ETH_ALEN; i++) 3221 cfilter.src_mac[i] = mask.src_mac[i] & tcf.src_mac[i]; 3222 3223 cfilter.vlan_id = mask.vlan_id & tcf.vlan_id; 3224 cfilter.dst_port = mask.dst_port & tcf.dst_port; 3225 cfilter.src_port = mask.src_port & tcf.src_port; 3226 3227 switch (vcf->flow_type) { 3228 case VIRTCHNL_TCP_V4_FLOW: 3229 cfilter.n_proto = ETH_P_IP; 3230 if (mask.dst_ip[0] & tcf.dst_ip[0]) 3231 memcpy(&cfilter.ip.v4.dst_ip, tcf.dst_ip, 3232 ARRAY_SIZE(tcf.dst_ip)); 3233 else if (mask.src_ip[0] & tcf.dst_ip[0]) 3234 memcpy(&cfilter.ip.v4.src_ip, tcf.src_ip, 3235 ARRAY_SIZE(tcf.dst_ip)); 3236 break; 3237 case VIRTCHNL_TCP_V6_FLOW: 3238 cfilter.n_proto = ETH_P_IPV6; 3239 if (mask.dst_ip[3] & tcf.dst_ip[3]) 3240 memcpy(&cfilter.ip.v6.dst_ip6, tcf.dst_ip, 3241 sizeof(cfilter.ip.v6.dst_ip6)); 3242 if (mask.src_ip[3] & tcf.src_ip[3]) 3243 memcpy(&cfilter.ip.v6.src_ip6, tcf.src_ip, 3244 sizeof(cfilter.ip.v6.src_ip6)); 3245 break; 3246 default: 3247 /* TC filter can be configured based on different combinations 3248 * and in this case IP is not a part of filter config 3249 */ 3250 dev_info(&pf->pdev->dev, "VF %d: Flow type not configured\n", 3251 vf->vf_id); 3252 } 3253 3254 /* get the vsi to which the tc belongs to */ 3255 vsi = pf->vsi[vf->ch[vcf->action_meta].vsi_idx]; 3256 cfilter.seid = vsi->seid; 3257 cfilter.flags = vcf->field_flags; 3258 3259 /* Deleting TC filter */ 3260 if (tcf.dst_port) 3261 ret = i40e_add_del_cloud_filter_big_buf(vsi, &cfilter, false); 3262 else 3263 ret = i40e_add_del_cloud_filter(vsi, &cfilter, false); 3264 if (ret) { 3265 dev_err(&pf->pdev->dev, 3266 "VF %d: Failed to delete cloud filter, err %s aq_err %s\n", 3267 vf->vf_id, i40e_stat_str(&pf->hw, ret), 3268 i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status)); 3269 goto err; 3270 } 3271 3272 hlist_for_each_entry_safe(cf, node, 3273 &vf->cloud_filter_list, cloud_node) { 3274 if (cf->seid != cfilter.seid) 3275 continue; 3276 if (mask.dst_port) 3277 if (cfilter.dst_port != cf->dst_port) 3278 continue; 3279 if (mask.dst_mac[0]) 3280 if (!ether_addr_equal(cf->src_mac, cfilter.src_mac)) 3281 continue; 3282 /* for ipv4 data to be valid, only first byte of mask is set */ 3283 if (cfilter.n_proto == ETH_P_IP && mask.dst_ip[0]) 3284 if (memcmp(&cfilter.ip.v4.dst_ip, &cf->ip.v4.dst_ip, 3285 ARRAY_SIZE(tcf.dst_ip))) 3286 continue; 3287 /* for ipv6, mask is set for all sixteen bytes (4 words) */ 3288 if (cfilter.n_proto == ETH_P_IPV6 && mask.dst_ip[3]) 3289 if (memcmp(&cfilter.ip.v6.dst_ip6, &cf->ip.v6.dst_ip6, 3290 sizeof(cfilter.ip.v6.src_ip6))) 3291 continue; 3292 if (mask.vlan_id) 3293 if (cfilter.vlan_id != cf->vlan_id) 3294 continue; 3295 3296 hlist_del(&cf->cloud_node); 3297 kfree(cf); 3298 vf->num_cloud_filters--; 3299 } 3300 3301 err: 3302 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_CLOUD_FILTER, 3303 aq_ret); 3304 } 3305 3306 /** 3307 * i40e_vc_add_cloud_filter 3308 * @vf: pointer to the VF info 3309 * @msg: pointer to the msg buffer 3310 * 3311 * This function adds a cloud filter programmed as TC filter for ADq 3312 **/ 3313 static int i40e_vc_add_cloud_filter(struct i40e_vf *vf, u8 *msg) 3314 { 3315 struct virtchnl_filter *vcf = (struct virtchnl_filter *)msg; 3316 struct virtchnl_l4_spec mask = vcf->mask.tcp_spec; 3317 struct virtchnl_l4_spec tcf = vcf->data.tcp_spec; 3318 struct i40e_cloud_filter *cfilter = NULL; 3319 struct i40e_pf *pf = vf->pf; 3320 struct i40e_vsi *vsi = NULL; 3321 i40e_status aq_ret = 0; 3322 int i, ret; 3323 3324 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 3325 aq_ret = I40E_ERR_PARAM; 3326 goto err; 3327 } 3328 3329 if (!vf->adq_enabled) { 3330 dev_info(&pf->pdev->dev, 3331 "VF %d: ADq is not enabled, can't apply cloud filter\n", 3332 vf->vf_id); 3333 aq_ret = I40E_ERR_PARAM; 3334 goto err; 3335 } 3336 3337 if (i40e_validate_cloud_filter(vf, vcf)) { 3338 dev_info(&pf->pdev->dev, 3339 "VF %d: Invalid input/s, can't apply cloud filter\n", 3340 vf->vf_id); 3341 aq_ret = I40E_ERR_PARAM; 3342 goto err; 3343 } 3344 3345 cfilter = kzalloc(sizeof(*cfilter), GFP_KERNEL); 3346 if (!cfilter) 3347 return -ENOMEM; 3348 3349 /* parse destination mac address */ 3350 for (i = 0; i < ETH_ALEN; i++) 3351 cfilter->dst_mac[i] = mask.dst_mac[i] & tcf.dst_mac[i]; 3352 3353 /* parse source mac address */ 3354 for (i = 0; i < ETH_ALEN; i++) 3355 cfilter->src_mac[i] = mask.src_mac[i] & tcf.src_mac[i]; 3356 3357 cfilter->vlan_id = mask.vlan_id & tcf.vlan_id; 3358 cfilter->dst_port = mask.dst_port & tcf.dst_port; 3359 cfilter->src_port = mask.src_port & tcf.src_port; 3360 3361 switch (vcf->flow_type) { 3362 case VIRTCHNL_TCP_V4_FLOW: 3363 cfilter->n_proto = ETH_P_IP; 3364 if (mask.dst_ip[0] & tcf.dst_ip[0]) 3365 memcpy(&cfilter->ip.v4.dst_ip, tcf.dst_ip, 3366 ARRAY_SIZE(tcf.dst_ip)); 3367 else if (mask.src_ip[0] & tcf.dst_ip[0]) 3368 memcpy(&cfilter->ip.v4.src_ip, tcf.src_ip, 3369 ARRAY_SIZE(tcf.dst_ip)); 3370 break; 3371 case VIRTCHNL_TCP_V6_FLOW: 3372 cfilter->n_proto = ETH_P_IPV6; 3373 if (mask.dst_ip[3] & tcf.dst_ip[3]) 3374 memcpy(&cfilter->ip.v6.dst_ip6, tcf.dst_ip, 3375 sizeof(cfilter->ip.v6.dst_ip6)); 3376 if (mask.src_ip[3] & tcf.src_ip[3]) 3377 memcpy(&cfilter->ip.v6.src_ip6, tcf.src_ip, 3378 sizeof(cfilter->ip.v6.src_ip6)); 3379 break; 3380 default: 3381 /* TC filter can be configured based on different combinations 3382 * and in this case IP is not a part of filter config 3383 */ 3384 dev_info(&pf->pdev->dev, "VF %d: Flow type not configured\n", 3385 vf->vf_id); 3386 } 3387 3388 /* get the VSI to which the TC belongs to */ 3389 vsi = pf->vsi[vf->ch[vcf->action_meta].vsi_idx]; 3390 cfilter->seid = vsi->seid; 3391 cfilter->flags = vcf->field_flags; 3392 3393 /* Adding cloud filter programmed as TC filter */ 3394 if (tcf.dst_port) 3395 ret = i40e_add_del_cloud_filter_big_buf(vsi, cfilter, true); 3396 else 3397 ret = i40e_add_del_cloud_filter(vsi, cfilter, true); 3398 if (ret) { 3399 dev_err(&pf->pdev->dev, 3400 "VF %d: Failed to add cloud filter, err %s aq_err %s\n", 3401 vf->vf_id, i40e_stat_str(&pf->hw, ret), 3402 i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status)); 3403 goto err; 3404 } 3405 3406 INIT_HLIST_NODE(&cfilter->cloud_node); 3407 hlist_add_head(&cfilter->cloud_node, &vf->cloud_filter_list); 3408 vf->num_cloud_filters++; 3409 err: 3410 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_CLOUD_FILTER, 3411 aq_ret); 3412 } 3413 3414 /** 3415 * i40e_vc_add_qch_msg: Add queue channel and enable ADq 3416 * @vf: pointer to the VF info 3417 * @msg: pointer to the msg buffer 3418 **/ 3419 static int i40e_vc_add_qch_msg(struct i40e_vf *vf, u8 *msg) 3420 { 3421 struct virtchnl_tc_info *tci = 3422 (struct virtchnl_tc_info *)msg; 3423 struct i40e_pf *pf = vf->pf; 3424 struct i40e_link_status *ls = &pf->hw.phy.link_info; 3425 int i, adq_request_qps = 0, speed = 0; 3426 i40e_status aq_ret = 0; 3427 3428 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 3429 aq_ret = I40E_ERR_PARAM; 3430 goto err; 3431 } 3432 3433 /* ADq cannot be applied if spoof check is ON */ 3434 if (vf->spoofchk) { 3435 dev_err(&pf->pdev->dev, 3436 "Spoof check is ON, turn it OFF to enable ADq\n"); 3437 aq_ret = I40E_ERR_PARAM; 3438 goto err; 3439 } 3440 3441 if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ADQ)) { 3442 dev_err(&pf->pdev->dev, 3443 "VF %d attempting to enable ADq, but hasn't properly negotiated that capability\n", 3444 vf->vf_id); 3445 aq_ret = I40E_ERR_PARAM; 3446 goto err; 3447 } 3448 3449 /* max number of traffic classes for VF currently capped at 4 */ 3450 if (!tci->num_tc || tci->num_tc > I40E_MAX_VF_VSI) { 3451 dev_err(&pf->pdev->dev, 3452 "VF %d trying to set %u TCs, valid range 1-4 TCs per VF\n", 3453 vf->vf_id, tci->num_tc); 3454 aq_ret = I40E_ERR_PARAM; 3455 goto err; 3456 } 3457 3458 /* validate queues for each TC */ 3459 for (i = 0; i < tci->num_tc; i++) 3460 if (!tci->list[i].count || 3461 tci->list[i].count > I40E_DEFAULT_QUEUES_PER_VF) { 3462 dev_err(&pf->pdev->dev, 3463 "VF %d: TC %d trying to set %u queues, valid range 1-4 queues per TC\n", 3464 vf->vf_id, i, tci->list[i].count); 3465 aq_ret = I40E_ERR_PARAM; 3466 goto err; 3467 } 3468 3469 /* need Max VF queues but already have default number of queues */ 3470 adq_request_qps = I40E_MAX_VF_QUEUES - I40E_DEFAULT_QUEUES_PER_VF; 3471 3472 if (pf->queues_left < adq_request_qps) { 3473 dev_err(&pf->pdev->dev, 3474 "No queues left to allocate to VF %d\n", 3475 vf->vf_id); 3476 aq_ret = I40E_ERR_PARAM; 3477 goto err; 3478 } else { 3479 /* we need to allocate max VF queues to enable ADq so as to 3480 * make sure ADq enabled VF always gets back queues when it 3481 * goes through a reset. 3482 */ 3483 vf->num_queue_pairs = I40E_MAX_VF_QUEUES; 3484 } 3485 3486 /* get link speed in MB to validate rate limit */ 3487 switch (ls->link_speed) { 3488 case VIRTCHNL_LINK_SPEED_100MB: 3489 speed = SPEED_100; 3490 break; 3491 case VIRTCHNL_LINK_SPEED_1GB: 3492 speed = SPEED_1000; 3493 break; 3494 case VIRTCHNL_LINK_SPEED_10GB: 3495 speed = SPEED_10000; 3496 break; 3497 case VIRTCHNL_LINK_SPEED_20GB: 3498 speed = SPEED_20000; 3499 break; 3500 case VIRTCHNL_LINK_SPEED_25GB: 3501 speed = SPEED_25000; 3502 break; 3503 case VIRTCHNL_LINK_SPEED_40GB: 3504 speed = SPEED_40000; 3505 break; 3506 default: 3507 dev_err(&pf->pdev->dev, 3508 "Cannot detect link speed\n"); 3509 aq_ret = I40E_ERR_PARAM; 3510 goto err; 3511 } 3512 3513 /* parse data from the queue channel info */ 3514 vf->num_tc = tci->num_tc; 3515 for (i = 0; i < vf->num_tc; i++) { 3516 if (tci->list[i].max_tx_rate) { 3517 if (tci->list[i].max_tx_rate > speed) { 3518 dev_err(&pf->pdev->dev, 3519 "Invalid max tx rate %llu specified for VF %d.", 3520 tci->list[i].max_tx_rate, 3521 vf->vf_id); 3522 aq_ret = I40E_ERR_PARAM; 3523 goto err; 3524 } else { 3525 vf->ch[i].max_tx_rate = 3526 tci->list[i].max_tx_rate; 3527 } 3528 } 3529 vf->ch[i].num_qps = tci->list[i].count; 3530 } 3531 3532 /* set this flag only after making sure all inputs are sane */ 3533 vf->adq_enabled = true; 3534 /* num_req_queues is set when user changes number of queues via ethtool 3535 * and this causes issue for default VSI(which depends on this variable) 3536 * when ADq is enabled, hence reset it. 3537 */ 3538 vf->num_req_queues = 0; 3539 3540 /* reset the VF in order to allocate resources */ 3541 i40e_vc_notify_vf_reset(vf); 3542 i40e_reset_vf(vf, false); 3543 3544 return I40E_SUCCESS; 3545 3546 /* send the response to the VF */ 3547 err: 3548 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_CHANNELS, 3549 aq_ret); 3550 } 3551 3552 /** 3553 * i40e_vc_del_qch_msg 3554 * @vf: pointer to the VF info 3555 * @msg: pointer to the msg buffer 3556 **/ 3557 static int i40e_vc_del_qch_msg(struct i40e_vf *vf, u8 *msg) 3558 { 3559 struct i40e_pf *pf = vf->pf; 3560 i40e_status aq_ret = 0; 3561 3562 if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) { 3563 aq_ret = I40E_ERR_PARAM; 3564 goto err; 3565 } 3566 3567 if (vf->adq_enabled) { 3568 i40e_del_all_cloud_filters(vf); 3569 i40e_del_qch(vf); 3570 vf->adq_enabled = false; 3571 vf->num_tc = 0; 3572 dev_info(&pf->pdev->dev, 3573 "Deleting Queue Channels and cloud filters for ADq on VF %d\n", 3574 vf->vf_id); 3575 } else { 3576 dev_info(&pf->pdev->dev, "VF %d trying to delete queue channels but ADq isn't enabled\n", 3577 vf->vf_id); 3578 aq_ret = I40E_ERR_PARAM; 3579 } 3580 3581 /* reset the VF in order to allocate resources */ 3582 i40e_vc_notify_vf_reset(vf); 3583 i40e_reset_vf(vf, false); 3584 3585 return I40E_SUCCESS; 3586 3587 err: 3588 return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_CHANNELS, 3589 aq_ret); 3590 } 3591 3592 /** 3593 * i40e_vc_process_vf_msg 3594 * @pf: pointer to the PF structure 3595 * @vf_id: source VF id 3596 * @v_opcode: operation code 3597 * @v_retval: unused return value code 3598 * @msg: pointer to the msg buffer 3599 * @msglen: msg length 3600 * 3601 * called from the common aeq/arq handler to 3602 * process request from VF 3603 **/ 3604 int i40e_vc_process_vf_msg(struct i40e_pf *pf, s16 vf_id, u32 v_opcode, 3605 u32 __always_unused v_retval, u8 *msg, u16 msglen) 3606 { 3607 struct i40e_hw *hw = &pf->hw; 3608 int local_vf_id = vf_id - (s16)hw->func_caps.vf_base_id; 3609 struct i40e_vf *vf; 3610 int ret; 3611 3612 pf->vf_aq_requests++; 3613 if (local_vf_id >= pf->num_alloc_vfs) 3614 return -EINVAL; 3615 vf = &(pf->vf[local_vf_id]); 3616 3617 /* Check if VF is disabled. */ 3618 if (test_bit(I40E_VF_STATE_DISABLED, &vf->vf_states)) 3619 return I40E_ERR_PARAM; 3620 3621 /* perform basic checks on the msg */ 3622 ret = virtchnl_vc_validate_vf_msg(&vf->vf_ver, v_opcode, msg, msglen); 3623 3624 /* perform additional checks specific to this driver */ 3625 if (v_opcode == VIRTCHNL_OP_CONFIG_RSS_KEY) { 3626 struct virtchnl_rss_key *vrk = (struct virtchnl_rss_key *)msg; 3627 3628 if (vrk->key_len != I40E_HKEY_ARRAY_SIZE) 3629 ret = -EINVAL; 3630 } else if (v_opcode == VIRTCHNL_OP_CONFIG_RSS_LUT) { 3631 struct virtchnl_rss_lut *vrl = (struct virtchnl_rss_lut *)msg; 3632 3633 if (vrl->lut_entries != I40E_VF_HLUT_ARRAY_SIZE) 3634 ret = -EINVAL; 3635 } 3636 3637 if (ret) { 3638 i40e_vc_send_resp_to_vf(vf, v_opcode, I40E_ERR_PARAM); 3639 dev_err(&pf->pdev->dev, "Invalid message from VF %d, opcode %d, len %d\n", 3640 local_vf_id, v_opcode, msglen); 3641 switch (ret) { 3642 case VIRTCHNL_ERR_PARAM: 3643 return -EPERM; 3644 default: 3645 return -EINVAL; 3646 } 3647 } 3648 3649 switch (v_opcode) { 3650 case VIRTCHNL_OP_VERSION: 3651 ret = i40e_vc_get_version_msg(vf, msg); 3652 break; 3653 case VIRTCHNL_OP_GET_VF_RESOURCES: 3654 ret = i40e_vc_get_vf_resources_msg(vf, msg); 3655 i40e_vc_notify_vf_link_state(vf); 3656 break; 3657 case VIRTCHNL_OP_RESET_VF: 3658 i40e_vc_reset_vf_msg(vf); 3659 ret = 0; 3660 break; 3661 case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE: 3662 ret = i40e_vc_config_promiscuous_mode_msg(vf, msg, msglen); 3663 break; 3664 case VIRTCHNL_OP_CONFIG_VSI_QUEUES: 3665 ret = i40e_vc_config_queues_msg(vf, msg, msglen); 3666 break; 3667 case VIRTCHNL_OP_CONFIG_IRQ_MAP: 3668 ret = i40e_vc_config_irq_map_msg(vf, msg, msglen); 3669 break; 3670 case VIRTCHNL_OP_ENABLE_QUEUES: 3671 ret = i40e_vc_enable_queues_msg(vf, msg, msglen); 3672 i40e_vc_notify_vf_link_state(vf); 3673 break; 3674 case VIRTCHNL_OP_DISABLE_QUEUES: 3675 ret = i40e_vc_disable_queues_msg(vf, msg, msglen); 3676 break; 3677 case VIRTCHNL_OP_ADD_ETH_ADDR: 3678 ret = i40e_vc_add_mac_addr_msg(vf, msg, msglen); 3679 break; 3680 case VIRTCHNL_OP_DEL_ETH_ADDR: 3681 ret = i40e_vc_del_mac_addr_msg(vf, msg, msglen); 3682 break; 3683 case VIRTCHNL_OP_ADD_VLAN: 3684 ret = i40e_vc_add_vlan_msg(vf, msg, msglen); 3685 break; 3686 case VIRTCHNL_OP_DEL_VLAN: 3687 ret = i40e_vc_remove_vlan_msg(vf, msg, msglen); 3688 break; 3689 case VIRTCHNL_OP_GET_STATS: 3690 ret = i40e_vc_get_stats_msg(vf, msg, msglen); 3691 break; 3692 case VIRTCHNL_OP_IWARP: 3693 ret = i40e_vc_iwarp_msg(vf, msg, msglen); 3694 break; 3695 case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP: 3696 ret = i40e_vc_iwarp_qvmap_msg(vf, msg, msglen, true); 3697 break; 3698 case VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP: 3699 ret = i40e_vc_iwarp_qvmap_msg(vf, msg, msglen, false); 3700 break; 3701 case VIRTCHNL_OP_CONFIG_RSS_KEY: 3702 ret = i40e_vc_config_rss_key(vf, msg, msglen); 3703 break; 3704 case VIRTCHNL_OP_CONFIG_RSS_LUT: 3705 ret = i40e_vc_config_rss_lut(vf, msg, msglen); 3706 break; 3707 case VIRTCHNL_OP_GET_RSS_HENA_CAPS: 3708 ret = i40e_vc_get_rss_hena(vf, msg, msglen); 3709 break; 3710 case VIRTCHNL_OP_SET_RSS_HENA: 3711 ret = i40e_vc_set_rss_hena(vf, msg, msglen); 3712 break; 3713 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING: 3714 ret = i40e_vc_enable_vlan_stripping(vf, msg, msglen); 3715 break; 3716 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING: 3717 ret = i40e_vc_disable_vlan_stripping(vf, msg, msglen); 3718 break; 3719 case VIRTCHNL_OP_REQUEST_QUEUES: 3720 ret = i40e_vc_request_queues_msg(vf, msg, msglen); 3721 break; 3722 case VIRTCHNL_OP_ENABLE_CHANNELS: 3723 ret = i40e_vc_add_qch_msg(vf, msg); 3724 break; 3725 case VIRTCHNL_OP_DISABLE_CHANNELS: 3726 ret = i40e_vc_del_qch_msg(vf, msg); 3727 break; 3728 case VIRTCHNL_OP_ADD_CLOUD_FILTER: 3729 ret = i40e_vc_add_cloud_filter(vf, msg); 3730 break; 3731 case VIRTCHNL_OP_DEL_CLOUD_FILTER: 3732 ret = i40e_vc_del_cloud_filter(vf, msg); 3733 break; 3734 case VIRTCHNL_OP_UNKNOWN: 3735 default: 3736 dev_err(&pf->pdev->dev, "Unsupported opcode %d from VF %d\n", 3737 v_opcode, local_vf_id); 3738 ret = i40e_vc_send_resp_to_vf(vf, v_opcode, 3739 I40E_ERR_NOT_IMPLEMENTED); 3740 break; 3741 } 3742 3743 return ret; 3744 } 3745 3746 /** 3747 * i40e_vc_process_vflr_event 3748 * @pf: pointer to the PF structure 3749 * 3750 * called from the vlfr irq handler to 3751 * free up VF resources and state variables 3752 **/ 3753 int i40e_vc_process_vflr_event(struct i40e_pf *pf) 3754 { 3755 struct i40e_hw *hw = &pf->hw; 3756 u32 reg, reg_idx, bit_idx; 3757 struct i40e_vf *vf; 3758 int vf_id; 3759 3760 if (!test_bit(__I40E_VFLR_EVENT_PENDING, pf->state)) 3761 return 0; 3762 3763 /* Re-enable the VFLR interrupt cause here, before looking for which 3764 * VF got reset. Otherwise, if another VF gets a reset while the 3765 * first one is being processed, that interrupt will be lost, and 3766 * that VF will be stuck in reset forever. 3767 */ 3768 reg = rd32(hw, I40E_PFINT_ICR0_ENA); 3769 reg |= I40E_PFINT_ICR0_ENA_VFLR_MASK; 3770 wr32(hw, I40E_PFINT_ICR0_ENA, reg); 3771 i40e_flush(hw); 3772 3773 clear_bit(__I40E_VFLR_EVENT_PENDING, pf->state); 3774 for (vf_id = 0; vf_id < pf->num_alloc_vfs; vf_id++) { 3775 reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32; 3776 bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32; 3777 /* read GLGEN_VFLRSTAT register to find out the flr VFs */ 3778 vf = &pf->vf[vf_id]; 3779 reg = rd32(hw, I40E_GLGEN_VFLRSTAT(reg_idx)); 3780 if (reg & BIT(bit_idx)) 3781 /* i40e_reset_vf will clear the bit in GLGEN_VFLRSTAT */ 3782 i40e_reset_vf(vf, true); 3783 } 3784 3785 return 0; 3786 } 3787 3788 /** 3789 * i40e_ndo_set_vf_mac 3790 * @netdev: network interface device structure 3791 * @vf_id: VF identifier 3792 * @mac: mac address 3793 * 3794 * program VF mac address 3795 **/ 3796 int i40e_ndo_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac) 3797 { 3798 struct i40e_netdev_priv *np = netdev_priv(netdev); 3799 struct i40e_vsi *vsi = np->vsi; 3800 struct i40e_pf *pf = vsi->back; 3801 struct i40e_mac_filter *f; 3802 struct i40e_vf *vf; 3803 int ret = 0; 3804 struct hlist_node *h; 3805 int bkt; 3806 u8 i; 3807 3808 /* validate the request */ 3809 if (vf_id >= pf->num_alloc_vfs) { 3810 dev_err(&pf->pdev->dev, 3811 "Invalid VF Identifier %d\n", vf_id); 3812 ret = -EINVAL; 3813 goto error_param; 3814 } 3815 3816 vf = &(pf->vf[vf_id]); 3817 vsi = pf->vsi[vf->lan_vsi_idx]; 3818 3819 /* When the VF is resetting wait until it is done. 3820 * It can take up to 200 milliseconds, 3821 * but wait for up to 300 milliseconds to be safe. 3822 */ 3823 for (i = 0; i < 15; i++) { 3824 if (test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) 3825 break; 3826 msleep(20); 3827 } 3828 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) { 3829 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n", 3830 vf_id); 3831 ret = -EAGAIN; 3832 goto error_param; 3833 } 3834 3835 if (is_multicast_ether_addr(mac)) { 3836 dev_err(&pf->pdev->dev, 3837 "Invalid Ethernet address %pM for VF %d\n", mac, vf_id); 3838 ret = -EINVAL; 3839 goto error_param; 3840 } 3841 3842 /* Lock once because below invoked function add/del_filter requires 3843 * mac_filter_hash_lock to be held 3844 */ 3845 spin_lock_bh(&vsi->mac_filter_hash_lock); 3846 3847 /* delete the temporary mac address */ 3848 if (!is_zero_ether_addr(vf->default_lan_addr.addr)) 3849 i40e_del_mac_filter(vsi, vf->default_lan_addr.addr); 3850 3851 /* Delete all the filters for this VSI - we're going to kill it 3852 * anyway. 3853 */ 3854 hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) 3855 __i40e_del_filter(vsi, f); 3856 3857 spin_unlock_bh(&vsi->mac_filter_hash_lock); 3858 3859 /* program mac filter */ 3860 if (i40e_sync_vsi_filters(vsi)) { 3861 dev_err(&pf->pdev->dev, "Unable to program ucast filters\n"); 3862 ret = -EIO; 3863 goto error_param; 3864 } 3865 ether_addr_copy(vf->default_lan_addr.addr, mac); 3866 3867 if (is_zero_ether_addr(mac)) { 3868 vf->pf_set_mac = false; 3869 dev_info(&pf->pdev->dev, "Removing MAC on VF %d\n", vf_id); 3870 } else { 3871 vf->pf_set_mac = true; 3872 dev_info(&pf->pdev->dev, "Setting MAC %pM on VF %d\n", 3873 mac, vf_id); 3874 } 3875 3876 /* Force the VF driver stop so it has to reload with new MAC address */ 3877 i40e_vc_disable_vf(vf); 3878 dev_info(&pf->pdev->dev, "Reload the VF driver to make this change effective.\n"); 3879 3880 error_param: 3881 return ret; 3882 } 3883 3884 /** 3885 * i40e_vsi_has_vlans - True if VSI has configured VLANs 3886 * @vsi: pointer to the vsi 3887 * 3888 * Check if a VSI has configured any VLANs. False if we have a port VLAN or if 3889 * we have no configured VLANs. Do not call while holding the 3890 * mac_filter_hash_lock. 3891 */ 3892 static bool i40e_vsi_has_vlans(struct i40e_vsi *vsi) 3893 { 3894 bool have_vlans; 3895 3896 /* If we have a port VLAN, then the VSI cannot have any VLANs 3897 * configured, as all MAC/VLAN filters will be assigned to the PVID. 3898 */ 3899 if (vsi->info.pvid) 3900 return false; 3901 3902 /* Since we don't have a PVID, we know that if the device is in VLAN 3903 * mode it must be because of a VLAN filter configured on this VSI. 3904 */ 3905 spin_lock_bh(&vsi->mac_filter_hash_lock); 3906 have_vlans = i40e_is_vsi_in_vlan(vsi); 3907 spin_unlock_bh(&vsi->mac_filter_hash_lock); 3908 3909 return have_vlans; 3910 } 3911 3912 /** 3913 * i40e_ndo_set_vf_port_vlan 3914 * @netdev: network interface device structure 3915 * @vf_id: VF identifier 3916 * @vlan_id: mac address 3917 * @qos: priority setting 3918 * @vlan_proto: vlan protocol 3919 * 3920 * program VF vlan id and/or qos 3921 **/ 3922 int i40e_ndo_set_vf_port_vlan(struct net_device *netdev, int vf_id, 3923 u16 vlan_id, u8 qos, __be16 vlan_proto) 3924 { 3925 u16 vlanprio = vlan_id | (qos << I40E_VLAN_PRIORITY_SHIFT); 3926 struct i40e_netdev_priv *np = netdev_priv(netdev); 3927 struct i40e_pf *pf = np->vsi->back; 3928 struct i40e_vsi *vsi; 3929 struct i40e_vf *vf; 3930 int ret = 0; 3931 3932 /* validate the request */ 3933 if (vf_id >= pf->num_alloc_vfs) { 3934 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id); 3935 ret = -EINVAL; 3936 goto error_pvid; 3937 } 3938 3939 if ((vlan_id > I40E_MAX_VLANID) || (qos > 7)) { 3940 dev_err(&pf->pdev->dev, "Invalid VF Parameters\n"); 3941 ret = -EINVAL; 3942 goto error_pvid; 3943 } 3944 3945 if (vlan_proto != htons(ETH_P_8021Q)) { 3946 dev_err(&pf->pdev->dev, "VF VLAN protocol is not supported\n"); 3947 ret = -EPROTONOSUPPORT; 3948 goto error_pvid; 3949 } 3950 3951 vf = &(pf->vf[vf_id]); 3952 vsi = pf->vsi[vf->lan_vsi_idx]; 3953 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) { 3954 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n", 3955 vf_id); 3956 ret = -EAGAIN; 3957 goto error_pvid; 3958 } 3959 3960 if (le16_to_cpu(vsi->info.pvid) == vlanprio) 3961 /* duplicate request, so just return success */ 3962 goto error_pvid; 3963 3964 if (i40e_vsi_has_vlans(vsi)) { 3965 dev_err(&pf->pdev->dev, 3966 "VF %d has already configured VLAN filters and the administrator is requesting a port VLAN override.\nPlease unload and reload the VF driver for this change to take effect.\n", 3967 vf_id); 3968 /* Administrator Error - knock the VF offline until he does 3969 * the right thing by reconfiguring his network correctly 3970 * and then reloading the VF driver. 3971 */ 3972 i40e_vc_disable_vf(vf); 3973 /* During reset the VF got a new VSI, so refresh the pointer. */ 3974 vsi = pf->vsi[vf->lan_vsi_idx]; 3975 } 3976 3977 /* Locked once because multiple functions below iterate list */ 3978 spin_lock_bh(&vsi->mac_filter_hash_lock); 3979 3980 /* Check for condition where there was already a port VLAN ID 3981 * filter set and now it is being deleted by setting it to zero. 3982 * Additionally check for the condition where there was a port 3983 * VLAN but now there is a new and different port VLAN being set. 3984 * Before deleting all the old VLAN filters we must add new ones 3985 * with -1 (I40E_VLAN_ANY) or otherwise we're left with all our 3986 * MAC addresses deleted. 3987 */ 3988 if ((!(vlan_id || qos) || 3989 vlanprio != le16_to_cpu(vsi->info.pvid)) && 3990 vsi->info.pvid) { 3991 ret = i40e_add_vlan_all_mac(vsi, I40E_VLAN_ANY); 3992 if (ret) { 3993 dev_info(&vsi->back->pdev->dev, 3994 "add VF VLAN failed, ret=%d aq_err=%d\n", ret, 3995 vsi->back->hw.aq.asq_last_status); 3996 spin_unlock_bh(&vsi->mac_filter_hash_lock); 3997 goto error_pvid; 3998 } 3999 } 4000 4001 if (vsi->info.pvid) { 4002 /* remove all filters on the old VLAN */ 4003 i40e_rm_vlan_all_mac(vsi, (le16_to_cpu(vsi->info.pvid) & 4004 VLAN_VID_MASK)); 4005 } 4006 4007 spin_unlock_bh(&vsi->mac_filter_hash_lock); 4008 if (vlan_id || qos) 4009 ret = i40e_vsi_add_pvid(vsi, vlanprio); 4010 else 4011 i40e_vsi_remove_pvid(vsi); 4012 spin_lock_bh(&vsi->mac_filter_hash_lock); 4013 4014 if (vlan_id) { 4015 dev_info(&pf->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n", 4016 vlan_id, qos, vf_id); 4017 4018 /* add new VLAN filter for each MAC */ 4019 ret = i40e_add_vlan_all_mac(vsi, vlan_id); 4020 if (ret) { 4021 dev_info(&vsi->back->pdev->dev, 4022 "add VF VLAN failed, ret=%d aq_err=%d\n", ret, 4023 vsi->back->hw.aq.asq_last_status); 4024 spin_unlock_bh(&vsi->mac_filter_hash_lock); 4025 goto error_pvid; 4026 } 4027 4028 /* remove the previously added non-VLAN MAC filters */ 4029 i40e_rm_vlan_all_mac(vsi, I40E_VLAN_ANY); 4030 } 4031 4032 spin_unlock_bh(&vsi->mac_filter_hash_lock); 4033 4034 /* Schedule the worker thread to take care of applying changes */ 4035 i40e_service_event_schedule(vsi->back); 4036 4037 if (ret) { 4038 dev_err(&pf->pdev->dev, "Unable to update VF vsi context\n"); 4039 goto error_pvid; 4040 } 4041 4042 /* The Port VLAN needs to be saved across resets the same as the 4043 * default LAN MAC address. 4044 */ 4045 vf->port_vlan_id = le16_to_cpu(vsi->info.pvid); 4046 ret = 0; 4047 4048 error_pvid: 4049 return ret; 4050 } 4051 4052 /** 4053 * i40e_ndo_set_vf_bw 4054 * @netdev: network interface device structure 4055 * @vf_id: VF identifier 4056 * @min_tx_rate: Minimum Tx rate 4057 * @max_tx_rate: Maximum Tx rate 4058 * 4059 * configure VF Tx rate 4060 **/ 4061 int i40e_ndo_set_vf_bw(struct net_device *netdev, int vf_id, int min_tx_rate, 4062 int max_tx_rate) 4063 { 4064 struct i40e_netdev_priv *np = netdev_priv(netdev); 4065 struct i40e_pf *pf = np->vsi->back; 4066 struct i40e_vsi *vsi; 4067 struct i40e_vf *vf; 4068 int ret = 0; 4069 4070 /* validate the request */ 4071 if (vf_id >= pf->num_alloc_vfs) { 4072 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d.\n", vf_id); 4073 ret = -EINVAL; 4074 goto error; 4075 } 4076 4077 if (min_tx_rate) { 4078 dev_err(&pf->pdev->dev, "Invalid min tx rate (%d) (greater than 0) specified for VF %d.\n", 4079 min_tx_rate, vf_id); 4080 return -EINVAL; 4081 } 4082 4083 vf = &(pf->vf[vf_id]); 4084 vsi = pf->vsi[vf->lan_vsi_idx]; 4085 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) { 4086 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n", 4087 vf_id); 4088 ret = -EAGAIN; 4089 goto error; 4090 } 4091 4092 ret = i40e_set_bw_limit(vsi, vsi->seid, max_tx_rate); 4093 if (ret) 4094 goto error; 4095 4096 vf->tx_rate = max_tx_rate; 4097 error: 4098 return ret; 4099 } 4100 4101 /** 4102 * i40e_ndo_get_vf_config 4103 * @netdev: network interface device structure 4104 * @vf_id: VF identifier 4105 * @ivi: VF configuration structure 4106 * 4107 * return VF configuration 4108 **/ 4109 int i40e_ndo_get_vf_config(struct net_device *netdev, 4110 int vf_id, struct ifla_vf_info *ivi) 4111 { 4112 struct i40e_netdev_priv *np = netdev_priv(netdev); 4113 struct i40e_vsi *vsi = np->vsi; 4114 struct i40e_pf *pf = vsi->back; 4115 struct i40e_vf *vf; 4116 int ret = 0; 4117 4118 /* validate the request */ 4119 if (vf_id >= pf->num_alloc_vfs) { 4120 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id); 4121 ret = -EINVAL; 4122 goto error_param; 4123 } 4124 4125 vf = &(pf->vf[vf_id]); 4126 /* first vsi is always the LAN vsi */ 4127 vsi = pf->vsi[vf->lan_vsi_idx]; 4128 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) { 4129 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n", 4130 vf_id); 4131 ret = -EAGAIN; 4132 goto error_param; 4133 } 4134 4135 ivi->vf = vf_id; 4136 4137 ether_addr_copy(ivi->mac, vf->default_lan_addr.addr); 4138 4139 ivi->max_tx_rate = vf->tx_rate; 4140 ivi->min_tx_rate = 0; 4141 ivi->vlan = le16_to_cpu(vsi->info.pvid) & I40E_VLAN_MASK; 4142 ivi->qos = (le16_to_cpu(vsi->info.pvid) & I40E_PRIORITY_MASK) >> 4143 I40E_VLAN_PRIORITY_SHIFT; 4144 if (vf->link_forced == false) 4145 ivi->linkstate = IFLA_VF_LINK_STATE_AUTO; 4146 else if (vf->link_up == true) 4147 ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE; 4148 else 4149 ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE; 4150 ivi->spoofchk = vf->spoofchk; 4151 ivi->trusted = vf->trusted; 4152 ret = 0; 4153 4154 error_param: 4155 return ret; 4156 } 4157 4158 /** 4159 * i40e_ndo_set_vf_link_state 4160 * @netdev: network interface device structure 4161 * @vf_id: VF identifier 4162 * @link: required link state 4163 * 4164 * Set the link state of a specified VF, regardless of physical link state 4165 **/ 4166 int i40e_ndo_set_vf_link_state(struct net_device *netdev, int vf_id, int link) 4167 { 4168 struct i40e_netdev_priv *np = netdev_priv(netdev); 4169 struct i40e_pf *pf = np->vsi->back; 4170 struct virtchnl_pf_event pfe; 4171 struct i40e_hw *hw = &pf->hw; 4172 struct i40e_vf *vf; 4173 int abs_vf_id; 4174 int ret = 0; 4175 4176 /* validate the request */ 4177 if (vf_id >= pf->num_alloc_vfs) { 4178 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id); 4179 ret = -EINVAL; 4180 goto error_out; 4181 } 4182 4183 vf = &pf->vf[vf_id]; 4184 abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id; 4185 4186 pfe.event = VIRTCHNL_EVENT_LINK_CHANGE; 4187 pfe.severity = PF_EVENT_SEVERITY_INFO; 4188 4189 switch (link) { 4190 case IFLA_VF_LINK_STATE_AUTO: 4191 vf->link_forced = false; 4192 pfe.event_data.link_event.link_status = 4193 pf->hw.phy.link_info.link_info & I40E_AQ_LINK_UP; 4194 pfe.event_data.link_event.link_speed = 4195 (enum virtchnl_link_speed) 4196 pf->hw.phy.link_info.link_speed; 4197 break; 4198 case IFLA_VF_LINK_STATE_ENABLE: 4199 vf->link_forced = true; 4200 vf->link_up = true; 4201 pfe.event_data.link_event.link_status = true; 4202 pfe.event_data.link_event.link_speed = I40E_LINK_SPEED_40GB; 4203 break; 4204 case IFLA_VF_LINK_STATE_DISABLE: 4205 vf->link_forced = true; 4206 vf->link_up = false; 4207 pfe.event_data.link_event.link_status = false; 4208 pfe.event_data.link_event.link_speed = 0; 4209 break; 4210 default: 4211 ret = -EINVAL; 4212 goto error_out; 4213 } 4214 /* Notify the VF of its new link state */ 4215 i40e_aq_send_msg_to_vf(hw, abs_vf_id, VIRTCHNL_OP_EVENT, 4216 0, (u8 *)&pfe, sizeof(pfe), NULL); 4217 4218 error_out: 4219 return ret; 4220 } 4221 4222 /** 4223 * i40e_ndo_set_vf_spoofchk 4224 * @netdev: network interface device structure 4225 * @vf_id: VF identifier 4226 * @enable: flag to enable or disable feature 4227 * 4228 * Enable or disable VF spoof checking 4229 **/ 4230 int i40e_ndo_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool enable) 4231 { 4232 struct i40e_netdev_priv *np = netdev_priv(netdev); 4233 struct i40e_vsi *vsi = np->vsi; 4234 struct i40e_pf *pf = vsi->back; 4235 struct i40e_vsi_context ctxt; 4236 struct i40e_hw *hw = &pf->hw; 4237 struct i40e_vf *vf; 4238 int ret = 0; 4239 4240 /* validate the request */ 4241 if (vf_id >= pf->num_alloc_vfs) { 4242 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id); 4243 ret = -EINVAL; 4244 goto out; 4245 } 4246 4247 vf = &(pf->vf[vf_id]); 4248 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) { 4249 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n", 4250 vf_id); 4251 ret = -EAGAIN; 4252 goto out; 4253 } 4254 4255 if (enable == vf->spoofchk) 4256 goto out; 4257 4258 vf->spoofchk = enable; 4259 memset(&ctxt, 0, sizeof(ctxt)); 4260 ctxt.seid = pf->vsi[vf->lan_vsi_idx]->seid; 4261 ctxt.pf_num = pf->hw.pf_id; 4262 ctxt.info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_SECURITY_VALID); 4263 if (enable) 4264 ctxt.info.sec_flags |= (I40E_AQ_VSI_SEC_FLAG_ENABLE_VLAN_CHK | 4265 I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK); 4266 ret = i40e_aq_update_vsi_params(hw, &ctxt, NULL); 4267 if (ret) { 4268 dev_err(&pf->pdev->dev, "Error %d updating VSI parameters\n", 4269 ret); 4270 ret = -EIO; 4271 } 4272 out: 4273 return ret; 4274 } 4275 4276 /** 4277 * i40e_ndo_set_vf_trust 4278 * @netdev: network interface device structure of the pf 4279 * @vf_id: VF identifier 4280 * @setting: trust setting 4281 * 4282 * Enable or disable VF trust setting 4283 **/ 4284 int i40e_ndo_set_vf_trust(struct net_device *netdev, int vf_id, bool setting) 4285 { 4286 struct i40e_netdev_priv *np = netdev_priv(netdev); 4287 struct i40e_pf *pf = np->vsi->back; 4288 struct i40e_vf *vf; 4289 int ret = 0; 4290 4291 /* validate the request */ 4292 if (vf_id >= pf->num_alloc_vfs) { 4293 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id); 4294 return -EINVAL; 4295 } 4296 4297 if (pf->flags & I40E_FLAG_MFP_ENABLED) { 4298 dev_err(&pf->pdev->dev, "Trusted VF not supported in MFP mode.\n"); 4299 return -EINVAL; 4300 } 4301 4302 vf = &pf->vf[vf_id]; 4303 4304 if (setting == vf->trusted) 4305 goto out; 4306 4307 vf->trusted = setting; 4308 i40e_vc_disable_vf(vf); 4309 dev_info(&pf->pdev->dev, "VF %u is now %strusted\n", 4310 vf_id, setting ? "" : "un"); 4311 4312 if (vf->adq_enabled) { 4313 if (!vf->trusted) { 4314 dev_info(&pf->pdev->dev, 4315 "VF %u no longer Trusted, deleting all cloud filters\n", 4316 vf_id); 4317 i40e_del_all_cloud_filters(vf); 4318 } 4319 } 4320 4321 out: 4322 return ret; 4323 } 4324