Merge branch 'pci/host-layerscape' into next
[karo-tx-linux.git] / drivers / pci / iov.c
1 /*
2  * drivers/pci/iov.c
3  *
4  * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com>
5  *
6  * PCI Express I/O Virtualization (IOV) support.
7  *   Single Root IOV 1.0
8  *   Address Translation Service 1.0
9  */
10
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>
18 #include "pci.h"
19
20 #define VIRTFN_ID_LEN   16
21
22 int pci_iov_virtfn_bus(struct pci_dev *dev, int vf_id)
23 {
24         if (!dev->is_physfn)
25                 return -EINVAL;
26         return dev->bus->number + ((dev->devfn + dev->sriov->offset +
27                                     dev->sriov->stride * vf_id) >> 8);
28 }
29
30 int pci_iov_virtfn_devfn(struct pci_dev *dev, int vf_id)
31 {
32         if (!dev->is_physfn)
33                 return -EINVAL;
34         return (dev->devfn + dev->sriov->offset +
35                 dev->sriov->stride * vf_id) & 0xff;
36 }
37
38 /*
39  * Per SR-IOV spec sec 3.3.10 and 3.3.11, First VF Offset and VF Stride may
40  * change when NumVFs changes.
41  *
42  * Update iov->offset and iov->stride when NumVFs is written.
43  */
44 static inline void pci_iov_set_numvfs(struct pci_dev *dev, int nr_virtfn)
45 {
46         struct pci_sriov *iov = dev->sriov;
47
48         pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
49         pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &iov->offset);
50         pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &iov->stride);
51 }
52
53 /*
54  * The PF consumes one bus number.  NumVFs, First VF Offset, and VF Stride
55  * determine how many additional bus numbers will be consumed by VFs.
56  *
57  * Iterate over all valid NumVFs, validate offset and stride, and calculate
58  * the maximum number of bus numbers that could ever be required.
59  */
60 static int compute_max_vf_buses(struct pci_dev *dev)
61 {
62         struct pci_sriov *iov = dev->sriov;
63         int nr_virtfn, busnr, rc = 0;
64
65         for (nr_virtfn = iov->total_VFs; nr_virtfn; nr_virtfn--) {
66                 pci_iov_set_numvfs(dev, nr_virtfn);
67                 if (!iov->offset || (nr_virtfn > 1 && !iov->stride)) {
68                         rc = -EIO;
69                         goto out;
70                 }
71
72                 busnr = pci_iov_virtfn_bus(dev, nr_virtfn - 1);
73                 if (busnr > iov->max_VF_buses)
74                         iov->max_VF_buses = busnr;
75         }
76
77 out:
78         pci_iov_set_numvfs(dev, 0);
79         return rc;
80 }
81
82 static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr)
83 {
84         struct pci_bus *child;
85
86         if (bus->number == busnr)
87                 return bus;
88
89         child = pci_find_bus(pci_domain_nr(bus), busnr);
90         if (child)
91                 return child;
92
93         child = pci_add_new_bus(bus, NULL, busnr);
94         if (!child)
95                 return NULL;
96
97         pci_bus_insert_busn_res(child, busnr, busnr);
98
99         return child;
100 }
101
102 static void virtfn_remove_bus(struct pci_bus *physbus, struct pci_bus *virtbus)
103 {
104         if (physbus != virtbus && list_empty(&virtbus->devices))
105                 pci_remove_bus(virtbus);
106 }
107
108 resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno)
109 {
110         if (!dev->is_physfn)
111                 return 0;
112
113         return dev->sriov->barsz[resno - PCI_IOV_RESOURCES];
114 }
115
116 static int virtfn_add(struct pci_dev *dev, int id, int reset)
117 {
118         int i;
119         int rc = -ENOMEM;
120         u64 size;
121         char buf[VIRTFN_ID_LEN];
122         struct pci_dev *virtfn;
123         struct resource *res;
124         struct pci_sriov *iov = dev->sriov;
125         struct pci_bus *bus;
126
127         mutex_lock(&iov->dev->sriov->lock);
128         bus = virtfn_add_bus(dev->bus, pci_iov_virtfn_bus(dev, id));
129         if (!bus)
130                 goto failed;
131
132         virtfn = pci_alloc_dev(bus);
133         if (!virtfn)
134                 goto failed0;
135
136         virtfn->devfn = pci_iov_virtfn_devfn(dev, id);
137         virtfn->vendor = dev->vendor;
138         pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device);
139         pci_setup_device(virtfn);
140         virtfn->dev.parent = dev->dev.parent;
141         virtfn->physfn = pci_dev_get(dev);
142         virtfn->is_virtfn = 1;
143         virtfn->multifunction = 0;
144
145         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
146                 res = &dev->resource[i + PCI_IOV_RESOURCES];
147                 if (!res->parent)
148                         continue;
149                 virtfn->resource[i].name = pci_name(virtfn);
150                 virtfn->resource[i].flags = res->flags;
151                 size = pci_iov_resource_size(dev, i + PCI_IOV_RESOURCES);
152                 virtfn->resource[i].start = res->start + size * id;
153                 virtfn->resource[i].end = virtfn->resource[i].start + size - 1;
154                 rc = request_resource(res, &virtfn->resource[i]);
155                 BUG_ON(rc);
156         }
157
158         if (reset)
159                 __pci_reset_function(virtfn);
160
161         pci_device_add(virtfn, virtfn->bus);
162         mutex_unlock(&iov->dev->sriov->lock);
163
164         pci_bus_add_device(virtfn);
165         sprintf(buf, "virtfn%u", id);
166         rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf);
167         if (rc)
168                 goto failed1;
169         rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn");
170         if (rc)
171                 goto failed2;
172
173         kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE);
174
175         return 0;
176
177 failed2:
178         sysfs_remove_link(&dev->dev.kobj, buf);
179 failed1:
180         pci_dev_put(dev);
181         mutex_lock(&iov->dev->sriov->lock);
182         pci_stop_and_remove_bus_device(virtfn);
183 failed0:
184         virtfn_remove_bus(dev->bus, bus);
185 failed:
186         mutex_unlock(&iov->dev->sriov->lock);
187
188         return rc;
189 }
190
191 static void virtfn_remove(struct pci_dev *dev, int id, int reset)
192 {
193         char buf[VIRTFN_ID_LEN];
194         struct pci_dev *virtfn;
195         struct pci_sriov *iov = dev->sriov;
196
197         virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus),
198                                              pci_iov_virtfn_bus(dev, id),
199                                              pci_iov_virtfn_devfn(dev, id));
200         if (!virtfn)
201                 return;
202
203         if (reset) {
204                 device_release_driver(&virtfn->dev);
205                 __pci_reset_function(virtfn);
206         }
207
208         sprintf(buf, "virtfn%u", id);
209         sysfs_remove_link(&dev->dev.kobj, buf);
210         /*
211          * pci_stop_dev() could have been called for this virtfn already,
212          * so the directory for the virtfn may have been removed before.
213          * Double check to avoid spurious sysfs warnings.
214          */
215         if (virtfn->dev.kobj.sd)
216                 sysfs_remove_link(&virtfn->dev.kobj, "physfn");
217
218         mutex_lock(&iov->dev->sriov->lock);
219         pci_stop_and_remove_bus_device(virtfn);
220         virtfn_remove_bus(dev->bus, virtfn->bus);
221         mutex_unlock(&iov->dev->sriov->lock);
222
223         /* balance pci_get_domain_bus_and_slot() */
224         pci_dev_put(virtfn);
225         pci_dev_put(dev);
226 }
227
228 int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs)
229 {
230         return 0;
231 }
232
233 int __weak pcibios_sriov_disable(struct pci_dev *pdev)
234 {
235         return 0;
236 }
237
238 static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
239 {
240         int rc;
241         int i;
242         int nres;
243         u16 initial;
244         struct resource *res;
245         struct pci_dev *pdev;
246         struct pci_sriov *iov = dev->sriov;
247         int bars = 0;
248         int bus;
249
250         if (!nr_virtfn)
251                 return 0;
252
253         if (iov->num_VFs)
254                 return -EINVAL;
255
256         pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial);
257         if (initial > iov->total_VFs ||
258             (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total_VFs)))
259                 return -EIO;
260
261         if (nr_virtfn < 0 || nr_virtfn > iov->total_VFs ||
262             (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial)))
263                 return -EINVAL;
264
265         nres = 0;
266         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
267                 bars |= (1 << (i + PCI_IOV_RESOURCES));
268                 res = &dev->resource[i + PCI_IOV_RESOURCES];
269                 if (res->parent)
270                         nres++;
271         }
272         if (nres != iov->nres) {
273                 dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n");
274                 return -ENOMEM;
275         }
276
277         bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1);
278         if (bus > dev->bus->busn_res.end) {
279                 dev_err(&dev->dev, "can't enable %d VFs (bus %02x out of range of %pR)\n",
280                         nr_virtfn, bus, &dev->bus->busn_res);
281                 return -ENOMEM;
282         }
283
284         if (pci_enable_resources(dev, bars)) {
285                 dev_err(&dev->dev, "SR-IOV: IOV BARS not allocated\n");
286                 return -ENOMEM;
287         }
288
289         if (iov->link != dev->devfn) {
290                 pdev = pci_get_slot(dev->bus, iov->link);
291                 if (!pdev)
292                         return -ENODEV;
293
294                 if (!pdev->is_physfn) {
295                         pci_dev_put(pdev);
296                         return -ENOSYS;
297                 }
298
299                 rc = sysfs_create_link(&dev->dev.kobj,
300                                         &pdev->dev.kobj, "dep_link");
301                 pci_dev_put(pdev);
302                 if (rc)
303                         return rc;
304         }
305
306         pci_iov_set_numvfs(dev, nr_virtfn);
307         iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE;
308         pci_cfg_access_lock(dev);
309         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
310         msleep(100);
311         pci_cfg_access_unlock(dev);
312
313         iov->initial_VFs = initial;
314         if (nr_virtfn < initial)
315                 initial = nr_virtfn;
316
317         rc = pcibios_sriov_enable(dev, initial);
318         if (rc) {
319                 dev_err(&dev->dev, "failure %d from pcibios_sriov_enable()\n", rc);
320                 goto err_pcibios;
321         }
322
323         for (i = 0; i < initial; i++) {
324                 rc = virtfn_add(dev, i, 0);
325                 if (rc)
326                         goto failed;
327         }
328
329         kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE);
330         iov->num_VFs = nr_virtfn;
331
332         return 0;
333
334 failed:
335         while (i--)
336                 virtfn_remove(dev, i, 0);
337
338         pcibios_sriov_disable(dev);
339 err_pcibios:
340         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
341         pci_cfg_access_lock(dev);
342         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
343         ssleep(1);
344         pci_cfg_access_unlock(dev);
345
346         if (iov->link != dev->devfn)
347                 sysfs_remove_link(&dev->dev.kobj, "dep_link");
348
349         pci_iov_set_numvfs(dev, 0);
350         return rc;
351 }
352
353 static void sriov_disable(struct pci_dev *dev)
354 {
355         int i;
356         struct pci_sriov *iov = dev->sriov;
357
358         if (!iov->num_VFs)
359                 return;
360
361         for (i = 0; i < iov->num_VFs; i++)
362                 virtfn_remove(dev, i, 0);
363
364         pcibios_sriov_disable(dev);
365
366         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
367         pci_cfg_access_lock(dev);
368         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
369         ssleep(1);
370         pci_cfg_access_unlock(dev);
371
372         if (iov->link != dev->devfn)
373                 sysfs_remove_link(&dev->dev.kobj, "dep_link");
374
375         iov->num_VFs = 0;
376         pci_iov_set_numvfs(dev, 0);
377 }
378
379 static int sriov_init(struct pci_dev *dev, int pos)
380 {
381         int i, bar64;
382         int rc;
383         int nres;
384         u32 pgsz;
385         u16 ctrl, total;
386         struct pci_sriov *iov;
387         struct resource *res;
388         struct pci_dev *pdev;
389
390         if (pci_pcie_type(dev) != PCI_EXP_TYPE_RC_END &&
391             pci_pcie_type(dev) != PCI_EXP_TYPE_ENDPOINT)
392                 return -ENODEV;
393
394         pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl);
395         if (ctrl & PCI_SRIOV_CTRL_VFE) {
396                 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0);
397                 ssleep(1);
398         }
399
400         ctrl = 0;
401         list_for_each_entry(pdev, &dev->bus->devices, bus_list)
402                 if (pdev->is_physfn)
403                         goto found;
404
405         pdev = NULL;
406         if (pci_ari_enabled(dev->bus))
407                 ctrl |= PCI_SRIOV_CTRL_ARI;
408
409 found:
410         pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl);
411
412         pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total);
413         if (!total)
414                 return 0;
415
416         pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz);
417         i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0;
418         pgsz &= ~((1 << i) - 1);
419         if (!pgsz)
420                 return -EIO;
421
422         pgsz &= ~(pgsz - 1);
423         pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz);
424
425         iov = kzalloc(sizeof(*iov), GFP_KERNEL);
426         if (!iov)
427                 return -ENOMEM;
428
429         nres = 0;
430         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
431                 res = &dev->resource[i + PCI_IOV_RESOURCES];
432                 /*
433                  * If it is already FIXED, don't change it, something
434                  * (perhaps EA or header fixups) wants it this way.
435                  */
436                 if (res->flags & IORESOURCE_PCI_FIXED)
437                         bar64 = (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
438                 else
439                         bar64 = __pci_read_base(dev, pci_bar_unknown, res,
440                                                 pos + PCI_SRIOV_BAR + i * 4);
441                 if (!res->flags)
442                         continue;
443                 if (resource_size(res) & (PAGE_SIZE - 1)) {
444                         rc = -EIO;
445                         goto failed;
446                 }
447                 iov->barsz[i] = resource_size(res);
448                 res->end = res->start + resource_size(res) * total - 1;
449                 dev_info(&dev->dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n",
450                          i, res, i, total);
451                 i += bar64;
452                 nres++;
453         }
454
455         iov->pos = pos;
456         iov->nres = nres;
457         iov->ctrl = ctrl;
458         iov->total_VFs = total;
459         iov->pgsz = pgsz;
460         iov->self = dev;
461         pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap);
462         pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link);
463         if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END)
464                 iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link);
465
466         if (pdev)
467                 iov->dev = pci_dev_get(pdev);
468         else
469                 iov->dev = dev;
470
471         mutex_init(&iov->lock);
472
473         dev->sriov = iov;
474         dev->is_physfn = 1;
475         rc = compute_max_vf_buses(dev);
476         if (rc)
477                 goto fail_max_buses;
478
479         return 0;
480
481 fail_max_buses:
482         dev->sriov = NULL;
483         dev->is_physfn = 0;
484 failed:
485         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
486                 res = &dev->resource[i + PCI_IOV_RESOURCES];
487                 res->flags = 0;
488         }
489
490         kfree(iov);
491         return rc;
492 }
493
494 static void sriov_release(struct pci_dev *dev)
495 {
496         BUG_ON(dev->sriov->num_VFs);
497
498         if (dev != dev->sriov->dev)
499                 pci_dev_put(dev->sriov->dev);
500
501         mutex_destroy(&dev->sriov->lock);
502
503         kfree(dev->sriov);
504         dev->sriov = NULL;
505 }
506
507 static void sriov_restore_state(struct pci_dev *dev)
508 {
509         int i;
510         u16 ctrl;
511         struct pci_sriov *iov = dev->sriov;
512
513         pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl);
514         if (ctrl & PCI_SRIOV_CTRL_VFE)
515                 return;
516
517         for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++)
518                 pci_update_resource(dev, i);
519
520         pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz);
521         pci_iov_set_numvfs(dev, iov->num_VFs);
522         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
523         if (iov->ctrl & PCI_SRIOV_CTRL_VFE)
524                 msleep(100);
525 }
526
527 /**
528  * pci_iov_init - initialize the IOV capability
529  * @dev: the PCI device
530  *
531  * Returns 0 on success, or negative on failure.
532  */
533 int pci_iov_init(struct pci_dev *dev)
534 {
535         int pos;
536
537         if (!pci_is_pcie(dev))
538                 return -ENODEV;
539
540         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV);
541         if (pos)
542                 return sriov_init(dev, pos);
543
544         return -ENODEV;
545 }
546
547 /**
548  * pci_iov_release - release resources used by the IOV capability
549  * @dev: the PCI device
550  */
551 void pci_iov_release(struct pci_dev *dev)
552 {
553         if (dev->is_physfn)
554                 sriov_release(dev);
555 }
556
557 /**
558  * pci_iov_resource_bar - get position of the SR-IOV BAR
559  * @dev: the PCI device
560  * @resno: the resource number
561  *
562  * Returns position of the BAR encapsulated in the SR-IOV capability.
563  */
564 int pci_iov_resource_bar(struct pci_dev *dev, int resno)
565 {
566         if (resno < PCI_IOV_RESOURCES || resno > PCI_IOV_RESOURCE_END)
567                 return 0;
568
569         BUG_ON(!dev->is_physfn);
570
571         return dev->sriov->pos + PCI_SRIOV_BAR +
572                 4 * (resno - PCI_IOV_RESOURCES);
573 }
574
575 resource_size_t __weak pcibios_iov_resource_alignment(struct pci_dev *dev,
576                                                       int resno)
577 {
578         return pci_iov_resource_size(dev, resno);
579 }
580
581 /**
582  * pci_sriov_resource_alignment - get resource alignment for VF BAR
583  * @dev: the PCI device
584  * @resno: the resource number
585  *
586  * Returns the alignment of the VF BAR found in the SR-IOV capability.
587  * This is not the same as the resource size which is defined as
588  * the VF BAR size multiplied by the number of VFs.  The alignment
589  * is just the VF BAR size.
590  */
591 resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno)
592 {
593         return pcibios_iov_resource_alignment(dev, resno);
594 }
595
596 /**
597  * pci_restore_iov_state - restore the state of the IOV capability
598  * @dev: the PCI device
599  */
600 void pci_restore_iov_state(struct pci_dev *dev)
601 {
602         if (dev->is_physfn)
603                 sriov_restore_state(dev);
604 }
605
606 /**
607  * pci_iov_bus_range - find bus range used by Virtual Function
608  * @bus: the PCI bus
609  *
610  * Returns max number of buses (exclude current one) used by Virtual
611  * Functions.
612  */
613 int pci_iov_bus_range(struct pci_bus *bus)
614 {
615         int max = 0;
616         struct pci_dev *dev;
617
618         list_for_each_entry(dev, &bus->devices, bus_list) {
619                 if (!dev->is_physfn)
620                         continue;
621                 if (dev->sriov->max_VF_buses > max)
622                         max = dev->sriov->max_VF_buses;
623         }
624
625         return max ? max - bus->number : 0;
626 }
627
628 /**
629  * pci_enable_sriov - enable the SR-IOV capability
630  * @dev: the PCI device
631  * @nr_virtfn: number of virtual functions to enable
632  *
633  * Returns 0 on success, or negative on failure.
634  */
635 int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
636 {
637         might_sleep();
638
639         if (!dev->is_physfn)
640                 return -ENOSYS;
641
642         return sriov_enable(dev, nr_virtfn);
643 }
644 EXPORT_SYMBOL_GPL(pci_enable_sriov);
645
646 /**
647  * pci_disable_sriov - disable the SR-IOV capability
648  * @dev: the PCI device
649  */
650 void pci_disable_sriov(struct pci_dev *dev)
651 {
652         might_sleep();
653
654         if (!dev->is_physfn)
655                 return;
656
657         sriov_disable(dev);
658 }
659 EXPORT_SYMBOL_GPL(pci_disable_sriov);
660
661 /**
662  * pci_num_vf - return number of VFs associated with a PF device_release_driver
663  * @dev: the PCI device
664  *
665  * Returns number of VFs, or 0 if SR-IOV is not enabled.
666  */
667 int pci_num_vf(struct pci_dev *dev)
668 {
669         if (!dev->is_physfn)
670                 return 0;
671
672         return dev->sriov->num_VFs;
673 }
674 EXPORT_SYMBOL_GPL(pci_num_vf);
675
676 /**
677  * pci_vfs_assigned - returns number of VFs are assigned to a guest
678  * @dev: the PCI device
679  *
680  * Returns number of VFs belonging to this device that are assigned to a guest.
681  * If device is not a physical function returns 0.
682  */
683 int pci_vfs_assigned(struct pci_dev *dev)
684 {
685         struct pci_dev *vfdev;
686         unsigned int vfs_assigned = 0;
687         unsigned short dev_id;
688
689         /* only search if we are a PF */
690         if (!dev->is_physfn)
691                 return 0;
692
693         /*
694          * determine the device ID for the VFs, the vendor ID will be the
695          * same as the PF so there is no need to check for that one
696          */
697         pci_read_config_word(dev, dev->sriov->pos + PCI_SRIOV_VF_DID, &dev_id);
698
699         /* loop through all the VFs to see if we own any that are assigned */
700         vfdev = pci_get_device(dev->vendor, dev_id, NULL);
701         while (vfdev) {
702                 /*
703                  * It is considered assigned if it is a virtual function with
704                  * our dev as the physical function and the assigned bit is set
705                  */
706                 if (vfdev->is_virtfn && (vfdev->physfn == dev) &&
707                         pci_is_dev_assigned(vfdev))
708                         vfs_assigned++;
709
710                 vfdev = pci_get_device(dev->vendor, dev_id, vfdev);
711         }
712
713         return vfs_assigned;
714 }
715 EXPORT_SYMBOL_GPL(pci_vfs_assigned);
716
717 /**
718  * pci_sriov_set_totalvfs -- reduce the TotalVFs available
719  * @dev: the PCI PF device
720  * @numvfs: number that should be used for TotalVFs supported
721  *
722  * Should be called from PF driver's probe routine with
723  * device's mutex held.
724  *
725  * Returns 0 if PF is an SRIOV-capable device and
726  * value of numvfs valid. If not a PF return -ENOSYS;
727  * if numvfs is invalid return -EINVAL;
728  * if VFs already enabled, return -EBUSY.
729  */
730 int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs)
731 {
732         if (!dev->is_physfn)
733                 return -ENOSYS;
734         if (numvfs > dev->sriov->total_VFs)
735                 return -EINVAL;
736
737         /* Shouldn't change if VFs already enabled */
738         if (dev->sriov->ctrl & PCI_SRIOV_CTRL_VFE)
739                 return -EBUSY;
740         else
741                 dev->sriov->driver_max_VFs = numvfs;
742
743         return 0;
744 }
745 EXPORT_SYMBOL_GPL(pci_sriov_set_totalvfs);
746
747 /**
748  * pci_sriov_get_totalvfs -- get total VFs supported on this device
749  * @dev: the PCI PF device
750  *
751  * For a PCIe device with SRIOV support, return the PCIe
752  * SRIOV capability value of TotalVFs or the value of driver_max_VFs
753  * if the driver reduced it.  Otherwise 0.
754  */
755 int pci_sriov_get_totalvfs(struct pci_dev *dev)
756 {
757         if (!dev->is_physfn)
758                 return 0;
759
760         if (dev->sriov->driver_max_VFs)
761                 return dev->sriov->driver_max_VFs;
762
763         return dev->sriov->total_VFs;
764 }
765 EXPORT_SYMBOL_GPL(pci_sriov_get_totalvfs);