1 // SPDX-License-Identifier: GPL-2.0
3 * PCI Express I/O Virtualization (IOV) support
5 * Address Translation Service 1.0
7 * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com>
10 #include <linux/pci.h>
11 #include <linux/slab.h>
12 #include <linux/mutex.h>
13 #include <linux/export.h>
14 #include <linux/string.h>
15 #include <linux/delay.h>
18 #define VIRTFN_ID_LEN 16
20 int pci_iov_virtfn_bus(struct pci_dev *dev, int vf_id)
24 return dev->bus->number + ((dev->devfn + dev->sriov->offset +
25 dev->sriov->stride * vf_id) >> 8);
28 int pci_iov_virtfn_devfn(struct pci_dev *dev, int vf_id)
32 return (dev->devfn + dev->sriov->offset +
33 dev->sriov->stride * vf_id) & 0xff;
37 * Per SR-IOV spec sec 3.3.10 and 3.3.11, First VF Offset and VF Stride may
38 * change when NumVFs changes.
40 * Update iov->offset and iov->stride when NumVFs is written.
42 static inline void pci_iov_set_numvfs(struct pci_dev *dev, int nr_virtfn)
44 struct pci_sriov *iov = dev->sriov;
46 pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
47 pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &iov->offset);
48 pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &iov->stride);
52 * The PF consumes one bus number. NumVFs, First VF Offset, and VF Stride
53 * determine how many additional bus numbers will be consumed by VFs.
55 * Iterate over all valid NumVFs, validate offset and stride, and calculate
56 * the maximum number of bus numbers that could ever be required.
58 static int compute_max_vf_buses(struct pci_dev *dev)
60 struct pci_sriov *iov = dev->sriov;
61 int nr_virtfn, busnr, rc = 0;
63 for (nr_virtfn = iov->total_VFs; nr_virtfn; nr_virtfn--) {
64 pci_iov_set_numvfs(dev, nr_virtfn);
65 if (!iov->offset || (nr_virtfn > 1 && !iov->stride)) {
70 busnr = pci_iov_virtfn_bus(dev, nr_virtfn - 1);
71 if (busnr > iov->max_VF_buses)
72 iov->max_VF_buses = busnr;
76 pci_iov_set_numvfs(dev, 0);
80 static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr)
82 struct pci_bus *child;
84 if (bus->number == busnr)
87 child = pci_find_bus(pci_domain_nr(bus), busnr);
91 child = pci_add_new_bus(bus, NULL, busnr);
95 pci_bus_insert_busn_res(child, busnr, busnr);
100 static void virtfn_remove_bus(struct pci_bus *physbus, struct pci_bus *virtbus)
102 if (physbus != virtbus && list_empty(&virtbus->devices))
103 pci_remove_bus(virtbus);
106 resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno)
111 return dev->sriov->barsz[resno - PCI_IOV_RESOURCES];
114 static void pci_read_vf_config_common(struct pci_dev *virtfn)
116 struct pci_dev *physfn = virtfn->physfn;
119 * Some config registers are the same across all associated VFs.
120 * Read them once from VF0 so we can skip reading them from the
123 * PCIe r4.0, sec 9.3.4.1, technically doesn't require all VFs to
124 * have the same Revision ID and Subsystem ID, but we assume they
127 pci_read_config_dword(virtfn, PCI_CLASS_REVISION,
128 &physfn->sriov->class);
129 pci_read_config_byte(virtfn, PCI_HEADER_TYPE,
130 &physfn->sriov->hdr_type);
131 pci_read_config_word(virtfn, PCI_SUBSYSTEM_VENDOR_ID,
132 &physfn->sriov->subsystem_vendor);
133 pci_read_config_word(virtfn, PCI_SUBSYSTEM_ID,
134 &physfn->sriov->subsystem_device);
137 int pci_iov_add_virtfn(struct pci_dev *dev, int id)
142 char buf[VIRTFN_ID_LEN];
143 struct pci_dev *virtfn;
144 struct resource *res;
145 struct pci_sriov *iov = dev->sriov;
148 bus = virtfn_add_bus(dev->bus, pci_iov_virtfn_bus(dev, id));
152 virtfn = pci_alloc_dev(bus);
156 virtfn->devfn = pci_iov_virtfn_devfn(dev, id);
157 virtfn->vendor = dev->vendor;
158 virtfn->device = iov->vf_device;
159 virtfn->is_virtfn = 1;
160 virtfn->physfn = pci_dev_get(dev);
161 virtfn->no_command_memory = 1;
164 pci_read_vf_config_common(virtfn);
166 rc = pci_setup_device(virtfn);
170 virtfn->dev.parent = dev->dev.parent;
171 virtfn->multifunction = 0;
173 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
174 res = &dev->resource[i + PCI_IOV_RESOURCES];
177 virtfn->resource[i].name = pci_name(virtfn);
178 virtfn->resource[i].flags = res->flags;
179 size = pci_iov_resource_size(dev, i + PCI_IOV_RESOURCES);
180 virtfn->resource[i].start = res->start + size * id;
181 virtfn->resource[i].end = virtfn->resource[i].start + size - 1;
182 rc = request_resource(res, &virtfn->resource[i]);
186 pci_device_add(virtfn, virtfn->bus);
188 sprintf(buf, "virtfn%u", id);
189 rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf);
192 rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn");
196 kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE);
198 pci_bus_add_device(virtfn);
203 sysfs_remove_link(&dev->dev.kobj, buf);
205 pci_stop_and_remove_bus_device(virtfn);
208 virtfn_remove_bus(dev->bus, bus);
214 void pci_iov_remove_virtfn(struct pci_dev *dev, int id)
216 char buf[VIRTFN_ID_LEN];
217 struct pci_dev *virtfn;
219 virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus),
220 pci_iov_virtfn_bus(dev, id),
221 pci_iov_virtfn_devfn(dev, id));
225 sprintf(buf, "virtfn%u", id);
226 sysfs_remove_link(&dev->dev.kobj, buf);
228 * pci_stop_dev() could have been called for this virtfn already,
229 * so the directory for the virtfn may have been removed before.
230 * Double check to avoid spurious sysfs warnings.
232 if (virtfn->dev.kobj.sd)
233 sysfs_remove_link(&virtfn->dev.kobj, "physfn");
235 pci_stop_and_remove_bus_device(virtfn);
236 virtfn_remove_bus(dev->bus, virtfn->bus);
238 /* balance pci_get_domain_bus_and_slot() */
243 static ssize_t sriov_totalvfs_show(struct device *dev,
244 struct device_attribute *attr,
247 struct pci_dev *pdev = to_pci_dev(dev);
249 return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev));
252 static ssize_t sriov_numvfs_show(struct device *dev,
253 struct device_attribute *attr,
256 struct pci_dev *pdev = to_pci_dev(dev);
259 /* Serialize vs sriov_numvfs_store() so readers see valid num_VFs */
260 device_lock(&pdev->dev);
261 num_vfs = pdev->sriov->num_VFs;
262 device_unlock(&pdev->dev);
264 return sprintf(buf, "%u\n", num_vfs);
268 * num_vfs > 0; number of VFs to enable
269 * num_vfs = 0; disable all VFs
271 * Note: SRIOV spec does not allow partial VF
272 * disable, so it's all or none.
274 static ssize_t sriov_numvfs_store(struct device *dev,
275 struct device_attribute *attr,
276 const char *buf, size_t count)
278 struct pci_dev *pdev = to_pci_dev(dev);
282 ret = kstrtou16(buf, 0, &num_vfs);
286 if (num_vfs > pci_sriov_get_totalvfs(pdev))
289 device_lock(&pdev->dev);
291 if (num_vfs == pdev->sriov->num_VFs)
294 /* is PF driver loaded w/callback */
295 if (!pdev->driver || !pdev->driver->sriov_configure) {
296 pci_info(pdev, "Driver does not support SRIOV configuration via sysfs\n");
303 ret = pdev->driver->sriov_configure(pdev, 0);
308 if (pdev->sriov->num_VFs) {
309 pci_warn(pdev, "%d VFs already enabled. Disable before enabling %d VFs\n",
310 pdev->sriov->num_VFs, num_vfs);
315 ret = pdev->driver->sriov_configure(pdev, num_vfs);
320 pci_warn(pdev, "%d VFs requested; only %d enabled\n",
324 device_unlock(&pdev->dev);
332 static ssize_t sriov_offset_show(struct device *dev,
333 struct device_attribute *attr,
336 struct pci_dev *pdev = to_pci_dev(dev);
338 return sprintf(buf, "%u\n", pdev->sriov->offset);
341 static ssize_t sriov_stride_show(struct device *dev,
342 struct device_attribute *attr,
345 struct pci_dev *pdev = to_pci_dev(dev);
347 return sprintf(buf, "%u\n", pdev->sriov->stride);
350 static ssize_t sriov_vf_device_show(struct device *dev,
351 struct device_attribute *attr,
354 struct pci_dev *pdev = to_pci_dev(dev);
356 return sprintf(buf, "%x\n", pdev->sriov->vf_device);
359 static ssize_t sriov_drivers_autoprobe_show(struct device *dev,
360 struct device_attribute *attr,
363 struct pci_dev *pdev = to_pci_dev(dev);
365 return sprintf(buf, "%u\n", pdev->sriov->drivers_autoprobe);
368 static ssize_t sriov_drivers_autoprobe_store(struct device *dev,
369 struct device_attribute *attr,
370 const char *buf, size_t count)
372 struct pci_dev *pdev = to_pci_dev(dev);
373 bool drivers_autoprobe;
375 if (kstrtobool(buf, &drivers_autoprobe) < 0)
378 pdev->sriov->drivers_autoprobe = drivers_autoprobe;
383 static DEVICE_ATTR_RO(sriov_totalvfs);
384 static DEVICE_ATTR_RW(sriov_numvfs);
385 static DEVICE_ATTR_RO(sriov_offset);
386 static DEVICE_ATTR_RO(sriov_stride);
387 static DEVICE_ATTR_RO(sriov_vf_device);
388 static DEVICE_ATTR_RW(sriov_drivers_autoprobe);
390 static struct attribute *sriov_dev_attrs[] = {
391 &dev_attr_sriov_totalvfs.attr,
392 &dev_attr_sriov_numvfs.attr,
393 &dev_attr_sriov_offset.attr,
394 &dev_attr_sriov_stride.attr,
395 &dev_attr_sriov_vf_device.attr,
396 &dev_attr_sriov_drivers_autoprobe.attr,
400 static umode_t sriov_attrs_are_visible(struct kobject *kobj,
401 struct attribute *a, int n)
403 struct device *dev = kobj_to_dev(kobj);
411 const struct attribute_group sriov_dev_attr_group = {
412 .attrs = sriov_dev_attrs,
413 .is_visible = sriov_attrs_are_visible,
416 int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs)
421 int __weak pcibios_sriov_disable(struct pci_dev *pdev)
426 static int sriov_add_vfs(struct pci_dev *dev, u16 num_vfs)
434 for (i = 0; i < num_vfs; i++) {
435 rc = pci_iov_add_virtfn(dev, i);
442 pci_iov_remove_virtfn(dev, i);
447 static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
453 struct resource *res;
454 struct pci_dev *pdev;
455 struct pci_sriov *iov = dev->sriov;
465 pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial);
466 if (initial > iov->total_VFs ||
467 (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs)))
470 if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs ||
471 (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial)))
475 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
476 bars |= (1 << (i + PCI_IOV_RESOURCES));
477 res = &dev->resource[i + PCI_IOV_RESOURCES];
481 if (nres != iov->nres) {
482 pci_err(dev, "not enough MMIO resources for SR-IOV\n");
486 bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1);
487 if (bus > dev->bus->busn_res.end) {
488 pci_err(dev, "can't enable %d VFs (bus %02x out of range of %pR)\n",
489 nr_virtfn, bus, &dev->bus->busn_res);
493 if (pci_enable_resources(dev, bars)) {
494 pci_err(dev, "SR-IOV: IOV BARS not allocated\n");
498 if (iov->link != dev->devfn) {
499 pdev = pci_get_slot(dev->bus, iov->link);
503 if (!pdev->is_physfn) {
508 rc = sysfs_create_link(&dev->dev.kobj,
509 &pdev->dev.kobj, "dep_link");
515 iov->initial_VFs = initial;
516 if (nr_virtfn < initial)
519 rc = pcibios_sriov_enable(dev, initial);
521 pci_err(dev, "failure %d from pcibios_sriov_enable()\n", rc);
525 pci_iov_set_numvfs(dev, nr_virtfn);
526 iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE;
527 pci_cfg_access_lock(dev);
528 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
530 pci_cfg_access_unlock(dev);
532 rc = sriov_add_vfs(dev, initial);
536 kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE);
537 iov->num_VFs = nr_virtfn;
542 iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
543 pci_cfg_access_lock(dev);
544 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
546 pci_cfg_access_unlock(dev);
548 pcibios_sriov_disable(dev);
550 if (iov->link != dev->devfn)
551 sysfs_remove_link(&dev->dev.kobj, "dep_link");
553 pci_iov_set_numvfs(dev, 0);
557 static void sriov_del_vfs(struct pci_dev *dev)
559 struct pci_sriov *iov = dev->sriov;
565 for (i = 0; i < iov->num_VFs; i++)
566 pci_iov_remove_virtfn(dev, i);
569 static void sriov_disable(struct pci_dev *dev)
571 struct pci_sriov *iov = dev->sriov;
577 iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
578 pci_cfg_access_lock(dev);
579 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
581 pci_cfg_access_unlock(dev);
583 pcibios_sriov_disable(dev);
585 if (iov->link != dev->devfn)
586 sysfs_remove_link(&dev->dev.kobj, "dep_link");
589 pci_iov_set_numvfs(dev, 0);
592 static int sriov_init(struct pci_dev *dev, int pos)
599 struct pci_sriov *iov;
600 struct resource *res;
601 struct pci_dev *pdev;
603 pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl);
604 if (ctrl & PCI_SRIOV_CTRL_VFE) {
605 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0);
610 list_for_each_entry(pdev, &dev->bus->devices, bus_list)
615 if (pci_ari_enabled(dev->bus))
616 ctrl |= PCI_SRIOV_CTRL_ARI;
619 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl);
621 pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total);
625 pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz);
626 i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0;
627 pgsz &= ~((1 << i) - 1);
632 pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz);
634 iov = kzalloc(sizeof(*iov), GFP_KERNEL);
639 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
640 res = &dev->resource[i + PCI_IOV_RESOURCES];
642 * If it is already FIXED, don't change it, something
643 * (perhaps EA or header fixups) wants it this way.
645 if (res->flags & IORESOURCE_PCI_FIXED)
646 bar64 = (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
648 bar64 = __pci_read_base(dev, pci_bar_unknown, res,
649 pos + PCI_SRIOV_BAR + i * 4);
652 if (resource_size(res) & (PAGE_SIZE - 1)) {
656 iov->barsz[i] = resource_size(res);
657 res->end = res->start + resource_size(res) * total - 1;
658 pci_info(dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n",
667 iov->total_VFs = total;
668 iov->driver_max_VFs = total;
669 pci_read_config_word(dev, pos + PCI_SRIOV_VF_DID, &iov->vf_device);
672 iov->drivers_autoprobe = true;
673 pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap);
674 pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link);
675 if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END)
676 iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link);
679 iov->dev = pci_dev_get(pdev);
685 rc = compute_max_vf_buses(dev);
695 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
696 res = &dev->resource[i + PCI_IOV_RESOURCES];
704 static void sriov_release(struct pci_dev *dev)
706 BUG_ON(dev->sriov->num_VFs);
708 if (dev != dev->sriov->dev)
709 pci_dev_put(dev->sriov->dev);
715 static void sriov_restore_state(struct pci_dev *dev)
719 struct pci_sriov *iov = dev->sriov;
721 pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl);
722 if (ctrl & PCI_SRIOV_CTRL_VFE)
726 * Restore PCI_SRIOV_CTRL_ARI before pci_iov_set_numvfs() because
727 * it reads offset & stride, which depend on PCI_SRIOV_CTRL_ARI.
729 ctrl &= ~PCI_SRIOV_CTRL_ARI;
730 ctrl |= iov->ctrl & PCI_SRIOV_CTRL_ARI;
731 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, ctrl);
733 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++)
734 pci_update_resource(dev, i + PCI_IOV_RESOURCES);
736 pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz);
737 pci_iov_set_numvfs(dev, iov->num_VFs);
738 pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
739 if (iov->ctrl & PCI_SRIOV_CTRL_VFE)
744 * pci_iov_init - initialize the IOV capability
745 * @dev: the PCI device
747 * Returns 0 on success, or negative on failure.
749 int pci_iov_init(struct pci_dev *dev)
753 if (!pci_is_pcie(dev))
756 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV);
758 return sriov_init(dev, pos);
764 * pci_iov_release - release resources used by the IOV capability
765 * @dev: the PCI device
767 void pci_iov_release(struct pci_dev *dev)
774 * pci_iov_remove - clean up SR-IOV state after PF driver is detached
775 * @dev: the PCI device
777 void pci_iov_remove(struct pci_dev *dev)
779 struct pci_sriov *iov = dev->sriov;
784 iov->driver_max_VFs = iov->total_VFs;
786 pci_warn(dev, "driver left SR-IOV enabled after remove\n");
790 * pci_iov_update_resource - update a VF BAR
791 * @dev: the PCI device
792 * @resno: the resource number
794 * Update a VF BAR in the SR-IOV capability of a PF.
796 void pci_iov_update_resource(struct pci_dev *dev, int resno)
798 struct pci_sriov *iov = dev->is_physfn ? dev->sriov : NULL;
799 struct resource *res = dev->resource + resno;
800 int vf_bar = resno - PCI_IOV_RESOURCES;
801 struct pci_bus_region region;
807 * The generic pci_restore_bars() path calls this for all devices,
808 * including VFs and non-SR-IOV devices. If this is not a PF, we
809 * have nothing to do.
814 pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &cmd);
815 if ((cmd & PCI_SRIOV_CTRL_VFE) && (cmd & PCI_SRIOV_CTRL_MSE)) {
816 dev_WARN(&dev->dev, "can't update enabled VF BAR%d %pR\n",
822 * Ignore unimplemented BARs, unused resource slots for 64-bit
823 * BARs, and non-movable resources, e.g., those described via
824 * Enhanced Allocation.
829 if (res->flags & IORESOURCE_UNSET)
832 if (res->flags & IORESOURCE_PCI_FIXED)
835 pcibios_resource_to_bus(dev->bus, ®ion, res);
837 new |= res->flags & ~PCI_BASE_ADDRESS_MEM_MASK;
839 reg = iov->pos + PCI_SRIOV_BAR + 4 * vf_bar;
840 pci_write_config_dword(dev, reg, new);
841 if (res->flags & IORESOURCE_MEM_64) {
842 new = region.start >> 16 >> 16;
843 pci_write_config_dword(dev, reg + 4, new);
847 resource_size_t __weak pcibios_iov_resource_alignment(struct pci_dev *dev,
850 return pci_iov_resource_size(dev, resno);
854 * pci_sriov_resource_alignment - get resource alignment for VF BAR
855 * @dev: the PCI device
856 * @resno: the resource number
858 * Returns the alignment of the VF BAR found in the SR-IOV capability.
859 * This is not the same as the resource size which is defined as
860 * the VF BAR size multiplied by the number of VFs. The alignment
861 * is just the VF BAR size.
863 resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno)
865 return pcibios_iov_resource_alignment(dev, resno);
869 * pci_restore_iov_state - restore the state of the IOV capability
870 * @dev: the PCI device
872 void pci_restore_iov_state(struct pci_dev *dev)
875 sriov_restore_state(dev);
879 * pci_vf_drivers_autoprobe - set PF property drivers_autoprobe for VFs
880 * @dev: the PCI device
881 * @auto_probe: set VF drivers auto probe flag
883 void pci_vf_drivers_autoprobe(struct pci_dev *dev, bool auto_probe)
886 dev->sriov->drivers_autoprobe = auto_probe;
890 * pci_iov_bus_range - find bus range used by Virtual Function
893 * Returns max number of buses (exclude current one) used by Virtual
896 int pci_iov_bus_range(struct pci_bus *bus)
901 list_for_each_entry(dev, &bus->devices, bus_list) {
904 if (dev->sriov->max_VF_buses > max)
905 max = dev->sriov->max_VF_buses;
908 return max ? max - bus->number : 0;
912 * pci_enable_sriov - enable the SR-IOV capability
913 * @dev: the PCI device
914 * @nr_virtfn: number of virtual functions to enable
916 * Returns 0 on success, or negative on failure.
918 int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
925 return sriov_enable(dev, nr_virtfn);
927 EXPORT_SYMBOL_GPL(pci_enable_sriov);
930 * pci_disable_sriov - disable the SR-IOV capability
931 * @dev: the PCI device
933 void pci_disable_sriov(struct pci_dev *dev)
942 EXPORT_SYMBOL_GPL(pci_disable_sriov);
945 * pci_num_vf - return number of VFs associated with a PF device_release_driver
946 * @dev: the PCI device
948 * Returns number of VFs, or 0 if SR-IOV is not enabled.
950 int pci_num_vf(struct pci_dev *dev)
955 return dev->sriov->num_VFs;
957 EXPORT_SYMBOL_GPL(pci_num_vf);
960 * pci_vfs_assigned - returns number of VFs are assigned to a guest
961 * @dev: the PCI device
963 * Returns number of VFs belonging to this device that are assigned to a guest.
964 * If device is not a physical function returns 0.
966 int pci_vfs_assigned(struct pci_dev *dev)
968 struct pci_dev *vfdev;
969 unsigned int vfs_assigned = 0;
970 unsigned short dev_id;
972 /* only search if we are a PF */
977 * determine the device ID for the VFs, the vendor ID will be the
978 * same as the PF so there is no need to check for that one
980 dev_id = dev->sriov->vf_device;
982 /* loop through all the VFs to see if we own any that are assigned */
983 vfdev = pci_get_device(dev->vendor, dev_id, NULL);
986 * It is considered assigned if it is a virtual function with
987 * our dev as the physical function and the assigned bit is set
989 if (vfdev->is_virtfn && (vfdev->physfn == dev) &&
990 pci_is_dev_assigned(vfdev))
993 vfdev = pci_get_device(dev->vendor, dev_id, vfdev);
998 EXPORT_SYMBOL_GPL(pci_vfs_assigned);
1001 * pci_sriov_set_totalvfs -- reduce the TotalVFs available
1002 * @dev: the PCI PF device
1003 * @numvfs: number that should be used for TotalVFs supported
1005 * Should be called from PF driver's probe routine with
1006 * device's mutex held.
1008 * Returns 0 if PF is an SRIOV-capable device and
1009 * value of numvfs valid. If not a PF return -ENOSYS;
1010 * if numvfs is invalid return -EINVAL;
1011 * if VFs already enabled, return -EBUSY.
1013 int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs)
1015 if (!dev->is_physfn)
1018 if (numvfs > dev->sriov->total_VFs)
1021 /* Shouldn't change if VFs already enabled */
1022 if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE)
1025 dev->sriov->driver_max_VFs = numvfs;
1028 EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs);
1031 * pci_sriov_get_totalvfs -- get total VFs supported on this device
1032 * @dev: the PCI PF device
1034 * For a PCIe device with SRIOV support, return the PCIe
1035 * SRIOV capability value of TotalVFs or the value of driver_max_VFs
1036 * if the driver reduced it. Otherwise 0.
1038 int pci_sriov_get_totalvfs(struct pci_dev *dev)
1040 if (!dev->is_physfn)
1043 return dev->sriov->driver_max_VFs;
1045 EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs);
1048 * pci_sriov_configure_simple - helper to configure SR-IOV
1049 * @dev: the PCI device
1050 * @nr_virtfn: number of virtual functions to enable, 0 to disable
1052 * Enable or disable SR-IOV for devices that don't require any PF setup
1053 * before enabling SR-IOV. Return value is negative on error, or number of
1054 * VFs allocated on success.
1056 int pci_sriov_configure_simple(struct pci_dev *dev, int nr_virtfn)
1062 if (!dev->is_physfn)
1065 if (pci_vfs_assigned(dev)) {
1066 pci_warn(dev, "Cannot modify SR-IOV while VFs are assigned\n");
1070 if (nr_virtfn == 0) {
1075 rc = sriov_enable(dev, nr_virtfn);
1081 EXPORT_SYMBOL_GPL(pci_sriov_configure_simple);