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 * 574449f079SWei Yang * Iterate over all valid NumVFs and calculate the maximum number of bus 584449f079SWei Yang * numbers that could ever be required. 594449f079SWei Yang */ 604449f079SWei Yang static inline u8 virtfn_max_buses(struct pci_dev *dev) 614449f079SWei Yang { 624449f079SWei Yang struct pci_sriov *iov = dev->sriov; 634449f079SWei Yang int nr_virtfn; 644449f079SWei Yang u8 max = 0; 65b07579c0SWei Yang int busnr; 664449f079SWei Yang 674449f079SWei Yang for (nr_virtfn = 1; nr_virtfn <= iov->total_VFs; nr_virtfn++) { 684449f079SWei Yang pci_iov_set_numvfs(dev, nr_virtfn); 69b07579c0SWei Yang busnr = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 704449f079SWei Yang if (busnr > max) 714449f079SWei Yang max = busnr; 724449f079SWei Yang } 734449f079SWei Yang 744449f079SWei Yang return max; 754449f079SWei Yang } 764449f079SWei Yang 77dd7cc44dSYu Zhao static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr) 78dd7cc44dSYu Zhao { 79dd7cc44dSYu Zhao struct pci_bus *child; 80dd7cc44dSYu Zhao 81dd7cc44dSYu Zhao if (bus->number == busnr) 82dd7cc44dSYu Zhao return bus; 83dd7cc44dSYu Zhao 84dd7cc44dSYu Zhao child = pci_find_bus(pci_domain_nr(bus), busnr); 85dd7cc44dSYu Zhao if (child) 86dd7cc44dSYu Zhao return child; 87dd7cc44dSYu Zhao 88dd7cc44dSYu Zhao child = pci_add_new_bus(bus, NULL, busnr); 89dd7cc44dSYu Zhao if (!child) 90dd7cc44dSYu Zhao return NULL; 91dd7cc44dSYu Zhao 92b7eac055SYinghai Lu pci_bus_insert_busn_res(child, busnr, busnr); 93dd7cc44dSYu Zhao 94dd7cc44dSYu Zhao return child; 95dd7cc44dSYu Zhao } 96dd7cc44dSYu Zhao 97dc087f2fSJiang Liu static void virtfn_remove_bus(struct pci_bus *physbus, struct pci_bus *virtbus) 98dd7cc44dSYu Zhao { 99dc087f2fSJiang Liu if (physbus != virtbus && list_empty(&virtbus->devices)) 100dc087f2fSJiang Liu pci_remove_bus(virtbus); 101dd7cc44dSYu Zhao } 102dd7cc44dSYu Zhao 1030e6c9122SWei Yang resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno) 1040e6c9122SWei Yang { 1050e6c9122SWei Yang if (!dev->is_physfn) 1060e6c9122SWei Yang return 0; 1070e6c9122SWei Yang 1080e6c9122SWei Yang return dev->sriov->barsz[resno - PCI_IOV_RESOURCES]; 1090e6c9122SWei Yang } 1100e6c9122SWei Yang 111dd7cc44dSYu Zhao static int virtfn_add(struct pci_dev *dev, int id, int reset) 112dd7cc44dSYu Zhao { 113dd7cc44dSYu Zhao int i; 114dc087f2fSJiang Liu int rc = -ENOMEM; 115dd7cc44dSYu Zhao u64 size; 116dd7cc44dSYu Zhao char buf[VIRTFN_ID_LEN]; 117dd7cc44dSYu Zhao struct pci_dev *virtfn; 118dd7cc44dSYu Zhao struct resource *res; 119dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 1208b1fce04SGu Zheng struct pci_bus *bus; 121dd7cc44dSYu Zhao 122dd7cc44dSYu Zhao mutex_lock(&iov->dev->sriov->lock); 123b07579c0SWei Yang bus = virtfn_add_bus(dev->bus, pci_iov_virtfn_bus(dev, id)); 124dc087f2fSJiang Liu if (!bus) 125dc087f2fSJiang Liu goto failed; 126dc087f2fSJiang Liu 127dc087f2fSJiang Liu virtfn = pci_alloc_dev(bus); 128dc087f2fSJiang Liu if (!virtfn) 129dc087f2fSJiang Liu goto failed0; 130dc087f2fSJiang Liu 131b07579c0SWei Yang virtfn->devfn = pci_iov_virtfn_devfn(dev, id); 132dd7cc44dSYu Zhao virtfn->vendor = dev->vendor; 133dd7cc44dSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device); 134dd7cc44dSYu Zhao pci_setup_device(virtfn); 135dd7cc44dSYu Zhao virtfn->dev.parent = dev->dev.parent; 136fbf33f51SXudong Hao virtfn->physfn = pci_dev_get(dev); 137fbf33f51SXudong Hao virtfn->is_virtfn = 1; 138aa931977SAlex Williamson virtfn->multifunction = 0; 139dd7cc44dSYu Zhao 140dd7cc44dSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 141c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 142dd7cc44dSYu Zhao if (!res->parent) 143dd7cc44dSYu Zhao continue; 144dd7cc44dSYu Zhao virtfn->resource[i].name = pci_name(virtfn); 145dd7cc44dSYu Zhao virtfn->resource[i].flags = res->flags; 1460e6c9122SWei Yang size = pci_iov_resource_size(dev, i + PCI_IOV_RESOURCES); 147dd7cc44dSYu Zhao virtfn->resource[i].start = res->start + size * id; 148dd7cc44dSYu Zhao virtfn->resource[i].end = virtfn->resource[i].start + size - 1; 149dd7cc44dSYu Zhao rc = request_resource(res, &virtfn->resource[i]); 150dd7cc44dSYu Zhao BUG_ON(rc); 151dd7cc44dSYu Zhao } 152dd7cc44dSYu Zhao 153dd7cc44dSYu Zhao if (reset) 1548c1c699fSYu Zhao __pci_reset_function(virtfn); 155dd7cc44dSYu Zhao 156dd7cc44dSYu Zhao pci_device_add(virtfn, virtfn->bus); 157dd7cc44dSYu Zhao mutex_unlock(&iov->dev->sriov->lock); 158dd7cc44dSYu Zhao 159c893d133SYijing Wang pci_bus_add_device(virtfn); 160dd7cc44dSYu Zhao sprintf(buf, "virtfn%u", id); 161dd7cc44dSYu Zhao rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf); 162dd7cc44dSYu Zhao if (rc) 163dd7cc44dSYu Zhao goto failed1; 164dd7cc44dSYu Zhao rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn"); 165dd7cc44dSYu Zhao if (rc) 166dd7cc44dSYu Zhao goto failed2; 167dd7cc44dSYu Zhao 168dd7cc44dSYu Zhao kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE); 169dd7cc44dSYu Zhao 170dd7cc44dSYu Zhao return 0; 171dd7cc44dSYu Zhao 172dd7cc44dSYu Zhao failed2: 173dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, buf); 174dd7cc44dSYu Zhao failed1: 175dd7cc44dSYu Zhao pci_dev_put(dev); 176dd7cc44dSYu Zhao mutex_lock(&iov->dev->sriov->lock); 177210647afSYinghai Lu pci_stop_and_remove_bus_device(virtfn); 178dc087f2fSJiang Liu failed0: 179dc087f2fSJiang Liu virtfn_remove_bus(dev->bus, bus); 180dc087f2fSJiang Liu failed: 181dd7cc44dSYu Zhao mutex_unlock(&iov->dev->sriov->lock); 182dd7cc44dSYu Zhao 183dd7cc44dSYu Zhao return rc; 184dd7cc44dSYu Zhao } 185dd7cc44dSYu Zhao 186dd7cc44dSYu Zhao static void virtfn_remove(struct pci_dev *dev, int id, int reset) 187dd7cc44dSYu Zhao { 188dd7cc44dSYu Zhao char buf[VIRTFN_ID_LEN]; 189dd7cc44dSYu Zhao struct pci_dev *virtfn; 190dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 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 if (reset) { 199dd7cc44dSYu Zhao device_release_driver(&virtfn->dev); 2008c1c699fSYu Zhao __pci_reset_function(virtfn); 201dd7cc44dSYu Zhao } 202dd7cc44dSYu Zhao 203dd7cc44dSYu Zhao sprintf(buf, "virtfn%u", id); 204dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, buf); 20509cedbefSYinghai Lu /* 20609cedbefSYinghai Lu * pci_stop_dev() could have been called for this virtfn already, 20709cedbefSYinghai Lu * so the directory for the virtfn may have been removed before. 20809cedbefSYinghai Lu * Double check to avoid spurious sysfs warnings. 20909cedbefSYinghai Lu */ 21009cedbefSYinghai Lu if (virtfn->dev.kobj.sd) 211dd7cc44dSYu Zhao sysfs_remove_link(&virtfn->dev.kobj, "physfn"); 212dd7cc44dSYu Zhao 213dd7cc44dSYu Zhao mutex_lock(&iov->dev->sriov->lock); 214210647afSYinghai Lu pci_stop_and_remove_bus_device(virtfn); 215dc087f2fSJiang Liu virtfn_remove_bus(dev->bus, virtfn->bus); 216dd7cc44dSYu Zhao mutex_unlock(&iov->dev->sriov->lock); 217dd7cc44dSYu Zhao 218dc087f2fSJiang Liu /* balance pci_get_domain_bus_and_slot() */ 219dc087f2fSJiang Liu pci_dev_put(virtfn); 220dd7cc44dSYu Zhao pci_dev_put(dev); 221dd7cc44dSYu Zhao } 222dd7cc44dSYu Zhao 223995df527SWei Yang int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs) 224995df527SWei Yang { 225995df527SWei Yang return 0; 226995df527SWei Yang } 227995df527SWei Yang 228dd7cc44dSYu Zhao static int sriov_enable(struct pci_dev *dev, int nr_virtfn) 229dd7cc44dSYu Zhao { 230dd7cc44dSYu Zhao int rc; 231dd7cc44dSYu Zhao int i, j; 232dd7cc44dSYu Zhao int nres; 233dd7cc44dSYu Zhao u16 offset, stride, initial; 234dd7cc44dSYu Zhao struct resource *res; 235dd7cc44dSYu Zhao struct pci_dev *pdev; 236dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 237bbef98abSRam Pai int bars = 0; 238b07579c0SWei Yang int bus; 239995df527SWei Yang int retval; 240dd7cc44dSYu Zhao 241dd7cc44dSYu Zhao if (!nr_virtfn) 242dd7cc44dSYu Zhao return 0; 243dd7cc44dSYu Zhao 2446b136724SBjorn Helgaas if (iov->num_VFs) 245dd7cc44dSYu Zhao return -EINVAL; 246dd7cc44dSYu Zhao 247dd7cc44dSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial); 2486b136724SBjorn Helgaas if (initial > iov->total_VFs || 2496b136724SBjorn Helgaas (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs))) 250dd7cc44dSYu Zhao return -EIO; 251dd7cc44dSYu Zhao 2526b136724SBjorn Helgaas if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs || 253dd7cc44dSYu Zhao (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial))) 254dd7cc44dSYu Zhao return -EINVAL; 255dd7cc44dSYu Zhao 256dd7cc44dSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &offset); 257dd7cc44dSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &stride); 258dd7cc44dSYu Zhao if (!offset || (nr_virtfn > 1 && !stride)) 259dd7cc44dSYu Zhao return -EIO; 260dd7cc44dSYu Zhao 261dd7cc44dSYu Zhao nres = 0; 262dd7cc44dSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 263bbef98abSRam Pai bars |= (1 << (i + PCI_IOV_RESOURCES)); 264c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 265dd7cc44dSYu Zhao if (res->parent) 266dd7cc44dSYu Zhao nres++; 267dd7cc44dSYu Zhao } 268dd7cc44dSYu Zhao if (nres != iov->nres) { 269dd7cc44dSYu Zhao dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n"); 270dd7cc44dSYu Zhao return -ENOMEM; 271dd7cc44dSYu Zhao } 272dd7cc44dSYu Zhao 273dd7cc44dSYu Zhao iov->offset = offset; 274dd7cc44dSYu Zhao iov->stride = stride; 275dd7cc44dSYu Zhao 276b07579c0SWei Yang bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1); 27768f8e9faSBjorn Helgaas if (bus > dev->bus->busn_res.end) { 27868f8e9faSBjorn Helgaas dev_err(&dev->dev, "can't enable %d VFs (bus %02x out of range of %pR)\n", 27968f8e9faSBjorn Helgaas nr_virtfn, bus, &dev->bus->busn_res); 280dd7cc44dSYu Zhao return -ENOMEM; 281dd7cc44dSYu Zhao } 282dd7cc44dSYu Zhao 283bbef98abSRam Pai if (pci_enable_resources(dev, bars)) { 284bbef98abSRam Pai dev_err(&dev->dev, "SR-IOV: IOV BARS not allocated\n"); 285bbef98abSRam Pai return -ENOMEM; 286bbef98abSRam Pai } 287bbef98abSRam Pai 288dd7cc44dSYu Zhao if (iov->link != dev->devfn) { 289dd7cc44dSYu Zhao pdev = pci_get_slot(dev->bus, iov->link); 290dd7cc44dSYu Zhao if (!pdev) 291dd7cc44dSYu Zhao return -ENODEV; 292dd7cc44dSYu Zhao 293dc087f2fSJiang Liu if (!pdev->is_physfn) { 294dd7cc44dSYu Zhao pci_dev_put(pdev); 295652d1100SStefan Assmann return -ENOSYS; 296dc087f2fSJiang Liu } 297dd7cc44dSYu Zhao 298dd7cc44dSYu Zhao rc = sysfs_create_link(&dev->dev.kobj, 299dd7cc44dSYu Zhao &pdev->dev.kobj, "dep_link"); 300dc087f2fSJiang Liu pci_dev_put(pdev); 301dd7cc44dSYu Zhao if (rc) 302dd7cc44dSYu Zhao return rc; 303dd7cc44dSYu Zhao } 304dd7cc44dSYu Zhao 305f59dca27SWei Yang pci_iov_set_numvfs(dev, nr_virtfn); 306dd7cc44dSYu Zhao iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE; 307fb51ccbfSJan Kiszka pci_cfg_access_lock(dev); 308dd7cc44dSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 309dd7cc44dSYu Zhao msleep(100); 310fb51ccbfSJan Kiszka pci_cfg_access_unlock(dev); 311dd7cc44dSYu Zhao 3126b136724SBjorn Helgaas iov->initial_VFs = initial; 313dd7cc44dSYu Zhao if (nr_virtfn < initial) 314dd7cc44dSYu Zhao initial = nr_virtfn; 315dd7cc44dSYu Zhao 316995df527SWei Yang if ((retval = pcibios_sriov_enable(dev, initial))) { 317995df527SWei Yang dev_err(&dev->dev, "failure %d from pcibios_sriov_enable()\n", 318995df527SWei Yang retval); 319995df527SWei Yang return retval; 320995df527SWei Yang } 321995df527SWei Yang 322dd7cc44dSYu Zhao for (i = 0; i < initial; i++) { 323dd7cc44dSYu Zhao rc = virtfn_add(dev, i, 0); 324dd7cc44dSYu Zhao if (rc) 325dd7cc44dSYu Zhao goto failed; 326dd7cc44dSYu Zhao } 327dd7cc44dSYu Zhao 328dd7cc44dSYu Zhao kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE); 3296b136724SBjorn Helgaas iov->num_VFs = nr_virtfn; 330dd7cc44dSYu Zhao 331dd7cc44dSYu Zhao return 0; 332dd7cc44dSYu Zhao 333dd7cc44dSYu Zhao failed: 334dd7cc44dSYu Zhao for (j = 0; j < i; j++) 335dd7cc44dSYu Zhao virtfn_remove(dev, j, 0); 336dd7cc44dSYu Zhao 337dd7cc44dSYu Zhao iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 338fb51ccbfSJan Kiszka pci_cfg_access_lock(dev); 339dd7cc44dSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 340f59dca27SWei Yang pci_iov_set_numvfs(dev, 0); 341dd7cc44dSYu Zhao ssleep(1); 342fb51ccbfSJan Kiszka pci_cfg_access_unlock(dev); 343dd7cc44dSYu Zhao 344dd7cc44dSYu Zhao if (iov->link != dev->devfn) 345dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, "dep_link"); 346dd7cc44dSYu Zhao 347dd7cc44dSYu Zhao return rc; 348dd7cc44dSYu Zhao } 349dd7cc44dSYu Zhao 350995df527SWei Yang int __weak pcibios_sriov_disable(struct pci_dev *pdev) 351995df527SWei Yang { 352995df527SWei Yang return 0; 353995df527SWei Yang } 354995df527SWei Yang 355dd7cc44dSYu Zhao static void sriov_disable(struct pci_dev *dev) 356dd7cc44dSYu Zhao { 357dd7cc44dSYu Zhao int i; 358dd7cc44dSYu Zhao struct pci_sriov *iov = dev->sriov; 359dd7cc44dSYu Zhao 3606b136724SBjorn Helgaas if (!iov->num_VFs) 361dd7cc44dSYu Zhao return; 362dd7cc44dSYu Zhao 3636b136724SBjorn Helgaas for (i = 0; i < iov->num_VFs; i++) 364dd7cc44dSYu Zhao virtfn_remove(dev, i, 0); 365dd7cc44dSYu Zhao 366995df527SWei Yang pcibios_sriov_disable(dev); 367995df527SWei Yang 368dd7cc44dSYu Zhao iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE); 369fb51ccbfSJan Kiszka pci_cfg_access_lock(dev); 370dd7cc44dSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 371dd7cc44dSYu Zhao ssleep(1); 372fb51ccbfSJan Kiszka pci_cfg_access_unlock(dev); 373dd7cc44dSYu Zhao 374dd7cc44dSYu Zhao if (iov->link != dev->devfn) 375dd7cc44dSYu Zhao sysfs_remove_link(&dev->dev.kobj, "dep_link"); 376dd7cc44dSYu Zhao 3776b136724SBjorn Helgaas iov->num_VFs = 0; 378f59dca27SWei Yang pci_iov_set_numvfs(dev, 0); 379dd7cc44dSYu Zhao } 380dd7cc44dSYu Zhao 381d1b054daSYu Zhao static int sriov_init(struct pci_dev *dev, int pos) 382d1b054daSYu Zhao { 3830e6c9122SWei Yang int i, bar64; 384d1b054daSYu Zhao int rc; 385d1b054daSYu Zhao int nres; 386d1b054daSYu Zhao u32 pgsz; 387d1b054daSYu Zhao u16 ctrl, total, offset, stride; 388d1b054daSYu Zhao struct pci_sriov *iov; 389d1b054daSYu Zhao struct resource *res; 390d1b054daSYu Zhao struct pci_dev *pdev; 391d1b054daSYu Zhao 39262f87c0eSYijing Wang if (pci_pcie_type(dev) != PCI_EXP_TYPE_RC_END && 39362f87c0eSYijing Wang pci_pcie_type(dev) != PCI_EXP_TYPE_ENDPOINT) 394d1b054daSYu Zhao return -ENODEV; 395d1b054daSYu Zhao 396d1b054daSYu Zhao pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl); 397d1b054daSYu Zhao if (ctrl & PCI_SRIOV_CTRL_VFE) { 398d1b054daSYu Zhao pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0); 399d1b054daSYu Zhao ssleep(1); 400d1b054daSYu Zhao } 401d1b054daSYu Zhao 402d1b054daSYu Zhao pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total); 403d1b054daSYu Zhao if (!total) 404d1b054daSYu Zhao return 0; 405d1b054daSYu Zhao 406d1b054daSYu Zhao ctrl = 0; 407d1b054daSYu Zhao list_for_each_entry(pdev, &dev->bus->devices, bus_list) 408d1b054daSYu Zhao if (pdev->is_physfn) 409d1b054daSYu Zhao goto found; 410d1b054daSYu Zhao 411d1b054daSYu Zhao pdev = NULL; 412d1b054daSYu Zhao if (pci_ari_enabled(dev->bus)) 413d1b054daSYu Zhao ctrl |= PCI_SRIOV_CTRL_ARI; 414d1b054daSYu Zhao 415d1b054daSYu Zhao found: 416d1b054daSYu Zhao pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl); 417045cc22eSethan.zhao pci_write_config_word(dev, pos + PCI_SRIOV_NUM_VF, 0); 418d1b054daSYu Zhao pci_read_config_word(dev, pos + PCI_SRIOV_VF_OFFSET, &offset); 419d1b054daSYu Zhao pci_read_config_word(dev, pos + PCI_SRIOV_VF_STRIDE, &stride); 420d1b054daSYu Zhao if (!offset || (total > 1 && !stride)) 421d1b054daSYu Zhao return -EIO; 422d1b054daSYu Zhao 423d1b054daSYu Zhao pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz); 424d1b054daSYu Zhao i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0; 425d1b054daSYu Zhao pgsz &= ~((1 << i) - 1); 426d1b054daSYu Zhao if (!pgsz) 427d1b054daSYu Zhao return -EIO; 428d1b054daSYu Zhao 429d1b054daSYu Zhao pgsz &= ~(pgsz - 1); 4308161fe91SVaidyanathan Srinivasan pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz); 431d1b054daSYu Zhao 4320e6c9122SWei Yang iov = kzalloc(sizeof(*iov), GFP_KERNEL); 4330e6c9122SWei Yang if (!iov) 4340e6c9122SWei Yang return -ENOMEM; 4350e6c9122SWei Yang 436d1b054daSYu Zhao nres = 0; 437d1b054daSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 438c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 4390e6c9122SWei Yang bar64 = __pci_read_base(dev, pci_bar_unknown, res, 440d1b054daSYu Zhao pos + PCI_SRIOV_BAR + i * 4); 441d1b054daSYu Zhao if (!res->flags) 442d1b054daSYu Zhao continue; 443d1b054daSYu Zhao if (resource_size(res) & (PAGE_SIZE - 1)) { 444d1b054daSYu Zhao rc = -EIO; 445d1b054daSYu Zhao goto failed; 446d1b054daSYu Zhao } 4470e6c9122SWei Yang iov->barsz[i] = resource_size(res); 448d1b054daSYu Zhao res->end = res->start + resource_size(res) * total - 1; 449e88ae01dSWei Yang dev_info(&dev->dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n", 450e88ae01dSWei Yang i, res, i, total); 4510e6c9122SWei Yang i += bar64; 452d1b054daSYu Zhao nres++; 453d1b054daSYu Zhao } 454d1b054daSYu Zhao 455d1b054daSYu Zhao iov->pos = pos; 456d1b054daSYu Zhao iov->nres = nres; 457d1b054daSYu Zhao iov->ctrl = ctrl; 4586b136724SBjorn Helgaas iov->total_VFs = total; 459d1b054daSYu Zhao iov->offset = offset; 460d1b054daSYu Zhao iov->stride = stride; 461d1b054daSYu Zhao iov->pgsz = pgsz; 462d1b054daSYu Zhao iov->self = dev; 463d1b054daSYu Zhao pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap); 464d1b054daSYu Zhao pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link); 46562f87c0eSYijing Wang if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END) 4664d135dbeSYu Zhao iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link); 467d1b054daSYu Zhao 468d1b054daSYu Zhao if (pdev) 469d1b054daSYu Zhao iov->dev = pci_dev_get(pdev); 470e277d2fcSYu Zhao else 471d1b054daSYu Zhao iov->dev = dev; 472e277d2fcSYu Zhao 473d1b054daSYu Zhao mutex_init(&iov->lock); 474d1b054daSYu Zhao 475d1b054daSYu Zhao dev->sriov = iov; 476d1b054daSYu Zhao dev->is_physfn = 1; 4774449f079SWei Yang iov->max_VF_buses = virtfn_max_buses(dev); 478d1b054daSYu Zhao 479d1b054daSYu Zhao return 0; 480d1b054daSYu Zhao 481d1b054daSYu Zhao failed: 482d1b054daSYu Zhao for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 483c1fe1f96SBjorn Helgaas res = &dev->resource[i + PCI_IOV_RESOURCES]; 484d1b054daSYu Zhao res->flags = 0; 485d1b054daSYu Zhao } 486d1b054daSYu Zhao 4870e6c9122SWei Yang kfree(iov); 488d1b054daSYu Zhao return rc; 489d1b054daSYu Zhao } 490d1b054daSYu Zhao 491d1b054daSYu Zhao static void sriov_release(struct pci_dev *dev) 492d1b054daSYu Zhao { 4936b136724SBjorn Helgaas BUG_ON(dev->sriov->num_VFs); 494dd7cc44dSYu Zhao 495e277d2fcSYu Zhao if (dev != dev->sriov->dev) 496d1b054daSYu Zhao pci_dev_put(dev->sriov->dev); 497d1b054daSYu Zhao 498e277d2fcSYu Zhao mutex_destroy(&dev->sriov->lock); 499e277d2fcSYu Zhao 500d1b054daSYu Zhao kfree(dev->sriov); 501d1b054daSYu Zhao dev->sriov = NULL; 502d1b054daSYu Zhao } 503d1b054daSYu Zhao 5048c5cdb6aSYu Zhao static void sriov_restore_state(struct pci_dev *dev) 5058c5cdb6aSYu Zhao { 5068c5cdb6aSYu Zhao int i; 5078c5cdb6aSYu Zhao u16 ctrl; 5088c5cdb6aSYu Zhao struct pci_sriov *iov = dev->sriov; 5098c5cdb6aSYu Zhao 5108c5cdb6aSYu Zhao pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl); 5118c5cdb6aSYu Zhao if (ctrl & PCI_SRIOV_CTRL_VFE) 5128c5cdb6aSYu Zhao return; 5138c5cdb6aSYu Zhao 5148c5cdb6aSYu Zhao for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++) 5158c5cdb6aSYu Zhao pci_update_resource(dev, i); 5168c5cdb6aSYu Zhao 5178c5cdb6aSYu Zhao pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz); 518f59dca27SWei Yang pci_iov_set_numvfs(dev, iov->num_VFs); 5198c5cdb6aSYu Zhao pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl); 5208c5cdb6aSYu Zhao if (iov->ctrl & PCI_SRIOV_CTRL_VFE) 5218c5cdb6aSYu Zhao msleep(100); 5228c5cdb6aSYu Zhao } 5238c5cdb6aSYu Zhao 524d1b054daSYu Zhao /** 525d1b054daSYu Zhao * pci_iov_init - initialize the IOV capability 526d1b054daSYu Zhao * @dev: the PCI device 527d1b054daSYu Zhao * 528d1b054daSYu Zhao * Returns 0 on success, or negative on failure. 529d1b054daSYu Zhao */ 530d1b054daSYu Zhao int pci_iov_init(struct pci_dev *dev) 531d1b054daSYu Zhao { 532d1b054daSYu Zhao int pos; 533d1b054daSYu Zhao 5345f4d91a1SKenji Kaneshige if (!pci_is_pcie(dev)) 535d1b054daSYu Zhao return -ENODEV; 536d1b054daSYu Zhao 537d1b054daSYu Zhao pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV); 538d1b054daSYu Zhao if (pos) 539d1b054daSYu Zhao return sriov_init(dev, pos); 540d1b054daSYu Zhao 541d1b054daSYu Zhao return -ENODEV; 542d1b054daSYu Zhao } 543d1b054daSYu Zhao 544d1b054daSYu Zhao /** 545d1b054daSYu Zhao * pci_iov_release - release resources used by the IOV capability 546d1b054daSYu Zhao * @dev: the PCI device 547d1b054daSYu Zhao */ 548d1b054daSYu Zhao void pci_iov_release(struct pci_dev *dev) 549d1b054daSYu Zhao { 550d1b054daSYu Zhao if (dev->is_physfn) 551d1b054daSYu Zhao sriov_release(dev); 552d1b054daSYu Zhao } 553d1b054daSYu Zhao 554d1b054daSYu Zhao /** 555d1b054daSYu Zhao * pci_iov_resource_bar - get position of the SR-IOV BAR 556d1b054daSYu Zhao * @dev: the PCI device 557d1b054daSYu Zhao * @resno: the resource number 558d1b054daSYu Zhao * 559d1b054daSYu Zhao * Returns position of the BAR encapsulated in the SR-IOV capability. 560d1b054daSYu Zhao */ 56126ff46c6SMyron Stowe int pci_iov_resource_bar(struct pci_dev *dev, int resno) 562d1b054daSYu Zhao { 563d1b054daSYu Zhao if (resno < PCI_IOV_RESOURCES || resno > PCI_IOV_RESOURCE_END) 564d1b054daSYu Zhao return 0; 565d1b054daSYu Zhao 566d1b054daSYu Zhao BUG_ON(!dev->is_physfn); 567d1b054daSYu Zhao 568d1b054daSYu Zhao return dev->sriov->pos + PCI_SRIOV_BAR + 569d1b054daSYu Zhao 4 * (resno - PCI_IOV_RESOURCES); 570d1b054daSYu Zhao } 5718c5cdb6aSYu Zhao 5728c5cdb6aSYu Zhao /** 5736faf17f6SChris Wright * pci_sriov_resource_alignment - get resource alignment for VF BAR 5746faf17f6SChris Wright * @dev: the PCI device 5756faf17f6SChris Wright * @resno: the resource number 5766faf17f6SChris Wright * 5776faf17f6SChris Wright * Returns the alignment of the VF BAR found in the SR-IOV capability. 5786faf17f6SChris Wright * This is not the same as the resource size which is defined as 5796faf17f6SChris Wright * the VF BAR size multiplied by the number of VFs. The alignment 5806faf17f6SChris Wright * is just the VF BAR size. 5816faf17f6SChris Wright */ 5820e52247aSCam Macdonell resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno) 5836faf17f6SChris Wright { 5840e6c9122SWei Yang return pci_iov_resource_size(dev, resno); 5856faf17f6SChris Wright } 5866faf17f6SChris Wright 5876faf17f6SChris Wright /** 5888c5cdb6aSYu Zhao * pci_restore_iov_state - restore the state of the IOV capability 5898c5cdb6aSYu Zhao * @dev: the PCI device 5908c5cdb6aSYu Zhao */ 5918c5cdb6aSYu Zhao void pci_restore_iov_state(struct pci_dev *dev) 5928c5cdb6aSYu Zhao { 5938c5cdb6aSYu Zhao if (dev->is_physfn) 5948c5cdb6aSYu Zhao sriov_restore_state(dev); 5958c5cdb6aSYu Zhao } 596a28724b0SYu Zhao 597a28724b0SYu Zhao /** 598a28724b0SYu Zhao * pci_iov_bus_range - find bus range used by Virtual Function 599a28724b0SYu Zhao * @bus: the PCI bus 600a28724b0SYu Zhao * 601a28724b0SYu Zhao * Returns max number of buses (exclude current one) used by Virtual 602a28724b0SYu Zhao * Functions. 603a28724b0SYu Zhao */ 604a28724b0SYu Zhao int pci_iov_bus_range(struct pci_bus *bus) 605a28724b0SYu Zhao { 606a28724b0SYu Zhao int max = 0; 607a28724b0SYu Zhao struct pci_dev *dev; 608a28724b0SYu Zhao 609a28724b0SYu Zhao list_for_each_entry(dev, &bus->devices, bus_list) { 610a28724b0SYu Zhao if (!dev->is_physfn) 611a28724b0SYu Zhao continue; 6124449f079SWei Yang if (dev->sriov->max_VF_buses > max) 6134449f079SWei Yang max = dev->sriov->max_VF_buses; 614a28724b0SYu Zhao } 615a28724b0SYu Zhao 616a28724b0SYu Zhao return max ? max - bus->number : 0; 617a28724b0SYu Zhao } 618dd7cc44dSYu Zhao 619dd7cc44dSYu Zhao /** 620dd7cc44dSYu Zhao * pci_enable_sriov - enable the SR-IOV capability 621dd7cc44dSYu Zhao * @dev: the PCI device 62252a8873bSRandy Dunlap * @nr_virtfn: number of virtual functions to enable 623dd7cc44dSYu Zhao * 624dd7cc44dSYu Zhao * Returns 0 on success, or negative on failure. 625dd7cc44dSYu Zhao */ 626dd7cc44dSYu Zhao int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn) 627dd7cc44dSYu Zhao { 628dd7cc44dSYu Zhao might_sleep(); 629dd7cc44dSYu Zhao 630dd7cc44dSYu Zhao if (!dev->is_physfn) 631652d1100SStefan Assmann return -ENOSYS; 632dd7cc44dSYu Zhao 633dd7cc44dSYu Zhao return sriov_enable(dev, nr_virtfn); 634dd7cc44dSYu Zhao } 635dd7cc44dSYu Zhao EXPORT_SYMBOL_GPL(pci_enable_sriov); 636dd7cc44dSYu Zhao 637dd7cc44dSYu Zhao /** 638dd7cc44dSYu Zhao * pci_disable_sriov - disable the SR-IOV capability 639dd7cc44dSYu Zhao * @dev: the PCI device 640dd7cc44dSYu Zhao */ 641dd7cc44dSYu Zhao void pci_disable_sriov(struct pci_dev *dev) 642dd7cc44dSYu Zhao { 643dd7cc44dSYu Zhao might_sleep(); 644dd7cc44dSYu Zhao 645dd7cc44dSYu Zhao if (!dev->is_physfn) 646dd7cc44dSYu Zhao return; 647dd7cc44dSYu Zhao 648dd7cc44dSYu Zhao sriov_disable(dev); 649dd7cc44dSYu Zhao } 650dd7cc44dSYu Zhao EXPORT_SYMBOL_GPL(pci_disable_sriov); 65174bb1bccSYu Zhao 65274bb1bccSYu Zhao /** 653fb8a0d9dSWilliams, Mitch A * pci_num_vf - return number of VFs associated with a PF device_release_driver 654fb8a0d9dSWilliams, Mitch A * @dev: the PCI device 655fb8a0d9dSWilliams, Mitch A * 656fb8a0d9dSWilliams, Mitch A * Returns number of VFs, or 0 if SR-IOV is not enabled. 657fb8a0d9dSWilliams, Mitch A */ 658fb8a0d9dSWilliams, Mitch A int pci_num_vf(struct pci_dev *dev) 659fb8a0d9dSWilliams, Mitch A { 6601452cd76SBjorn Helgaas if (!dev->is_physfn) 661fb8a0d9dSWilliams, Mitch A return 0; 6621452cd76SBjorn Helgaas 6636b136724SBjorn Helgaas return dev->sriov->num_VFs; 664fb8a0d9dSWilliams, Mitch A } 665fb8a0d9dSWilliams, Mitch A EXPORT_SYMBOL_GPL(pci_num_vf); 666bff73156SDonald Dutile 667bff73156SDonald Dutile /** 6685a8eb242SAlexander Duyck * pci_vfs_assigned - returns number of VFs are assigned to a guest 6695a8eb242SAlexander Duyck * @dev: the PCI device 6705a8eb242SAlexander Duyck * 6715a8eb242SAlexander Duyck * Returns number of VFs belonging to this device that are assigned to a guest. 672652d1100SStefan Assmann * If device is not a physical function returns 0. 6735a8eb242SAlexander Duyck */ 6745a8eb242SAlexander Duyck int pci_vfs_assigned(struct pci_dev *dev) 6755a8eb242SAlexander Duyck { 6765a8eb242SAlexander Duyck struct pci_dev *vfdev; 6775a8eb242SAlexander Duyck unsigned int vfs_assigned = 0; 6785a8eb242SAlexander Duyck unsigned short dev_id; 6795a8eb242SAlexander Duyck 6805a8eb242SAlexander Duyck /* only search if we are a PF */ 6815a8eb242SAlexander Duyck if (!dev->is_physfn) 6825a8eb242SAlexander Duyck return 0; 6835a8eb242SAlexander Duyck 6845a8eb242SAlexander Duyck /* 6855a8eb242SAlexander Duyck * determine the device ID for the VFs, the vendor ID will be the 6865a8eb242SAlexander Duyck * same as the PF so there is no need to check for that one 6875a8eb242SAlexander Duyck */ 6885a8eb242SAlexander Duyck pci_read_config_word(dev, dev->sriov->pos + PCI_SRIOV_VF_DID, &dev_id); 6895a8eb242SAlexander Duyck 6905a8eb242SAlexander Duyck /* loop through all the VFs to see if we own any that are assigned */ 6915a8eb242SAlexander Duyck vfdev = pci_get_device(dev->vendor, dev_id, NULL); 6925a8eb242SAlexander Duyck while (vfdev) { 6935a8eb242SAlexander Duyck /* 6945a8eb242SAlexander Duyck * It is considered assigned if it is a virtual function with 6955a8eb242SAlexander Duyck * our dev as the physical function and the assigned bit is set 6965a8eb242SAlexander Duyck */ 6975a8eb242SAlexander Duyck if (vfdev->is_virtfn && (vfdev->physfn == dev) && 698be63497cSEthan Zhao pci_is_dev_assigned(vfdev)) 6995a8eb242SAlexander Duyck vfs_assigned++; 7005a8eb242SAlexander Duyck 7015a8eb242SAlexander Duyck vfdev = pci_get_device(dev->vendor, dev_id, vfdev); 7025a8eb242SAlexander Duyck } 7035a8eb242SAlexander Duyck 7045a8eb242SAlexander Duyck return vfs_assigned; 7055a8eb242SAlexander Duyck } 7065a8eb242SAlexander Duyck EXPORT_SYMBOL_GPL(pci_vfs_assigned); 7075a8eb242SAlexander Duyck 7085a8eb242SAlexander Duyck /** 709bff73156SDonald Dutile * pci_sriov_set_totalvfs -- reduce the TotalVFs available 710bff73156SDonald Dutile * @dev: the PCI PF device 7112094f167SRandy Dunlap * @numvfs: number that should be used for TotalVFs supported 712bff73156SDonald Dutile * 713bff73156SDonald Dutile * Should be called from PF driver's probe routine with 714bff73156SDonald Dutile * device's mutex held. 715bff73156SDonald Dutile * 716bff73156SDonald Dutile * Returns 0 if PF is an SRIOV-capable device and 717652d1100SStefan Assmann * value of numvfs valid. If not a PF return -ENOSYS; 718652d1100SStefan Assmann * if numvfs is invalid return -EINVAL; 719bff73156SDonald Dutile * if VFs already enabled, return -EBUSY. 720bff73156SDonald Dutile */ 721bff73156SDonald Dutile int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs) 722bff73156SDonald Dutile { 723652d1100SStefan Assmann if (!dev->is_physfn) 724652d1100SStefan Assmann return -ENOSYS; 725652d1100SStefan Assmann if (numvfs > dev->sriov->total_VFs) 726bff73156SDonald Dutile return -EINVAL; 727bff73156SDonald Dutile 728bff73156SDonald Dutile /* Shouldn't change if VFs already enabled */ 729bff73156SDonald Dutile if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE) 730bff73156SDonald Dutile return -EBUSY; 731bff73156SDonald Dutile else 7326b136724SBjorn Helgaas dev->sriov->driver_max_VFs = numvfs; 733bff73156SDonald Dutile 734bff73156SDonald Dutile return 0; 735bff73156SDonald Dutile } 736bff73156SDonald Dutile EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs); 737bff73156SDonald Dutile 738bff73156SDonald Dutile /** 739ddc191f5SJonghwan Choi * pci_sriov_get_totalvfs -- get total VFs supported on this device 740bff73156SDonald Dutile * @dev: the PCI PF device 741bff73156SDonald Dutile * 742bff73156SDonald Dutile * For a PCIe device with SRIOV support, return the PCIe 7436b136724SBjorn Helgaas * SRIOV capability value of TotalVFs or the value of driver_max_VFs 744652d1100SStefan Assmann * if the driver reduced it. Otherwise 0. 745bff73156SDonald Dutile */ 746bff73156SDonald Dutile int pci_sriov_get_totalvfs(struct pci_dev *dev) 747bff73156SDonald Dutile { 7481452cd76SBjorn Helgaas if (!dev->is_physfn) 749652d1100SStefan Assmann return 0; 750bff73156SDonald Dutile 7516b136724SBjorn Helgaas if (dev->sriov->driver_max_VFs) 7526b136724SBjorn Helgaas return dev->sriov->driver_max_VFs; 7531452cd76SBjorn Helgaas 7546b136724SBjorn Helgaas return dev->sriov->total_VFs; 755bff73156SDonald Dutile } 756bff73156SDonald Dutile EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs); 757