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