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