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