1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2013 - 2018 Intel Corporation. */ 3 4 #include "fm10k.h" 5 #include "fm10k_vf.h" 6 #include "fm10k_pf.h" 7 8 static s32 fm10k_iov_msg_error(struct fm10k_hw *hw, u32 **results, 9 struct fm10k_mbx_info *mbx) 10 { 11 struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx; 12 struct fm10k_intfc *interface = hw->back; 13 struct pci_dev *pdev = interface->pdev; 14 15 dev_err(&pdev->dev, "Unknown message ID %u on VF %d\n", 16 **results & FM10K_TLV_ID_MASK, vf_info->vf_idx); 17 18 return fm10k_tlv_msg_error(hw, results, mbx); 19 } 20 21 /** 22 * fm10k_iov_msg_queue_mac_vlan - Message handler for MAC/VLAN request from VF 23 * @hw: Pointer to hardware structure 24 * @results: Pointer array to message, results[0] is pointer to message 25 * @mbx: Pointer to mailbox information structure 26 * 27 * This function is a custom handler for MAC/VLAN requests from the VF. The 28 * assumption is that it is acceptable to directly hand off the message from 29 * the VF to the PF's switch manager. However, we use a MAC/VLAN message 30 * queue to avoid overloading the mailbox when a large number of requests 31 * come in. 32 **/ 33 static s32 fm10k_iov_msg_queue_mac_vlan(struct fm10k_hw *hw, u32 **results, 34 struct fm10k_mbx_info *mbx) 35 { 36 struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx; 37 struct fm10k_intfc *interface = hw->back; 38 u8 mac[ETH_ALEN]; 39 u32 *result; 40 int err = 0; 41 bool set; 42 u16 vlan; 43 u32 vid; 44 45 /* we shouldn't be updating rules on a disabled interface */ 46 if (!FM10K_VF_FLAG_ENABLED(vf_info)) 47 err = FM10K_ERR_PARAM; 48 49 if (!err && !!results[FM10K_MAC_VLAN_MSG_VLAN]) { 50 result = results[FM10K_MAC_VLAN_MSG_VLAN]; 51 52 /* record VLAN id requested */ 53 err = fm10k_tlv_attr_get_u32(result, &vid); 54 if (err) 55 return err; 56 57 set = !(vid & FM10K_VLAN_CLEAR); 58 vid &= ~FM10K_VLAN_CLEAR; 59 60 /* if the length field has been set, this is a multi-bit 61 * update request. For multi-bit requests, simply disallow 62 * them when the pf_vid has been set. In this case, the PF 63 * should have already cleared the VLAN_TABLE, and if we 64 * allowed them, it could allow a rogue VF to receive traffic 65 * on a VLAN it was not assigned. In the single-bit case, we 66 * need to modify requests for VLAN 0 to use the default PF or 67 * SW vid when assigned. 68 */ 69 70 if (vid >> 16) { 71 /* prevent multi-bit requests when PF has 72 * administratively set the VLAN for this VF 73 */ 74 if (vf_info->pf_vid) 75 return FM10K_ERR_PARAM; 76 } else { 77 err = fm10k_iov_select_vid(vf_info, (u16)vid); 78 if (err < 0) 79 return err; 80 81 vid = err; 82 } 83 84 /* update VSI info for VF in regards to VLAN table */ 85 err = hw->mac.ops.update_vlan(hw, vid, vf_info->vsi, set); 86 } 87 88 if (!err && !!results[FM10K_MAC_VLAN_MSG_MAC]) { 89 result = results[FM10K_MAC_VLAN_MSG_MAC]; 90 91 /* record unicast MAC address requested */ 92 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan); 93 if (err) 94 return err; 95 96 /* block attempts to set MAC for a locked device */ 97 if (is_valid_ether_addr(vf_info->mac) && 98 !ether_addr_equal(mac, vf_info->mac)) 99 return FM10K_ERR_PARAM; 100 101 set = !(vlan & FM10K_VLAN_CLEAR); 102 vlan &= ~FM10K_VLAN_CLEAR; 103 104 err = fm10k_iov_select_vid(vf_info, vlan); 105 if (err < 0) 106 return err; 107 108 vlan = (u16)err; 109 110 /* Add this request to the MAC/VLAN queue */ 111 err = fm10k_queue_mac_request(interface, vf_info->glort, 112 mac, vlan, set); 113 } 114 115 if (!err && !!results[FM10K_MAC_VLAN_MSG_MULTICAST]) { 116 result = results[FM10K_MAC_VLAN_MSG_MULTICAST]; 117 118 /* record multicast MAC address requested */ 119 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan); 120 if (err) 121 return err; 122 123 /* verify that the VF is allowed to request multicast */ 124 if (!(vf_info->vf_flags & FM10K_VF_FLAG_MULTI_ENABLED)) 125 return FM10K_ERR_PARAM; 126 127 set = !(vlan & FM10K_VLAN_CLEAR); 128 vlan &= ~FM10K_VLAN_CLEAR; 129 130 err = fm10k_iov_select_vid(vf_info, vlan); 131 if (err < 0) 132 return err; 133 134 vlan = (u16)err; 135 136 /* Add this request to the MAC/VLAN queue */ 137 err = fm10k_queue_mac_request(interface, vf_info->glort, 138 mac, vlan, set); 139 } 140 141 return err; 142 } 143 144 static const struct fm10k_msg_data iov_mbx_data[] = { 145 FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test), 146 FM10K_VF_MSG_MSIX_HANDLER(fm10k_iov_msg_msix_pf), 147 FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_iov_msg_queue_mac_vlan), 148 FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_iov_msg_lport_state_pf), 149 FM10K_TLV_MSG_ERROR_HANDLER(fm10k_iov_msg_error), 150 }; 151 152 s32 fm10k_iov_event(struct fm10k_intfc *interface) 153 { 154 struct fm10k_hw *hw = &interface->hw; 155 struct fm10k_iov_data *iov_data; 156 s64 vflre; 157 int i; 158 159 /* if there is no iov_data then there is no mailbox to process */ 160 if (!READ_ONCE(interface->iov_data)) 161 return 0; 162 163 rcu_read_lock(); 164 165 iov_data = interface->iov_data; 166 167 /* check again now that we are in the RCU block */ 168 if (!iov_data) 169 goto read_unlock; 170 171 if (!(fm10k_read_reg(hw, FM10K_EICR) & FM10K_EICR_VFLR)) 172 goto read_unlock; 173 174 /* read VFLRE to determine if any VFs have been reset */ 175 vflre = fm10k_read_reg(hw, FM10K_PFVFLRE(1)); 176 vflre <<= 32; 177 vflre |= fm10k_read_reg(hw, FM10K_PFVFLRE(0)); 178 179 i = iov_data->num_vfs; 180 181 for (vflre <<= 64 - i; vflre && i--; vflre += vflre) { 182 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 183 184 if (vflre >= 0) 185 continue; 186 187 hw->iov.ops.reset_resources(hw, vf_info); 188 vf_info->mbx.ops.connect(hw, &vf_info->mbx); 189 } 190 191 read_unlock: 192 rcu_read_unlock(); 193 194 return 0; 195 } 196 197 s32 fm10k_iov_mbx(struct fm10k_intfc *interface) 198 { 199 struct fm10k_hw *hw = &interface->hw; 200 struct fm10k_iov_data *iov_data; 201 int i; 202 203 /* if there is no iov_data then there is no mailbox to process */ 204 if (!READ_ONCE(interface->iov_data)) 205 return 0; 206 207 rcu_read_lock(); 208 209 iov_data = interface->iov_data; 210 211 /* check again now that we are in the RCU block */ 212 if (!iov_data) 213 goto read_unlock; 214 215 /* lock the mailbox for transmit and receive */ 216 fm10k_mbx_lock(interface); 217 218 /* Most VF messages sent to the PF cause the PF to respond by 219 * requesting from the SM mailbox. This means that too many VF 220 * messages processed at once could cause a mailbox timeout on the PF. 221 * To prevent this, store a pointer to the next VF mbx to process. Use 222 * that as the start of the loop so that we don't starve whichever VF 223 * got ignored on the previous run. 224 */ 225 process_mbx: 226 for (i = iov_data->next_vf_mbx ? : iov_data->num_vfs; i--;) { 227 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 228 struct fm10k_mbx_info *mbx = &vf_info->mbx; 229 u16 glort = vf_info->glort; 230 231 /* process the SM mailbox first to drain outgoing messages */ 232 hw->mbx.ops.process(hw, &hw->mbx); 233 234 /* verify port mapping is valid, if not reset port */ 235 if (vf_info->vf_flags && !fm10k_glort_valid_pf(hw, glort)) { 236 hw->iov.ops.reset_lport(hw, vf_info); 237 fm10k_clear_macvlan_queue(interface, glort, false); 238 } 239 240 /* reset VFs that have mailbox timed out */ 241 if (!mbx->timeout) { 242 hw->iov.ops.reset_resources(hw, vf_info); 243 mbx->ops.connect(hw, mbx); 244 } 245 246 /* guarantee we have free space in the SM mailbox */ 247 if (hw->mbx.state == FM10K_STATE_OPEN && 248 !hw->mbx.ops.tx_ready(&hw->mbx, FM10K_VFMBX_MSG_MTU)) { 249 /* keep track of how many times this occurs */ 250 interface->hw_sm_mbx_full++; 251 252 /* make sure we try again momentarily */ 253 fm10k_service_event_schedule(interface); 254 255 break; 256 } 257 258 /* cleanup mailbox and process received messages */ 259 mbx->ops.process(hw, mbx); 260 } 261 262 /* if we stopped processing mailboxes early, update next_vf_mbx. 263 * Otherwise, reset next_vf_mbx, and restart loop so that we process 264 * the remaining mailboxes we skipped at the start. 265 */ 266 if (i >= 0) { 267 iov_data->next_vf_mbx = i + 1; 268 } else if (iov_data->next_vf_mbx) { 269 iov_data->next_vf_mbx = 0; 270 goto process_mbx; 271 } 272 273 /* free the lock */ 274 fm10k_mbx_unlock(interface); 275 276 read_unlock: 277 rcu_read_unlock(); 278 279 return 0; 280 } 281 282 void fm10k_iov_suspend(struct pci_dev *pdev) 283 { 284 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 285 struct fm10k_iov_data *iov_data = interface->iov_data; 286 struct fm10k_hw *hw = &interface->hw; 287 int num_vfs, i; 288 289 /* pull out num_vfs from iov_data */ 290 num_vfs = iov_data ? iov_data->num_vfs : 0; 291 292 /* shut down queue mapping for VFs */ 293 fm10k_write_reg(hw, FM10K_DGLORTMAP(fm10k_dglort_vf_rss), 294 FM10K_DGLORTMAP_NONE); 295 296 /* Stop any active VFs and reset their resources */ 297 for (i = 0; i < num_vfs; i++) { 298 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 299 300 hw->iov.ops.reset_resources(hw, vf_info); 301 hw->iov.ops.reset_lport(hw, vf_info); 302 fm10k_clear_macvlan_queue(interface, vf_info->glort, false); 303 } 304 } 305 306 static void fm10k_mask_aer_comp_abort(struct pci_dev *pdev) 307 { 308 u32 err_mask; 309 int pos; 310 311 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR); 312 if (!pos) 313 return; 314 315 /* Mask the completion abort bit in the ERR_UNCOR_MASK register, 316 * preventing the device from reporting these errors to the upstream 317 * PCIe root device. This avoids bringing down platforms which upgrade 318 * non-fatal completer aborts into machine check exceptions. Completer 319 * aborts can occur whenever a VF reads a queue it doesn't own. 320 */ 321 pci_read_config_dword(pdev, pos + PCI_ERR_UNCOR_MASK, &err_mask); 322 err_mask |= PCI_ERR_UNC_COMP_ABORT; 323 pci_write_config_dword(pdev, pos + PCI_ERR_UNCOR_MASK, err_mask); 324 325 mmiowb(); 326 } 327 328 int fm10k_iov_resume(struct pci_dev *pdev) 329 { 330 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 331 struct fm10k_iov_data *iov_data = interface->iov_data; 332 struct fm10k_dglort_cfg dglort = { 0 }; 333 struct fm10k_hw *hw = &interface->hw; 334 int num_vfs, i; 335 336 /* pull out num_vfs from iov_data */ 337 num_vfs = iov_data ? iov_data->num_vfs : 0; 338 339 /* return error if iov_data is not already populated */ 340 if (!iov_data) 341 return -ENOMEM; 342 343 /* Lower severity of completer abort error reporting as 344 * the VFs can trigger this any time they read a queue 345 * that they don't own. 346 */ 347 fm10k_mask_aer_comp_abort(pdev); 348 349 /* allocate hardware resources for the VFs */ 350 hw->iov.ops.assign_resources(hw, num_vfs, num_vfs); 351 352 /* configure DGLORT mapping for RSS */ 353 dglort.glort = hw->mac.dglort_map & FM10K_DGLORTMAP_NONE; 354 dglort.idx = fm10k_dglort_vf_rss; 355 dglort.inner_rss = 1; 356 dglort.rss_l = fls(fm10k_queues_per_pool(hw) - 1); 357 dglort.queue_b = fm10k_vf_queue_index(hw, 0); 358 dglort.vsi_l = fls(hw->iov.total_vfs - 1); 359 dglort.vsi_b = 1; 360 361 hw->mac.ops.configure_dglort_map(hw, &dglort); 362 363 /* assign resources to the device */ 364 for (i = 0; i < num_vfs; i++) { 365 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 366 367 /* allocate all but the last GLORT to the VFs */ 368 if (i == (~hw->mac.dglort_map >> FM10K_DGLORTMAP_MASK_SHIFT)) 369 break; 370 371 /* assign GLORT to VF, and restrict it to multicast */ 372 hw->iov.ops.set_lport(hw, vf_info, i, 373 FM10K_VF_FLAG_MULTI_CAPABLE); 374 375 /* mailbox is disconnected so we don't send a message */ 376 hw->iov.ops.assign_default_mac_vlan(hw, vf_info); 377 378 /* now we are ready so we can connect */ 379 vf_info->mbx.ops.connect(hw, &vf_info->mbx); 380 } 381 382 return 0; 383 } 384 385 s32 fm10k_iov_update_pvid(struct fm10k_intfc *interface, u16 glort, u16 pvid) 386 { 387 struct fm10k_iov_data *iov_data = interface->iov_data; 388 struct fm10k_hw *hw = &interface->hw; 389 struct fm10k_vf_info *vf_info; 390 u16 vf_idx = (glort - hw->mac.dglort_map) & FM10K_DGLORTMAP_NONE; 391 392 /* no IOV support, not our message to process */ 393 if (!iov_data) 394 return FM10K_ERR_PARAM; 395 396 /* glort outside our range, not our message to process */ 397 if (vf_idx >= iov_data->num_vfs) 398 return FM10K_ERR_PARAM; 399 400 /* determine if an update has occurred and if so notify the VF */ 401 vf_info = &iov_data->vf_info[vf_idx]; 402 if (vf_info->sw_vid != pvid) { 403 vf_info->sw_vid = pvid; 404 hw->iov.ops.assign_default_mac_vlan(hw, vf_info); 405 } 406 407 return 0; 408 } 409 410 static void fm10k_iov_free_data(struct pci_dev *pdev) 411 { 412 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 413 414 if (!interface->iov_data) 415 return; 416 417 /* reclaim hardware resources */ 418 fm10k_iov_suspend(pdev); 419 420 /* drop iov_data from interface */ 421 kfree_rcu(interface->iov_data, rcu); 422 interface->iov_data = NULL; 423 } 424 425 static s32 fm10k_iov_alloc_data(struct pci_dev *pdev, int num_vfs) 426 { 427 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 428 struct fm10k_iov_data *iov_data = interface->iov_data; 429 struct fm10k_hw *hw = &interface->hw; 430 size_t size; 431 int i, err; 432 433 /* return error if iov_data is already populated */ 434 if (iov_data) 435 return -EBUSY; 436 437 /* The PF should always be able to assign resources */ 438 if (!hw->iov.ops.assign_resources) 439 return -ENODEV; 440 441 /* nothing to do if no VFs are requested */ 442 if (!num_vfs) 443 return 0; 444 445 /* allocate memory for VF storage */ 446 size = offsetof(struct fm10k_iov_data, vf_info[num_vfs]); 447 iov_data = kzalloc(size, GFP_KERNEL); 448 if (!iov_data) 449 return -ENOMEM; 450 451 /* record number of VFs */ 452 iov_data->num_vfs = num_vfs; 453 454 /* loop through vf_info structures initializing each entry */ 455 for (i = 0; i < num_vfs; i++) { 456 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 457 458 /* Record VF VSI value */ 459 vf_info->vsi = i + 1; 460 vf_info->vf_idx = i; 461 462 /* initialize mailbox memory */ 463 err = fm10k_pfvf_mbx_init(hw, &vf_info->mbx, iov_mbx_data, i); 464 if (err) { 465 dev_err(&pdev->dev, 466 "Unable to initialize SR-IOV mailbox\n"); 467 kfree(iov_data); 468 return err; 469 } 470 } 471 472 /* assign iov_data to interface */ 473 interface->iov_data = iov_data; 474 475 /* allocate hardware resources for the VFs */ 476 fm10k_iov_resume(pdev); 477 478 return 0; 479 } 480 481 void fm10k_iov_disable(struct pci_dev *pdev) 482 { 483 if (pci_num_vf(pdev) && pci_vfs_assigned(pdev)) 484 dev_err(&pdev->dev, 485 "Cannot disable SR-IOV while VFs are assigned\n"); 486 else 487 pci_disable_sriov(pdev); 488 489 fm10k_iov_free_data(pdev); 490 } 491 492 int fm10k_iov_configure(struct pci_dev *pdev, int num_vfs) 493 { 494 int current_vfs = pci_num_vf(pdev); 495 int err = 0; 496 497 if (current_vfs && pci_vfs_assigned(pdev)) { 498 dev_err(&pdev->dev, 499 "Cannot modify SR-IOV while VFs are assigned\n"); 500 num_vfs = current_vfs; 501 } else { 502 pci_disable_sriov(pdev); 503 fm10k_iov_free_data(pdev); 504 } 505 506 /* allocate resources for the VFs */ 507 err = fm10k_iov_alloc_data(pdev, num_vfs); 508 if (err) 509 return err; 510 511 /* allocate VFs if not already allocated */ 512 if (num_vfs && num_vfs != current_vfs) { 513 err = pci_enable_sriov(pdev, num_vfs); 514 if (err) { 515 dev_err(&pdev->dev, 516 "Enable PCI SR-IOV failed: %d\n", err); 517 return err; 518 } 519 } 520 521 return num_vfs; 522 } 523 524 static inline void fm10k_reset_vf_info(struct fm10k_intfc *interface, 525 struct fm10k_vf_info *vf_info) 526 { 527 struct fm10k_hw *hw = &interface->hw; 528 529 /* assigning the MAC address will send a mailbox message */ 530 fm10k_mbx_lock(interface); 531 532 /* disable LPORT for this VF which clears switch rules */ 533 hw->iov.ops.reset_lport(hw, vf_info); 534 535 fm10k_clear_macvlan_queue(interface, vf_info->glort, false); 536 537 /* assign new MAC+VLAN for this VF */ 538 hw->iov.ops.assign_default_mac_vlan(hw, vf_info); 539 540 /* re-enable the LPORT for this VF */ 541 hw->iov.ops.set_lport(hw, vf_info, vf_info->vf_idx, 542 FM10K_VF_FLAG_MULTI_CAPABLE); 543 544 fm10k_mbx_unlock(interface); 545 } 546 547 int fm10k_ndo_set_vf_mac(struct net_device *netdev, int vf_idx, u8 *mac) 548 { 549 struct fm10k_intfc *interface = netdev_priv(netdev); 550 struct fm10k_iov_data *iov_data = interface->iov_data; 551 struct fm10k_vf_info *vf_info; 552 553 /* verify SR-IOV is active and that vf idx is valid */ 554 if (!iov_data || vf_idx >= iov_data->num_vfs) 555 return -EINVAL; 556 557 /* verify MAC addr is valid */ 558 if (!is_zero_ether_addr(mac) && !is_valid_ether_addr(mac)) 559 return -EINVAL; 560 561 /* record new MAC address */ 562 vf_info = &iov_data->vf_info[vf_idx]; 563 ether_addr_copy(vf_info->mac, mac); 564 565 fm10k_reset_vf_info(interface, vf_info); 566 567 return 0; 568 } 569 570 int fm10k_ndo_set_vf_vlan(struct net_device *netdev, int vf_idx, u16 vid, 571 u8 qos, __be16 vlan_proto) 572 { 573 struct fm10k_intfc *interface = netdev_priv(netdev); 574 struct fm10k_iov_data *iov_data = interface->iov_data; 575 struct fm10k_hw *hw = &interface->hw; 576 struct fm10k_vf_info *vf_info; 577 578 /* verify SR-IOV is active and that vf idx is valid */ 579 if (!iov_data || vf_idx >= iov_data->num_vfs) 580 return -EINVAL; 581 582 /* QOS is unsupported and VLAN IDs accepted range 0-4094 */ 583 if (qos || (vid > (VLAN_VID_MASK - 1))) 584 return -EINVAL; 585 586 /* VF VLAN Protocol part to default is unsupported */ 587 if (vlan_proto != htons(ETH_P_8021Q)) 588 return -EPROTONOSUPPORT; 589 590 vf_info = &iov_data->vf_info[vf_idx]; 591 592 /* exit if there is nothing to do */ 593 if (vf_info->pf_vid == vid) 594 return 0; 595 596 /* record default VLAN ID for VF */ 597 vf_info->pf_vid = vid; 598 599 /* Clear the VLAN table for the VF */ 600 hw->mac.ops.update_vlan(hw, FM10K_VLAN_ALL, vf_info->vsi, false); 601 602 fm10k_reset_vf_info(interface, vf_info); 603 604 return 0; 605 } 606 607 int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx, 608 int __always_unused min_rate, int max_rate) 609 { 610 struct fm10k_intfc *interface = netdev_priv(netdev); 611 struct fm10k_iov_data *iov_data = interface->iov_data; 612 struct fm10k_hw *hw = &interface->hw; 613 614 /* verify SR-IOV is active and that vf idx is valid */ 615 if (!iov_data || vf_idx >= iov_data->num_vfs) 616 return -EINVAL; 617 618 /* rate limit cannot be less than 10Mbs or greater than link speed */ 619 if (max_rate && 620 (max_rate < FM10K_VF_TC_MIN || max_rate > FM10K_VF_TC_MAX)) 621 return -EINVAL; 622 623 /* store values */ 624 iov_data->vf_info[vf_idx].rate = max_rate; 625 626 /* update hardware configuration */ 627 hw->iov.ops.configure_tc(hw, vf_idx, max_rate); 628 629 return 0; 630 } 631 632 int fm10k_ndo_get_vf_config(struct net_device *netdev, 633 int vf_idx, struct ifla_vf_info *ivi) 634 { 635 struct fm10k_intfc *interface = netdev_priv(netdev); 636 struct fm10k_iov_data *iov_data = interface->iov_data; 637 struct fm10k_vf_info *vf_info; 638 639 /* verify SR-IOV is active and that vf idx is valid */ 640 if (!iov_data || vf_idx >= iov_data->num_vfs) 641 return -EINVAL; 642 643 vf_info = &iov_data->vf_info[vf_idx]; 644 645 ivi->vf = vf_idx; 646 ivi->max_tx_rate = vf_info->rate; 647 ivi->min_tx_rate = 0; 648 ether_addr_copy(ivi->mac, vf_info->mac); 649 ivi->vlan = vf_info->pf_vid; 650 ivi->qos = 0; 651 652 return 0; 653 } 654