4 * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com>
6 * PCI Express I/O Virtualization (IOV) support.
8 * Address Translation Service 1.0
11 #include <linux/pci.h>
12 #include <linux/slab.h>
13 #include <linux/mutex.h>
14 #include <linux/export.h>
15 #include <linux/string.h>
16 #include <linux/delay.h>
17 #include <linux/pci-ats.h>
20 #define VIRTFN_ID_LEN 16
22 static inline u8
virtfn_bus(struct pci_dev
*dev
, int id
)
24 return dev
->bus
->number
+ ((dev
->devfn
+ dev
->sriov
->offset
+
25 dev
->sriov
->stride
* id
) >> 8);
28 static inline u8
virtfn_devfn(struct pci_dev
*dev
, int id
)
30 return (dev
->devfn
+ dev
->sriov
->offset
+
31 dev
->sriov
->stride
* id
) & 0xff;
34 static struct pci_bus
*virtfn_add_bus(struct pci_bus
*bus
, int busnr
)
36 struct pci_bus
*child
;
38 if (bus
->number
== busnr
)
41 child
= pci_find_bus(pci_domain_nr(bus
), busnr
);
45 child
= pci_add_new_bus(bus
, NULL
, busnr
);
49 pci_bus_insert_busn_res(child
, busnr
, busnr
);
54 static void virtfn_remove_bus(struct pci_bus
*physbus
, struct pci_bus
*virtbus
)
56 if (physbus
!= virtbus
&& list_empty(&virtbus
->devices
))
57 pci_remove_bus(virtbus
);
60 static int virtfn_add(struct pci_dev
*dev
, int id
, int reset
)
65 char buf
[VIRTFN_ID_LEN
];
66 struct pci_dev
*virtfn
;
68 struct pci_sriov
*iov
= dev
->sriov
;
71 mutex_lock(&iov
->dev
->sriov
->lock
);
72 bus
= virtfn_add_bus(dev
->bus
, virtfn_bus(dev
, id
));
76 virtfn
= pci_alloc_dev(bus
);
80 virtfn
->devfn
= virtfn_devfn(dev
, id
);
81 virtfn
->vendor
= dev
->vendor
;
82 pci_read_config_word(dev
, iov
->pos
+ PCI_SRIOV_VF_DID
, &virtfn
->device
);
83 pci_setup_device(virtfn
);
84 virtfn
->dev
.parent
= dev
->dev
.parent
;
85 virtfn
->physfn
= pci_dev_get(dev
);
86 virtfn
->is_virtfn
= 1;
88 for (i
= 0; i
< PCI_SRIOV_NUM_BARS
; i
++) {
89 res
= dev
->resource
+ PCI_IOV_RESOURCES
+ i
;
92 virtfn
->resource
[i
].name
= pci_name(virtfn
);
93 virtfn
->resource
[i
].flags
= res
->flags
;
94 size
= resource_size(res
);
95 do_div(size
, iov
->total_VFs
);
96 virtfn
->resource
[i
].start
= res
->start
+ size
* id
;
97 virtfn
->resource
[i
].end
= virtfn
->resource
[i
].start
+ size
- 1;
98 rc
= request_resource(res
, &virtfn
->resource
[i
]);
103 __pci_reset_function(virtfn
);
105 pci_device_add(virtfn
, virtfn
->bus
);
106 mutex_unlock(&iov
->dev
->sriov
->lock
);
108 rc
= pci_bus_add_device(virtfn
);
109 sprintf(buf
, "virtfn%u", id
);
110 rc
= sysfs_create_link(&dev
->dev
.kobj
, &virtfn
->dev
.kobj
, buf
);
113 rc
= sysfs_create_link(&virtfn
->dev
.kobj
, &dev
->dev
.kobj
, "physfn");
117 kobject_uevent(&virtfn
->dev
.kobj
, KOBJ_CHANGE
);
122 sysfs_remove_link(&dev
->dev
.kobj
, buf
);
125 mutex_lock(&iov
->dev
->sriov
->lock
);
126 pci_stop_and_remove_bus_device(virtfn
);
128 virtfn_remove_bus(dev
->bus
, bus
);
130 mutex_unlock(&iov
->dev
->sriov
->lock
);
135 static void virtfn_remove(struct pci_dev
*dev
, int id
, int reset
)
137 char buf
[VIRTFN_ID_LEN
];
138 struct pci_dev
*virtfn
;
139 struct pci_sriov
*iov
= dev
->sriov
;
141 virtfn
= pci_get_domain_bus_and_slot(pci_domain_nr(dev
->bus
),
143 virtfn_devfn(dev
, id
));
148 device_release_driver(&virtfn
->dev
);
149 __pci_reset_function(virtfn
);
152 sprintf(buf
, "virtfn%u", id
);
153 sysfs_remove_link(&dev
->dev
.kobj
, buf
);
155 * pci_stop_dev() could have been called for this virtfn already,
156 * so the directory for the virtfn may have been removed before.
157 * Double check to avoid spurious sysfs warnings.
159 if (virtfn
->dev
.kobj
.sd
)
160 sysfs_remove_link(&virtfn
->dev
.kobj
, "physfn");
162 mutex_lock(&iov
->dev
->sriov
->lock
);
163 pci_stop_and_remove_bus_device(virtfn
);
164 virtfn_remove_bus(dev
->bus
, virtfn
->bus
);
165 mutex_unlock(&iov
->dev
->sriov
->lock
);
167 /* balance pci_get_domain_bus_and_slot() */
172 static int sriov_migration(struct pci_dev
*dev
)
175 struct pci_sriov
*iov
= dev
->sriov
;
180 if (!(iov
->cap
& PCI_SRIOV_CAP_VFM
))
183 pci_read_config_word(dev
, iov
->pos
+ PCI_SRIOV_STATUS
, &status
);
184 if (!(status
& PCI_SRIOV_STATUS_VFM
))
187 schedule_work(&iov
->mtask
);
192 static void sriov_migration_task(struct work_struct
*work
)
197 struct pci_sriov
*iov
= container_of(work
, struct pci_sriov
, mtask
);
199 for (i
= iov
->initial_VFs
; i
< iov
->num_VFs
; i
++) {
200 state
= readb(iov
->mstate
+ i
);
201 if (state
== PCI_SRIOV_VFM_MI
) {
202 writeb(PCI_SRIOV_VFM_AV
, iov
->mstate
+ i
);
203 state
= readb(iov
->mstate
+ i
);
204 if (state
== PCI_SRIOV_VFM_AV
)
205 virtfn_add(iov
->self
, i
, 1);
206 } else if (state
== PCI_SRIOV_VFM_MO
) {
207 virtfn_remove(iov
->self
, i
, 1);
208 writeb(PCI_SRIOV_VFM_UA
, iov
->mstate
+ i
);
209 state
= readb(iov
->mstate
+ i
);
210 if (state
== PCI_SRIOV_VFM_AV
)
211 virtfn_add(iov
->self
, i
, 0);
215 pci_read_config_word(iov
->self
, iov
->pos
+ PCI_SRIOV_STATUS
, &status
);
216 status
&= ~PCI_SRIOV_STATUS_VFM
;
217 pci_write_config_word(iov
->self
, iov
->pos
+ PCI_SRIOV_STATUS
, status
);
220 static int sriov_enable_migration(struct pci_dev
*dev
, int nr_virtfn
)
225 struct pci_sriov
*iov
= dev
->sriov
;
227 if (nr_virtfn
<= iov
->initial_VFs
)
230 pci_read_config_dword(dev
, iov
->pos
+ PCI_SRIOV_VFM
, &table
);
231 bir
= PCI_SRIOV_VFM_BIR(table
);
232 if (bir
> PCI_STD_RESOURCE_END
)
235 table
= PCI_SRIOV_VFM_OFFSET(table
);
236 if (table
+ nr_virtfn
> pci_resource_len(dev
, bir
))
239 pa
= pci_resource_start(dev
, bir
) + table
;
240 iov
->mstate
= ioremap(pa
, nr_virtfn
);
244 INIT_WORK(&iov
->mtask
, sriov_migration_task
);
246 iov
->ctrl
|= PCI_SRIOV_CTRL_VFM
| PCI_SRIOV_CTRL_INTR
;
247 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_CTRL
, iov
->ctrl
);
252 static void sriov_disable_migration(struct pci_dev
*dev
)
254 struct pci_sriov
*iov
= dev
->sriov
;
256 iov
->ctrl
&= ~(PCI_SRIOV_CTRL_VFM
| PCI_SRIOV_CTRL_INTR
);
257 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_CTRL
, iov
->ctrl
);
259 cancel_work_sync(&iov
->mtask
);
260 iounmap(iov
->mstate
);
263 static int sriov_enable(struct pci_dev
*dev
, int nr_virtfn
)
268 u16 offset
, stride
, initial
;
269 struct resource
*res
;
270 struct pci_dev
*pdev
;
271 struct pci_sriov
*iov
= dev
->sriov
;
280 pci_read_config_word(dev
, iov
->pos
+ PCI_SRIOV_INITIAL_VF
, &initial
);
281 if (initial
> iov
->total_VFs
||
282 (!(iov
->cap
& PCI_SRIOV_CAP_VFM
) && (initial
!= iov
->total_VFs
)))
285 if (nr_virtfn
< 0 || nr_virtfn
> iov
->total_VFs
||
286 (!(iov
->cap
& PCI_SRIOV_CAP_VFM
) && (nr_virtfn
> initial
)))
289 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_NUM_VF
, nr_virtfn
);
290 pci_read_config_word(dev
, iov
->pos
+ PCI_SRIOV_VF_OFFSET
, &offset
);
291 pci_read_config_word(dev
, iov
->pos
+ PCI_SRIOV_VF_STRIDE
, &stride
);
292 if (!offset
|| (nr_virtfn
> 1 && !stride
))
296 for (i
= 0; i
< PCI_SRIOV_NUM_BARS
; i
++) {
297 bars
|= (1 << (i
+ PCI_IOV_RESOURCES
));
298 res
= dev
->resource
+ PCI_IOV_RESOURCES
+ i
;
302 if (nres
!= iov
->nres
) {
303 dev_err(&dev
->dev
, "not enough MMIO resources for SR-IOV\n");
307 iov
->offset
= offset
;
308 iov
->stride
= stride
;
310 if (virtfn_bus(dev
, nr_virtfn
- 1) > dev
->bus
->busn_res
.end
) {
311 dev_err(&dev
->dev
, "SR-IOV: bus number out of range\n");
315 if (pci_enable_resources(dev
, bars
)) {
316 dev_err(&dev
->dev
, "SR-IOV: IOV BARS not allocated\n");
320 if (iov
->link
!= dev
->devfn
) {
321 pdev
= pci_get_slot(dev
->bus
, iov
->link
);
325 if (!pdev
->is_physfn
) {
330 rc
= sysfs_create_link(&dev
->dev
.kobj
,
331 &pdev
->dev
.kobj
, "dep_link");
337 iov
->ctrl
|= PCI_SRIOV_CTRL_VFE
| PCI_SRIOV_CTRL_MSE
;
338 pci_cfg_access_lock(dev
);
339 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_CTRL
, iov
->ctrl
);
341 pci_cfg_access_unlock(dev
);
343 iov
->initial_VFs
= initial
;
344 if (nr_virtfn
< initial
)
347 for (i
= 0; i
< initial
; i
++) {
348 rc
= virtfn_add(dev
, i
, 0);
353 if (iov
->cap
& PCI_SRIOV_CAP_VFM
) {
354 rc
= sriov_enable_migration(dev
, nr_virtfn
);
359 kobject_uevent(&dev
->dev
.kobj
, KOBJ_CHANGE
);
360 iov
->num_VFs
= nr_virtfn
;
365 for (j
= 0; j
< i
; j
++)
366 virtfn_remove(dev
, j
, 0);
368 iov
->ctrl
&= ~(PCI_SRIOV_CTRL_VFE
| PCI_SRIOV_CTRL_MSE
);
369 pci_cfg_access_lock(dev
);
370 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_CTRL
, iov
->ctrl
);
372 pci_cfg_access_unlock(dev
);
374 if (iov
->link
!= dev
->devfn
)
375 sysfs_remove_link(&dev
->dev
.kobj
, "dep_link");
380 static void sriov_disable(struct pci_dev
*dev
)
383 struct pci_sriov
*iov
= dev
->sriov
;
388 if (iov
->cap
& PCI_SRIOV_CAP_VFM
)
389 sriov_disable_migration(dev
);
391 for (i
= 0; i
< iov
->num_VFs
; i
++)
392 virtfn_remove(dev
, i
, 0);
394 iov
->ctrl
&= ~(PCI_SRIOV_CTRL_VFE
| PCI_SRIOV_CTRL_MSE
);
395 pci_cfg_access_lock(dev
);
396 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_CTRL
, iov
->ctrl
);
398 pci_cfg_access_unlock(dev
);
400 if (iov
->link
!= dev
->devfn
)
401 sysfs_remove_link(&dev
->dev
.kobj
, "dep_link");
406 static int sriov_init(struct pci_dev
*dev
, int pos
)
412 u16 ctrl
, total
, offset
, stride
;
413 struct pci_sriov
*iov
;
414 struct resource
*res
;
415 struct pci_dev
*pdev
;
417 if (pci_pcie_type(dev
) != PCI_EXP_TYPE_RC_END
&&
418 pci_pcie_type(dev
) != PCI_EXP_TYPE_ENDPOINT
)
421 pci_read_config_word(dev
, pos
+ PCI_SRIOV_CTRL
, &ctrl
);
422 if (ctrl
& PCI_SRIOV_CTRL_VFE
) {
423 pci_write_config_word(dev
, pos
+ PCI_SRIOV_CTRL
, 0);
427 pci_read_config_word(dev
, pos
+ PCI_SRIOV_TOTAL_VF
, &total
);
432 list_for_each_entry(pdev
, &dev
->bus
->devices
, bus_list
)
437 if (pci_ari_enabled(dev
->bus
))
438 ctrl
|= PCI_SRIOV_CTRL_ARI
;
441 pci_write_config_word(dev
, pos
+ PCI_SRIOV_CTRL
, ctrl
);
442 pci_read_config_word(dev
, pos
+ PCI_SRIOV_VF_OFFSET
, &offset
);
443 pci_read_config_word(dev
, pos
+ PCI_SRIOV_VF_STRIDE
, &stride
);
444 if (!offset
|| (total
> 1 && !stride
))
447 pci_read_config_dword(dev
, pos
+ PCI_SRIOV_SUP_PGSIZE
, &pgsz
);
448 i
= PAGE_SHIFT
> 12 ? PAGE_SHIFT
- 12 : 0;
449 pgsz
&= ~((1 << i
) - 1);
454 pci_write_config_dword(dev
, pos
+ PCI_SRIOV_SYS_PGSIZE
, pgsz
);
457 for (i
= 0; i
< PCI_SRIOV_NUM_BARS
; i
++) {
458 res
= dev
->resource
+ PCI_IOV_RESOURCES
+ i
;
459 i
+= __pci_read_base(dev
, pci_bar_unknown
, res
,
460 pos
+ PCI_SRIOV_BAR
+ i
* 4);
463 if (resource_size(res
) & (PAGE_SIZE
- 1)) {
467 res
->end
= res
->start
+ resource_size(res
) * total
- 1;
471 iov
= kzalloc(sizeof(*iov
), GFP_KERNEL
);
480 iov
->total_VFs
= total
;
481 iov
->offset
= offset
;
482 iov
->stride
= stride
;
485 pci_read_config_dword(dev
, pos
+ PCI_SRIOV_CAP
, &iov
->cap
);
486 pci_read_config_byte(dev
, pos
+ PCI_SRIOV_FUNC_LINK
, &iov
->link
);
487 if (pci_pcie_type(dev
) == PCI_EXP_TYPE_RC_END
)
488 iov
->link
= PCI_DEVFN(PCI_SLOT(dev
->devfn
), iov
->link
);
491 iov
->dev
= pci_dev_get(pdev
);
495 mutex_init(&iov
->lock
);
503 for (i
= 0; i
< PCI_SRIOV_NUM_BARS
; i
++) {
504 res
= dev
->resource
+ PCI_IOV_RESOURCES
+ i
;
511 static void sriov_release(struct pci_dev
*dev
)
513 BUG_ON(dev
->sriov
->num_VFs
);
515 if (dev
!= dev
->sriov
->dev
)
516 pci_dev_put(dev
->sriov
->dev
);
518 mutex_destroy(&dev
->sriov
->lock
);
524 static void sriov_restore_state(struct pci_dev
*dev
)
528 struct pci_sriov
*iov
= dev
->sriov
;
530 pci_read_config_word(dev
, iov
->pos
+ PCI_SRIOV_CTRL
, &ctrl
);
531 if (ctrl
& PCI_SRIOV_CTRL_VFE
)
534 for (i
= PCI_IOV_RESOURCES
; i
<= PCI_IOV_RESOURCE_END
; i
++)
535 pci_update_resource(dev
, i
);
537 pci_write_config_dword(dev
, iov
->pos
+ PCI_SRIOV_SYS_PGSIZE
, iov
->pgsz
);
538 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_NUM_VF
, iov
->num_VFs
);
539 pci_write_config_word(dev
, iov
->pos
+ PCI_SRIOV_CTRL
, iov
->ctrl
);
540 if (iov
->ctrl
& PCI_SRIOV_CTRL_VFE
)
545 * pci_iov_init - initialize the IOV capability
546 * @dev: the PCI device
548 * Returns 0 on success, or negative on failure.
550 int pci_iov_init(struct pci_dev
*dev
)
554 if (!pci_is_pcie(dev
))
557 pos
= pci_find_ext_capability(dev
, PCI_EXT_CAP_ID_SRIOV
);
559 return sriov_init(dev
, pos
);
565 * pci_iov_release - release resources used by the IOV capability
566 * @dev: the PCI device
568 void pci_iov_release(struct pci_dev
*dev
)
575 * pci_iov_resource_bar - get position of the SR-IOV BAR
576 * @dev: the PCI device
577 * @resno: the resource number
578 * @type: the BAR type to be filled in
580 * Returns position of the BAR encapsulated in the SR-IOV capability.
582 int pci_iov_resource_bar(struct pci_dev
*dev
, int resno
,
583 enum pci_bar_type
*type
)
585 if (resno
< PCI_IOV_RESOURCES
|| resno
> PCI_IOV_RESOURCE_END
)
588 BUG_ON(!dev
->is_physfn
);
590 *type
= pci_bar_unknown
;
592 return dev
->sriov
->pos
+ PCI_SRIOV_BAR
+
593 4 * (resno
- PCI_IOV_RESOURCES
);
597 * pci_sriov_resource_alignment - get resource alignment for VF BAR
598 * @dev: the PCI device
599 * @resno: the resource number
601 * Returns the alignment of the VF BAR found in the SR-IOV capability.
602 * This is not the same as the resource size which is defined as
603 * the VF BAR size multiplied by the number of VFs. The alignment
604 * is just the VF BAR size.
606 resource_size_t
pci_sriov_resource_alignment(struct pci_dev
*dev
, int resno
)
609 enum pci_bar_type type
;
610 int reg
= pci_iov_resource_bar(dev
, resno
, &type
);
615 __pci_read_base(dev
, type
, &tmp
, reg
);
616 return resource_alignment(&tmp
);
620 * pci_restore_iov_state - restore the state of the IOV capability
621 * @dev: the PCI device
623 void pci_restore_iov_state(struct pci_dev
*dev
)
626 sriov_restore_state(dev
);
630 * pci_iov_bus_range - find bus range used by Virtual Function
633 * Returns max number of buses (exclude current one) used by Virtual
636 int pci_iov_bus_range(struct pci_bus
*bus
)
642 list_for_each_entry(dev
, &bus
->devices
, bus_list
) {
645 busnr
= virtfn_bus(dev
, dev
->sriov
->total_VFs
- 1);
650 return max
? max
- bus
->number
: 0;
654 * pci_enable_sriov - enable the SR-IOV capability
655 * @dev: the PCI device
656 * @nr_virtfn: number of virtual functions to enable
658 * Returns 0 on success, or negative on failure.
660 int pci_enable_sriov(struct pci_dev
*dev
, int nr_virtfn
)
667 return sriov_enable(dev
, nr_virtfn
);
669 EXPORT_SYMBOL_GPL(pci_enable_sriov
);
672 * pci_disable_sriov - disable the SR-IOV capability
673 * @dev: the PCI device
675 void pci_disable_sriov(struct pci_dev
*dev
)
684 EXPORT_SYMBOL_GPL(pci_disable_sriov
);
687 * pci_sriov_migration - notify SR-IOV core of Virtual Function Migration
688 * @dev: the PCI device
690 * Returns IRQ_HANDLED if the IRQ is handled, or IRQ_NONE if not.
692 * Physical Function driver is responsible to register IRQ handler using
693 * VF Migration Interrupt Message Number, and call this function when the
694 * interrupt is generated by the hardware.
696 irqreturn_t
pci_sriov_migration(struct pci_dev
*dev
)
701 return sriov_migration(dev
) ? IRQ_HANDLED
: IRQ_NONE
;
703 EXPORT_SYMBOL_GPL(pci_sriov_migration
);
706 * pci_num_vf - return number of VFs associated with a PF device_release_driver
707 * @dev: the PCI device
709 * Returns number of VFs, or 0 if SR-IOV is not enabled.
711 int pci_num_vf(struct pci_dev
*dev
)
716 return dev
->sriov
->num_VFs
;
718 EXPORT_SYMBOL_GPL(pci_num_vf
);
721 * pci_vfs_assigned - returns number of VFs are assigned to a guest
722 * @dev: the PCI device
724 * Returns number of VFs belonging to this device that are assigned to a guest.
725 * If device is not a physical function returns -ENODEV.
727 int pci_vfs_assigned(struct pci_dev
*dev
)
729 struct pci_dev
*vfdev
;
730 unsigned int vfs_assigned
= 0;
731 unsigned short dev_id
;
733 /* only search if we are a PF */
738 * determine the device ID for the VFs, the vendor ID will be the
739 * same as the PF so there is no need to check for that one
741 pci_read_config_word(dev
, dev
->sriov
->pos
+ PCI_SRIOV_VF_DID
, &dev_id
);
743 /* loop through all the VFs to see if we own any that are assigned */
744 vfdev
= pci_get_device(dev
->vendor
, dev_id
, NULL
);
747 * It is considered assigned if it is a virtual function with
748 * our dev as the physical function and the assigned bit is set
750 if (vfdev
->is_virtfn
&& (vfdev
->physfn
== dev
) &&
751 (vfdev
->dev_flags
& PCI_DEV_FLAGS_ASSIGNED
))
754 vfdev
= pci_get_device(dev
->vendor
, dev_id
, vfdev
);
759 EXPORT_SYMBOL_GPL(pci_vfs_assigned
);
762 * pci_sriov_set_totalvfs -- reduce the TotalVFs available
763 * @dev: the PCI PF device
764 * @numvfs: number that should be used for TotalVFs supported
766 * Should be called from PF driver's probe routine with
767 * device's mutex held.
769 * Returns 0 if PF is an SRIOV-capable device and
770 * value of numvfs valid. If not a PF with VFS, return -EINVAL;
771 * if VFs already enabled, return -EBUSY.
773 int pci_sriov_set_totalvfs(struct pci_dev
*dev
, u16 numvfs
)
775 if (!dev
->is_physfn
|| (numvfs
> dev
->sriov
->total_VFs
))
778 /* Shouldn't change if VFs already enabled */
779 if (dev
->sriov
->ctrl
& PCI_SRIOV_CTRL_VFE
)
782 dev
->sriov
->driver_max_VFs
= numvfs
;
786 EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs
);
789 * pci_sriov_get_totalvfs -- get total VFs supported on this devic3
790 * @dev: the PCI PF device
792 * For a PCIe device with SRIOV support, return the PCIe
793 * SRIOV capability value of TotalVFs or the value of driver_max_VFs
794 * if the driver reduced it. Otherwise, -EINVAL.
796 int pci_sriov_get_totalvfs(struct pci_dev
*dev
)
801 if (dev
->sriov
->driver_max_VFs
)
802 return dev
->sriov
->driver_max_VFs
;
804 return dev
->sriov
->total_VFs
;
806 EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs
);