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 static ssize_t sriov_totalvfs_show(struct device *dev, 244 struct device_attribute *attr, 245 char *buf) 246 { 247 struct pci_dev *pdev = to_pci_dev(dev); 248 249 return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev)); 250 } 251 252 static ssize_t sriov_numvfs_show(struct device *dev, 253 struct device_attribute *attr, 254 char *buf) 255 { 256 struct pci_dev *pdev = to_pci_dev(dev); 257 258 return sprintf(buf, "%u\n", pdev->sriov->num_VFs); 259 } 260 261 /* 262 * num_vfs > 0; number of VFs to enable 263 * num_vfs = 0; disable all VFs 264 * 265 * Note: SRIOV spec does not allow partial VF 266 * disable, so it's all or none. 267 */ 268 static ssize_t sriov_numvfs_store(struct device *dev, 269 struct device_attribute *attr, 270 const char *buf, size_t count) 271 { 272 struct pci_dev *pdev = to_pci_dev(dev); 273 int ret; 274 u16 num_vfs; 275 276 ret = kstrtou16(buf, 0, &num_vfs); 277 if (ret < 0) 278 return ret; 279 280 if (num_vfs > pci_sriov_get_totalvfs(pdev)) 281 return -ERANGE; 282 283 device_lock(&pdev->dev); 284 285 if (num_vfs == pdev->sriov->num_VFs) 286 goto exit; 287 288 /* is PF driver loaded w/callback */ 289 if (!pdev->driver || !pdev->driver->sriov_configure) { 290 pci_info(pdev, "Driver does not support SRIOV configuration via sysfs\n"); 291 ret = -ENOENT; 292 goto exit; 293 } 294 295 if (num_vfs == 0) { 296 /* disable VFs */ 297 ret = pdev->driver->sriov_configure(pdev, 0); 298 goto exit; 299 } 300 301 /* enable VFs */ 302 if (pdev->sriov->num_VFs) { 303 pci_warn(pdev, "%d VFs already enabled. Disable before enabling %d VFs\n", 304 pdev->sriov->num_VFs, num_vfs); 305 ret = -EBUSY; 306 goto exit; 307 } 308 309 ret = pdev->driver->sriov_configure(pdev, num_vfs); 310 if (ret < 0) 311 goto exit; 312 313 if (ret != num_vfs) 314 pci_warn(pdev, "%d VFs requested; only %d enabled\n", 315 num_vfs, ret); 316 317 exit: 318 device_unlock(&pdev->dev); 319 320 if (ret < 0) 321 return ret; 322 323 return count; 324 } 325 326 static ssize_t sriov_offset_show(struct device *dev, 327 struct device_attribute *attr, 328 char *buf) 329 { 330 struct pci_dev *pdev = to_pci_dev(dev); 331 332 return sprintf(buf, "%u\n", pdev->sriov->offset); 333 } 334 335 static ssize_t sriov_stride_show(struct device *dev, 336 struct device_attribute *attr, 337 char *buf) 338 { 339 struct pci_dev *pdev = to_pci_dev(dev); 340 341 return sprintf(buf, "%u\n", pdev->sriov->stride); 342 } 343 344 static ssize_t sriov_vf_device_show(struct device *dev, 345 struct device_attribute *attr, 346 char *buf) 347 { 348 struct pci_dev *pdev = to_pci_dev(dev); 349 350 return sprintf(buf, "%x\n", pdev->sriov->vf_device); 351 } 352 353 static ssize_t sriov_drivers_autoprobe_show(struct device *dev, 354 struct device_attribute *attr, 355 char *buf) 356 { 357 struct pci_dev *pdev = to_pci_dev(dev); 358 359 return sprintf(buf, "%u\n", pdev->sriov->drivers_autoprobe); 360 } 361 362 static ssize_t sriov_drivers_autoprobe_store(struct device *dev, 363 struct device_attribute *attr, 364 const char *buf, size_t count) 365 { 366 struct pci_dev *pdev = to_pci_dev(dev); 367 bool drivers_autoprobe; 368 369 if (kstrtobool(buf, &drivers_autoprobe) < 0) 370 return -EINVAL; 371 372 pdev->sriov->drivers_autoprobe = drivers_autoprobe; 373 374 return count; 375 } 376 377 static DEVICE_ATTR_RO(sriov_totalvfs); 378 static DEVICE_ATTR_RW(sriov_numvfs); 379 static DEVICE_ATTR_RO(sriov_offset); 380 static DEVICE_ATTR_RO(sriov_stride); 381 static DEVICE_ATTR_RO(sriov_vf_device); 382 static DEVICE_ATTR_RW(sriov_drivers_autoprobe); 383 384 static struct attribute *sriov_dev_attrs[] = { 385 &dev_attr_sriov_totalvfs.attr, 386 &dev_attr_sriov_numvfs.attr, 387 &dev_attr_sriov_offset.attr, 388 &dev_attr_sriov_stride.attr, 389 &dev_attr_sriov_vf_device.attr, 390 &dev_attr_sriov_drivers_autoprobe.attr, 391 NULL, 392 }; 393 394 static umode_t sriov_attrs_are_visible(struct kobject *kobj, 395 struct attribute *a, int n) 396 { 397 struct device *dev = kobj_to_dev(kobj); 398 399 if (!dev_is_pf(dev)) 400 return 0; 401 402 return a->mode; 403 } 404 405 const struct attribute_group sriov_dev_attr_group = { 406 .attrs = sriov_dev_attrs, 407 .is_visible = sriov_attrs_are_visible, 408 }; 409 410 int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs) 411 { 412 return 0; 413 } 414 415 int __weak pcibios_sriov_disable(struct pci_dev *pdev) 416 { 417 return 0; 418 } 419 420 static int sriov_add_vfs(struct pci_dev *dev, u16 num_vfs) 421 { 422 unsigned int i; 423 int rc; 424 425 if (dev->no_vf_scan) 426 return 0; 427 428 for (i = 0; i < num_vfs; i++) { 429 rc = pci_iov_add_virtfn(dev, i); 430 if (rc) 431 goto failed; 432 } 433 return 0; 434 failed: 435 while (i--) 436 pci_iov_remove_virtfn(dev, i); 437 438 return rc; 439 } 440 441 static int sriov_enable(struct pci_dev *dev, int nr_virtfn) 442 { 443 int rc; 444 int i; 445 int nres; 446 u16 initial; 447 struct resource *res; 448 struct pci_dev *pdev; 449 struct pci_sriov *iov = dev->sriov; 450 int bars = 0; 451 int bus; 452 453 if (!nr_virtfn) 454 return 0; 455 456 if (iov->num_VFs) 457 return -EINVAL; 458 459 pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial); 460 if (initial > iov->total_VFs || 461 (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs))) 462 return -EIO; 463 464 if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs || 465 (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial))) 466 return -EINVAL; 467 468 nres = 0; 469 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 470 bars |= (1 << (i + PCI_IOV_RESOURCES)); 471 res = &dev->resource[i + PCI_IOV_RESOURCES]; 472 if (res->parent) 473 nres++; 474 } 475 if (nres != iov->nres) { 476 pci_err(dev, "not enough MMIO resources for SR-IOV\n"); 477 return -ENOMEM; 478 } 479 480 bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 481 if (bus > dev->bus->busn_res.end) { 482 pci_err(dev, "can't enable %d VFs (bus %02x out of range of %pR)\n", 483 nr_virtfn, bus, &dev->bus->busn_res); 484 return -ENOMEM; 485 } 486 487 if (pci_enable_resources(dev, bars)) { 488 pci_err(dev, "SR-IOV: IOV BARS not allocated\n"); 489 return -ENOMEM; 490 } 491 492 if (iov->link != dev->devfn) { 493 pdev = pci_get_slot(dev->bus, iov->link); 494 if (!pdev) 495 return -ENODEV; 496 497 if (!pdev->is_physfn) { 498 pci_dev_put(pdev); 499 return -ENOSYS; 500 } 501 502 rc = sysfs_create_link(&dev->dev.kobj, 503 &pdev->dev.kobj, "dep_link"); 504 pci_dev_put(pdev); 505 if (rc) 506 return rc; 507 } 508 509 iov->initial_VFs = initial; 510 if (nr_virtfn < initial) 511 initial = nr_virtfn; 512 513 rc = pcibios_sriov_enable(dev, initial); 514 if (rc) { 515 pci_err(dev, "failure %d from pcibios_sriov_enable()\n", rc); 516 goto err_pcibios; 517 } 518 519 pci_iov_set_numvfs(dev, nr_virtfn); 520 iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE; 521 pci_cfg_access_lock(dev); 522 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 523 msleep(100); 524 pci_cfg_access_unlock(dev); 525 526 rc = sriov_add_vfs(dev, initial); 527 if (rc) 528 goto err_pcibios; 529 530 kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE); 531 iov->num_VFs = nr_virtfn; 532 533 return 0; 534 535 err_pcibios: 536 iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 537 pci_cfg_access_lock(dev); 538 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 539 ssleep(1); 540 pci_cfg_access_unlock(dev); 541 542 pcibios_sriov_disable(dev); 543 544 if (iov->link != dev->devfn) 545 sysfs_remove_link(&dev->dev.kobj, "dep_link"); 546 547 pci_iov_set_numvfs(dev, 0); 548 return rc; 549 } 550 551 static void sriov_del_vfs(struct pci_dev *dev) 552 { 553 struct pci_sriov *iov = dev->sriov; 554 int i; 555 556 if (dev->no_vf_scan) 557 return; 558 559 for (i = 0; i < iov->num_VFs; i++) 560 pci_iov_remove_virtfn(dev, i); 561 } 562 563 static void sriov_disable(struct pci_dev *dev) 564 { 565 struct pci_sriov *iov = dev->sriov; 566 567 if (!iov->num_VFs) 568 return; 569 570 sriov_del_vfs(dev); 571 iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 572 pci_cfg_access_lock(dev); 573 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 574 ssleep(1); 575 pci_cfg_access_unlock(dev); 576 577 pcibios_sriov_disable(dev); 578 579 if (iov->link != dev->devfn) 580 sysfs_remove_link(&dev->dev.kobj, "dep_link"); 581 582 iov->num_VFs = 0; 583 pci_iov_set_numvfs(dev, 0); 584 } 585 586 static int sriov_init(struct pci_dev *dev, int pos) 587 { 588 int i, bar64; 589 int rc; 590 int nres; 591 u32 pgsz; 592 u16 ctrl, total; 593 struct pci_sriov *iov; 594 struct resource *res; 595 struct pci_dev *pdev; 596 597 pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl); 598 if (ctrl & PCI_SRIOV_CTRL_VFE) { 599 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0); 600 ssleep(1); 601 } 602 603 ctrl = 0; 604 list_for_each_entry(pdev, &dev->bus->devices, bus_list) 605 if (pdev->is_physfn) 606 goto found; 607 608 pdev = NULL; 609 if (pci_ari_enabled(dev->bus)) 610 ctrl |= PCI_SRIOV_CTRL_ARI; 611 612 found: 613 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl); 614 615 pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total); 616 if (!total) 617 return 0; 618 619 pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz); 620 i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0; 621 pgsz &= ~((1 << i) - 1); 622 if (!pgsz) 623 return -EIO; 624 625 pgsz &= ~(pgsz - 1); 626 pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz); 627 628 iov = kzalloc(sizeof(*iov), GFP_KERNEL); 629 if (!iov) 630 return -ENOMEM; 631 632 nres = 0; 633 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 634 res = &dev->resource[i + PCI_IOV_RESOURCES]; 635 /* 636 * If it is already FIXED, don't change it, something 637 * (perhaps EA or header fixups) wants it this way. 638 */ 639 if (res->flags & IORESOURCE_PCI_FIXED) 640 bar64 = (res->flags & IORESOURCE_MEM_64) ? 1 : 0; 641 else 642 bar64 = __pci_read_base(dev, pci_bar_unknown, res, 643 pos + PCI_SRIOV_BAR + i * 4); 644 if (!res->flags) 645 continue; 646 if (resource_size(res) & (PAGE_SIZE - 1)) { 647 rc = -EIO; 648 goto failed; 649 } 650 iov->barsz[i] = resource_size(res); 651 res->end = res->start + resource_size(res) * total - 1; 652 pci_info(dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n", 653 i, res, i, total); 654 i += bar64; 655 nres++; 656 } 657 658 iov->pos = pos; 659 iov->nres = nres; 660 iov->ctrl = ctrl; 661 iov->total_VFs = total; 662 iov->driver_max_VFs = total; 663 pci_read_config_word(dev, pos + PCI_SRIOV_VF_DID, &iov->vf_device); 664 iov->pgsz = pgsz; 665 iov->self = dev; 666 iov->drivers_autoprobe = true; 667 pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap); 668 pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link); 669 if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END) 670 iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link); 671 672 if (pdev) 673 iov->dev = pci_dev_get(pdev); 674 else 675 iov->dev = dev; 676 677 dev->sriov = iov; 678 dev->is_physfn = 1; 679 rc = compute_max_vf_buses(dev); 680 if (rc) 681 goto fail_max_buses; 682 683 return 0; 684 685 fail_max_buses: 686 dev->sriov = NULL; 687 dev->is_physfn = 0; 688 failed: 689 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 690 res = &dev->resource[i + PCI_IOV_RESOURCES]; 691 res->flags = 0; 692 } 693 694 kfree(iov); 695 return rc; 696 } 697 698 static void sriov_release(struct pci_dev *dev) 699 { 700 BUG_ON(dev->sriov->num_VFs); 701 702 if (dev != dev->sriov->dev) 703 pci_dev_put(dev->sriov->dev); 704 705 kfree(dev->sriov); 706 dev->sriov = NULL; 707 } 708 709 static void sriov_restore_state(struct pci_dev *dev) 710 { 711 int i; 712 u16 ctrl; 713 struct pci_sriov *iov = dev->sriov; 714 715 pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl); 716 if (ctrl & PCI_SRIOV_CTRL_VFE) 717 return; 718 719 /* 720 * Restore PCI_SRIOV_CTRL_ARI before pci_iov_set_numvfs() because 721 * it reads offset & stride, which depend on PCI_SRIOV_CTRL_ARI. 722 */ 723 ctrl &= ~PCI_SRIOV_CTRL_ARI; 724 ctrl |= iov->ctrl & PCI_SRIOV_CTRL_ARI; 725 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, ctrl); 726 727 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) 728 pci_update_resource(dev, i + PCI_IOV_RESOURCES); 729 730 pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz); 731 pci_iov_set_numvfs(dev, iov->num_VFs); 732 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 733 if (iov->ctrl & PCI_SRIOV_CTRL_VFE) 734 msleep(100); 735 } 736 737 /** 738 * pci_iov_init - initialize the IOV capability 739 * @dev: the PCI device 740 * 741 * Returns 0 on success, or negative on failure. 742 */ 743 int pci_iov_init(struct pci_dev *dev) 744 { 745 int pos; 746 747 if (!pci_is_pcie(dev)) 748 return -ENODEV; 749 750 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV); 751 if (pos) 752 return sriov_init(dev, pos); 753 754 return -ENODEV; 755 } 756 757 /** 758 * pci_iov_release - release resources used by the IOV capability 759 * @dev: the PCI device 760 */ 761 void pci_iov_release(struct pci_dev *dev) 762 { 763 if (dev->is_physfn) 764 sriov_release(dev); 765 } 766 767 /** 768 * pci_iov_remove - clean up SR-IOV state after PF driver is detached 769 * @dev: the PCI device 770 */ 771 void pci_iov_remove(struct pci_dev *dev) 772 { 773 struct pci_sriov *iov = dev->sriov; 774 775 if (!dev->is_physfn) 776 return; 777 778 iov->driver_max_VFs = iov->total_VFs; 779 if (iov->num_VFs) 780 pci_warn(dev, "driver left SR-IOV enabled after remove\n"); 781 } 782 783 /** 784 * pci_iov_update_resource - update a VF BAR 785 * @dev: the PCI device 786 * @resno: the resource number 787 * 788 * Update a VF BAR in the SR-IOV capability of a PF. 789 */ 790 void pci_iov_update_resource(struct pci_dev *dev, int resno) 791 { 792 struct pci_sriov *iov = dev->is_physfn ? dev->sriov : NULL; 793 struct resource *res = dev->resource + resno; 794 int vf_bar = resno - PCI_IOV_RESOURCES; 795 struct pci_bus_region region; 796 u16 cmd; 797 u32 new; 798 int reg; 799 800 /* 801 * The generic pci_restore_bars() path calls this for all devices, 802 * including VFs and non-SR-IOV devices. If this is not a PF, we 803 * have nothing to do. 804 */ 805 if (!iov) 806 return; 807 808 pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &cmd); 809 if ((cmd & PCI_SRIOV_CTRL_VFE) && (cmd & PCI_SRIOV_CTRL_MSE)) { 810 dev_WARN(&dev->dev, "can't update enabled VF BAR%d %pR\n", 811 vf_bar, res); 812 return; 813 } 814 815 /* 816 * Ignore unimplemented BARs, unused resource slots for 64-bit 817 * BARs, and non-movable resources, e.g., those described via 818 * Enhanced Allocation. 819 */ 820 if (!res->flags) 821 return; 822 823 if (res->flags & IORESOURCE_UNSET) 824 return; 825 826 if (res->flags & IORESOURCE_PCI_FIXED) 827 return; 828 829 pcibios_resource_to_bus(dev->bus, ®ion, res); 830 new = region.start; 831 new |= res->flags & ~PCI_BASE_ADDRESS_MEM_MASK; 832 833 reg = iov->pos + PCI_SRIOV_BAR + 4 * vf_bar; 834 pci_write_config_dword(dev, reg, new); 835 if (res->flags & IORESOURCE_MEM_64) { 836 new = region.start >> 16 >> 16; 837 pci_write_config_dword(dev, reg + 4, new); 838 } 839 } 840 841 resource_size_t __weak pcibios_iov_resource_alignment(struct pci_dev *dev, 842 int resno) 843 { 844 return pci_iov_resource_size(dev, resno); 845 } 846 847 /** 848 * pci_sriov_resource_alignment - get resource alignment for VF BAR 849 * @dev: the PCI device 850 * @resno: the resource number 851 * 852 * Returns the alignment of the VF BAR found in the SR-IOV capability. 853 * This is not the same as the resource size which is defined as 854 * the VF BAR size multiplied by the number of VFs. The alignment 855 * is just the VF BAR size. 856 */ 857 resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno) 858 { 859 return pcibios_iov_resource_alignment(dev, resno); 860 } 861 862 /** 863 * pci_restore_iov_state - restore the state of the IOV capability 864 * @dev: the PCI device 865 */ 866 void pci_restore_iov_state(struct pci_dev *dev) 867 { 868 if (dev->is_physfn) 869 sriov_restore_state(dev); 870 } 871 872 /** 873 * pci_vf_drivers_autoprobe - set PF property drivers_autoprobe for VFs 874 * @dev: the PCI device 875 * @auto_probe: set VF drivers auto probe flag 876 */ 877 void pci_vf_drivers_autoprobe(struct pci_dev *dev, bool auto_probe) 878 { 879 if (dev->is_physfn) 880 dev->sriov->drivers_autoprobe = auto_probe; 881 } 882 883 /** 884 * pci_iov_bus_range - find bus range used by Virtual Function 885 * @bus: the PCI bus 886 * 887 * Returns max number of buses (exclude current one) used by Virtual 888 * Functions. 889 */ 890 int pci_iov_bus_range(struct pci_bus *bus) 891 { 892 int max = 0; 893 struct pci_dev *dev; 894 895 list_for_each_entry(dev, &bus->devices, bus_list) { 896 if (!dev->is_physfn) 897 continue; 898 if (dev->sriov->max_VF_buses > max) 899 max = dev->sriov->max_VF_buses; 900 } 901 902 return max ? max - bus->number : 0; 903 } 904 905 /** 906 * pci_enable_sriov - enable the SR-IOV capability 907 * @dev: the PCI device 908 * @nr_virtfn: number of virtual functions to enable 909 * 910 * Returns 0 on success, or negative on failure. 911 */ 912 int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn) 913 { 914 might_sleep(); 915 916 if (!dev->is_physfn) 917 return -ENOSYS; 918 919 return sriov_enable(dev, nr_virtfn); 920 } 921 EXPORT_SYMBOL_GPL(pci_enable_sriov); 922 923 /** 924 * pci_disable_sriov - disable the SR-IOV capability 925 * @dev: the PCI device 926 */ 927 void pci_disable_sriov(struct pci_dev *dev) 928 { 929 might_sleep(); 930 931 if (!dev->is_physfn) 932 return; 933 934 sriov_disable(dev); 935 } 936 EXPORT_SYMBOL_GPL(pci_disable_sriov); 937 938 /** 939 * pci_num_vf - return number of VFs associated with a PF device_release_driver 940 * @dev: the PCI device 941 * 942 * Returns number of VFs, or 0 if SR-IOV is not enabled. 943 */ 944 int pci_num_vf(struct pci_dev *dev) 945 { 946 if (!dev->is_physfn) 947 return 0; 948 949 return dev->sriov->num_VFs; 950 } 951 EXPORT_SYMBOL_GPL(pci_num_vf); 952 953 /** 954 * pci_vfs_assigned - returns number of VFs are assigned to a guest 955 * @dev: the PCI device 956 * 957 * Returns number of VFs belonging to this device that are assigned to a guest. 958 * If device is not a physical function returns 0. 959 */ 960 int pci_vfs_assigned(struct pci_dev *dev) 961 { 962 struct pci_dev *vfdev; 963 unsigned int vfs_assigned = 0; 964 unsigned short dev_id; 965 966 /* only search if we are a PF */ 967 if (!dev->is_physfn) 968 return 0; 969 970 /* 971 * determine the device ID for the VFs, the vendor ID will be the 972 * same as the PF so there is no need to check for that one 973 */ 974 dev_id = dev->sriov->vf_device; 975 976 /* loop through all the VFs to see if we own any that are assigned */ 977 vfdev = pci_get_device(dev->vendor, dev_id, NULL); 978 while (vfdev) { 979 /* 980 * It is considered assigned if it is a virtual function with 981 * our dev as the physical function and the assigned bit is set 982 */ 983 if (vfdev->is_virtfn && (vfdev->physfn == dev) && 984 pci_is_dev_assigned(vfdev)) 985 vfs_assigned++; 986 987 vfdev = pci_get_device(dev->vendor, dev_id, vfdev); 988 } 989 990 return vfs_assigned; 991 } 992 EXPORT_SYMBOL_GPL(pci_vfs_assigned); 993 994 /** 995 * pci_sriov_set_totalvfs -- reduce the TotalVFs available 996 * @dev: the PCI PF device 997 * @numvfs: number that should be used for TotalVFs supported 998 * 999 * Should be called from PF driver's probe routine with 1000 * device's mutex held. 1001 * 1002 * Returns 0 if PF is an SRIOV-capable device and 1003 * value of numvfs valid. If not a PF return -ENOSYS; 1004 * if numvfs is invalid return -EINVAL; 1005 * if VFs already enabled, return -EBUSY. 1006 */ 1007 int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs) 1008 { 1009 if (!dev->is_physfn) 1010 return -ENOSYS; 1011 1012 if (numvfs > dev->sriov->total_VFs) 1013 return -EINVAL; 1014 1015 /* Shouldn't change if VFs already enabled */ 1016 if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE) 1017 return -EBUSY; 1018 1019 dev->sriov->driver_max_VFs = numvfs; 1020 return 0; 1021 } 1022 EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs); 1023 1024 /** 1025 * pci_sriov_get_totalvfs -- get total VFs supported on this device 1026 * @dev: the PCI PF device 1027 * 1028 * For a PCIe device with SRIOV support, return the PCIe 1029 * SRIOV capability value of TotalVFs or the value of driver_max_VFs 1030 * if the driver reduced it. Otherwise 0. 1031 */ 1032 int pci_sriov_get_totalvfs(struct pci_dev *dev) 1033 { 1034 if (!dev->is_physfn) 1035 return 0; 1036 1037 return dev->sriov->driver_max_VFs; 1038 } 1039 EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs); 1040 1041 /** 1042 * pci_sriov_configure_simple - helper to configure SR-IOV 1043 * @dev: the PCI device 1044 * @nr_virtfn: number of virtual functions to enable, 0 to disable 1045 * 1046 * Enable or disable SR-IOV for devices that don't require any PF setup 1047 * before enabling SR-IOV. Return value is negative on error, or number of 1048 * VFs allocated on success. 1049 */ 1050 int pci_sriov_configure_simple(struct pci_dev *dev, int nr_virtfn) 1051 { 1052 int rc; 1053 1054 might_sleep(); 1055 1056 if (!dev->is_physfn) 1057 return -ENODEV; 1058 1059 if (pci_vfs_assigned(dev)) { 1060 pci_warn(dev, "Cannot modify SR-IOV while VFs are assigned\n"); 1061 return -EPERM; 1062 } 1063 1064 if (nr_virtfn == 0) { 1065 sriov_disable(dev); 1066 return 0; 1067 } 1068 1069 rc = sriov_enable(dev, nr_virtfn); 1070 if (rc < 0) 1071 return rc; 1072 1073 return nr_virtfn; 1074 } 1075 EXPORT_SYMBOL_GPL(pci_sriov_configure_simple); 1076