LXR linux/drivers/pci/iov.c

   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        pci_bus_insert_busn_res(child, busnr, 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_VFs);
 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_stop_and_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        /*
 177         * pci_stop_dev() could have been called for this virtfn already,
 178         * so the directory for the virtfn may have been removed before.
 179         * Double check to avoid spurious sysfs warnings.
 180         */
 181        if (virtfn->dev.kobj.sd)
 182                sysfs_remove_link(&virtfn->dev.kobj, "physfn");
 183
 184        mutex_lock(&iov->dev->sriov->lock);
 185        pci_stop_and_remove_bus_device(virtfn);
 186        virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
 187        mutex_unlock(&iov->dev->sriov->lock);
 188
 189        pci_dev_put(dev);
 190}
 191
 192static int sriov_migration(struct pci_dev *dev)
 193{
 194        u16 status;
 195        struct pci_sriov *iov = dev->sriov;
 196
 197        if (!iov->num_VFs)
 198                return 0;
 199
 200        if (!(iov->cap & PCI_SRIOV_CAP_VFM))
 201                return 0;
 202
 203        pci_read_config_word(dev, iov->pos + PCI_SRIOV_STATUS, &status);
 204        if (!(status & PCI_SRIOV_STATUS_VFM))
 205                return 0;
 206
 207        schedule_work(&iov->mtask);
 208
 209        return 1;
 210}
 211
 212static void sriov_migration_task(struct work_struct *work)
 213{
 214        int i;
 215        u8 state;
 216        u16 status;
 217        struct pci_sriov *iov = container_of(work, struct pci_sriov, mtask);
 218
 219        for (i = iov->initial_VFs; i < iov->num_VFs; i++) {
 220                state = readb(iov->mstate + i);
 221                if (state == PCI_SRIOV_VFM_MI) {
 222                        writeb(PCI_SRIOV_VFM_AV, iov->mstate + i);
 223                        state = readb(iov->mstate + i);
 224                        if (state == PCI_SRIOV_VFM_AV)
 225                                virtfn_add(iov->self, i, 1);
 226                } else if (state == PCI_SRIOV_VFM_MO) {
 227                        virtfn_remove(iov->self, i, 1);
 228                        writeb(PCI_SRIOV_VFM_UA, iov->mstate + i);
 229                        state = readb(iov->mstate + i);
 230                        if (state == PCI_SRIOV_VFM_AV)
 231                                virtfn_add(iov->self, i, 0);
 232                }
 233        }
 234
 235        pci_read_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, &status);
 236        status &= ~PCI_SRIOV_STATUS_VFM;
 237        pci_write_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, status);
 238}
 239
 240static int sriov_enable_migration(struct pci_dev *dev, int nr_virtfn)
 241{
 242        int bir;
 243        u32 table;
 244        resource_size_t pa;
 245        struct pci_sriov *iov = dev->sriov;
 246
 247        if (nr_virtfn <= iov->initial_VFs)
 248                return 0;
 249
 250        pci_read_config_dword(dev, iov->pos + PCI_SRIOV_VFM, &table);
 251        bir = PCI_SRIOV_VFM_BIR(table);
 252        if (bir > PCI_STD_RESOURCE_END)
 253                return -EIO;
 254
 255        table = PCI_SRIOV_VFM_OFFSET(table);
 256        if (table + nr_virtfn > pci_resource_len(dev, bir))
 257                return -EIO;
 258
 259        pa = pci_resource_start(dev, bir) + table;
 260        iov->mstate = ioremap(pa, nr_virtfn);
 261        if (!iov->mstate)
 262                return -ENOMEM;
 263
 264        INIT_WORK(&iov->mtask, sriov_migration_task);
 265
 266        iov->ctrl |= PCI_SRIOV_CTRL_VFM | PCI_SRIOV_CTRL_INTR;
 267        pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 268
 269        return 0;
 270}
 271
 272static void sriov_disable_migration(struct pci_dev *dev)
 273{
 274        struct pci_sriov *iov = dev->sriov;
 275
 276        iov->ctrl &= ~(PCI_SRIOV_CTRL_VFM | PCI_SRIOV_CTRL_INTR);
 277        pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 278
 279        cancel_work_sync(&iov->mtask);
 280        iounmap(iov->mstate);
 281}
 282
 283static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
 284{
 285        int rc;
 286        int i, j;
 287        int nres;
 288        u16 offset, stride, initial;
 289        struct resource *res;
 290        struct pci_dev *pdev;
 291        struct pci_sriov *iov = dev->sriov;
 292        int bars = 0;
 293
 294        if (!nr_virtfn)
 295                return 0;
 296
 297        if (iov->num_VFs)
 298                return -EINVAL;
 299
 300        pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial);
 301        if (initial > iov->total_VFs ||
 302            (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs)))
 303                return -EIO;
 304
 305        if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs ||
 306            (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial)))
 307                return -EINVAL;
 308
 309        pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
 310        pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &offset);
 311        pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &stride);
 312        if (!offset || (nr_virtfn > 1 && !stride))
 313                return -EIO;
 314
 315        nres = 0;
 316        for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
 317                bars |= (1 << (i + PCI_IOV_RESOURCES));
 318                res = dev->resource + PCI_IOV_RESOURCES + i;
 319                if (res->parent)
 320                        nres++;
 321        }
 322        if (nres != iov->nres) {
 323                dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n");
 324                return -ENOMEM;
 325        }
 326
 327        iov->offset = offset;
 328        iov->stride = stride;
 329
 330        if (virtfn_bus(dev, nr_virtfn - 1) > dev->bus->busn_res.end) {
 331                dev_err(&dev->dev, "SR-IOV: bus number out of range\n");
 332                return -ENOMEM;
 333        }
 334
 335        if (pci_enable_resources(dev, bars)) {
 336                dev_err(&dev->dev, "SR-IOV: IOV BARS not allocated\n");
 337                return -ENOMEM;
 338        }
 339
 340        if (iov->link != dev->devfn) {
 341                pdev = pci_get_slot(dev->bus, iov->link);
 342                if (!pdev)
 343                        return -ENODEV;
 344
 345                pci_dev_put(pdev);
 346
 347                if (!pdev->is_physfn)
 348                        return -ENODEV;
 349
 350                rc = sysfs_create_link(&dev->dev.kobj,
 351                                        &pdev->dev.kobj, "dep_link");
 352                if (rc)
 353                        return rc;
 354        }
 355
 356        iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE;
 357        pci_cfg_access_lock(dev);
 358        pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 359        msleep(100);
 360        pci_cfg_access_unlock(dev);
 361
 362        iov->initial_VFs = initial;
 363        if (nr_virtfn < initial)
 364                initial = nr_virtfn;
 365
 366        for (i = 0; i < initial; i++) {
 367                rc = virtfn_add(dev, i, 0);
 368                if (rc)
 369                        goto failed;
 370        }
 371
 372        if (iov->cap & PCI_SRIOV_CAP_VFM) {
 373                rc = sriov_enable_migration(dev, nr_virtfn);
 374                if (rc)
 375                        goto failed;
 376        }
 377
 378        kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE);
 379        iov->num_VFs = nr_virtfn;
 380
 381        return 0;
 382
 383failed:
 384        for (j = 0; j < i; j++)
 385                virtfn_remove(dev, j, 0);
 386
 387        iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
 388        pci_cfg_access_lock(dev);
 389        pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 390        ssleep(1);
 391        pci_cfg_access_unlock(dev);
 392
 393        if (iov->link != dev->devfn)
 394                sysfs_remove_link(&dev->dev.kobj, "dep_link");
 395
 396        return rc;
 397}
 398
 399static void sriov_disable(struct pci_dev *dev)
 400{
 401        int i;
 402        struct pci_sriov *iov = dev->sriov;
 403
 404        if (!iov->num_VFs)
 405                return;
 406
 407        if (iov->cap & PCI_SRIOV_CAP_VFM)
 408                sriov_disable_migration(dev);
 409
 410        for (i = 0; i < iov->num_VFs; i++)
 411                virtfn_remove(dev, i, 0);
 412
 413        iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
 414        pci_cfg_access_lock(dev);
 415        pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 416        ssleep(1);
 417        pci_cfg_access_unlock(dev);
 418
 419        if (iov->link != dev->devfn)
 420                sysfs_remove_link(&dev->dev.kobj, "dep_link");
 421
 422        iov->num_VFs = 0;
 423}
 424
 425static int sriov_init(struct pci_dev *dev, int pos)
 426{
 427        int i;
 428        int rc;
 429        int nres;
 430        u32 pgsz;
 431        u16 ctrl, total, offset, stride;
 432        struct pci_sriov *iov;
 433        struct resource *res;
 434        struct pci_dev *pdev;
 435
 436        if (pci_pcie_type(dev) != PCI_EXP_TYPE_RC_END &&
 437            pci_pcie_type(dev) != PCI_EXP_TYPE_ENDPOINT)
 438                return -ENODEV;
 439
 440        pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl);
 441        if (ctrl & PCI_SRIOV_CTRL_VFE) {
 442                pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0);
 443                ssleep(1);
 444        }
 445
 446        pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total);
 447        if (!total)
 448                return 0;
 449
 450        ctrl = 0;
 451        list_for_each_entry(pdev, &dev->bus->devices, bus_list)
 452                if (pdev->is_physfn)
 453                        goto found;
 454
 455        pdev = NULL;
 456        if (pci_ari_enabled(dev->bus))
 457                ctrl |= PCI_SRIOV_CTRL_ARI;
 458
 459found:
 460        pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl);
 461        pci_read_config_word(dev, pos + PCI_SRIOV_VF_OFFSET, &offset);
 462        pci_read_config_word(dev, pos + PCI_SRIOV_VF_STRIDE, &stride);
 463        if (!offset || (total > 1 && !stride))
 464                return -EIO;
 465
 466        pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz);
 467        i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0;
 468        pgsz &= ~((1 << i) - 1);
 469        if (!pgsz)
 470                return -EIO;
 471
 472        pgsz &= ~(pgsz - 1);
 473        pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz);
 474
 475        nres = 0;
 476        for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
 477                res = dev->resource + PCI_IOV_RESOURCES + i;
 478                i += __pci_read_base(dev, pci_bar_unknown, res,
 479                                     pos + PCI_SRIOV_BAR + i * 4);
 480                if (!res->flags)
 481                        continue;
 482                if (resource_size(res) & (PAGE_SIZE - 1)) {
 483                        rc = -EIO;
 484                        goto failed;
 485                }
 486                res->end = res->start + resource_size(res) * total - 1;
 487                nres++;
 488        }
 489
 490        iov = kzalloc(sizeof(*iov), GFP_KERNEL);
 491        if (!iov) {
 492                rc = -ENOMEM;
 493                goto failed;
 494        }
 495
 496        iov->pos = pos;
 497        iov->nres = nres;
 498        iov->ctrl = ctrl;
 499        iov->total_VFs = total;
 500        iov->offset = offset;
 501        iov->stride = stride;
 502        iov->pgsz = pgsz;
 503        iov->self = dev;
 504        pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap);
 505        pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link);
 506        if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END)
 507                iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link);
 508
 509        if (pdev)
 510                iov->dev = pci_dev_get(pdev);
 511        else
 512                iov->dev = dev;
 513
 514        mutex_init(&iov->lock);
 515
 516        dev->sriov = iov;
 517        dev->is_physfn = 1;
 518
 519        return 0;
 520
 521failed:
 522        for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
 523                res = dev->resource + PCI_IOV_RESOURCES + i;
 524                res->flags = 0;
 525        }
 526
 527        return rc;
 528}
 529
 530static void sriov_release(struct pci_dev *dev)
 531{
 532        BUG_ON(dev->sriov->num_VFs);
 533
 534        if (dev != dev->sriov->dev)
 535                pci_dev_put(dev->sriov->dev);
 536
 537        mutex_destroy(&dev->sriov->lock);
 538
 539        kfree(dev->sriov);
 540        dev->sriov = NULL;
 541}
 542
 543static void sriov_restore_state(struct pci_dev *dev)
 544{
 545        int i;
 546        u16 ctrl;
 547        struct pci_sriov *iov = dev->sriov;
 548
 549        pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl);
 550        if (ctrl & PCI_SRIOV_CTRL_VFE)
 551                return;
 552
 553        for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++)
 554                pci_update_resource(dev, i);
 555
 556        pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz);
 557        pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, iov->num_VFs);
 558        pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 559        if (iov->ctrl & PCI_SRIOV_CTRL_VFE)
 560                msleep(100);
 561}
 562
 563/**
 564 * pci_iov_init - initialize the IOV capability
 565 * @dev: the PCI device
 566 *
 567 * Returns 0 on success, or negative on failure.
 568 */
 569int pci_iov_init(struct pci_dev *dev)
 570{
 571        int pos;
 572
 573        if (!pci_is_pcie(dev))
 574                return -ENODEV;
 575
 576        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV);
 577        if (pos)
 578                return sriov_init(dev, pos);
 579
 580        return -ENODEV;
 581}
 582
 583/**
 584 * pci_iov_release - release resources used by the IOV capability
 585 * @dev: the PCI device
 586 */
 587void pci_iov_release(struct pci_dev *dev)
 588{
 589        if (dev->is_physfn)
 590                sriov_release(dev);
 591}
 592
 593/**
 594 * pci_iov_resource_bar - get position of the SR-IOV BAR
 595 * @dev: the PCI device
 596 * @resno: the resource number
 597 * @type: the BAR type to be filled in
 598 *
 599 * Returns position of the BAR encapsulated in the SR-IOV capability.
 600 */
 601int pci_iov_resource_bar(struct pci_dev *dev, int resno,
 602                         enum pci_bar_type *type)
 603{
 604        if (resno < PCI_IOV_RESOURCES || resno > PCI_IOV_RESOURCE_END)
 605                return 0;
 606
 607        BUG_ON(!dev->is_physfn);
 608
 609        *type = pci_bar_unknown;
 610
 611        return dev->sriov->pos + PCI_SRIOV_BAR +
 612                4 * (resno - PCI_IOV_RESOURCES);
 613}
 614
 615/**
 616 * pci_sriov_resource_alignment - get resource alignment for VF BAR
 617 * @dev: the PCI device
 618 * @resno: the resource number
 619 *
 620 * Returns the alignment of the VF BAR found in the SR-IOV capability.
 621 * This is not the same as the resource size which is defined as
 622 * the VF BAR size multiplied by the number of VFs.  The alignment
 623 * is just the VF BAR size.
 624 */
 625resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno)
 626{
 627        struct resource tmp;
 628        enum pci_bar_type type;
 629        int reg = pci_iov_resource_bar(dev, resno, &type);
 630        
 631        if (!reg)
 632                return 0;
 633
 634         __pci_read_base(dev, type, &tmp, reg);
 635        return resource_alignment(&tmp);
 636}
 637
 638/**
 639 * pci_restore_iov_state - restore the state of the IOV capability
 640 * @dev: the PCI device
 641 */
 642void pci_restore_iov_state(struct pci_dev *dev)
 643{
 644        if (dev->is_physfn)
 645                sriov_restore_state(dev);
 646}
 647
 648/**
 649 * pci_iov_bus_range - find bus range used by Virtual Function
 650 * @bus: the PCI bus
 651 *
 652 * Returns max number of buses (exclude current one) used by Virtual
 653 * Functions.
 654 */
 655int pci_iov_bus_range(struct pci_bus *bus)
 656{
 657        int max = 0;
 658        u8 busnr;
 659        struct pci_dev *dev;
 660
 661        list_for_each_entry(dev, &bus->devices, bus_list) {
 662                if (!dev->is_physfn)
 663                        continue;
 664                busnr = virtfn_bus(dev, dev->sriov->total_VFs - 1);
 665                if (busnr > max)
 666                        max = busnr;
 667        }
 668
 669        return max ? max - bus->number : 0;
 670}
 671
 672/**
 673 * pci_enable_sriov - enable the SR-IOV capability
 674 * @dev: the PCI device
 675 * @nr_virtfn: number of virtual functions to enable
 676 *
 677 * Returns 0 on success, or negative on failure.
 678 */
 679int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
 680{
 681        might_sleep();
 682
 683        if (!dev->is_physfn)
 684                return -ENODEV;
 685
 686        return sriov_enable(dev, nr_virtfn);
 687}
 688EXPORT_SYMBOL_GPL(pci_enable_sriov);
 689
 690/**
 691 * pci_disable_sriov - disable the SR-IOV capability
 692 * @dev: the PCI device
 693 */
 694void pci_disable_sriov(struct pci_dev *dev)
 695{
 696        might_sleep();
 697
 698        if (!dev->is_physfn)
 699                return;
 700
 701        sriov_disable(dev);
 702}
 703EXPORT_SYMBOL_GPL(pci_disable_sriov);
 704
 705/**
 706 * pci_sriov_migration - notify SR-IOV core of Virtual Function Migration
 707 * @dev: the PCI device
 708 *
 709 * Returns IRQ_HANDLED if the IRQ is handled, or IRQ_NONE if not.
 710 *
 711 * Physical Function driver is responsible to register IRQ handler using
 712 * VF Migration Interrupt Message Number, and call this function when the
 713 * interrupt is generated by the hardware.
 714 */
 715irqreturn_t pci_sriov_migration(struct pci_dev *dev)
 716{
 717        if (!dev->is_physfn)
 718                return IRQ_NONE;
 719
 720        return sriov_migration(dev) ? IRQ_HANDLED : IRQ_NONE;
 721}
 722EXPORT_SYMBOL_GPL(pci_sriov_migration);
 723
 724/**
 725 * pci_num_vf - return number of VFs associated with a PF device_release_driver
 726 * @dev: the PCI device
 727 *
 728 * Returns number of VFs, or 0 if SR-IOV is not enabled.
 729 */
 730int pci_num_vf(struct pci_dev *dev)
 731{
 732        if (!dev->is_physfn)
 733                return 0;
 734
 735        return dev->sriov->num_VFs;
 736}
 737EXPORT_SYMBOL_GPL(pci_num_vf);
 738
 739/**
 740 * pci_sriov_set_totalvfs -- reduce the TotalVFs available
 741 * @dev: the PCI PF device
 742 * @numvfs: number that should be used for TotalVFs supported
 743 *
 744 * Should be called from PF driver's probe routine with
 745 * device's mutex held.
 746 *
 747 * Returns 0 if PF is an SRIOV-capable device and
 748 * value of numvfs valid. If not a PF with VFS, return -EINVAL;
 749 * if VFs already enabled, return -EBUSY.
 750 */
 751int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs)
 752{
 753        if (!dev->is_physfn || (numvfs > dev->sriov->total_VFs))
 754                return -EINVAL;
 755
 756        /* Shouldn't change if VFs already enabled */
 757        if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE)
 758                return -EBUSY;
 759        else
 760                dev->sriov->driver_max_VFs = numvfs;
 761
 762        return 0;
 763}
 764EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs);
 765
 766/**
 767 * pci_sriov_get_totalvfs -- get total VFs supported on this devic3
 768 * @dev: the PCI PF device
 769 *
 770 * For a PCIe device with SRIOV support, return the PCIe
 771 * SRIOV capability value of TotalVFs or the value of driver_max_VFs
 772 * if the driver reduced it.  Otherwise, -EINVAL.
 773 */
 774int pci_sriov_get_totalvfs(struct pci_dev *dev)
 775{
 776        if (!dev->is_physfn)
 777                return -EINVAL;
 778
 779        if (dev->sriov->driver_max_VFs)
 780                return dev->sriov->driver_max_VFs;
 781
 782        return dev->sriov->total_VFs;
 783}
 784EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs);
 785