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