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