1d1b054daSYu Zhao /* 2d1b054daSYu Zhao * drivers/pci/iov.c 3d1b054daSYu Zhao * 4d1b054daSYu Zhao * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com> 5d1b054daSYu Zhao * 6d1b054daSYu Zhao * PCI Express I/O Virtualization (IOV) support. 7d1b054daSYu Zhao * Single Root IOV 1.0 8302b4215SYu Zhao * Address Translation Service 1.0 9d1b054daSYu Zhao */ 10d1b054daSYu Zhao 11d1b054daSYu Zhao #include <linux/pci.h> 125a0e3ad6STejun Heo #include <linux/slab.h> 13d1b054daSYu Zhao #include <linux/mutex.h> 14363c75dbSPaul Gortmaker #include <linux/export.h> 15d1b054daSYu Zhao #include <linux/string.h> 16d1b054daSYu Zhao #include <linux/delay.h> 175cdede24SJoerg Roedel #include <linux/pci-ats.h> 18d1b054daSYu Zhao #include "pci.h" 19d1b054daSYu Zhao 20dd7cc44dSYu Zhao #define VIRTFN_ID_LEN 16 21d1b054daSYu Zhao 22b07579c0SWei Yang int pci_iov_virtfn_bus(struct pci_dev *dev, int vf_id) 23a28724b0SYu Zhao { 24b07579c0SWei Yang if (!dev->is_physfn) 25b07579c0SWei Yang return -EINVAL; 26a28724b0SYu Zhao return dev->bus->number + ((dev->devfn + dev->sriov->offset + 27b07579c0SWei Yang dev->sriov->stride * vf_id) >> 8); 28a28724b0SYu Zhao } 29a28724b0SYu Zhao 30b07579c0SWei Yang int pci_iov_virtfn_devfn(struct pci_dev *dev, int vf_id) 31a28724b0SYu Zhao { 32b07579c0SWei Yang if (!dev->is_physfn) 33b07579c0SWei Yang return -EINVAL; 34a28724b0SYu Zhao return (dev->devfn + dev->sriov->offset + 35b07579c0SWei Yang dev->sriov->stride * vf_id) & 0xff; 36a28724b0SYu Zhao } 37a28724b0SYu Zhao 38f59dca27SWei Yang /* 39f59dca27SWei Yang * Per SR-IOV spec sec 3.3.10 and 3.3.11, First VF Offset and VF Stride may 40f59dca27SWei Yang * change when NumVFs changes. 41f59dca27SWei Yang * 42f59dca27SWei Yang * Update iov->offset and iov->stride when NumVFs is written. 43f59dca27SWei Yang */ 44f59dca27SWei Yang static inline void pci_iov_set_numvfs(struct pci_dev *dev, int nr_virtfn) 45f59dca27SWei Yang { 46f59dca27SWei Yang struct pci_sriov *iov = dev->sriov; 47f59dca27SWei Yang 48f59dca27SWei Yang pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn); 49f59dca27SWei Yang pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &iov->offset); 50f59dca27SWei Yang pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &iov->stride); 51f59dca27SWei Yang } 52f59dca27SWei Yang 534449f079SWei Yang /* 544449f079SWei Yang * The PF consumes one bus number. NumVFs, First VF Offset, and VF Stride 554449f079SWei Yang * determine how many additional bus numbers will be consumed by VFs. 564449f079SWei Yang * 57ea9a8854SAlexander Duyck * Iterate over all valid NumVFs, validate offset and stride, and calculate 58ea9a8854SAlexander Duyck * the maximum number of bus numbers that could ever be required. 594449f079SWei Yang */ 60ea9a8854SAlexander Duyck static int compute_max_vf_buses(struct pci_dev *dev) 614449f079SWei Yang { 624449f079SWei Yang struct pci_sriov *iov = dev->sriov; 63ea9a8854SAlexander Duyck int nr_virtfn, busnr, rc = 0; 644449f079SWei Yang 65ea9a8854SAlexander Duyck for (nr_virtfn = iov->total_VFs; nr_virtfn; nr_virtfn--) { 664449f079SWei Yang pci_iov_set_numvfs(dev, nr_virtfn); 67ea9a8854SAlexander Duyck if (!iov->offset || (nr_virtfn > 1 && !iov->stride)) { 68ea9a8854SAlexander Duyck rc = -EIO; 69ea9a8854SAlexander Duyck goto out; 704449f079SWei Yang } 714449f079SWei Yang 72ea9a8854SAlexander Duyck busnr = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 73ea9a8854SAlexander Duyck if (busnr > iov->max_VF_buses) 74ea9a8854SAlexander Duyck iov->max_VF_buses = busnr; 75ea9a8854SAlexander Duyck } 76ea9a8854SAlexander Duyck 77ea9a8854SAlexander Duyck out: 78ea9a8854SAlexander Duyck pci_iov_set_numvfs(dev, 0); 79ea9a8854SAlexander Duyck return rc; 804449f079SWei Yang } 814449f079SWei Yang 82dd7cc44dSYu Zhao static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr) 83dd7cc44dSYu Zhao { 84dd7cc44dSYu Zhao struct pci_bus *child; 85dd7cc44dSYu Zhao 86dd7cc44dSYu Zhao if (bus->number == busnr) 87dd7cc44dSYu Zhao return bus; 88dd7cc44dSYu Zhao 89dd7cc44dSYu Zhao child = pci_find_bus(pci_domain_nr(bus), busnr); 90dd7cc44dSYu Zhao if (child) 91dd7cc44dSYu Zhao return child; 92dd7cc44dSYu Zhao 93dd7cc44dSYu Zhao child = pci_add_new_bus(bus, NULL, busnr); 94dd7cc44dSYu Zhao if (!child) 95dd7cc44dSYu Zhao return NULL; 96dd7cc44dSYu Zhao 97b7eac055SYinghai Lu pci_bus_insert_busn_res(child, busnr, busnr); 98dd7cc44dSYu Zhao 99dd7cc44dSYu Zhao return child; 100dd7cc44dSYu Zhao } 101dd7cc44dSYu Zhao 102dc087f2fSJiang Liu static void virtfn_remove_bus(struct pci_bus *physbus, struct pci_bus *virtbus) 103dd7cc44dSYu Zhao { 104dc087f2fSJiang Liu if (physbus != virtbus && list_empty(&virtbus->devices)) 105dc087f2fSJiang Liu pci_remove_bus(virtbus); 106dd7cc44dSYu Zhao } 107dd7cc44dSYu Zhao 1080e6c9122SWei Yang resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno) 1090e6c9122SWei Yang { 1100e6c9122SWei Yang if (!dev->is_physfn) 1110e6c9122SWei Yang return 0; 1120e6c9122SWei Yang 1130e6c9122SWei Yang return dev->sriov->barsz[resno - PCI_IOV_RESOURCES]; 1140e6c9122SWei Yang } 1150e6c9122SWei Yang 116753f6124SJan H. Schönherr int pci_iov_add_virtfn(struct pci_dev *dev, int id) 117dd7cc44dSYu Zhao { 118dd7cc44dSYu Zhao int i; 119dc087f2fSJiang Liu int rc = -ENOMEM; 120dd7cc44dSYu Zhao u64 size; 121dd7cc44dSYu Zhao char buf[VIRTFN_ID_LEN]; 122dd7cc44dSYu Zhao struct pci_dev *virtfn; 123dd7cc44dSYu Zhao struct resource *res; 124dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 1258b1fce04SGu Zheng struct pci_bus *bus; 126dd7cc44dSYu Zhao 127b07579c0SWei Yang bus = virtfn_add_bus(dev->bus, pci_iov_virtfn_bus(dev, id)); 128dc087f2fSJiang Liu if (!bus) 129dc087f2fSJiang Liu goto failed; 130dc087f2fSJiang Liu 131dc087f2fSJiang Liu virtfn = pci_alloc_dev(bus); 132dc087f2fSJiang Liu if (!virtfn) 133dc087f2fSJiang Liu goto failed0; 134dc087f2fSJiang Liu 135b07579c0SWei Yang virtfn->devfn = pci_iov_virtfn_devfn(dev, id); 136dd7cc44dSYu Zhao virtfn->vendor = dev->vendor; 137dd7cc44dSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device); 138156c5532SPo Liu rc = pci_setup_device(virtfn); 139156c5532SPo Liu if (rc) 140156c5532SPo Liu goto failed0; 141156c5532SPo Liu 142dd7cc44dSYu Zhao virtfn->dev.parent = dev->dev.parent; 143fbf33f51SXudong Hao virtfn->physfn = pci_dev_get(dev); 144fbf33f51SXudong Hao virtfn->is_virtfn = 1; 145aa931977SAlex Williamson virtfn->multifunction = 0; 146dd7cc44dSYu Zhao 147dd7cc44dSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 148c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 149dd7cc44dSYu Zhao if (!res->parent) 150dd7cc44dSYu Zhao continue; 151dd7cc44dSYu Zhao virtfn->resource[i].name = pci_name(virtfn); 152dd7cc44dSYu Zhao virtfn->resource[i].flags = res->flags; 1530e6c9122SWei Yang size = pci_iov_resource_size(dev, i + PCI_IOV_RESOURCES); 154dd7cc44dSYu Zhao virtfn->resource[i].start = res->start + size * id; 155dd7cc44dSYu Zhao virtfn->resource[i].end = virtfn->resource[i].start + size - 1; 156dd7cc44dSYu Zhao rc = request_resource(res, &virtfn->resource[i]); 157dd7cc44dSYu Zhao BUG_ON(rc); 158dd7cc44dSYu Zhao } 159dd7cc44dSYu Zhao 160dd7cc44dSYu Zhao pci_device_add(virtfn, virtfn->bus); 161dd7cc44dSYu Zhao 162c893d133SYijing Wang pci_bus_add_device(virtfn); 163dd7cc44dSYu Zhao sprintf(buf, "virtfn%u", id); 164dd7cc44dSYu Zhao rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf); 165dd7cc44dSYu Zhao if (rc) 166dd7cc44dSYu Zhao goto failed1; 167dd7cc44dSYu Zhao rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn"); 168dd7cc44dSYu Zhao if (rc) 169dd7cc44dSYu Zhao goto failed2; 170dd7cc44dSYu Zhao 171dd7cc44dSYu Zhao kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE); 172dd7cc44dSYu Zhao 173dd7cc44dSYu Zhao return 0; 174dd7cc44dSYu Zhao 175dd7cc44dSYu Zhao failed2: 176dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, buf); 177dd7cc44dSYu Zhao failed1: 178dd7cc44dSYu Zhao pci_dev_put(dev); 179210647afSYinghai Lu pci_stop_and_remove_bus_device(virtfn); 180dc087f2fSJiang Liu failed0: 181dc087f2fSJiang Liu virtfn_remove_bus(dev->bus, bus); 182dc087f2fSJiang Liu failed: 183dd7cc44dSYu Zhao 184dd7cc44dSYu Zhao return rc; 185dd7cc44dSYu Zhao } 186dd7cc44dSYu Zhao 187753f6124SJan H. Schönherr void pci_iov_remove_virtfn(struct pci_dev *dev, int id) 188dd7cc44dSYu Zhao { 189dd7cc44dSYu Zhao char buf[VIRTFN_ID_LEN]; 190dd7cc44dSYu Zhao struct pci_dev *virtfn; 191dd7cc44dSYu Zhao 192dc087f2fSJiang Liu virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus), 193b07579c0SWei Yang pci_iov_virtfn_bus(dev, id), 194b07579c0SWei Yang pci_iov_virtfn_devfn(dev, id)); 195dd7cc44dSYu Zhao if (!virtfn) 196dd7cc44dSYu Zhao return; 197dd7cc44dSYu Zhao 198dd7cc44dSYu Zhao sprintf(buf, "virtfn%u", id); 199dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, buf); 20009cedbefSYinghai Lu /* 20109cedbefSYinghai Lu * pci_stop_dev() could have been called for this virtfn already, 20209cedbefSYinghai Lu * so the directory for the virtfn may have been removed before. 20309cedbefSYinghai Lu * Double check to avoid spurious sysfs warnings. 20409cedbefSYinghai Lu */ 20509cedbefSYinghai Lu if (virtfn->dev.kobj.sd) 206dd7cc44dSYu Zhao sysfs_remove_link(&virtfn->dev.kobj, "physfn"); 207dd7cc44dSYu Zhao 208210647afSYinghai Lu pci_stop_and_remove_bus_device(virtfn); 209dc087f2fSJiang Liu virtfn_remove_bus(dev->bus, virtfn->bus); 210dd7cc44dSYu Zhao 211dc087f2fSJiang Liu /* balance pci_get_domain_bus_and_slot() */ 212dc087f2fSJiang Liu pci_dev_put(virtfn); 213dd7cc44dSYu Zhao pci_dev_put(dev); 214dd7cc44dSYu Zhao } 215dd7cc44dSYu Zhao 216995df527SWei Yang int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs) 217995df527SWei Yang { 218995df527SWei Yang return 0; 219995df527SWei Yang } 220995df527SWei Yang 221a39e3fcdSAlexander Duyck int __weak pcibios_sriov_disable(struct pci_dev *pdev) 222a39e3fcdSAlexander Duyck { 223a39e3fcdSAlexander Duyck return 0; 224a39e3fcdSAlexander Duyck } 225a39e3fcdSAlexander Duyck 226dd7cc44dSYu Zhao static int sriov_enable(struct pci_dev *dev, int nr_virtfn) 227dd7cc44dSYu Zhao { 228dd7cc44dSYu Zhao int rc; 2293443c382SAlexander Duyck int i; 230dd7cc44dSYu Zhao int nres; 231ce288ec3SAlexander Duyck u16 initial; 232dd7cc44dSYu Zhao struct resource *res; 233dd7cc44dSYu Zhao struct pci_dev *pdev; 234dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 235bbef98abSRam Pai int bars = 0; 236b07579c0SWei Yang int bus; 237dd7cc44dSYu Zhao 238dd7cc44dSYu Zhao if (!nr_virtfn) 239dd7cc44dSYu Zhao return 0; 240dd7cc44dSYu Zhao 2416b136724SBjorn Helgaas if (iov->num_VFs) 242dd7cc44dSYu Zhao return -EINVAL; 243dd7cc44dSYu Zhao 244dd7cc44dSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial); 2456b136724SBjorn Helgaas if (initial > iov->total_VFs || 2466b136724SBjorn Helgaas (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs))) 247dd7cc44dSYu Zhao return -EIO; 248dd7cc44dSYu Zhao 2496b136724SBjorn Helgaas if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs || 250dd7cc44dSYu Zhao (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial))) 251dd7cc44dSYu Zhao return -EINVAL; 252dd7cc44dSYu Zhao 253dd7cc44dSYu Zhao nres = 0; 254dd7cc44dSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 255bbef98abSRam Pai bars |= (1 << (i + PCI_IOV_RESOURCES)); 256c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 257dd7cc44dSYu Zhao if (res->parent) 258dd7cc44dSYu Zhao nres++; 259dd7cc44dSYu Zhao } 260dd7cc44dSYu Zhao if (nres != iov->nres) { 261dd7cc44dSYu Zhao dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n"); 262dd7cc44dSYu Zhao return -ENOMEM; 263dd7cc44dSYu Zhao } 264dd7cc44dSYu Zhao 265b07579c0SWei Yang bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 26668f8e9faSBjorn Helgaas if (bus > dev->bus->busn_res.end) { 26768f8e9faSBjorn Helgaas dev_err(&dev->dev, "can't enable %d VFs (bus %02x out of range of %pR)\n", 26868f8e9faSBjorn Helgaas nr_virtfn, bus, &dev->bus->busn_res); 269dd7cc44dSYu Zhao return -ENOMEM; 270dd7cc44dSYu Zhao } 271dd7cc44dSYu Zhao 272bbef98abSRam Pai if (pci_enable_resources(dev, bars)) { 273bbef98abSRam Pai dev_err(&dev->dev, "SR-IOV: IOV BARS not allocated\n"); 274bbef98abSRam Pai return -ENOMEM; 275bbef98abSRam Pai } 276bbef98abSRam Pai 277dd7cc44dSYu Zhao if (iov->link != dev->devfn) { 278dd7cc44dSYu Zhao pdev = pci_get_slot(dev->bus, iov->link); 279dd7cc44dSYu Zhao if (!pdev) 280dd7cc44dSYu Zhao return -ENODEV; 281dd7cc44dSYu Zhao 282dc087f2fSJiang Liu if (!pdev->is_physfn) { 283dd7cc44dSYu Zhao pci_dev_put(pdev); 284652d1100SStefan Assmann return -ENOSYS; 285dc087f2fSJiang Liu } 286dd7cc44dSYu Zhao 287dd7cc44dSYu Zhao rc = sysfs_create_link(&dev->dev.kobj, 288dd7cc44dSYu Zhao &pdev->dev.kobj, "dep_link"); 289dc087f2fSJiang Liu pci_dev_put(pdev); 290dd7cc44dSYu Zhao if (rc) 291dd7cc44dSYu Zhao return rc; 292dd7cc44dSYu Zhao } 293dd7cc44dSYu Zhao 2946b136724SBjorn Helgaas iov->initial_VFs = initial; 295dd7cc44dSYu Zhao if (nr_virtfn < initial) 296dd7cc44dSYu Zhao initial = nr_virtfn; 297dd7cc44dSYu Zhao 298c23b6135SAlexander Duyck rc = pcibios_sriov_enable(dev, initial); 299c23b6135SAlexander Duyck if (rc) { 300c23b6135SAlexander Duyck dev_err(&dev->dev, "failure %d from pcibios_sriov_enable()\n", rc); 301c23b6135SAlexander Duyck goto err_pcibios; 302995df527SWei Yang } 303995df527SWei Yang 304f40ec3c7SGavin Shan pci_iov_set_numvfs(dev, nr_virtfn); 305f40ec3c7SGavin Shan iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE; 306f40ec3c7SGavin Shan pci_cfg_access_lock(dev); 307f40ec3c7SGavin Shan pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 308f40ec3c7SGavin Shan msleep(100); 309f40ec3c7SGavin Shan pci_cfg_access_unlock(dev); 310f40ec3c7SGavin Shan 311dd7cc44dSYu Zhao for (i = 0; i < initial; i++) { 312753f6124SJan H. Schönherr rc = pci_iov_add_virtfn(dev, i); 313dd7cc44dSYu Zhao if (rc) 314dd7cc44dSYu Zhao goto failed; 315dd7cc44dSYu Zhao } 316dd7cc44dSYu Zhao 317dd7cc44dSYu Zhao kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE); 3186b136724SBjorn Helgaas iov->num_VFs = nr_virtfn; 319dd7cc44dSYu Zhao 320dd7cc44dSYu Zhao return 0; 321dd7cc44dSYu Zhao 322dd7cc44dSYu Zhao failed: 3233443c382SAlexander Duyck while (i--) 324753f6124SJan H. Schönherr pci_iov_remove_virtfn(dev, i); 325dd7cc44dSYu Zhao 326c23b6135SAlexander Duyck err_pcibios: 327dd7cc44dSYu Zhao iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 328fb51ccbfSJan Kiszka pci_cfg_access_lock(dev); 329dd7cc44dSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 330dd7cc44dSYu Zhao ssleep(1); 331fb51ccbfSJan Kiszka pci_cfg_access_unlock(dev); 332dd7cc44dSYu Zhao 3330fc690a7SGavin Shan pcibios_sriov_disable(dev); 3340fc690a7SGavin Shan 335dd7cc44dSYu Zhao if (iov->link != dev->devfn) 336dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, "dep_link"); 337dd7cc44dSYu Zhao 338b3908644SAlexander Duyck pci_iov_set_numvfs(dev, 0); 339dd7cc44dSYu Zhao return rc; 340dd7cc44dSYu Zhao } 341dd7cc44dSYu Zhao 342dd7cc44dSYu Zhao static void sriov_disable(struct pci_dev *dev) 343dd7cc44dSYu Zhao { 344dd7cc44dSYu Zhao int i; 345dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 346dd7cc44dSYu Zhao 3476b136724SBjorn Helgaas if (!iov->num_VFs) 348dd7cc44dSYu Zhao return; 349dd7cc44dSYu Zhao 3506b136724SBjorn Helgaas for (i = 0; i < iov->num_VFs; i++) 351753f6124SJan H. Schönherr pci_iov_remove_virtfn(dev, i); 352dd7cc44dSYu Zhao 353dd7cc44dSYu Zhao iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 354fb51ccbfSJan Kiszka pci_cfg_access_lock(dev); 355dd7cc44dSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 356dd7cc44dSYu Zhao ssleep(1); 357fb51ccbfSJan Kiszka pci_cfg_access_unlock(dev); 358dd7cc44dSYu Zhao 3590fc690a7SGavin Shan pcibios_sriov_disable(dev); 3600fc690a7SGavin Shan 361dd7cc44dSYu Zhao if (iov->link != dev->devfn) 362dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, "dep_link"); 363dd7cc44dSYu Zhao 3646b136724SBjorn Helgaas iov->num_VFs = 0; 365f59dca27SWei Yang pci_iov_set_numvfs(dev, 0); 366dd7cc44dSYu Zhao } 367dd7cc44dSYu Zhao 368d1b054daSYu Zhao static int sriov_init(struct pci_dev *dev, int pos) 369d1b054daSYu Zhao { 3700e6c9122SWei Yang int i, bar64; 371d1b054daSYu Zhao int rc; 372d1b054daSYu Zhao int nres; 373d1b054daSYu Zhao u32 pgsz; 374ea9a8854SAlexander Duyck u16 ctrl, total; 375d1b054daSYu Zhao struct pci_sriov *iov; 376d1b054daSYu Zhao struct resource *res; 377d1b054daSYu Zhao struct pci_dev *pdev; 378d1b054daSYu Zhao 379d1b054daSYu Zhao pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl); 380d1b054daSYu Zhao if (ctrl & PCI_SRIOV_CTRL_VFE) { 381d1b054daSYu Zhao pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0); 382d1b054daSYu Zhao ssleep(1); 383d1b054daSYu Zhao } 384d1b054daSYu Zhao 385d1b054daSYu Zhao ctrl = 0; 386d1b054daSYu Zhao list_for_each_entry(pdev, &dev->bus->devices, bus_list) 387d1b054daSYu Zhao if (pdev->is_physfn) 388d1b054daSYu Zhao goto found; 389d1b054daSYu Zhao 390d1b054daSYu Zhao pdev = NULL; 391d1b054daSYu Zhao if (pci_ari_enabled(dev->bus)) 392d1b054daSYu Zhao ctrl |= PCI_SRIOV_CTRL_ARI; 393d1b054daSYu Zhao 394d1b054daSYu Zhao found: 395d1b054daSYu Zhao pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl); 396d1b054daSYu Zhao 397ff45f9ddSBen Shelton pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total); 398ff45f9ddSBen Shelton if (!total) 399ff45f9ddSBen Shelton return 0; 400d1b054daSYu Zhao 401d1b054daSYu Zhao pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz); 402d1b054daSYu Zhao i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0; 403d1b054daSYu Zhao pgsz &= ~((1 << i) - 1); 404d1b054daSYu Zhao if (!pgsz) 405d1b054daSYu Zhao return -EIO; 406d1b054daSYu Zhao 407d1b054daSYu Zhao pgsz &= ~(pgsz - 1); 4088161fe91SVaidyanathan Srinivasan pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz); 409d1b054daSYu Zhao 4100e6c9122SWei Yang iov = kzalloc(sizeof(*iov), GFP_KERNEL); 4110e6c9122SWei Yang if (!iov) 4120e6c9122SWei Yang return -ENOMEM; 4130e6c9122SWei Yang 414d1b054daSYu Zhao nres = 0; 415d1b054daSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 416c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 41711183991SDavid Daney /* 41811183991SDavid Daney * If it is already FIXED, don't change it, something 41911183991SDavid Daney * (perhaps EA or header fixups) wants it this way. 42011183991SDavid Daney */ 42111183991SDavid Daney if (res->flags & IORESOURCE_PCI_FIXED) 42211183991SDavid Daney bar64 = (res->flags & IORESOURCE_MEM_64) ? 1 : 0; 42311183991SDavid Daney else 4240e6c9122SWei Yang bar64 = __pci_read_base(dev, pci_bar_unknown, res, 425d1b054daSYu Zhao pos + PCI_SRIOV_BAR + i * 4); 426d1b054daSYu Zhao if (!res->flags) 427d1b054daSYu Zhao continue; 428d1b054daSYu Zhao if (resource_size(res) & (PAGE_SIZE - 1)) { 429d1b054daSYu Zhao rc = -EIO; 430d1b054daSYu Zhao goto failed; 431d1b054daSYu Zhao } 4320e6c9122SWei Yang iov->barsz[i] = resource_size(res); 433d1b054daSYu Zhao res->end = res->start + resource_size(res) * total - 1; 434e88ae01dSWei Yang dev_info(&dev->dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n", 435e88ae01dSWei Yang i, res, i, total); 4360e6c9122SWei Yang i += bar64; 437d1b054daSYu Zhao nres++; 438d1b054daSYu Zhao } 439d1b054daSYu Zhao 440d1b054daSYu Zhao iov->pos = pos; 441d1b054daSYu Zhao iov->nres = nres; 442d1b054daSYu Zhao iov->ctrl = ctrl; 4436b136724SBjorn Helgaas iov->total_VFs = total; 444d1b054daSYu Zhao iov->pgsz = pgsz; 445d1b054daSYu Zhao iov->self = dev; 4460e7df224SBodong Wang iov->drivers_autoprobe = true; 447d1b054daSYu Zhao pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap); 448d1b054daSYu Zhao pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link); 44962f87c0eSYijing Wang if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END) 4504d135dbeSYu Zhao iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link); 451d1b054daSYu Zhao 452d1b054daSYu Zhao if (pdev) 453d1b054daSYu Zhao iov->dev = pci_dev_get(pdev); 454e277d2fcSYu Zhao else 455d1b054daSYu Zhao iov->dev = dev; 456e277d2fcSYu Zhao 457d1b054daSYu Zhao dev->sriov = iov; 458d1b054daSYu Zhao dev->is_physfn = 1; 459ea9a8854SAlexander Duyck rc = compute_max_vf_buses(dev); 460ea9a8854SAlexander Duyck if (rc) 461ea9a8854SAlexander Duyck goto fail_max_buses; 462d1b054daSYu Zhao 463d1b054daSYu Zhao return 0; 464d1b054daSYu Zhao 465ea9a8854SAlexander Duyck fail_max_buses: 466ea9a8854SAlexander Duyck dev->sriov = NULL; 467ea9a8854SAlexander Duyck dev->is_physfn = 0; 468d1b054daSYu Zhao failed: 469d1b054daSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 470c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 471d1b054daSYu Zhao res->flags = 0; 472d1b054daSYu Zhao } 473d1b054daSYu Zhao 4740e6c9122SWei Yang kfree(iov); 475d1b054daSYu Zhao return rc; 476d1b054daSYu Zhao } 477d1b054daSYu Zhao 478d1b054daSYu Zhao static void sriov_release(struct pci_dev *dev) 479d1b054daSYu Zhao { 4806b136724SBjorn Helgaas BUG_ON(dev->sriov->num_VFs); 481dd7cc44dSYu Zhao 482e277d2fcSYu Zhao if (dev != dev->sriov->dev) 483d1b054daSYu Zhao pci_dev_put(dev->sriov->dev); 484d1b054daSYu Zhao 485d1b054daSYu Zhao kfree(dev->sriov); 486d1b054daSYu Zhao dev->sriov = NULL; 487d1b054daSYu Zhao } 488d1b054daSYu Zhao 4898c5cdb6aSYu Zhao static void sriov_restore_state(struct pci_dev *dev) 4908c5cdb6aSYu Zhao { 4918c5cdb6aSYu Zhao int i; 4928c5cdb6aSYu Zhao u16 ctrl; 4938c5cdb6aSYu Zhao struct pci_sriov *iov = dev->sriov; 4948c5cdb6aSYu Zhao 4958c5cdb6aSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl); 4968c5cdb6aSYu Zhao if (ctrl & PCI_SRIOV_CTRL_VFE) 4978c5cdb6aSYu Zhao return; 4988c5cdb6aSYu Zhao 4998c5cdb6aSYu Zhao for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++) 5008c5cdb6aSYu Zhao pci_update_resource(dev, i); 5018c5cdb6aSYu Zhao 5028c5cdb6aSYu Zhao pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz); 503f59dca27SWei Yang pci_iov_set_numvfs(dev, iov->num_VFs); 5048c5cdb6aSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 5058c5cdb6aSYu Zhao if (iov->ctrl & PCI_SRIOV_CTRL_VFE) 5068c5cdb6aSYu Zhao msleep(100); 5078c5cdb6aSYu Zhao } 5088c5cdb6aSYu Zhao 509d1b054daSYu Zhao /** 510d1b054daSYu Zhao * pci_iov_init - initialize the IOV capability 511d1b054daSYu Zhao * @dev: the PCI device 512d1b054daSYu Zhao * 513d1b054daSYu Zhao * Returns 0 on success, or negative on failure. 514d1b054daSYu Zhao */ 515d1b054daSYu Zhao int pci_iov_init(struct pci_dev *dev) 516d1b054daSYu Zhao { 517d1b054daSYu Zhao int pos; 518d1b054daSYu Zhao 5195f4d91a1SKenji Kaneshige if (!pci_is_pcie(dev)) 520d1b054daSYu Zhao return -ENODEV; 521d1b054daSYu Zhao 522d1b054daSYu Zhao pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV); 523d1b054daSYu Zhao if (pos) 524d1b054daSYu Zhao return sriov_init(dev, pos); 525d1b054daSYu Zhao 526d1b054daSYu Zhao return -ENODEV; 527d1b054daSYu Zhao } 528d1b054daSYu Zhao 529d1b054daSYu Zhao /** 530d1b054daSYu Zhao * pci_iov_release - release resources used by the IOV capability 531d1b054daSYu Zhao * @dev: the PCI device 532d1b054daSYu Zhao */ 533d1b054daSYu Zhao void pci_iov_release(struct pci_dev *dev) 534d1b054daSYu Zhao { 535d1b054daSYu Zhao if (dev->is_physfn) 536d1b054daSYu Zhao sriov_release(dev); 537d1b054daSYu Zhao } 538d1b054daSYu Zhao 539d1b054daSYu Zhao /** 5406ffa2489SBjorn Helgaas * pci_iov_update_resource - update a VF BAR 5416ffa2489SBjorn Helgaas * @dev: the PCI device 5426ffa2489SBjorn Helgaas * @resno: the resource number 5436ffa2489SBjorn Helgaas * 5446ffa2489SBjorn Helgaas * Update a VF BAR in the SR-IOV capability of a PF. 5456ffa2489SBjorn Helgaas */ 5466ffa2489SBjorn Helgaas void pci_iov_update_resource(struct pci_dev *dev, int resno) 5476ffa2489SBjorn Helgaas { 5486ffa2489SBjorn Helgaas struct pci_sriov *iov = dev->is_physfn ? dev->sriov : NULL; 5496ffa2489SBjorn Helgaas struct resource *res = dev->resource + resno; 5506ffa2489SBjorn Helgaas int vf_bar = resno - PCI_IOV_RESOURCES; 5516ffa2489SBjorn Helgaas struct pci_bus_region region; 552546ba9f8SBjorn Helgaas u16 cmd; 5536ffa2489SBjorn Helgaas u32 new; 5546ffa2489SBjorn Helgaas int reg; 5556ffa2489SBjorn Helgaas 5566ffa2489SBjorn Helgaas /* 5576ffa2489SBjorn Helgaas * The generic pci_restore_bars() path calls this for all devices, 5586ffa2489SBjorn Helgaas * including VFs and non-SR-IOV devices. If this is not a PF, we 5596ffa2489SBjorn Helgaas * have nothing to do. 5606ffa2489SBjorn Helgaas */ 5616ffa2489SBjorn Helgaas if (!iov) 5626ffa2489SBjorn Helgaas return; 5636ffa2489SBjorn Helgaas 564546ba9f8SBjorn Helgaas pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &cmd); 565546ba9f8SBjorn Helgaas if ((cmd & PCI_SRIOV_CTRL_VFE) && (cmd & PCI_SRIOV_CTRL_MSE)) { 566546ba9f8SBjorn Helgaas dev_WARN(&dev->dev, "can't update enabled VF BAR%d %pR\n", 567546ba9f8SBjorn Helgaas vf_bar, res); 568546ba9f8SBjorn Helgaas return; 569546ba9f8SBjorn Helgaas } 570546ba9f8SBjorn Helgaas 5716ffa2489SBjorn Helgaas /* 5726ffa2489SBjorn Helgaas * Ignore unimplemented BARs, unused resource slots for 64-bit 5736ffa2489SBjorn Helgaas * BARs, and non-movable resources, e.g., those described via 5746ffa2489SBjorn Helgaas * Enhanced Allocation. 5756ffa2489SBjorn Helgaas */ 5766ffa2489SBjorn Helgaas if (!res->flags) 5776ffa2489SBjorn Helgaas return; 5786ffa2489SBjorn Helgaas 5796ffa2489SBjorn Helgaas if (res->flags & IORESOURCE_UNSET) 5806ffa2489SBjorn Helgaas return; 5816ffa2489SBjorn Helgaas 5826ffa2489SBjorn Helgaas if (res->flags & IORESOURCE_PCI_FIXED) 5836ffa2489SBjorn Helgaas return; 5846ffa2489SBjorn Helgaas 5856ffa2489SBjorn Helgaas pcibios_resource_to_bus(dev->bus, ®ion, res); 5866ffa2489SBjorn Helgaas new = region.start; 5876ffa2489SBjorn Helgaas new |= res->flags & ~PCI_BASE_ADDRESS_MEM_MASK; 5886ffa2489SBjorn Helgaas 5896ffa2489SBjorn Helgaas reg = iov->pos + PCI_SRIOV_BAR + 4 * vf_bar; 5906ffa2489SBjorn Helgaas pci_write_config_dword(dev, reg, new); 5916ffa2489SBjorn Helgaas if (res->flags & IORESOURCE_MEM_64) { 5926ffa2489SBjorn Helgaas new = region.start >> 16 >> 16; 5936ffa2489SBjorn Helgaas pci_write_config_dword(dev, reg + 4, new); 5946ffa2489SBjorn Helgaas } 5956ffa2489SBjorn Helgaas } 5966ffa2489SBjorn Helgaas 597978d2d68SWei Yang resource_size_t __weak pcibios_iov_resource_alignment(struct pci_dev *dev, 598978d2d68SWei Yang int resno) 599978d2d68SWei Yang { 600978d2d68SWei Yang return pci_iov_resource_size(dev, resno); 601978d2d68SWei Yang } 602978d2d68SWei Yang 6038c5cdb6aSYu Zhao /** 6046faf17f6SChris Wright * pci_sriov_resource_alignment - get resource alignment for VF BAR 6056faf17f6SChris Wright * @dev: the PCI device 6066faf17f6SChris Wright * @resno: the resource number 6076faf17f6SChris Wright * 6086faf17f6SChris Wright * Returns the alignment of the VF BAR found in the SR-IOV capability. 6096faf17f6SChris Wright * This is not the same as the resource size which is defined as 6106faf17f6SChris Wright * the VF BAR size multiplied by the number of VFs. The alignment 6116faf17f6SChris Wright * is just the VF BAR size. 6126faf17f6SChris Wright */ 6130e52247aSCam Macdonell resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno) 6146faf17f6SChris Wright { 615978d2d68SWei Yang return pcibios_iov_resource_alignment(dev, resno); 6166faf17f6SChris Wright } 6176faf17f6SChris Wright 6186faf17f6SChris Wright /** 6198c5cdb6aSYu Zhao * pci_restore_iov_state - restore the state of the IOV capability 6208c5cdb6aSYu Zhao * @dev: the PCI device 6218c5cdb6aSYu Zhao */ 6228c5cdb6aSYu Zhao void pci_restore_iov_state(struct pci_dev *dev) 6238c5cdb6aSYu Zhao { 6248c5cdb6aSYu Zhao if (dev->is_physfn) 6258c5cdb6aSYu Zhao sriov_restore_state(dev); 6268c5cdb6aSYu Zhao } 627a28724b0SYu Zhao 628a28724b0SYu Zhao /** 629a28724b0SYu Zhao * pci_iov_bus_range - find bus range used by Virtual Function 630a28724b0SYu Zhao * @bus: the PCI bus 631a28724b0SYu Zhao * 632a28724b0SYu Zhao * Returns max number of buses (exclude current one) used by Virtual 633a28724b0SYu Zhao * Functions. 634a28724b0SYu Zhao */ 635a28724b0SYu Zhao int pci_iov_bus_range(struct pci_bus *bus) 636a28724b0SYu Zhao { 637a28724b0SYu Zhao int max = 0; 638a28724b0SYu Zhao struct pci_dev *dev; 639a28724b0SYu Zhao 640a28724b0SYu Zhao list_for_each_entry(dev, &bus->devices, bus_list) { 641a28724b0SYu Zhao if (!dev->is_physfn) 642a28724b0SYu Zhao continue; 6434449f079SWei Yang if (dev->sriov->max_VF_buses > max) 6444449f079SWei Yang max = dev->sriov->max_VF_buses; 645a28724b0SYu Zhao } 646a28724b0SYu Zhao 647a28724b0SYu Zhao return max ? max - bus->number : 0; 648a28724b0SYu Zhao } 649dd7cc44dSYu Zhao 650dd7cc44dSYu Zhao /** 651dd7cc44dSYu Zhao * pci_enable_sriov - enable the SR-IOV capability 652dd7cc44dSYu Zhao * @dev: the PCI device 65352a8873bSRandy Dunlap * @nr_virtfn: number of virtual functions to enable 654dd7cc44dSYu Zhao * 655dd7cc44dSYu Zhao * Returns 0 on success, or negative on failure. 656dd7cc44dSYu Zhao */ 657dd7cc44dSYu Zhao int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn) 658dd7cc44dSYu Zhao { 659dd7cc44dSYu Zhao might_sleep(); 660dd7cc44dSYu Zhao 661dd7cc44dSYu Zhao if (!dev->is_physfn) 662652d1100SStefan Assmann return -ENOSYS; 663dd7cc44dSYu Zhao 664dd7cc44dSYu Zhao return sriov_enable(dev, nr_virtfn); 665dd7cc44dSYu Zhao } 666dd7cc44dSYu Zhao EXPORT_SYMBOL_GPL(pci_enable_sriov); 667dd7cc44dSYu Zhao 668dd7cc44dSYu Zhao /** 669dd7cc44dSYu Zhao * pci_disable_sriov - disable the SR-IOV capability 670dd7cc44dSYu Zhao * @dev: the PCI device 671dd7cc44dSYu Zhao */ 672dd7cc44dSYu Zhao void pci_disable_sriov(struct pci_dev *dev) 673dd7cc44dSYu Zhao { 674dd7cc44dSYu Zhao might_sleep(); 675dd7cc44dSYu Zhao 676dd7cc44dSYu Zhao if (!dev->is_physfn) 677dd7cc44dSYu Zhao return; 678dd7cc44dSYu Zhao 679dd7cc44dSYu Zhao sriov_disable(dev); 680dd7cc44dSYu Zhao } 681dd7cc44dSYu Zhao EXPORT_SYMBOL_GPL(pci_disable_sriov); 68274bb1bccSYu Zhao 68374bb1bccSYu Zhao /** 684fb8a0d9dSWilliams, Mitch A * pci_num_vf - return number of VFs associated with a PF device_release_driver 685fb8a0d9dSWilliams, Mitch A * @dev: the PCI device 686fb8a0d9dSWilliams, Mitch A * 687fb8a0d9dSWilliams, Mitch A * Returns number of VFs, or 0 if SR-IOV is not enabled. 688fb8a0d9dSWilliams, Mitch A */ 689fb8a0d9dSWilliams, Mitch A int pci_num_vf(struct pci_dev *dev) 690fb8a0d9dSWilliams, Mitch A { 6911452cd76SBjorn Helgaas if (!dev->is_physfn) 692fb8a0d9dSWilliams, Mitch A return 0; 6931452cd76SBjorn Helgaas 6946b136724SBjorn Helgaas return dev->sriov->num_VFs; 695fb8a0d9dSWilliams, Mitch A } 696fb8a0d9dSWilliams, Mitch A EXPORT_SYMBOL_GPL(pci_num_vf); 697bff73156SDonald Dutile 698bff73156SDonald Dutile /** 6995a8eb242SAlexander Duyck * pci_vfs_assigned - returns number of VFs are assigned to a guest 7005a8eb242SAlexander Duyck * @dev: the PCI device 7015a8eb242SAlexander Duyck * 7025a8eb242SAlexander Duyck * Returns number of VFs belonging to this device that are assigned to a guest. 703652d1100SStefan Assmann * If device is not a physical function returns 0. 7045a8eb242SAlexander Duyck */ 7055a8eb242SAlexander Duyck int pci_vfs_assigned(struct pci_dev *dev) 7065a8eb242SAlexander Duyck { 7075a8eb242SAlexander Duyck struct pci_dev *vfdev; 7085a8eb242SAlexander Duyck unsigned int vfs_assigned = 0; 7095a8eb242SAlexander Duyck unsigned short dev_id; 7105a8eb242SAlexander Duyck 7115a8eb242SAlexander Duyck /* only search if we are a PF */ 7125a8eb242SAlexander Duyck if (!dev->is_physfn) 7135a8eb242SAlexander Duyck return 0; 7145a8eb242SAlexander Duyck 7155a8eb242SAlexander Duyck /* 7165a8eb242SAlexander Duyck * determine the device ID for the VFs, the vendor ID will be the 7175a8eb242SAlexander Duyck * same as the PF so there is no need to check for that one 7185a8eb242SAlexander Duyck */ 7195a8eb242SAlexander Duyck pci_read_config_word(dev, dev->sriov->pos + PCI_SRIOV_VF_DID, &dev_id); 7205a8eb242SAlexander Duyck 7215a8eb242SAlexander Duyck /* loop through all the VFs to see if we own any that are assigned */ 7225a8eb242SAlexander Duyck vfdev = pci_get_device(dev->vendor, dev_id, NULL); 7235a8eb242SAlexander Duyck while (vfdev) { 7245a8eb242SAlexander Duyck /* 7255a8eb242SAlexander Duyck * It is considered assigned if it is a virtual function with 7265a8eb242SAlexander Duyck * our dev as the physical function and the assigned bit is set 7275a8eb242SAlexander Duyck */ 7285a8eb242SAlexander Duyck if (vfdev->is_virtfn && (vfdev->physfn == dev) && 729be63497cSEthan Zhao pci_is_dev_assigned(vfdev)) 7305a8eb242SAlexander Duyck vfs_assigned++; 7315a8eb242SAlexander Duyck 7325a8eb242SAlexander Duyck vfdev = pci_get_device(dev->vendor, dev_id, vfdev); 7335a8eb242SAlexander Duyck } 7345a8eb242SAlexander Duyck 7355a8eb242SAlexander Duyck return vfs_assigned; 7365a8eb242SAlexander Duyck } 7375a8eb242SAlexander Duyck EXPORT_SYMBOL_GPL(pci_vfs_assigned); 7385a8eb242SAlexander Duyck 7395a8eb242SAlexander Duyck /** 740bff73156SDonald Dutile * pci_sriov_set_totalvfs -- reduce the TotalVFs available 741bff73156SDonald Dutile * @dev: the PCI PF device 7422094f167SRandy Dunlap * @numvfs: number that should be used for TotalVFs supported 743bff73156SDonald Dutile * 744bff73156SDonald Dutile * Should be called from PF driver's probe routine with 745bff73156SDonald Dutile * device's mutex held. 746bff73156SDonald Dutile * 747bff73156SDonald Dutile * Returns 0 if PF is an SRIOV-capable device and 748652d1100SStefan Assmann * value of numvfs valid. If not a PF return -ENOSYS; 749652d1100SStefan Assmann * if numvfs is invalid return -EINVAL; 750bff73156SDonald Dutile * if VFs already enabled, return -EBUSY. 751bff73156SDonald Dutile */ 752bff73156SDonald Dutile int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs) 753bff73156SDonald Dutile { 754652d1100SStefan Assmann if (!dev->is_physfn) 755652d1100SStefan Assmann return -ENOSYS; 756652d1100SStefan Assmann if (numvfs > dev->sriov->total_VFs) 757bff73156SDonald Dutile return -EINVAL; 758bff73156SDonald Dutile 759bff73156SDonald Dutile /* Shouldn't change if VFs already enabled */ 760bff73156SDonald Dutile if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE) 761bff73156SDonald Dutile return -EBUSY; 762bff73156SDonald Dutile else 7636b136724SBjorn Helgaas dev->sriov->driver_max_VFs = numvfs; 764bff73156SDonald Dutile 765bff73156SDonald Dutile return 0; 766bff73156SDonald Dutile } 767bff73156SDonald Dutile EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs); 768bff73156SDonald Dutile 769bff73156SDonald Dutile /** 770ddc191f5SJonghwan Choi * pci_sriov_get_totalvfs -- get total VFs supported on this device 771bff73156SDonald Dutile * @dev: the PCI PF device 772bff73156SDonald Dutile * 773bff73156SDonald Dutile * For a PCIe device with SRIOV support, return the PCIe 7746b136724SBjorn Helgaas * SRIOV capability value of TotalVFs or the value of driver_max_VFs 775652d1100SStefan Assmann * if the driver reduced it. Otherwise 0. 776bff73156SDonald Dutile */ 777bff73156SDonald Dutile int pci_sriov_get_totalvfs(struct pci_dev *dev) 778bff73156SDonald Dutile { 7791452cd76SBjorn Helgaas if (!dev->is_physfn) 780652d1100SStefan Assmann return 0; 781bff73156SDonald Dutile 7826b136724SBjorn Helgaas if (dev->sriov->driver_max_VFs) 7836b136724SBjorn Helgaas return dev->sriov->driver_max_VFs; 7841452cd76SBjorn Helgaas 7856b136724SBjorn Helgaas return dev->sriov->total_VFs; 786bff73156SDonald Dutile } 787bff73156SDonald Dutile EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs); 788