17328c8f4SBjorn Helgaas // SPDX-License-Identifier: GPL-2.0 2d1b054daSYu Zhao /* 3df62ab5eSBjorn Helgaas * PCI Express I/O Virtualization (IOV) support 4d1b054daSYu Zhao * Single Root IOV 1.0 5302b4215SYu Zhao * Address Translation Service 1.0 6df62ab5eSBjorn Helgaas * 7df62ab5eSBjorn Helgaas * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com> 8d1b054daSYu Zhao */ 9d1b054daSYu Zhao 10d1b054daSYu Zhao #include <linux/pci.h> 115a0e3ad6STejun Heo #include <linux/slab.h> 12d1b054daSYu Zhao #include <linux/mutex.h> 13363c75dbSPaul Gortmaker #include <linux/export.h> 14d1b054daSYu Zhao #include <linux/string.h> 15d1b054daSYu Zhao #include <linux/delay.h> 16d1b054daSYu Zhao #include "pci.h" 17d1b054daSYu Zhao 18dd7cc44dSYu Zhao #define VIRTFN_ID_LEN 16 19d1b054daSYu Zhao 20b07579c0SWei Yang int pci_iov_virtfn_bus(struct pci_dev *dev, int vf_id) 21a28724b0SYu Zhao { 22b07579c0SWei Yang if (!dev->is_physfn) 23b07579c0SWei Yang return -EINVAL; 24a28724b0SYu Zhao return dev->bus->number + ((dev->devfn + dev->sriov->offset + 25b07579c0SWei Yang dev->sriov->stride * vf_id) >> 8); 26a28724b0SYu Zhao } 27a28724b0SYu Zhao 28b07579c0SWei Yang int pci_iov_virtfn_devfn(struct pci_dev *dev, int vf_id) 29a28724b0SYu Zhao { 30b07579c0SWei Yang if (!dev->is_physfn) 31b07579c0SWei Yang return -EINVAL; 32a28724b0SYu Zhao return (dev->devfn + dev->sriov->offset + 33b07579c0SWei Yang dev->sriov->stride * vf_id) & 0xff; 34a28724b0SYu Zhao } 35a28724b0SYu Zhao 36f59dca27SWei Yang /* 37f59dca27SWei Yang * Per SR-IOV spec sec 3.3.10 and 3.3.11, First VF Offset and VF Stride may 38f59dca27SWei Yang * change when NumVFs changes. 39f59dca27SWei Yang * 40f59dca27SWei Yang * Update iov->offset and iov->stride when NumVFs is written. 41f59dca27SWei Yang */ 42f59dca27SWei Yang static inline void pci_iov_set_numvfs(struct pci_dev *dev, int nr_virtfn) 43f59dca27SWei Yang { 44f59dca27SWei Yang struct pci_sriov *iov = dev->sriov; 45f59dca27SWei Yang 46f59dca27SWei Yang pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn); 47f59dca27SWei Yang pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &iov->offset); 48f59dca27SWei Yang pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &iov->stride); 49f59dca27SWei Yang } 50f59dca27SWei Yang 514449f079SWei Yang /* 524449f079SWei Yang * The PF consumes one bus number. NumVFs, First VF Offset, and VF Stride 534449f079SWei Yang * determine how many additional bus numbers will be consumed by VFs. 544449f079SWei Yang * 55ea9a8854SAlexander Duyck * Iterate over all valid NumVFs, validate offset and stride, and calculate 56ea9a8854SAlexander Duyck * the maximum number of bus numbers that could ever be required. 574449f079SWei Yang */ 58ea9a8854SAlexander Duyck static int compute_max_vf_buses(struct pci_dev *dev) 594449f079SWei Yang { 604449f079SWei Yang struct pci_sriov *iov = dev->sriov; 61ea9a8854SAlexander Duyck int nr_virtfn, busnr, rc = 0; 624449f079SWei Yang 63ea9a8854SAlexander Duyck for (nr_virtfn = iov->total_VFs; nr_virtfn; nr_virtfn--) { 644449f079SWei Yang pci_iov_set_numvfs(dev, nr_virtfn); 65ea9a8854SAlexander Duyck if (!iov->offset || (nr_virtfn > 1 && !iov->stride)) { 66ea9a8854SAlexander Duyck rc = -EIO; 67ea9a8854SAlexander Duyck goto out; 684449f079SWei Yang } 694449f079SWei Yang 70ea9a8854SAlexander Duyck busnr = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 71ea9a8854SAlexander Duyck if (busnr > iov->max_VF_buses) 72ea9a8854SAlexander Duyck iov->max_VF_buses = busnr; 73ea9a8854SAlexander Duyck } 74ea9a8854SAlexander Duyck 75ea9a8854SAlexander Duyck out: 76ea9a8854SAlexander Duyck pci_iov_set_numvfs(dev, 0); 77ea9a8854SAlexander Duyck return rc; 784449f079SWei Yang } 794449f079SWei Yang 80dd7cc44dSYu Zhao static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr) 81dd7cc44dSYu Zhao { 82dd7cc44dSYu Zhao struct pci_bus *child; 83dd7cc44dSYu Zhao 84dd7cc44dSYu Zhao if (bus->number == busnr) 85dd7cc44dSYu Zhao return bus; 86dd7cc44dSYu Zhao 87dd7cc44dSYu Zhao child = pci_find_bus(pci_domain_nr(bus), busnr); 88dd7cc44dSYu Zhao if (child) 89dd7cc44dSYu Zhao return child; 90dd7cc44dSYu Zhao 91dd7cc44dSYu Zhao child = pci_add_new_bus(bus, NULL, busnr); 92dd7cc44dSYu Zhao if (!child) 93dd7cc44dSYu Zhao return NULL; 94dd7cc44dSYu Zhao 95b7eac055SYinghai Lu pci_bus_insert_busn_res(child, busnr, busnr); 96dd7cc44dSYu Zhao 97dd7cc44dSYu Zhao return child; 98dd7cc44dSYu Zhao } 99dd7cc44dSYu Zhao 100dc087f2fSJiang Liu static void virtfn_remove_bus(struct pci_bus *physbus, struct pci_bus *virtbus) 101dd7cc44dSYu Zhao { 102dc087f2fSJiang Liu if (physbus != virtbus && list_empty(&virtbus->devices)) 103dc087f2fSJiang Liu pci_remove_bus(virtbus); 104dd7cc44dSYu Zhao } 105dd7cc44dSYu Zhao 1060e6c9122SWei Yang resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno) 1070e6c9122SWei Yang { 1080e6c9122SWei Yang if (!dev->is_physfn) 1090e6c9122SWei Yang return 0; 1100e6c9122SWei Yang 1110e6c9122SWei Yang return dev->sriov->barsz[resno - PCI_IOV_RESOURCES]; 1120e6c9122SWei Yang } 1130e6c9122SWei Yang 114cf0921beSKarimAllah Ahmed static void pci_read_vf_config_common(struct pci_dev *virtfn) 115cf0921beSKarimAllah Ahmed { 116cf0921beSKarimAllah Ahmed struct pci_dev *physfn = virtfn->physfn; 117cf0921beSKarimAllah Ahmed 118cf0921beSKarimAllah Ahmed /* 119cf0921beSKarimAllah Ahmed * Some config registers are the same across all associated VFs. 120cf0921beSKarimAllah Ahmed * Read them once from VF0 so we can skip reading them from the 121cf0921beSKarimAllah Ahmed * other VFs. 122cf0921beSKarimAllah Ahmed * 123cf0921beSKarimAllah Ahmed * PCIe r4.0, sec 9.3.4.1, technically doesn't require all VFs to 124cf0921beSKarimAllah Ahmed * have the same Revision ID and Subsystem ID, but we assume they 125cf0921beSKarimAllah Ahmed * do. 126cf0921beSKarimAllah Ahmed */ 127cf0921beSKarimAllah Ahmed pci_read_config_dword(virtfn, PCI_CLASS_REVISION, 128cf0921beSKarimAllah Ahmed &physfn->sriov->class); 129cf0921beSKarimAllah Ahmed pci_read_config_byte(virtfn, PCI_HEADER_TYPE, 130cf0921beSKarimAllah Ahmed &physfn->sriov->hdr_type); 131cf0921beSKarimAllah Ahmed pci_read_config_word(virtfn, PCI_SUBSYSTEM_VENDOR_ID, 132cf0921beSKarimAllah Ahmed &physfn->sriov->subsystem_vendor); 133cf0921beSKarimAllah Ahmed pci_read_config_word(virtfn, PCI_SUBSYSTEM_ID, 134cf0921beSKarimAllah Ahmed &physfn->sriov->subsystem_device); 135cf0921beSKarimAllah Ahmed } 136cf0921beSKarimAllah Ahmed 137753f6124SJan H. Schönherr int pci_iov_add_virtfn(struct pci_dev *dev, int id) 138dd7cc44dSYu Zhao { 139dd7cc44dSYu Zhao int i; 140dc087f2fSJiang Liu int rc = -ENOMEM; 141dd7cc44dSYu Zhao u64 size; 142dd7cc44dSYu Zhao char buf[VIRTFN_ID_LEN]; 143dd7cc44dSYu Zhao struct pci_dev *virtfn; 144dd7cc44dSYu Zhao struct resource *res; 145dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 1468b1fce04SGu Zheng struct pci_bus *bus; 147dd7cc44dSYu Zhao 148b07579c0SWei Yang bus = virtfn_add_bus(dev->bus, pci_iov_virtfn_bus(dev, id)); 149dc087f2fSJiang Liu if (!bus) 150dc087f2fSJiang Liu goto failed; 151dc087f2fSJiang Liu 152dc087f2fSJiang Liu virtfn = pci_alloc_dev(bus); 153dc087f2fSJiang Liu if (!virtfn) 154dc087f2fSJiang Liu goto failed0; 155dc087f2fSJiang Liu 156b07579c0SWei Yang virtfn->devfn = pci_iov_virtfn_devfn(dev, id); 157dd7cc44dSYu Zhao virtfn->vendor = dev->vendor; 1583142d832SFilippo Sironi virtfn->device = iov->vf_device; 159cf0921beSKarimAllah Ahmed virtfn->is_virtfn = 1; 160cf0921beSKarimAllah Ahmed virtfn->physfn = pci_dev_get(dev); 161cf0921beSKarimAllah Ahmed 162cf0921beSKarimAllah Ahmed if (id == 0) 163cf0921beSKarimAllah Ahmed pci_read_vf_config_common(virtfn); 164cf0921beSKarimAllah Ahmed 165156c5532SPo Liu rc = pci_setup_device(virtfn); 166156c5532SPo Liu if (rc) 167cf0921beSKarimAllah Ahmed goto failed1; 168156c5532SPo Liu 169dd7cc44dSYu Zhao virtfn->dev.parent = dev->dev.parent; 170aa931977SAlex Williamson virtfn->multifunction = 0; 171dd7cc44dSYu Zhao 172dd7cc44dSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 173c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 174dd7cc44dSYu Zhao if (!res->parent) 175dd7cc44dSYu Zhao continue; 176dd7cc44dSYu Zhao virtfn->resource[i].name = pci_name(virtfn); 177dd7cc44dSYu Zhao virtfn->resource[i].flags = res->flags; 1780e6c9122SWei Yang size = pci_iov_resource_size(dev, i + PCI_IOV_RESOURCES); 179dd7cc44dSYu Zhao virtfn->resource[i].start = res->start + size * id; 180dd7cc44dSYu Zhao virtfn->resource[i].end = virtfn->resource[i].start + size - 1; 181dd7cc44dSYu Zhao rc = request_resource(res, &virtfn->resource[i]); 182dd7cc44dSYu Zhao BUG_ON(rc); 183dd7cc44dSYu Zhao } 184dd7cc44dSYu Zhao 185dd7cc44dSYu Zhao pci_device_add(virtfn, virtfn->bus); 186dd7cc44dSYu Zhao 187dd7cc44dSYu Zhao sprintf(buf, "virtfn%u", id); 188dd7cc44dSYu Zhao rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf); 189dd7cc44dSYu Zhao if (rc) 190cf0921beSKarimAllah Ahmed goto failed2; 191dd7cc44dSYu Zhao rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn"); 192dd7cc44dSYu Zhao if (rc) 193cf0921beSKarimAllah Ahmed goto failed3; 194dd7cc44dSYu Zhao 195dd7cc44dSYu Zhao kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE); 196dd7cc44dSYu Zhao 19727d61629SStuart Hayes pci_bus_add_device(virtfn); 19827d61629SStuart Hayes 199dd7cc44dSYu Zhao return 0; 200dd7cc44dSYu Zhao 201cf0921beSKarimAllah Ahmed failed3: 202dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, buf); 203cf0921beSKarimAllah Ahmed failed2: 204cf0921beSKarimAllah Ahmed pci_stop_and_remove_bus_device(virtfn); 205dd7cc44dSYu Zhao failed1: 206dd7cc44dSYu Zhao pci_dev_put(dev); 207dc087f2fSJiang Liu failed0: 208dc087f2fSJiang Liu virtfn_remove_bus(dev->bus, bus); 209dc087f2fSJiang Liu failed: 210dd7cc44dSYu Zhao 211dd7cc44dSYu Zhao return rc; 212dd7cc44dSYu Zhao } 213dd7cc44dSYu Zhao 214753f6124SJan H. Schönherr void pci_iov_remove_virtfn(struct pci_dev *dev, int id) 215dd7cc44dSYu Zhao { 216dd7cc44dSYu Zhao char buf[VIRTFN_ID_LEN]; 217dd7cc44dSYu Zhao struct pci_dev *virtfn; 218dd7cc44dSYu Zhao 219dc087f2fSJiang Liu virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus), 220b07579c0SWei Yang pci_iov_virtfn_bus(dev, id), 221b07579c0SWei Yang pci_iov_virtfn_devfn(dev, id)); 222dd7cc44dSYu Zhao if (!virtfn) 223dd7cc44dSYu Zhao return; 224dd7cc44dSYu Zhao 225dd7cc44dSYu Zhao sprintf(buf, "virtfn%u", id); 226dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, buf); 22709cedbefSYinghai Lu /* 22809cedbefSYinghai Lu * pci_stop_dev() could have been called for this virtfn already, 22909cedbefSYinghai Lu * so the directory for the virtfn may have been removed before. 23009cedbefSYinghai Lu * Double check to avoid spurious sysfs warnings. 23109cedbefSYinghai Lu */ 23209cedbefSYinghai Lu if (virtfn->dev.kobj.sd) 233dd7cc44dSYu Zhao sysfs_remove_link(&virtfn->dev.kobj, "physfn"); 234dd7cc44dSYu Zhao 235210647afSYinghai Lu pci_stop_and_remove_bus_device(virtfn); 236dc087f2fSJiang Liu virtfn_remove_bus(dev->bus, virtfn->bus); 237dd7cc44dSYu Zhao 238dc087f2fSJiang Liu /* balance pci_get_domain_bus_and_slot() */ 239dc087f2fSJiang Liu pci_dev_put(virtfn); 240dd7cc44dSYu Zhao pci_dev_put(dev); 241dd7cc44dSYu Zhao } 242dd7cc44dSYu Zhao 243995df527SWei Yang int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs) 244995df527SWei Yang { 245995df527SWei Yang return 0; 246995df527SWei Yang } 247995df527SWei Yang 248a39e3fcdSAlexander Duyck int __weak pcibios_sriov_disable(struct pci_dev *pdev) 249a39e3fcdSAlexander Duyck { 250a39e3fcdSAlexander Duyck return 0; 251a39e3fcdSAlexander Duyck } 252a39e3fcdSAlexander Duyck 25318f9e9d1SSebastian Ott static int sriov_add_vfs(struct pci_dev *dev, u16 num_vfs) 25418f9e9d1SSebastian Ott { 25518f9e9d1SSebastian Ott unsigned int i; 25618f9e9d1SSebastian Ott int rc; 25718f9e9d1SSebastian Ott 258aff68a5aSSebastian Ott if (dev->no_vf_scan) 259aff68a5aSSebastian Ott return 0; 260aff68a5aSSebastian Ott 26118f9e9d1SSebastian Ott for (i = 0; i < num_vfs; i++) { 26218f9e9d1SSebastian Ott rc = pci_iov_add_virtfn(dev, i); 26318f9e9d1SSebastian Ott if (rc) 26418f9e9d1SSebastian Ott goto failed; 26518f9e9d1SSebastian Ott } 26618f9e9d1SSebastian Ott return 0; 26718f9e9d1SSebastian Ott failed: 26818f9e9d1SSebastian Ott while (i--) 26918f9e9d1SSebastian Ott pci_iov_remove_virtfn(dev, i); 27018f9e9d1SSebastian Ott 27118f9e9d1SSebastian Ott return rc; 27218f9e9d1SSebastian Ott } 27318f9e9d1SSebastian Ott 274dd7cc44dSYu Zhao static int sriov_enable(struct pci_dev *dev, int nr_virtfn) 275dd7cc44dSYu Zhao { 276dd7cc44dSYu Zhao int rc; 2773443c382SAlexander Duyck int i; 278dd7cc44dSYu Zhao int nres; 279ce288ec3SAlexander Duyck u16 initial; 280dd7cc44dSYu Zhao struct resource *res; 281dd7cc44dSYu Zhao struct pci_dev *pdev; 282dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 283bbef98abSRam Pai int bars = 0; 284b07579c0SWei Yang int bus; 285dd7cc44dSYu Zhao 286dd7cc44dSYu Zhao if (!nr_virtfn) 287dd7cc44dSYu Zhao return 0; 288dd7cc44dSYu Zhao 2896b136724SBjorn Helgaas if (iov->num_VFs) 290dd7cc44dSYu Zhao return -EINVAL; 291dd7cc44dSYu Zhao 292dd7cc44dSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial); 2936b136724SBjorn Helgaas if (initial > iov->total_VFs || 2946b136724SBjorn Helgaas (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs))) 295dd7cc44dSYu Zhao return -EIO; 296dd7cc44dSYu Zhao 2976b136724SBjorn Helgaas if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs || 298dd7cc44dSYu Zhao (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial))) 299dd7cc44dSYu Zhao return -EINVAL; 300dd7cc44dSYu Zhao 301dd7cc44dSYu Zhao nres = 0; 302dd7cc44dSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 303bbef98abSRam Pai bars |= (1 << (i + PCI_IOV_RESOURCES)); 304c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 305dd7cc44dSYu Zhao if (res->parent) 306dd7cc44dSYu Zhao nres++; 307dd7cc44dSYu Zhao } 308dd7cc44dSYu Zhao if (nres != iov->nres) { 3097506dc79SFrederick Lawler pci_err(dev, "not enough MMIO resources for SR-IOV\n"); 310dd7cc44dSYu Zhao return -ENOMEM; 311dd7cc44dSYu Zhao } 312dd7cc44dSYu Zhao 313b07579c0SWei Yang bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 31468f8e9faSBjorn Helgaas if (bus > dev->bus->busn_res.end) { 3157506dc79SFrederick Lawler pci_err(dev, "can't enable %d VFs (bus %02x out of range of %pR)\n", 31668f8e9faSBjorn Helgaas nr_virtfn, bus, &dev->bus->busn_res); 317dd7cc44dSYu Zhao return -ENOMEM; 318dd7cc44dSYu Zhao } 319dd7cc44dSYu Zhao 320bbef98abSRam Pai if (pci_enable_resources(dev, bars)) { 3217506dc79SFrederick Lawler pci_err(dev, "SR-IOV: IOV BARS not allocated\n"); 322bbef98abSRam Pai return -ENOMEM; 323bbef98abSRam Pai } 324bbef98abSRam Pai 325dd7cc44dSYu Zhao if (iov->link != dev->devfn) { 326dd7cc44dSYu Zhao pdev = pci_get_slot(dev->bus, iov->link); 327dd7cc44dSYu Zhao if (!pdev) 328dd7cc44dSYu Zhao return -ENODEV; 329dd7cc44dSYu Zhao 330dc087f2fSJiang Liu if (!pdev->is_physfn) { 331dd7cc44dSYu Zhao pci_dev_put(pdev); 332652d1100SStefan Assmann return -ENOSYS; 333dc087f2fSJiang Liu } 334dd7cc44dSYu Zhao 335dd7cc44dSYu Zhao rc = sysfs_create_link(&dev->dev.kobj, 336dd7cc44dSYu Zhao &pdev->dev.kobj, "dep_link"); 337dc087f2fSJiang Liu pci_dev_put(pdev); 338dd7cc44dSYu Zhao if (rc) 339dd7cc44dSYu Zhao return rc; 340dd7cc44dSYu Zhao } 341dd7cc44dSYu Zhao 3426b136724SBjorn Helgaas iov->initial_VFs = initial; 343dd7cc44dSYu Zhao if (nr_virtfn < initial) 344dd7cc44dSYu Zhao initial = nr_virtfn; 345dd7cc44dSYu Zhao 346c23b6135SAlexander Duyck rc = pcibios_sriov_enable(dev, initial); 347c23b6135SAlexander Duyck if (rc) { 3487506dc79SFrederick Lawler pci_err(dev, "failure %d from pcibios_sriov_enable()\n", rc); 349c23b6135SAlexander Duyck goto err_pcibios; 350995df527SWei Yang } 351995df527SWei Yang 352f40ec3c7SGavin Shan pci_iov_set_numvfs(dev, nr_virtfn); 353f40ec3c7SGavin Shan iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE; 354f40ec3c7SGavin Shan pci_cfg_access_lock(dev); 355f40ec3c7SGavin Shan pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 356f40ec3c7SGavin Shan msleep(100); 357f40ec3c7SGavin Shan pci_cfg_access_unlock(dev); 358f40ec3c7SGavin Shan 35918f9e9d1SSebastian Ott rc = sriov_add_vfs(dev, initial); 360dd7cc44dSYu Zhao if (rc) 36118f9e9d1SSebastian Ott goto err_pcibios; 362dd7cc44dSYu Zhao 363dd7cc44dSYu Zhao kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE); 3646b136724SBjorn Helgaas iov->num_VFs = nr_virtfn; 365dd7cc44dSYu Zhao 366dd7cc44dSYu Zhao return 0; 367dd7cc44dSYu Zhao 368c23b6135SAlexander Duyck err_pcibios: 369dd7cc44dSYu Zhao iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 370fb51ccbfSJan Kiszka pci_cfg_access_lock(dev); 371dd7cc44dSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 372dd7cc44dSYu Zhao ssleep(1); 373fb51ccbfSJan Kiszka pci_cfg_access_unlock(dev); 374dd7cc44dSYu Zhao 3750fc690a7SGavin Shan pcibios_sriov_disable(dev); 3760fc690a7SGavin Shan 377dd7cc44dSYu Zhao if (iov->link != dev->devfn) 378dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, "dep_link"); 379dd7cc44dSYu Zhao 380b3908644SAlexander Duyck pci_iov_set_numvfs(dev, 0); 381dd7cc44dSYu Zhao return rc; 382dd7cc44dSYu Zhao } 383dd7cc44dSYu Zhao 38418f9e9d1SSebastian Ott static void sriov_del_vfs(struct pci_dev *dev) 38518f9e9d1SSebastian Ott { 38618f9e9d1SSebastian Ott struct pci_sriov *iov = dev->sriov; 38718f9e9d1SSebastian Ott int i; 38818f9e9d1SSebastian Ott 389aff68a5aSSebastian Ott if (dev->no_vf_scan) 390aff68a5aSSebastian Ott return; 391aff68a5aSSebastian Ott 39218f9e9d1SSebastian Ott for (i = 0; i < iov->num_VFs; i++) 39318f9e9d1SSebastian Ott pci_iov_remove_virtfn(dev, i); 39418f9e9d1SSebastian Ott } 39518f9e9d1SSebastian Ott 396dd7cc44dSYu Zhao static void sriov_disable(struct pci_dev *dev) 397dd7cc44dSYu Zhao { 398dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 399dd7cc44dSYu Zhao 4006b136724SBjorn Helgaas if (!iov->num_VFs) 401dd7cc44dSYu Zhao return; 402dd7cc44dSYu Zhao 40318f9e9d1SSebastian Ott sriov_del_vfs(dev); 404dd7cc44dSYu Zhao iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 405fb51ccbfSJan Kiszka pci_cfg_access_lock(dev); 406dd7cc44dSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 407dd7cc44dSYu Zhao ssleep(1); 408fb51ccbfSJan Kiszka pci_cfg_access_unlock(dev); 409dd7cc44dSYu Zhao 4100fc690a7SGavin Shan pcibios_sriov_disable(dev); 4110fc690a7SGavin Shan 412dd7cc44dSYu Zhao if (iov->link != dev->devfn) 413dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, "dep_link"); 414dd7cc44dSYu Zhao 4156b136724SBjorn Helgaas iov->num_VFs = 0; 416f59dca27SWei Yang pci_iov_set_numvfs(dev, 0); 417dd7cc44dSYu Zhao } 418dd7cc44dSYu Zhao 419d1b054daSYu Zhao static int sriov_init(struct pci_dev *dev, int pos) 420d1b054daSYu Zhao { 4210e6c9122SWei Yang int i, bar64; 422d1b054daSYu Zhao int rc; 423d1b054daSYu Zhao int nres; 424d1b054daSYu Zhao u32 pgsz; 425ea9a8854SAlexander Duyck u16 ctrl, total; 426d1b054daSYu Zhao struct pci_sriov *iov; 427d1b054daSYu Zhao struct resource *res; 428d1b054daSYu Zhao struct pci_dev *pdev; 429d1b054daSYu Zhao 430d1b054daSYu Zhao pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl); 431d1b054daSYu Zhao if (ctrl & PCI_SRIOV_CTRL_VFE) { 432d1b054daSYu Zhao pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0); 433d1b054daSYu Zhao ssleep(1); 434d1b054daSYu Zhao } 435d1b054daSYu Zhao 436d1b054daSYu Zhao ctrl = 0; 437d1b054daSYu Zhao list_for_each_entry(pdev, &dev->bus->devices, bus_list) 438d1b054daSYu Zhao if (pdev->is_physfn) 439d1b054daSYu Zhao goto found; 440d1b054daSYu Zhao 441d1b054daSYu Zhao pdev = NULL; 442d1b054daSYu Zhao if (pci_ari_enabled(dev->bus)) 443d1b054daSYu Zhao ctrl |= PCI_SRIOV_CTRL_ARI; 444d1b054daSYu Zhao 445d1b054daSYu Zhao found: 446d1b054daSYu Zhao pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl); 447d1b054daSYu Zhao 448ff45f9ddSBen Shelton pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total); 449ff45f9ddSBen Shelton if (!total) 450ff45f9ddSBen Shelton return 0; 451d1b054daSYu Zhao 452d1b054daSYu Zhao pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz); 453d1b054daSYu Zhao i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0; 454d1b054daSYu Zhao pgsz &= ~((1 << i) - 1); 455d1b054daSYu Zhao if (!pgsz) 456d1b054daSYu Zhao return -EIO; 457d1b054daSYu Zhao 458d1b054daSYu Zhao pgsz &= ~(pgsz - 1); 4598161fe91SVaidyanathan Srinivasan pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz); 460d1b054daSYu Zhao 4610e6c9122SWei Yang iov = kzalloc(sizeof(*iov), GFP_KERNEL); 4620e6c9122SWei Yang if (!iov) 4630e6c9122SWei Yang return -ENOMEM; 4640e6c9122SWei Yang 465d1b054daSYu Zhao nres = 0; 466d1b054daSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 467c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 46811183991SDavid Daney /* 46911183991SDavid Daney * If it is already FIXED, don't change it, something 47011183991SDavid Daney * (perhaps EA or header fixups) wants it this way. 47111183991SDavid Daney */ 47211183991SDavid Daney if (res->flags & IORESOURCE_PCI_FIXED) 47311183991SDavid Daney bar64 = (res->flags & IORESOURCE_MEM_64) ? 1 : 0; 47411183991SDavid Daney else 4750e6c9122SWei Yang bar64 = __pci_read_base(dev, pci_bar_unknown, res, 476d1b054daSYu Zhao pos + PCI_SRIOV_BAR + i * 4); 477d1b054daSYu Zhao if (!res->flags) 478d1b054daSYu Zhao continue; 479d1b054daSYu Zhao if (resource_size(res) & (PAGE_SIZE - 1)) { 480d1b054daSYu Zhao rc = -EIO; 481d1b054daSYu Zhao goto failed; 482d1b054daSYu Zhao } 4830e6c9122SWei Yang iov->barsz[i] = resource_size(res); 484d1b054daSYu Zhao res->end = res->start + resource_size(res) * total - 1; 4857506dc79SFrederick Lawler pci_info(dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n", 486e88ae01dSWei Yang i, res, i, total); 4870e6c9122SWei Yang i += bar64; 488d1b054daSYu Zhao nres++; 489d1b054daSYu Zhao } 490d1b054daSYu Zhao 491d1b054daSYu Zhao iov->pos = pos; 492d1b054daSYu Zhao iov->nres = nres; 493d1b054daSYu Zhao iov->ctrl = ctrl; 4946b136724SBjorn Helgaas iov->total_VFs = total; 4958d85a7a4SJakub Kicinski iov->driver_max_VFs = total; 4963142d832SFilippo Sironi pci_read_config_word(dev, pos + PCI_SRIOV_VF_DID, &iov->vf_device); 497d1b054daSYu Zhao iov->pgsz = pgsz; 498d1b054daSYu Zhao iov->self = dev; 4990e7df224SBodong Wang iov->drivers_autoprobe = true; 500d1b054daSYu Zhao pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap); 501d1b054daSYu Zhao pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link); 50262f87c0eSYijing Wang if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END) 5034d135dbeSYu Zhao iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link); 504d1b054daSYu Zhao 505d1b054daSYu Zhao if (pdev) 506d1b054daSYu Zhao iov->dev = pci_dev_get(pdev); 507e277d2fcSYu Zhao else 508d1b054daSYu Zhao iov->dev = dev; 509e277d2fcSYu Zhao 510d1b054daSYu Zhao dev->sriov = iov; 511d1b054daSYu Zhao dev->is_physfn = 1; 512ea9a8854SAlexander Duyck rc = compute_max_vf_buses(dev); 513ea9a8854SAlexander Duyck if (rc) 514ea9a8854SAlexander Duyck goto fail_max_buses; 515d1b054daSYu Zhao 516d1b054daSYu Zhao return 0; 517d1b054daSYu Zhao 518ea9a8854SAlexander Duyck fail_max_buses: 519ea9a8854SAlexander Duyck dev->sriov = NULL; 520ea9a8854SAlexander Duyck dev->is_physfn = 0; 521d1b054daSYu Zhao failed: 522d1b054daSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 523c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 524d1b054daSYu Zhao res->flags = 0; 525d1b054daSYu Zhao } 526d1b054daSYu Zhao 5270e6c9122SWei Yang kfree(iov); 528d1b054daSYu Zhao return rc; 529d1b054daSYu Zhao } 530d1b054daSYu Zhao 531d1b054daSYu Zhao static void sriov_release(struct pci_dev *dev) 532d1b054daSYu Zhao { 5336b136724SBjorn Helgaas BUG_ON(dev->sriov->num_VFs); 534dd7cc44dSYu Zhao 535e277d2fcSYu Zhao if (dev != dev->sriov->dev) 536d1b054daSYu Zhao pci_dev_put(dev->sriov->dev); 537d1b054daSYu Zhao 538d1b054daSYu Zhao kfree(dev->sriov); 539d1b054daSYu Zhao dev->sriov = NULL; 540d1b054daSYu Zhao } 541d1b054daSYu Zhao 5428c5cdb6aSYu Zhao static void sriov_restore_state(struct pci_dev *dev) 5438c5cdb6aSYu Zhao { 5448c5cdb6aSYu Zhao int i; 5458c5cdb6aSYu Zhao u16 ctrl; 5468c5cdb6aSYu Zhao struct pci_sriov *iov = dev->sriov; 5478c5cdb6aSYu Zhao 5488c5cdb6aSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl); 5498c5cdb6aSYu Zhao if (ctrl & PCI_SRIOV_CTRL_VFE) 5508c5cdb6aSYu Zhao return; 5518c5cdb6aSYu Zhao 552ff26449eSTony Nguyen /* 553ff26449eSTony Nguyen * Restore PCI_SRIOV_CTRL_ARI before pci_iov_set_numvfs() because 554ff26449eSTony Nguyen * it reads offset & stride, which depend on PCI_SRIOV_CTRL_ARI. 555ff26449eSTony Nguyen */ 556ff26449eSTony Nguyen ctrl &= ~PCI_SRIOV_CTRL_ARI; 557ff26449eSTony Nguyen ctrl |= iov->ctrl & PCI_SRIOV_CTRL_ARI; 558ff26449eSTony Nguyen pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, ctrl); 559ff26449eSTony Nguyen 56039098edbSDenis Efremov for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) 56139098edbSDenis Efremov pci_update_resource(dev, i + PCI_IOV_RESOURCES); 5628c5cdb6aSYu Zhao 5638c5cdb6aSYu Zhao pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz); 564f59dca27SWei Yang pci_iov_set_numvfs(dev, iov->num_VFs); 5658c5cdb6aSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 5668c5cdb6aSYu Zhao if (iov->ctrl & PCI_SRIOV_CTRL_VFE) 5678c5cdb6aSYu Zhao msleep(100); 5688c5cdb6aSYu Zhao } 5698c5cdb6aSYu Zhao 570d1b054daSYu Zhao /** 571d1b054daSYu Zhao * pci_iov_init - initialize the IOV capability 572d1b054daSYu Zhao * @dev: the PCI device 573d1b054daSYu Zhao * 574d1b054daSYu Zhao * Returns 0 on success, or negative on failure. 575d1b054daSYu Zhao */ 576d1b054daSYu Zhao int pci_iov_init(struct pci_dev *dev) 577d1b054daSYu Zhao { 578d1b054daSYu Zhao int pos; 579d1b054daSYu Zhao 5805f4d91a1SKenji Kaneshige if (!pci_is_pcie(dev)) 581d1b054daSYu Zhao return -ENODEV; 582d1b054daSYu Zhao 583d1b054daSYu Zhao pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV); 584d1b054daSYu Zhao if (pos) 585d1b054daSYu Zhao return sriov_init(dev, pos); 586d1b054daSYu Zhao 587d1b054daSYu Zhao return -ENODEV; 588d1b054daSYu Zhao } 589d1b054daSYu Zhao 590d1b054daSYu Zhao /** 591d1b054daSYu Zhao * pci_iov_release - release resources used by the IOV capability 592d1b054daSYu Zhao * @dev: the PCI device 593d1b054daSYu Zhao */ 594d1b054daSYu Zhao void pci_iov_release(struct pci_dev *dev) 595d1b054daSYu Zhao { 596d1b054daSYu Zhao if (dev->is_physfn) 597d1b054daSYu Zhao sriov_release(dev); 598d1b054daSYu Zhao } 599d1b054daSYu Zhao 600d1b054daSYu Zhao /** 60138972375SJakub Kicinski * pci_iov_remove - clean up SR-IOV state after PF driver is detached 60238972375SJakub Kicinski * @dev: the PCI device 60338972375SJakub Kicinski */ 60438972375SJakub Kicinski void pci_iov_remove(struct pci_dev *dev) 60538972375SJakub Kicinski { 60638972375SJakub Kicinski struct pci_sriov *iov = dev->sriov; 60738972375SJakub Kicinski 60838972375SJakub Kicinski if (!dev->is_physfn) 60938972375SJakub Kicinski return; 61038972375SJakub Kicinski 61138972375SJakub Kicinski iov->driver_max_VFs = iov->total_VFs; 61238972375SJakub Kicinski if (iov->num_VFs) 61338972375SJakub Kicinski pci_warn(dev, "driver left SR-IOV enabled after remove\n"); 61438972375SJakub Kicinski } 61538972375SJakub Kicinski 61638972375SJakub Kicinski /** 6176ffa2489SBjorn Helgaas * pci_iov_update_resource - update a VF BAR 6186ffa2489SBjorn Helgaas * @dev: the PCI device 6196ffa2489SBjorn Helgaas * @resno: the resource number 6206ffa2489SBjorn Helgaas * 6216ffa2489SBjorn Helgaas * Update a VF BAR in the SR-IOV capability of a PF. 6226ffa2489SBjorn Helgaas */ 6236ffa2489SBjorn Helgaas void pci_iov_update_resource(struct pci_dev *dev, int resno) 6246ffa2489SBjorn Helgaas { 6256ffa2489SBjorn Helgaas struct pci_sriov *iov = dev->is_physfn ? dev->sriov : NULL; 6266ffa2489SBjorn Helgaas struct resource *res = dev->resource + resno; 6276ffa2489SBjorn Helgaas int vf_bar = resno - PCI_IOV_RESOURCES; 6286ffa2489SBjorn Helgaas struct pci_bus_region region; 629546ba9f8SBjorn Helgaas u16 cmd; 6306ffa2489SBjorn Helgaas u32 new; 6316ffa2489SBjorn Helgaas int reg; 6326ffa2489SBjorn Helgaas 6336ffa2489SBjorn Helgaas /* 6346ffa2489SBjorn Helgaas * The generic pci_restore_bars() path calls this for all devices, 6356ffa2489SBjorn Helgaas * including VFs and non-SR-IOV devices. If this is not a PF, we 6366ffa2489SBjorn Helgaas * have nothing to do. 6376ffa2489SBjorn Helgaas */ 6386ffa2489SBjorn Helgaas if (!iov) 6396ffa2489SBjorn Helgaas return; 6406ffa2489SBjorn Helgaas 641546ba9f8SBjorn Helgaas pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &cmd); 642546ba9f8SBjorn Helgaas if ((cmd & PCI_SRIOV_CTRL_VFE) && (cmd & PCI_SRIOV_CTRL_MSE)) { 643546ba9f8SBjorn Helgaas dev_WARN(&dev->dev, "can't update enabled VF BAR%d %pR\n", 644546ba9f8SBjorn Helgaas vf_bar, res); 645546ba9f8SBjorn Helgaas return; 646546ba9f8SBjorn Helgaas } 647546ba9f8SBjorn Helgaas 6486ffa2489SBjorn Helgaas /* 6496ffa2489SBjorn Helgaas * Ignore unimplemented BARs, unused resource slots for 64-bit 6506ffa2489SBjorn Helgaas * BARs, and non-movable resources, e.g., those described via 6516ffa2489SBjorn Helgaas * Enhanced Allocation. 6526ffa2489SBjorn Helgaas */ 6536ffa2489SBjorn Helgaas if (!res->flags) 6546ffa2489SBjorn Helgaas return; 6556ffa2489SBjorn Helgaas 6566ffa2489SBjorn Helgaas if (res->flags & IORESOURCE_UNSET) 6576ffa2489SBjorn Helgaas return; 6586ffa2489SBjorn Helgaas 6596ffa2489SBjorn Helgaas if (res->flags & IORESOURCE_PCI_FIXED) 6606ffa2489SBjorn Helgaas return; 6616ffa2489SBjorn Helgaas 6626ffa2489SBjorn Helgaas pcibios_resource_to_bus(dev->bus, ®ion, res); 6636ffa2489SBjorn Helgaas new = region.start; 6646ffa2489SBjorn Helgaas new |= res->flags & ~PCI_BASE_ADDRESS_MEM_MASK; 6656ffa2489SBjorn Helgaas 6666ffa2489SBjorn Helgaas reg = iov->pos + PCI_SRIOV_BAR + 4 * vf_bar; 6676ffa2489SBjorn Helgaas pci_write_config_dword(dev, reg, new); 6686ffa2489SBjorn Helgaas if (res->flags & IORESOURCE_MEM_64) { 6696ffa2489SBjorn Helgaas new = region.start >> 16 >> 16; 6706ffa2489SBjorn Helgaas pci_write_config_dword(dev, reg + 4, new); 6716ffa2489SBjorn Helgaas } 6726ffa2489SBjorn Helgaas } 6736ffa2489SBjorn Helgaas 674978d2d68SWei Yang resource_size_t __weak pcibios_iov_resource_alignment(struct pci_dev *dev, 675978d2d68SWei Yang int resno) 676978d2d68SWei Yang { 677978d2d68SWei Yang return pci_iov_resource_size(dev, resno); 678978d2d68SWei Yang } 679978d2d68SWei Yang 6808c5cdb6aSYu Zhao /** 6816faf17f6SChris Wright * pci_sriov_resource_alignment - get resource alignment for VF BAR 6826faf17f6SChris Wright * @dev: the PCI device 6836faf17f6SChris Wright * @resno: the resource number 6846faf17f6SChris Wright * 6856faf17f6SChris Wright * Returns the alignment of the VF BAR found in the SR-IOV capability. 6866faf17f6SChris Wright * This is not the same as the resource size which is defined as 6876faf17f6SChris Wright * the VF BAR size multiplied by the number of VFs. The alignment 6886faf17f6SChris Wright * is just the VF BAR size. 6896faf17f6SChris Wright */ 6900e52247aSCam Macdonell resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno) 6916faf17f6SChris Wright { 692978d2d68SWei Yang return pcibios_iov_resource_alignment(dev, resno); 6936faf17f6SChris Wright } 6946faf17f6SChris Wright 6956faf17f6SChris Wright /** 6968c5cdb6aSYu Zhao * pci_restore_iov_state - restore the state of the IOV capability 6978c5cdb6aSYu Zhao * @dev: the PCI device 6988c5cdb6aSYu Zhao */ 6998c5cdb6aSYu Zhao void pci_restore_iov_state(struct pci_dev *dev) 7008c5cdb6aSYu Zhao { 7018c5cdb6aSYu Zhao if (dev->is_physfn) 7028c5cdb6aSYu Zhao sriov_restore_state(dev); 7038c5cdb6aSYu Zhao } 704a28724b0SYu Zhao 705a28724b0SYu Zhao /** 706608c0d88SBryant G. Ly * pci_vf_drivers_autoprobe - set PF property drivers_autoprobe for VFs 707608c0d88SBryant G. Ly * @dev: the PCI device 708608c0d88SBryant G. Ly * @auto_probe: set VF drivers auto probe flag 709608c0d88SBryant G. Ly */ 710608c0d88SBryant G. Ly void pci_vf_drivers_autoprobe(struct pci_dev *dev, bool auto_probe) 711608c0d88SBryant G. Ly { 712608c0d88SBryant G. Ly if (dev->is_physfn) 713608c0d88SBryant G. Ly dev->sriov->drivers_autoprobe = auto_probe; 714608c0d88SBryant G. Ly } 715608c0d88SBryant G. Ly 716608c0d88SBryant G. Ly /** 717a28724b0SYu Zhao * pci_iov_bus_range - find bus range used by Virtual Function 718a28724b0SYu Zhao * @bus: the PCI bus 719a28724b0SYu Zhao * 720a28724b0SYu Zhao * Returns max number of buses (exclude current one) used by Virtual 721a28724b0SYu Zhao * Functions. 722a28724b0SYu Zhao */ 723a28724b0SYu Zhao int pci_iov_bus_range(struct pci_bus *bus) 724a28724b0SYu Zhao { 725a28724b0SYu Zhao int max = 0; 726a28724b0SYu Zhao struct pci_dev *dev; 727a28724b0SYu Zhao 728a28724b0SYu Zhao list_for_each_entry(dev, &bus->devices, bus_list) { 729a28724b0SYu Zhao if (!dev->is_physfn) 730a28724b0SYu Zhao continue; 7314449f079SWei Yang if (dev->sriov->max_VF_buses > max) 7324449f079SWei Yang max = dev->sriov->max_VF_buses; 733a28724b0SYu Zhao } 734a28724b0SYu Zhao 735a28724b0SYu Zhao return max ? max - bus->number : 0; 736a28724b0SYu Zhao } 737dd7cc44dSYu Zhao 738dd7cc44dSYu Zhao /** 739dd7cc44dSYu Zhao * pci_enable_sriov - enable the SR-IOV capability 740dd7cc44dSYu Zhao * @dev: the PCI device 74152a8873bSRandy Dunlap * @nr_virtfn: number of virtual functions to enable 742dd7cc44dSYu Zhao * 743dd7cc44dSYu Zhao * Returns 0 on success, or negative on failure. 744dd7cc44dSYu Zhao */ 745dd7cc44dSYu Zhao int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn) 746dd7cc44dSYu Zhao { 747dd7cc44dSYu Zhao might_sleep(); 748dd7cc44dSYu Zhao 749dd7cc44dSYu Zhao if (!dev->is_physfn) 750652d1100SStefan Assmann return -ENOSYS; 751dd7cc44dSYu Zhao 752dd7cc44dSYu Zhao return sriov_enable(dev, nr_virtfn); 753dd7cc44dSYu Zhao } 754dd7cc44dSYu Zhao EXPORT_SYMBOL_GPL(pci_enable_sriov); 755dd7cc44dSYu Zhao 756dd7cc44dSYu Zhao /** 757dd7cc44dSYu Zhao * pci_disable_sriov - disable the SR-IOV capability 758dd7cc44dSYu Zhao * @dev: the PCI device 759dd7cc44dSYu Zhao */ 760dd7cc44dSYu Zhao void pci_disable_sriov(struct pci_dev *dev) 761dd7cc44dSYu Zhao { 762dd7cc44dSYu Zhao might_sleep(); 763dd7cc44dSYu Zhao 764dd7cc44dSYu Zhao if (!dev->is_physfn) 765dd7cc44dSYu Zhao return; 766dd7cc44dSYu Zhao 767dd7cc44dSYu Zhao sriov_disable(dev); 768dd7cc44dSYu Zhao } 769dd7cc44dSYu Zhao EXPORT_SYMBOL_GPL(pci_disable_sriov); 77074bb1bccSYu Zhao 77174bb1bccSYu Zhao /** 772fb8a0d9dSWilliams, Mitch A * pci_num_vf - return number of VFs associated with a PF device_release_driver 773fb8a0d9dSWilliams, Mitch A * @dev: the PCI device 774fb8a0d9dSWilliams, Mitch A * 775fb8a0d9dSWilliams, Mitch A * Returns number of VFs, or 0 if SR-IOV is not enabled. 776fb8a0d9dSWilliams, Mitch A */ 777fb8a0d9dSWilliams, Mitch A int pci_num_vf(struct pci_dev *dev) 778fb8a0d9dSWilliams, Mitch A { 7791452cd76SBjorn Helgaas if (!dev->is_physfn) 780fb8a0d9dSWilliams, Mitch A return 0; 7811452cd76SBjorn Helgaas 7826b136724SBjorn Helgaas return dev->sriov->num_VFs; 783fb8a0d9dSWilliams, Mitch A } 784fb8a0d9dSWilliams, Mitch A EXPORT_SYMBOL_GPL(pci_num_vf); 785bff73156SDonald Dutile 786bff73156SDonald Dutile /** 7875a8eb242SAlexander Duyck * pci_vfs_assigned - returns number of VFs are assigned to a guest 7885a8eb242SAlexander Duyck * @dev: the PCI device 7895a8eb242SAlexander Duyck * 7905a8eb242SAlexander Duyck * Returns number of VFs belonging to this device that are assigned to a guest. 791652d1100SStefan Assmann * If device is not a physical function returns 0. 7925a8eb242SAlexander Duyck */ 7935a8eb242SAlexander Duyck int pci_vfs_assigned(struct pci_dev *dev) 7945a8eb242SAlexander Duyck { 7955a8eb242SAlexander Duyck struct pci_dev *vfdev; 7965a8eb242SAlexander Duyck unsigned int vfs_assigned = 0; 7975a8eb242SAlexander Duyck unsigned short dev_id; 7985a8eb242SAlexander Duyck 7995a8eb242SAlexander Duyck /* only search if we are a PF */ 8005a8eb242SAlexander Duyck if (!dev->is_physfn) 8015a8eb242SAlexander Duyck return 0; 8025a8eb242SAlexander Duyck 8035a8eb242SAlexander Duyck /* 8045a8eb242SAlexander Duyck * determine the device ID for the VFs, the vendor ID will be the 8055a8eb242SAlexander Duyck * same as the PF so there is no need to check for that one 8065a8eb242SAlexander Duyck */ 8073142d832SFilippo Sironi dev_id = dev->sriov->vf_device; 8085a8eb242SAlexander Duyck 8095a8eb242SAlexander Duyck /* loop through all the VFs to see if we own any that are assigned */ 8105a8eb242SAlexander Duyck vfdev = pci_get_device(dev->vendor, dev_id, NULL); 8115a8eb242SAlexander Duyck while (vfdev) { 8125a8eb242SAlexander Duyck /* 8135a8eb242SAlexander Duyck * It is considered assigned if it is a virtual function with 8145a8eb242SAlexander Duyck * our dev as the physical function and the assigned bit is set 8155a8eb242SAlexander Duyck */ 8165a8eb242SAlexander Duyck if (vfdev->is_virtfn && (vfdev->physfn == dev) && 817be63497cSEthan Zhao pci_is_dev_assigned(vfdev)) 8185a8eb242SAlexander Duyck vfs_assigned++; 8195a8eb242SAlexander Duyck 8205a8eb242SAlexander Duyck vfdev = pci_get_device(dev->vendor, dev_id, vfdev); 8215a8eb242SAlexander Duyck } 8225a8eb242SAlexander Duyck 8235a8eb242SAlexander Duyck return vfs_assigned; 8245a8eb242SAlexander Duyck } 8255a8eb242SAlexander Duyck EXPORT_SYMBOL_GPL(pci_vfs_assigned); 8265a8eb242SAlexander Duyck 8275a8eb242SAlexander Duyck /** 828bff73156SDonald Dutile * pci_sriov_set_totalvfs -- reduce the TotalVFs available 829bff73156SDonald Dutile * @dev: the PCI PF device 8302094f167SRandy Dunlap * @numvfs: number that should be used for TotalVFs supported 831bff73156SDonald Dutile * 832bff73156SDonald Dutile * Should be called from PF driver's probe routine with 833bff73156SDonald Dutile * device's mutex held. 834bff73156SDonald Dutile * 835bff73156SDonald Dutile * Returns 0 if PF is an SRIOV-capable device and 836652d1100SStefan Assmann * value of numvfs valid. If not a PF return -ENOSYS; 837652d1100SStefan Assmann * if numvfs is invalid return -EINVAL; 838bff73156SDonald Dutile * if VFs already enabled, return -EBUSY. 839bff73156SDonald Dutile */ 840bff73156SDonald Dutile int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs) 841bff73156SDonald Dutile { 842652d1100SStefan Assmann if (!dev->is_physfn) 843652d1100SStefan Assmann return -ENOSYS; 84451259d00SBjorn Helgaas 845652d1100SStefan Assmann if (numvfs > dev->sriov->total_VFs) 846bff73156SDonald Dutile return -EINVAL; 847bff73156SDonald Dutile 848bff73156SDonald Dutile /* Shouldn't change if VFs already enabled */ 849bff73156SDonald Dutile if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE) 850bff73156SDonald Dutile return -EBUSY; 851bff73156SDonald Dutile 85251259d00SBjorn Helgaas dev->sriov->driver_max_VFs = numvfs; 853bff73156SDonald Dutile return 0; 854bff73156SDonald Dutile } 855bff73156SDonald Dutile EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs); 856bff73156SDonald Dutile 857bff73156SDonald Dutile /** 858ddc191f5SJonghwan Choi * pci_sriov_get_totalvfs -- get total VFs supported on this device 859bff73156SDonald Dutile * @dev: the PCI PF device 860bff73156SDonald Dutile * 861bff73156SDonald Dutile * For a PCIe device with SRIOV support, return the PCIe 8626b136724SBjorn Helgaas * SRIOV capability value of TotalVFs or the value of driver_max_VFs 863652d1100SStefan Assmann * if the driver reduced it. Otherwise 0. 864bff73156SDonald Dutile */ 865bff73156SDonald Dutile int pci_sriov_get_totalvfs(struct pci_dev *dev) 866bff73156SDonald Dutile { 8671452cd76SBjorn Helgaas if (!dev->is_physfn) 868652d1100SStefan Assmann return 0; 869bff73156SDonald Dutile 8706b136724SBjorn Helgaas return dev->sriov->driver_max_VFs; 871bff73156SDonald Dutile } 872bff73156SDonald Dutile EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs); 8738effc395SAlexander Duyck 8748effc395SAlexander Duyck /** 8758effc395SAlexander Duyck * pci_sriov_configure_simple - helper to configure SR-IOV 8768effc395SAlexander Duyck * @dev: the PCI device 8778effc395SAlexander Duyck * @nr_virtfn: number of virtual functions to enable, 0 to disable 8788effc395SAlexander Duyck * 8798effc395SAlexander Duyck * Enable or disable SR-IOV for devices that don't require any PF setup 8808effc395SAlexander Duyck * before enabling SR-IOV. Return value is negative on error, or number of 8818effc395SAlexander Duyck * VFs allocated on success. 8828effc395SAlexander Duyck */ 8838effc395SAlexander Duyck int pci_sriov_configure_simple(struct pci_dev *dev, int nr_virtfn) 8848effc395SAlexander Duyck { 8858effc395SAlexander Duyck int rc; 8868effc395SAlexander Duyck 8878effc395SAlexander Duyck might_sleep(); 8888effc395SAlexander Duyck 8898effc395SAlexander Duyck if (!dev->is_physfn) 8908effc395SAlexander Duyck return -ENODEV; 8918effc395SAlexander Duyck 8928effc395SAlexander Duyck if (pci_vfs_assigned(dev)) { 8938effc395SAlexander Duyck pci_warn(dev, "Cannot modify SR-IOV while VFs are assigned\n"); 8948effc395SAlexander Duyck return -EPERM; 8958effc395SAlexander Duyck } 8968effc395SAlexander Duyck 8978effc395SAlexander Duyck if (nr_virtfn == 0) { 8988effc395SAlexander Duyck sriov_disable(dev); 8998effc395SAlexander Duyck return 0; 9008effc395SAlexander Duyck } 9018effc395SAlexander Duyck 9028effc395SAlexander Duyck rc = sriov_enable(dev, nr_virtfn); 9038effc395SAlexander Duyck if (rc < 0) 9048effc395SAlexander Duyck return rc; 9058effc395SAlexander Duyck 9068effc395SAlexander Duyck return nr_virtfn; 9078effc395SAlexander Duyck } 9088effc395SAlexander Duyck EXPORT_SYMBOL_GPL(pci_sriov_configure_simple); 909