1 /* 2 * drivers/pci/iov.c 3 * 4 * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com> 5 * 6 * PCI Express I/O Virtualization (IOV) support. 7 * Single Root IOV 1.0 8 * Address Translation Service 1.0 9 */ 10 11 #include <linux/pci.h> 12 #include <linux/slab.h> 13 #include <linux/mutex.h> 14 #include <linux/export.h> 15 #include <linux/string.h> 16 #include <linux/delay.h> 17 #include <linux/pci-ats.h> 18 #include "pci.h" 19 20 #define VIRTFN_ID_LEN 16 21 22 int pci_iov_virtfn_bus(struct pci_dev *dev, int vf_id) 23 { 24 if (!dev->is_physfn) 25 return -EINVAL; 26 return dev->bus->number + ((dev->devfn + dev->sriov->offset + 27 dev->sriov->stride * vf_id) >> 8); 28 } 29 30 int pci_iov_virtfn_devfn(struct pci_dev *dev, int vf_id) 31 { 32 if (!dev->is_physfn) 33 return -EINVAL; 34 return (dev->devfn + dev->sriov->offset + 35 dev->sriov->stride * vf_id) & 0xff; 36 } 37 38 /* 39 * Per SR-IOV spec sec 3.3.10 and 3.3.11, First VF Offset and VF Stride may 40 * change when NumVFs changes. 41 * 42 * Update iov->offset and iov->stride when NumVFs is written. 43 */ 44 static inline void pci_iov_set_numvfs(struct pci_dev *dev, int nr_virtfn) 45 { 46 struct pci_sriov *iov = dev->sriov; 47 48 pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn); 49 pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &iov->offset); 50 pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &iov->stride); 51 } 52 53 /* 54 * The PF consumes one bus number. NumVFs, First VF Offset, and VF Stride 55 * determine how many additional bus numbers will be consumed by VFs. 56 * 57 * Iterate over all valid NumVFs, validate offset and stride, and calculate 58 * the maximum number of bus numbers that could ever be required. 59 */ 60 static int compute_max_vf_buses(struct pci_dev *dev) 61 { 62 struct pci_sriov *iov = dev->sriov; 63 int nr_virtfn, busnr, rc = 0; 64 65 for (nr_virtfn = iov->total_VFs; nr_virtfn; nr_virtfn--) { 66 pci_iov_set_numvfs(dev, nr_virtfn); 67 if (!iov->offset || (nr_virtfn > 1 && !iov->stride)) { 68 rc = -EIO; 69 goto out; 70 } 71 72 busnr = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 73 if (busnr > iov->max_VF_buses) 74 iov->max_VF_buses = busnr; 75 } 76 77 out: 78 pci_iov_set_numvfs(dev, 0); 79 return rc; 80 } 81 82 static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr) 83 { 84 struct pci_bus *child; 85 86 if (bus->number == busnr) 87 return bus; 88 89 child = pci_find_bus(pci_domain_nr(bus), busnr); 90 if (child) 91 return child; 92 93 child = pci_add_new_bus(bus, NULL, busnr); 94 if (!child) 95 return NULL; 96 97 pci_bus_insert_busn_res(child, busnr, busnr); 98 99 return child; 100 } 101 102 static void virtfn_remove_bus(struct pci_bus *physbus, struct pci_bus *virtbus) 103 { 104 if (physbus != virtbus && list_empty(&virtbus->devices)) 105 pci_remove_bus(virtbus); 106 } 107 108 resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno) 109 { 110 if (!dev->is_physfn) 111 return 0; 112 113 return dev->sriov->barsz[resno - PCI_IOV_RESOURCES]; 114 } 115 116 static int virtfn_add(struct pci_dev *dev, int id, int reset) 117 { 118 int i; 119 int rc = -ENOMEM; 120 u64 size; 121 char buf[VIRTFN_ID_LEN]; 122 struct pci_dev *virtfn; 123 struct resource *res; 124 struct pci_sriov *iov = dev->sriov; 125 struct pci_bus *bus; 126 127 mutex_lock(&iov->dev->sriov->lock); 128 bus = virtfn_add_bus(dev->bus, pci_iov_virtfn_bus(dev, id)); 129 if (!bus) 130 goto failed; 131 132 virtfn = pci_alloc_dev(bus); 133 if (!virtfn) 134 goto failed0; 135 136 virtfn->devfn = pci_iov_virtfn_devfn(dev, id); 137 virtfn->vendor = dev->vendor; 138 pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device); 139 pci_setup_device(virtfn); 140 virtfn->dev.parent = dev->dev.parent; 141 virtfn->physfn = pci_dev_get(dev); 142 virtfn->is_virtfn = 1; 143 virtfn->multifunction = 0; 144 145 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 146 res = &dev->resource[i + PCI_IOV_RESOURCES]; 147 if (!res->parent) 148 continue; 149 virtfn->resource[i].name = pci_name(virtfn); 150 virtfn->resource[i].flags = res->flags; 151 size = pci_iov_resource_size(dev, i + PCI_IOV_RESOURCES); 152 virtfn->resource[i].start = res->start + size * id; 153 virtfn->resource[i].end = virtfn->resource[i].start + size - 1; 154 rc = request_resource(res, &virtfn->resource[i]); 155 BUG_ON(rc); 156 } 157 158 if (reset) 159 __pci_reset_function(virtfn); 160 161 pci_device_add(virtfn, virtfn->bus); 162 mutex_unlock(&iov->dev->sriov->lock); 163 164 pci_bus_add_device(virtfn); 165 sprintf(buf, "virtfn%u", id); 166 rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf); 167 if (rc) 168 goto failed1; 169 rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn"); 170 if (rc) 171 goto failed2; 172 173 kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE); 174 175 return 0; 176 177 failed2: 178 sysfs_remove_link(&dev->dev.kobj, buf); 179 failed1: 180 pci_dev_put(dev); 181 mutex_lock(&iov->dev->sriov->lock); 182 pci_stop_and_remove_bus_device(virtfn); 183 failed0: 184 virtfn_remove_bus(dev->bus, bus); 185 failed: 186 mutex_unlock(&iov->dev->sriov->lock); 187 188 return rc; 189 } 190 191 static void virtfn_remove(struct pci_dev *dev, int id, int reset) 192 { 193 char buf[VIRTFN_ID_LEN]; 194 struct pci_dev *virtfn; 195 struct pci_sriov *iov = dev->sriov; 196 197 virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus), 198 pci_iov_virtfn_bus(dev, id), 199 pci_iov_virtfn_devfn(dev, id)); 200 if (!virtfn) 201 return; 202 203 if (reset) { 204 device_release_driver(&virtfn->dev); 205 __pci_reset_function(virtfn); 206 } 207 208 sprintf(buf, "virtfn%u", id); 209 sysfs_remove_link(&dev->dev.kobj, buf); 210 /* 211 * pci_stop_dev() could have been called for this virtfn already, 212 * so the directory for the virtfn may have been removed before. 213 * Double check to avoid spurious sysfs warnings. 214 */ 215 if (virtfn->dev.kobj.sd) 216 sysfs_remove_link(&virtfn->dev.kobj, "physfn"); 217 218 mutex_lock(&iov->dev->sriov->lock); 219 pci_stop_and_remove_bus_device(virtfn); 220 virtfn_remove_bus(dev->bus, virtfn->bus); 221 mutex_unlock(&iov->dev->sriov->lock); 222 223 /* balance pci_get_domain_bus_and_slot() */ 224 pci_dev_put(virtfn); 225 pci_dev_put(dev); 226 } 227 228 int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs) 229 { 230 return 0; 231 } 232 233 int __weak pcibios_sriov_disable(struct pci_dev *pdev) 234 { 235 return 0; 236 } 237 238 static int sriov_enable(struct pci_dev *dev, int nr_virtfn) 239 { 240 int rc; 241 int i; 242 int nres; 243 u16 initial; 244 struct resource *res; 245 struct pci_dev *pdev; 246 struct pci_sriov *iov = dev->sriov; 247 int bars = 0; 248 int bus; 249 250 if (!nr_virtfn) 251 return 0; 252 253 if (iov->num_VFs) 254 return -EINVAL; 255 256 pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial); 257 if (initial > iov->total_VFs || 258 (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs))) 259 return -EIO; 260 261 if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs || 262 (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial))) 263 return -EINVAL; 264 265 nres = 0; 266 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 267 bars |= (1 << (i + PCI_IOV_RESOURCES)); 268 res = &dev->resource[i + PCI_IOV_RESOURCES]; 269 if (res->parent) 270 nres++; 271 } 272 if (nres != iov->nres) { 273 dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n"); 274 return -ENOMEM; 275 } 276 277 bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 278 if (bus > dev->bus->busn_res.end) { 279 dev_err(&dev->dev, "can't enable %d VFs (bus %02x out of range of %pR)\n", 280 nr_virtfn, bus, &dev->bus->busn_res); 281 return -ENOMEM; 282 } 283 284 if (pci_enable_resources(dev, bars)) { 285 dev_err(&dev->dev, "SR-IOV: IOV BARS not allocated\n"); 286 return -ENOMEM; 287 } 288 289 if (iov->link != dev->devfn) { 290 pdev = pci_get_slot(dev->bus, iov->link); 291 if (!pdev) 292 return -ENODEV; 293 294 if (!pdev->is_physfn) { 295 pci_dev_put(pdev); 296 return -ENOSYS; 297 } 298 299 rc = sysfs_create_link(&dev->dev.kobj, 300 &pdev->dev.kobj, "dep_link"); 301 pci_dev_put(pdev); 302 if (rc) 303 return rc; 304 } 305 306 pci_iov_set_numvfs(dev, nr_virtfn); 307 iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE; 308 pci_cfg_access_lock(dev); 309 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 310 msleep(100); 311 pci_cfg_access_unlock(dev); 312 313 iov->initial_VFs = initial; 314 if (nr_virtfn < initial) 315 initial = nr_virtfn; 316 317 rc = pcibios_sriov_enable(dev, initial); 318 if (rc) { 319 dev_err(&dev->dev, "failure %d from pcibios_sriov_enable()\n", rc); 320 goto err_pcibios; 321 } 322 323 for (i = 0; i < initial; i++) { 324 rc = virtfn_add(dev, i, 0); 325 if (rc) 326 goto failed; 327 } 328 329 kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE); 330 iov->num_VFs = nr_virtfn; 331 332 return 0; 333 334 failed: 335 while (i--) 336 virtfn_remove(dev, i, 0); 337 338 pcibios_sriov_disable(dev); 339 err_pcibios: 340 iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 341 pci_cfg_access_lock(dev); 342 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 343 ssleep(1); 344 pci_cfg_access_unlock(dev); 345 346 if (iov->link != dev->devfn) 347 sysfs_remove_link(&dev->dev.kobj, "dep_link"); 348 349 pci_iov_set_numvfs(dev, 0); 350 return rc; 351 } 352 353 static void sriov_disable(struct pci_dev *dev) 354 { 355 int i; 356 struct pci_sriov *iov = dev->sriov; 357 358 if (!iov->num_VFs) 359 return; 360 361 for (i = 0; i < iov->num_VFs; i++) 362 virtfn_remove(dev, i, 0); 363 364 pcibios_sriov_disable(dev); 365 366 iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 367 pci_cfg_access_lock(dev); 368 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 369 ssleep(1); 370 pci_cfg_access_unlock(dev); 371 372 if (iov->link != dev->devfn) 373 sysfs_remove_link(&dev->dev.kobj, "dep_link"); 374 375 iov->num_VFs = 0; 376 pci_iov_set_numvfs(dev, 0); 377 } 378 379 static int sriov_init(struct pci_dev *dev, int pos) 380 { 381 int i, bar64; 382 int rc; 383 int nres; 384 u32 pgsz; 385 u16 ctrl, total; 386 struct pci_sriov *iov; 387 struct resource *res; 388 struct pci_dev *pdev; 389 390 if (pci_pcie_type(dev) != PCI_EXP_TYPE_RC_END && 391 pci_pcie_type(dev) != PCI_EXP_TYPE_ENDPOINT) 392 return -ENODEV; 393 394 pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl); 395 if (ctrl & PCI_SRIOV_CTRL_VFE) { 396 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0); 397 ssleep(1); 398 } 399 400 ctrl = 0; 401 list_for_each_entry(pdev, &dev->bus->devices, bus_list) 402 if (pdev->is_physfn) 403 goto found; 404 405 pdev = NULL; 406 if (pci_ari_enabled(dev->bus)) 407 ctrl |= PCI_SRIOV_CTRL_ARI; 408 409 found: 410 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl); 411 412 pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total); 413 if (!total) 414 return 0; 415 416 pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz); 417 i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0; 418 pgsz &= ~((1 << i) - 1); 419 if (!pgsz) 420 return -EIO; 421 422 pgsz &= ~(pgsz - 1); 423 pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz); 424 425 iov = kzalloc(sizeof(*iov), GFP_KERNEL); 426 if (!iov) 427 return -ENOMEM; 428 429 nres = 0; 430 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 431 res = &dev->resource[i + PCI_IOV_RESOURCES]; 432 /* 433 * If it is already FIXED, don't change it, something 434 * (perhaps EA or header fixups) wants it this way. 435 */ 436 if (res->flags & IORESOURCE_PCI_FIXED) 437 bar64 = (res->flags & IORESOURCE_MEM_64) ? 1 : 0; 438 else 439 bar64 = __pci_read_base(dev, pci_bar_unknown, res, 440 pos + PCI_SRIOV_BAR + i * 4); 441 if (!res->flags) 442 continue; 443 if (resource_size(res) & (PAGE_SIZE - 1)) { 444 rc = -EIO; 445 goto failed; 446 } 447 iov->barsz[i] = resource_size(res); 448 res->end = res->start + resource_size(res) * total - 1; 449 dev_info(&dev->dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n", 450 i, res, i, total); 451 i += bar64; 452 nres++; 453 } 454 455 iov->pos = pos; 456 iov->nres = nres; 457 iov->ctrl = ctrl; 458 iov->total_VFs = total; 459 iov->pgsz = pgsz; 460 iov->self = dev; 461 pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap); 462 pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link); 463 if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END) 464 iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link); 465 466 if (pdev) 467 iov->dev = pci_dev_get(pdev); 468 else 469 iov->dev = dev; 470 471 mutex_init(&iov->lock); 472 473 dev->sriov = iov; 474 dev->is_physfn = 1; 475 rc = compute_max_vf_buses(dev); 476 if (rc) 477 goto fail_max_buses; 478 479 return 0; 480 481 fail_max_buses: 482 dev->sriov = NULL; 483 dev->is_physfn = 0; 484 failed: 485 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 486 res = &dev->resource[i + PCI_IOV_RESOURCES]; 487 res->flags = 0; 488 } 489 490 kfree(iov); 491 return rc; 492 } 493 494 static void sriov_release(struct pci_dev *dev) 495 { 496 BUG_ON(dev->sriov->num_VFs); 497 498 if (dev != dev->sriov->dev) 499 pci_dev_put(dev->sriov->dev); 500 501 mutex_destroy(&dev->sriov->lock); 502 503 kfree(dev->sriov); 504 dev->sriov = NULL; 505 } 506 507 static void sriov_restore_state(struct pci_dev *dev) 508 { 509 int i; 510 u16 ctrl; 511 struct pci_sriov *iov = dev->sriov; 512 513 pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl); 514 if (ctrl & PCI_SRIOV_CTRL_VFE) 515 return; 516 517 for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++) 518 pci_update_resource(dev, i); 519 520 pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz); 521 pci_iov_set_numvfs(dev, iov->num_VFs); 522 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 523 if (iov->ctrl & PCI_SRIOV_CTRL_VFE) 524 msleep(100); 525 } 526 527 /** 528 * pci_iov_init - initialize the IOV capability 529 * @dev: the PCI device 530 * 531 * Returns 0 on success, or negative on failure. 532 */ 533 int pci_iov_init(struct pci_dev *dev) 534 { 535 int pos; 536 537 if (!pci_is_pcie(dev)) 538 return -ENODEV; 539 540 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV); 541 if (pos) 542 return sriov_init(dev, pos); 543 544 return -ENODEV; 545 } 546 547 /** 548 * pci_iov_release - release resources used by the IOV capability 549 * @dev: the PCI device 550 */ 551 void pci_iov_release(struct pci_dev *dev) 552 { 553 if (dev->is_physfn) 554 sriov_release(dev); 555 } 556 557 /** 558 * pci_iov_resource_bar - get position of the SR-IOV BAR 559 * @dev: the PCI device 560 * @resno: the resource number 561 * 562 * Returns position of the BAR encapsulated in the SR-IOV capability. 563 */ 564 int pci_iov_resource_bar(struct pci_dev *dev, int resno) 565 { 566 if (resno < PCI_IOV_RESOURCES || resno > PCI_IOV_RESOURCE_END) 567 return 0; 568 569 BUG_ON(!dev->is_physfn); 570 571 return dev->sriov->pos + PCI_SRIOV_BAR + 572 4 * (resno - PCI_IOV_RESOURCES); 573 } 574 575 resource_size_t __weak pcibios_iov_resource_alignment(struct pci_dev *dev, 576 int resno) 577 { 578 return pci_iov_resource_size(dev, resno); 579 } 580 581 /** 582 * pci_sriov_resource_alignment - get resource alignment for VF BAR 583 * @dev: the PCI device 584 * @resno: the resource number 585 * 586 * Returns the alignment of the VF BAR found in the SR-IOV capability. 587 * This is not the same as the resource size which is defined as 588 * the VF BAR size multiplied by the number of VFs. The alignment 589 * is just the VF BAR size. 590 */ 591 resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno) 592 { 593 return pcibios_iov_resource_alignment(dev, resno); 594 } 595 596 /** 597 * pci_restore_iov_state - restore the state of the IOV capability 598 * @dev: the PCI device 599 */ 600 void pci_restore_iov_state(struct pci_dev *dev) 601 { 602 if (dev->is_physfn) 603 sriov_restore_state(dev); 604 } 605 606 /** 607 * pci_iov_bus_range - find bus range used by Virtual Function 608 * @bus: the PCI bus 609 * 610 * Returns max number of buses (exclude current one) used by Virtual 611 * Functions. 612 */ 613 int pci_iov_bus_range(struct pci_bus *bus) 614 { 615 int max = 0; 616 struct pci_dev *dev; 617 618 list_for_each_entry(dev, &bus->devices, bus_list) { 619 if (!dev->is_physfn) 620 continue; 621 if (dev->sriov->max_VF_buses > max) 622 max = dev->sriov->max_VF_buses; 623 } 624 625 return max ? max - bus->number : 0; 626 } 627 628 /** 629 * pci_enable_sriov - enable the SR-IOV capability 630 * @dev: the PCI device 631 * @nr_virtfn: number of virtual functions to enable 632 * 633 * Returns 0 on success, or negative on failure. 634 */ 635 int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn) 636 { 637 might_sleep(); 638 639 if (!dev->is_physfn) 640 return -ENOSYS; 641 642 return sriov_enable(dev, nr_virtfn); 643 } 644 EXPORT_SYMBOL_GPL(pci_enable_sriov); 645 646 /** 647 * pci_disable_sriov - disable the SR-IOV capability 648 * @dev: the PCI device 649 */ 650 void pci_disable_sriov(struct pci_dev *dev) 651 { 652 might_sleep(); 653 654 if (!dev->is_physfn) 655 return; 656 657 sriov_disable(dev); 658 } 659 EXPORT_SYMBOL_GPL(pci_disable_sriov); 660 661 /** 662 * pci_num_vf - return number of VFs associated with a PF device_release_driver 663 * @dev: the PCI device 664 * 665 * Returns number of VFs, or 0 if SR-IOV is not enabled. 666 */ 667 int pci_num_vf(struct pci_dev *dev) 668 { 669 if (!dev->is_physfn) 670 return 0; 671 672 return dev->sriov->num_VFs; 673 } 674 EXPORT_SYMBOL_GPL(pci_num_vf); 675 676 /** 677 * pci_vfs_assigned - returns number of VFs are assigned to a guest 678 * @dev: the PCI device 679 * 680 * Returns number of VFs belonging to this device that are assigned to a guest. 681 * If device is not a physical function returns 0. 682 */ 683 int pci_vfs_assigned(struct pci_dev *dev) 684 { 685 struct pci_dev *vfdev; 686 unsigned int vfs_assigned = 0; 687 unsigned short dev_id; 688 689 /* only search if we are a PF */ 690 if (!dev->is_physfn) 691 return 0; 692 693 /* 694 * determine the device ID for the VFs, the vendor ID will be the 695 * same as the PF so there is no need to check for that one 696 */ 697 pci_read_config_word(dev, dev->sriov->pos + PCI_SRIOV_VF_DID, &dev_id); 698 699 /* loop through all the VFs to see if we own any that are assigned */ 700 vfdev = pci_get_device(dev->vendor, dev_id, NULL); 701 while (vfdev) { 702 /* 703 * It is considered assigned if it is a virtual function with 704 * our dev as the physical function and the assigned bit is set 705 */ 706 if (vfdev->is_virtfn && (vfdev->physfn == dev) && 707 pci_is_dev_assigned(vfdev)) 708 vfs_assigned++; 709 710 vfdev = pci_get_device(dev->vendor, dev_id, vfdev); 711 } 712 713 return vfs_assigned; 714 } 715 EXPORT_SYMBOL_GPL(pci_vfs_assigned); 716 717 /** 718 * pci_sriov_set_totalvfs -- reduce the TotalVFs available 719 * @dev: the PCI PF device 720 * @numvfs: number that should be used for TotalVFs supported 721 * 722 * Should be called from PF driver's probe routine with 723 * device's mutex held. 724 * 725 * Returns 0 if PF is an SRIOV-capable device and 726 * value of numvfs valid. If not a PF return -ENOSYS; 727 * if numvfs is invalid return -EINVAL; 728 * if VFs already enabled, return -EBUSY. 729 */ 730 int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs) 731 { 732 if (!dev->is_physfn) 733 return -ENOSYS; 734 if (numvfs > dev->sriov->total_VFs) 735 return -EINVAL; 736 737 /* Shouldn't change if VFs already enabled */ 738 if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE) 739 return -EBUSY; 740 else 741 dev->sriov->driver_max_VFs = numvfs; 742 743 return 0; 744 } 745 EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs); 746 747 /** 748 * pci_sriov_get_totalvfs -- get total VFs supported on this device 749 * @dev: the PCI PF device 750 * 751 * For a PCIe device with SRIOV support, return the PCIe 752 * SRIOV capability value of TotalVFs or the value of driver_max_VFs 753 * if the driver reduced it. Otherwise 0. 754 */ 755 int pci_sriov_get_totalvfs(struct pci_dev *dev) 756 { 757 if (!dev->is_physfn) 758 return 0; 759 760 if (dev->sriov->driver_max_VFs) 761 return dev->sriov->driver_max_VFs; 762 763 return dev->sriov->total_VFs; 764 } 765 EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs); 766