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