PCI/AER: Move pci_uevent_ers() out of pci.h
[muen/linux.git] / drivers / pci / pci-driver.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * drivers/pci/pci-driver.c
4  *
5  * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com>
6  * (C) Copyright 2007 Novell Inc.
7  */
8
9 #include <linux/pci.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/device.h>
13 #include <linux/mempolicy.h>
14 #include <linux/string.h>
15 #include <linux/slab.h>
16 #include <linux/sched.h>
17 #include <linux/cpu.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/suspend.h>
20 #include <linux/kexec.h>
21 #include "pci.h"
22
23 struct pci_dynid {
24         struct list_head node;
25         struct pci_device_id id;
26 };
27
28 /**
29  * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
30  * @drv: target pci driver
31  * @vendor: PCI vendor ID
32  * @device: PCI device ID
33  * @subvendor: PCI subvendor ID
34  * @subdevice: PCI subdevice ID
35  * @class: PCI class
36  * @class_mask: PCI class mask
37  * @driver_data: private driver data
38  *
39  * Adds a new dynamic pci device ID to this driver and causes the
40  * driver to probe for all devices again.  @drv must have been
41  * registered prior to calling this function.
42  *
43  * CONTEXT:
44  * Does GFP_KERNEL allocation.
45  *
46  * RETURNS:
47  * 0 on success, -errno on failure.
48  */
49 int pci_add_dynid(struct pci_driver *drv,
50                   unsigned int vendor, unsigned int device,
51                   unsigned int subvendor, unsigned int subdevice,
52                   unsigned int class, unsigned int class_mask,
53                   unsigned long driver_data)
54 {
55         struct pci_dynid *dynid;
56
57         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
58         if (!dynid)
59                 return -ENOMEM;
60
61         dynid->id.vendor = vendor;
62         dynid->id.device = device;
63         dynid->id.subvendor = subvendor;
64         dynid->id.subdevice = subdevice;
65         dynid->id.class = class;
66         dynid->id.class_mask = class_mask;
67         dynid->id.driver_data = driver_data;
68
69         spin_lock(&drv->dynids.lock);
70         list_add_tail(&dynid->node, &drv->dynids.list);
71         spin_unlock(&drv->dynids.lock);
72
73         return driver_attach(&drv->driver);
74 }
75 EXPORT_SYMBOL_GPL(pci_add_dynid);
76
77 static void pci_free_dynids(struct pci_driver *drv)
78 {
79         struct pci_dynid *dynid, *n;
80
81         spin_lock(&drv->dynids.lock);
82         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
83                 list_del(&dynid->node);
84                 kfree(dynid);
85         }
86         spin_unlock(&drv->dynids.lock);
87 }
88
89 /**
90  * store_new_id - sysfs frontend to pci_add_dynid()
91  * @driver: target device driver
92  * @buf: buffer for scanning device ID data
93  * @count: input size
94  *
95  * Allow PCI IDs to be added to an existing driver via sysfs.
96  */
97 static ssize_t new_id_store(struct device_driver *driver, const char *buf,
98                             size_t count)
99 {
100         struct pci_driver *pdrv = to_pci_driver(driver);
101         const struct pci_device_id *ids = pdrv->id_table;
102         __u32 vendor, device, subvendor = PCI_ANY_ID,
103                 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
104         unsigned long driver_data = 0;
105         int fields = 0;
106         int retval = 0;
107
108         fields = sscanf(buf, "%x %x %x %x %x %x %lx",
109                         &vendor, &device, &subvendor, &subdevice,
110                         &class, &class_mask, &driver_data);
111         if (fields < 2)
112                 return -EINVAL;
113
114         if (fields != 7) {
115                 struct pci_dev *pdev = kzalloc(sizeof(*pdev), GFP_KERNEL);
116                 if (!pdev)
117                         return -ENOMEM;
118
119                 pdev->vendor = vendor;
120                 pdev->device = device;
121                 pdev->subsystem_vendor = subvendor;
122                 pdev->subsystem_device = subdevice;
123                 pdev->class = class;
124
125                 if (pci_match_id(pdrv->id_table, pdev))
126                         retval = -EEXIST;
127
128                 kfree(pdev);
129
130                 if (retval)
131                         return retval;
132         }
133
134         /* Only accept driver_data values that match an existing id_table
135            entry */
136         if (ids) {
137                 retval = -EINVAL;
138                 while (ids->vendor || ids->subvendor || ids->class_mask) {
139                         if (driver_data == ids->driver_data) {
140                                 retval = 0;
141                                 break;
142                         }
143                         ids++;
144                 }
145                 if (retval)     /* No match */
146                         return retval;
147         }
148
149         retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
150                                class, class_mask, driver_data);
151         if (retval)
152                 return retval;
153         return count;
154 }
155 static DRIVER_ATTR_WO(new_id);
156
157 /**
158  * store_remove_id - remove a PCI device ID from this driver
159  * @driver: target device driver
160  * @buf: buffer for scanning device ID data
161  * @count: input size
162  *
163  * Removes a dynamic pci device ID to this driver.
164  */
165 static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
166                                size_t count)
167 {
168         struct pci_dynid *dynid, *n;
169         struct pci_driver *pdrv = to_pci_driver(driver);
170         __u32 vendor, device, subvendor = PCI_ANY_ID,
171                 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
172         int fields = 0;
173         size_t retval = -ENODEV;
174
175         fields = sscanf(buf, "%x %x %x %x %x %x",
176                         &vendor, &device, &subvendor, &subdevice,
177                         &class, &class_mask);
178         if (fields < 2)
179                 return -EINVAL;
180
181         spin_lock(&pdrv->dynids.lock);
182         list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
183                 struct pci_device_id *id = &dynid->id;
184                 if ((id->vendor == vendor) &&
185                     (id->device == device) &&
186                     (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
187                     (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
188                     !((id->class ^ class) & class_mask)) {
189                         list_del(&dynid->node);
190                         kfree(dynid);
191                         retval = count;
192                         break;
193                 }
194         }
195         spin_unlock(&pdrv->dynids.lock);
196
197         return retval;
198 }
199 static DRIVER_ATTR_WO(remove_id);
200
201 static struct attribute *pci_drv_attrs[] = {
202         &driver_attr_new_id.attr,
203         &driver_attr_remove_id.attr,
204         NULL,
205 };
206 ATTRIBUTE_GROUPS(pci_drv);
207
208 /**
209  * pci_match_id - See if a pci device matches a given pci_id table
210  * @ids: array of PCI device id structures to search in
211  * @dev: the PCI device structure to match against.
212  *
213  * Used by a driver to check whether a PCI device present in the
214  * system is in its list of supported devices.  Returns the matching
215  * pci_device_id structure or %NULL if there is no match.
216  *
217  * Deprecated, don't use this as it will not catch any dynamic ids
218  * that a driver might want to check for.
219  */
220 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
221                                          struct pci_dev *dev)
222 {
223         if (ids) {
224                 while (ids->vendor || ids->subvendor || ids->class_mask) {
225                         if (pci_match_one_device(ids, dev))
226                                 return ids;
227                         ids++;
228                 }
229         }
230         return NULL;
231 }
232 EXPORT_SYMBOL(pci_match_id);
233
234 static const struct pci_device_id pci_device_id_any = {
235         .vendor = PCI_ANY_ID,
236         .device = PCI_ANY_ID,
237         .subvendor = PCI_ANY_ID,
238         .subdevice = PCI_ANY_ID,
239 };
240
241 /**
242  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
243  * @drv: the PCI driver to match against
244  * @dev: the PCI device structure to match against
245  *
246  * Used by a driver to check whether a PCI device present in the
247  * system is in its list of supported devices.  Returns the matching
248  * pci_device_id structure or %NULL if there is no match.
249  */
250 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
251                                                     struct pci_dev *dev)
252 {
253         struct pci_dynid *dynid;
254         const struct pci_device_id *found_id = NULL;
255
256         /* When driver_override is set, only bind to the matching driver */
257         if (dev->driver_override && strcmp(dev->driver_override, drv->name))
258                 return NULL;
259
260         /* Look at the dynamic ids first, before the static ones */
261         spin_lock(&drv->dynids.lock);
262         list_for_each_entry(dynid, &drv->dynids.list, node) {
263                 if (pci_match_one_device(&dynid->id, dev)) {
264                         found_id = &dynid->id;
265                         break;
266                 }
267         }
268         spin_unlock(&drv->dynids.lock);
269
270         if (!found_id)
271                 found_id = pci_match_id(drv->id_table, dev);
272
273         /* driver_override will always match, send a dummy id */
274         if (!found_id && dev->driver_override)
275                 found_id = &pci_device_id_any;
276
277         return found_id;
278 }
279
280 struct drv_dev_and_id {
281         struct pci_driver *drv;
282         struct pci_dev *dev;
283         const struct pci_device_id *id;
284 };
285
286 static long local_pci_probe(void *_ddi)
287 {
288         struct drv_dev_and_id *ddi = _ddi;
289         struct pci_dev *pci_dev = ddi->dev;
290         struct pci_driver *pci_drv = ddi->drv;
291         struct device *dev = &pci_dev->dev;
292         int rc;
293
294         /*
295          * Unbound PCI devices are always put in D0, regardless of
296          * runtime PM status.  During probe, the device is set to
297          * active and the usage count is incremented.  If the driver
298          * supports runtime PM, it should call pm_runtime_put_noidle(),
299          * or any other runtime PM helper function decrementing the usage
300          * count, in its probe routine and pm_runtime_get_noresume() in
301          * its remove routine.
302          */
303         pm_runtime_get_sync(dev);
304         pci_dev->driver = pci_drv;
305         rc = pci_drv->probe(pci_dev, ddi->id);
306         if (!rc)
307                 return rc;
308         if (rc < 0) {
309                 pci_dev->driver = NULL;
310                 pm_runtime_put_sync(dev);
311                 return rc;
312         }
313         /*
314          * Probe function should return < 0 for failure, 0 for success
315          * Treat values > 0 as success, but warn.
316          */
317         dev_warn(dev, "Driver probe function unexpectedly returned %d\n", rc);
318         return 0;
319 }
320
321 static bool pci_physfn_is_probed(struct pci_dev *dev)
322 {
323 #ifdef CONFIG_PCI_IOV
324         return dev->is_virtfn && dev->physfn->is_probed;
325 #else
326         return false;
327 #endif
328 }
329
330 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
331                           const struct pci_device_id *id)
332 {
333         int error, node, cpu;
334         struct drv_dev_and_id ddi = { drv, dev, id };
335
336         /*
337          * Execute driver initialization on node where the device is
338          * attached.  This way the driver likely allocates its local memory
339          * on the right node.
340          */
341         node = dev_to_node(&dev->dev);
342         dev->is_probed = 1;
343
344         cpu_hotplug_disable();
345
346         /*
347          * Prevent nesting work_on_cpu() for the case where a Virtual Function
348          * device is probed from work_on_cpu() of the Physical device.
349          */
350         if (node < 0 || node >= MAX_NUMNODES || !node_online(node) ||
351             pci_physfn_is_probed(dev))
352                 cpu = nr_cpu_ids;
353         else
354                 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
355
356         if (cpu < nr_cpu_ids)
357                 error = work_on_cpu(cpu, local_pci_probe, &ddi);
358         else
359                 error = local_pci_probe(&ddi);
360
361         dev->is_probed = 0;
362         cpu_hotplug_enable();
363         return error;
364 }
365
366 /**
367  * __pci_device_probe - check if a driver wants to claim a specific PCI device
368  * @drv: driver to call to check if it wants the PCI device
369  * @pci_dev: PCI device being probed
370  *
371  * returns 0 on success, else error.
372  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
373  */
374 static int __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
375 {
376         const struct pci_device_id *id;
377         int error = 0;
378
379         if (!pci_dev->driver && drv->probe) {
380                 error = -ENODEV;
381
382                 id = pci_match_device(drv, pci_dev);
383                 if (id)
384                         error = pci_call_probe(drv, pci_dev, id);
385         }
386         return error;
387 }
388
389 int __weak pcibios_alloc_irq(struct pci_dev *dev)
390 {
391         return 0;
392 }
393
394 void __weak pcibios_free_irq(struct pci_dev *dev)
395 {
396 }
397
398 #ifdef CONFIG_PCI_IOV
399 static inline bool pci_device_can_probe(struct pci_dev *pdev)
400 {
401         return (!pdev->is_virtfn || pdev->physfn->sriov->drivers_autoprobe);
402 }
403 #else
404 static inline bool pci_device_can_probe(struct pci_dev *pdev)
405 {
406         return true;
407 }
408 #endif
409
410 static int pci_device_probe(struct device *dev)
411 {
412         int error;
413         struct pci_dev *pci_dev = to_pci_dev(dev);
414         struct pci_driver *drv = to_pci_driver(dev->driver);
415
416         pci_assign_irq(pci_dev);
417
418         error = pcibios_alloc_irq(pci_dev);
419         if (error < 0)
420                 return error;
421
422         pci_dev_get(pci_dev);
423         if (pci_device_can_probe(pci_dev)) {
424                 error = __pci_device_probe(drv, pci_dev);
425                 if (error) {
426                         pcibios_free_irq(pci_dev);
427                         pci_dev_put(pci_dev);
428                 }
429         }
430
431         return error;
432 }
433
434 static int pci_device_remove(struct device *dev)
435 {
436         struct pci_dev *pci_dev = to_pci_dev(dev);
437         struct pci_driver *drv = pci_dev->driver;
438
439         if (drv) {
440                 if (drv->remove) {
441                         pm_runtime_get_sync(dev);
442                         drv->remove(pci_dev);
443                         pm_runtime_put_noidle(dev);
444                 }
445                 pcibios_free_irq(pci_dev);
446                 pci_dev->driver = NULL;
447         }
448
449         /* Undo the runtime PM settings in local_pci_probe() */
450         pm_runtime_put_sync(dev);
451
452         /*
453          * If the device is still on, set the power state as "unknown",
454          * since it might change by the next time we load the driver.
455          */
456         if (pci_dev->current_state == PCI_D0)
457                 pci_dev->current_state = PCI_UNKNOWN;
458
459         /*
460          * We would love to complain here if pci_dev->is_enabled is set, that
461          * the driver should have called pci_disable_device(), but the
462          * unfortunate fact is there are too many odd BIOS and bridge setups
463          * that don't like drivers doing that all of the time.
464          * Oh well, we can dream of sane hardware when we sleep, no matter how
465          * horrible the crap we have to deal with is when we are awake...
466          */
467
468         pci_dev_put(pci_dev);
469         return 0;
470 }
471
472 static void pci_device_shutdown(struct device *dev)
473 {
474         struct pci_dev *pci_dev = to_pci_dev(dev);
475         struct pci_driver *drv = pci_dev->driver;
476
477         pm_runtime_resume(dev);
478
479         if (drv && drv->shutdown)
480                 drv->shutdown(pci_dev);
481
482         /*
483          * If this is a kexec reboot, turn off Bus Master bit on the
484          * device to tell it to not continue to do DMA. Don't touch
485          * devices in D3cold or unknown states.
486          * If it is not a kexec reboot, firmware will hit the PCI
487          * devices with big hammer and stop their DMA any way.
488          */
489         if (kexec_in_progress && (pci_dev->current_state <= PCI_D3hot))
490                 pci_clear_master(pci_dev);
491 }
492
493 #ifdef CONFIG_PM
494
495 /* Auxiliary functions used for system resume and run-time resume. */
496
497 /**
498  * pci_restore_standard_config - restore standard config registers of PCI device
499  * @pci_dev: PCI device to handle
500  */
501 static int pci_restore_standard_config(struct pci_dev *pci_dev)
502 {
503         pci_update_current_state(pci_dev, PCI_UNKNOWN);
504
505         if (pci_dev->current_state != PCI_D0) {
506                 int error = pci_set_power_state(pci_dev, PCI_D0);
507                 if (error)
508                         return error;
509         }
510
511         pci_restore_state(pci_dev);
512         pci_pme_restore(pci_dev);
513         return 0;
514 }
515
516 #endif
517
518 #ifdef CONFIG_PM_SLEEP
519
520 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
521 {
522         pci_power_up(pci_dev);
523         pci_restore_state(pci_dev);
524         pci_pme_restore(pci_dev);
525         pci_fixup_device(pci_fixup_resume_early, pci_dev);
526 }
527
528 /*
529  * Default "suspend" method for devices that have no driver provided suspend,
530  * or not even a driver at all (second part).
531  */
532 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
533 {
534         /*
535          * mark its power state as "unknown", since we don't know if
536          * e.g. the BIOS will change its device state when we suspend.
537          */
538         if (pci_dev->current_state == PCI_D0)
539                 pci_dev->current_state = PCI_UNKNOWN;
540 }
541
542 /*
543  * Default "resume" method for devices that have no driver provided resume,
544  * or not even a driver at all (second part).
545  */
546 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
547 {
548         int retval;
549
550         /* if the device was enabled before suspend, reenable */
551         retval = pci_reenable_device(pci_dev);
552         /*
553          * if the device was busmaster before the suspend, make it busmaster
554          * again
555          */
556         if (pci_dev->is_busmaster)
557                 pci_set_master(pci_dev);
558
559         return retval;
560 }
561
562 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
563 {
564         struct pci_dev *pci_dev = to_pci_dev(dev);
565         struct pci_driver *drv = pci_dev->driver;
566
567         if (drv && drv->suspend) {
568                 pci_power_t prev = pci_dev->current_state;
569                 int error;
570
571                 error = drv->suspend(pci_dev, state);
572                 suspend_report_result(drv->suspend, error);
573                 if (error)
574                         return error;
575
576                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
577                     && pci_dev->current_state != PCI_UNKNOWN) {
578                         WARN_ONCE(pci_dev->current_state != prev,
579                                 "PCI PM: Device state not saved by %pF\n",
580                                 drv->suspend);
581                 }
582         }
583
584         pci_fixup_device(pci_fixup_suspend, pci_dev);
585
586         return 0;
587 }
588
589 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
590 {
591         struct pci_dev *pci_dev = to_pci_dev(dev);
592         struct pci_driver *drv = pci_dev->driver;
593
594         if (drv && drv->suspend_late) {
595                 pci_power_t prev = pci_dev->current_state;
596                 int error;
597
598                 error = drv->suspend_late(pci_dev, state);
599                 suspend_report_result(drv->suspend_late, error);
600                 if (error)
601                         return error;
602
603                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
604                     && pci_dev->current_state != PCI_UNKNOWN) {
605                         WARN_ONCE(pci_dev->current_state != prev,
606                                 "PCI PM: Device state not saved by %pF\n",
607                                 drv->suspend_late);
608                         goto Fixup;
609                 }
610         }
611
612         if (!pci_dev->state_saved)
613                 pci_save_state(pci_dev);
614
615         pci_pm_set_unknown_state(pci_dev);
616
617 Fixup:
618         pci_fixup_device(pci_fixup_suspend_late, pci_dev);
619
620         return 0;
621 }
622
623 static int pci_legacy_resume_early(struct device *dev)
624 {
625         struct pci_dev *pci_dev = to_pci_dev(dev);
626         struct pci_driver *drv = pci_dev->driver;
627
628         return drv && drv->resume_early ?
629                         drv->resume_early(pci_dev) : 0;
630 }
631
632 static int pci_legacy_resume(struct device *dev)
633 {
634         struct pci_dev *pci_dev = to_pci_dev(dev);
635         struct pci_driver *drv = pci_dev->driver;
636
637         pci_fixup_device(pci_fixup_resume, pci_dev);
638
639         return drv && drv->resume ?
640                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
641 }
642
643 /* Auxiliary functions used by the new power management framework */
644
645 static void pci_pm_default_resume(struct pci_dev *pci_dev)
646 {
647         pci_fixup_device(pci_fixup_resume, pci_dev);
648         pci_enable_wake(pci_dev, PCI_D0, false);
649 }
650
651 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
652 {
653         /* Disable non-bridge devices without PM support */
654         if (!pci_has_subordinate(pci_dev))
655                 pci_disable_enabled_device(pci_dev);
656 }
657
658 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
659 {
660         struct pci_driver *drv = pci_dev->driver;
661         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
662                 || drv->resume_early);
663
664         /*
665          * Legacy PM support is used by default, so warn if the new framework is
666          * supported as well.  Drivers are supposed to support either the
667          * former, or the latter, but not both at the same time.
668          */
669         WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
670                 drv->name, pci_dev->vendor, pci_dev->device);
671
672         return ret;
673 }
674
675 /* New power management framework */
676
677 static int pci_pm_prepare(struct device *dev)
678 {
679         struct device_driver *drv = dev->driver;
680
681         if (drv && drv->pm && drv->pm->prepare) {
682                 int error = drv->pm->prepare(dev);
683                 if (error < 0)
684                         return error;
685
686                 if (!error && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
687                         return 0;
688         }
689         return pci_dev_keep_suspended(to_pci_dev(dev));
690 }
691
692 static void pci_pm_complete(struct device *dev)
693 {
694         struct pci_dev *pci_dev = to_pci_dev(dev);
695
696         pci_dev_complete_resume(pci_dev);
697         pm_generic_complete(dev);
698
699         /* Resume device if platform firmware has put it in reset-power-on */
700         if (pm_runtime_suspended(dev) && pm_resume_via_firmware()) {
701                 pci_power_t pre_sleep_state = pci_dev->current_state;
702
703                 pci_update_current_state(pci_dev, pci_dev->current_state);
704                 if (pci_dev->current_state < pre_sleep_state)
705                         pm_request_resume(dev);
706         }
707 }
708
709 #else /* !CONFIG_PM_SLEEP */
710
711 #define pci_pm_prepare  NULL
712 #define pci_pm_complete NULL
713
714 #endif /* !CONFIG_PM_SLEEP */
715
716 #ifdef CONFIG_SUSPEND
717
718 static int pci_pm_suspend(struct device *dev)
719 {
720         struct pci_dev *pci_dev = to_pci_dev(dev);
721         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
722
723         if (pci_has_legacy_pm_support(pci_dev))
724                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
725
726         if (!pm) {
727                 pci_pm_default_suspend(pci_dev);
728                 return 0;
729         }
730
731         /*
732          * PCI devices suspended at run time may need to be resumed at this
733          * point, because in general it may be necessary to reconfigure them for
734          * system suspend.  Namely, if the device is expected to wake up the
735          * system from the sleep state, it may have to be reconfigured for this
736          * purpose, or if the device is not expected to wake up the system from
737          * the sleep state, it should be prevented from signaling wakeup events
738          * going forward.
739          *
740          * Also if the driver of the device does not indicate that its system
741          * suspend callbacks can cope with runtime-suspended devices, it is
742          * better to resume the device from runtime suspend here.
743          */
744         if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
745             !pci_dev_keep_suspended(pci_dev))
746                 pm_runtime_resume(dev);
747
748         pci_dev->state_saved = false;
749         if (pm->suspend) {
750                 pci_power_t prev = pci_dev->current_state;
751                 int error;
752
753                 error = pm->suspend(dev);
754                 suspend_report_result(pm->suspend, error);
755                 if (error)
756                         return error;
757
758                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
759                     && pci_dev->current_state != PCI_UNKNOWN) {
760                         WARN_ONCE(pci_dev->current_state != prev,
761                                 "PCI PM: State of device not saved by %pF\n",
762                                 pm->suspend);
763                 }
764         }
765
766         return 0;
767 }
768
769 static int pci_pm_suspend_late(struct device *dev)
770 {
771         if (dev_pm_smart_suspend_and_suspended(dev))
772                 return 0;
773
774         pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
775
776         return pm_generic_suspend_late(dev);
777 }
778
779 static int pci_pm_suspend_noirq(struct device *dev)
780 {
781         struct pci_dev *pci_dev = to_pci_dev(dev);
782         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
783
784         if (dev_pm_smart_suspend_and_suspended(dev)) {
785                 dev->power.may_skip_resume = true;
786                 return 0;
787         }
788
789         if (pci_has_legacy_pm_support(pci_dev))
790                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
791
792         if (!pm) {
793                 pci_save_state(pci_dev);
794                 goto Fixup;
795         }
796
797         if (pm->suspend_noirq) {
798                 pci_power_t prev = pci_dev->current_state;
799                 int error;
800
801                 error = pm->suspend_noirq(dev);
802                 suspend_report_result(pm->suspend_noirq, error);
803                 if (error)
804                         return error;
805
806                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
807                     && pci_dev->current_state != PCI_UNKNOWN) {
808                         WARN_ONCE(pci_dev->current_state != prev,
809                                 "PCI PM: State of device not saved by %pF\n",
810                                 pm->suspend_noirq);
811                         goto Fixup;
812                 }
813         }
814
815         if (!pci_dev->state_saved) {
816                 pci_save_state(pci_dev);
817                 if (pci_power_manageable(pci_dev))
818                         pci_prepare_to_sleep(pci_dev);
819         }
820
821         dev_dbg(dev, "PCI PM: Suspend power state: %s\n",
822                 pci_power_name(pci_dev->current_state));
823
824         pci_pm_set_unknown_state(pci_dev);
825
826         /*
827          * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
828          * PCI COMMAND register isn't 0, the BIOS assumes that the controller
829          * hasn't been quiesced and tries to turn it off.  If the controller
830          * is already in D3, this can hang or cause memory corruption.
831          *
832          * Since the value of the COMMAND register doesn't matter once the
833          * device has been suspended, we can safely set it to 0 here.
834          */
835         if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
836                 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
837
838 Fixup:
839         pci_fixup_device(pci_fixup_suspend_late, pci_dev);
840
841         /*
842          * If the target system sleep state is suspend-to-idle, it is sufficient
843          * to check whether or not the device's wakeup settings are good for
844          * runtime PM.  Otherwise, the pm_resume_via_firmware() check will cause
845          * pci_pm_complete() to take care of fixing up the device's state
846          * anyway, if need be.
847          */
848         dev->power.may_skip_resume = device_may_wakeup(dev) ||
849                                         !device_can_wakeup(dev);
850
851         return 0;
852 }
853
854 static int pci_pm_resume_noirq(struct device *dev)
855 {
856         struct pci_dev *pci_dev = to_pci_dev(dev);
857         struct device_driver *drv = dev->driver;
858         int error = 0;
859
860         if (dev_pm_may_skip_resume(dev))
861                 return 0;
862
863         /*
864          * Devices with DPM_FLAG_SMART_SUSPEND may be left in runtime suspend
865          * during system suspend, so update their runtime PM status to "active"
866          * as they are going to be put into D0 shortly.
867          */
868         if (dev_pm_smart_suspend_and_suspended(dev))
869                 pm_runtime_set_active(dev);
870
871         pci_pm_default_resume_early(pci_dev);
872
873         if (pci_has_legacy_pm_support(pci_dev))
874                 return pci_legacy_resume_early(dev);
875
876         if (drv && drv->pm && drv->pm->resume_noirq)
877                 error = drv->pm->resume_noirq(dev);
878
879         return error;
880 }
881
882 static int pci_pm_resume(struct device *dev)
883 {
884         struct pci_dev *pci_dev = to_pci_dev(dev);
885         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
886         int error = 0;
887
888         /*
889          * This is necessary for the suspend error path in which resume is
890          * called without restoring the standard config registers of the device.
891          */
892         if (pci_dev->state_saved)
893                 pci_restore_standard_config(pci_dev);
894
895         if (pci_has_legacy_pm_support(pci_dev))
896                 return pci_legacy_resume(dev);
897
898         pci_pm_default_resume(pci_dev);
899
900         if (pm) {
901                 if (pm->resume)
902                         error = pm->resume(dev);
903         } else {
904                 pci_pm_reenable_device(pci_dev);
905         }
906
907         return error;
908 }
909
910 #else /* !CONFIG_SUSPEND */
911
912 #define pci_pm_suspend          NULL
913 #define pci_pm_suspend_late     NULL
914 #define pci_pm_suspend_noirq    NULL
915 #define pci_pm_resume           NULL
916 #define pci_pm_resume_noirq     NULL
917
918 #endif /* !CONFIG_SUSPEND */
919
920 #ifdef CONFIG_HIBERNATE_CALLBACKS
921
922
923 /*
924  * pcibios_pm_ops - provide arch-specific hooks when a PCI device is doing
925  * a hibernate transition
926  */
927 struct dev_pm_ops __weak pcibios_pm_ops;
928
929 static int pci_pm_freeze(struct device *dev)
930 {
931         struct pci_dev *pci_dev = to_pci_dev(dev);
932         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
933
934         if (pci_has_legacy_pm_support(pci_dev))
935                 return pci_legacy_suspend(dev, PMSG_FREEZE);
936
937         if (!pm) {
938                 pci_pm_default_suspend(pci_dev);
939                 return 0;
940         }
941
942         /*
943          * This used to be done in pci_pm_prepare() for all devices and some
944          * drivers may depend on it, so do it here.  Ideally, runtime-suspended
945          * devices should not be touched during freeze/thaw transitions,
946          * however.
947          */
948         if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND))
949                 pm_runtime_resume(dev);
950
951         pci_dev->state_saved = false;
952         if (pm->freeze) {
953                 int error;
954
955                 error = pm->freeze(dev);
956                 suspend_report_result(pm->freeze, error);
957                 if (error)
958                         return error;
959         }
960
961         return 0;
962 }
963
964 static int pci_pm_freeze_late(struct device *dev)
965 {
966         if (dev_pm_smart_suspend_and_suspended(dev))
967                 return 0;
968
969         return pm_generic_freeze_late(dev);
970 }
971
972 static int pci_pm_freeze_noirq(struct device *dev)
973 {
974         struct pci_dev *pci_dev = to_pci_dev(dev);
975         struct device_driver *drv = dev->driver;
976
977         if (dev_pm_smart_suspend_and_suspended(dev))
978                 return 0;
979
980         if (pci_has_legacy_pm_support(pci_dev))
981                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
982
983         if (drv && drv->pm && drv->pm->freeze_noirq) {
984                 int error;
985
986                 error = drv->pm->freeze_noirq(dev);
987                 suspend_report_result(drv->pm->freeze_noirq, error);
988                 if (error)
989                         return error;
990         }
991
992         if (!pci_dev->state_saved)
993                 pci_save_state(pci_dev);
994
995         pci_pm_set_unknown_state(pci_dev);
996
997         if (pcibios_pm_ops.freeze_noirq)
998                 return pcibios_pm_ops.freeze_noirq(dev);
999
1000         return 0;
1001 }
1002
1003 static int pci_pm_thaw_noirq(struct device *dev)
1004 {
1005         struct pci_dev *pci_dev = to_pci_dev(dev);
1006         struct device_driver *drv = dev->driver;
1007         int error = 0;
1008
1009         /*
1010          * If the device is in runtime suspend, the code below may not work
1011          * correctly with it, so skip that code and make the PM core skip all of
1012          * the subsequent "thaw" callbacks for the device.
1013          */
1014         if (dev_pm_smart_suspend_and_suspended(dev)) {
1015                 dev_pm_skip_next_resume_phases(dev);
1016                 return 0;
1017         }
1018
1019         if (pcibios_pm_ops.thaw_noirq) {
1020                 error = pcibios_pm_ops.thaw_noirq(dev);
1021                 if (error)
1022                         return error;
1023         }
1024
1025         if (pci_has_legacy_pm_support(pci_dev))
1026                 return pci_legacy_resume_early(dev);
1027
1028         /*
1029          * pci_restore_state() requires the device to be in D0 (because of MSI
1030          * restoration among other things), so force it into D0 in case the
1031          * driver's "freeze" callbacks put it into a low-power state directly.
1032          */
1033         pci_set_power_state(pci_dev, PCI_D0);
1034         pci_restore_state(pci_dev);
1035
1036         if (drv && drv->pm && drv->pm->thaw_noirq)
1037                 error = drv->pm->thaw_noirq(dev);
1038
1039         return error;
1040 }
1041
1042 static int pci_pm_thaw(struct device *dev)
1043 {
1044         struct pci_dev *pci_dev = to_pci_dev(dev);
1045         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1046         int error = 0;
1047
1048         if (pci_has_legacy_pm_support(pci_dev))
1049                 return pci_legacy_resume(dev);
1050
1051         if (pm) {
1052                 if (pm->thaw)
1053                         error = pm->thaw(dev);
1054         } else {
1055                 pci_pm_reenable_device(pci_dev);
1056         }
1057
1058         pci_dev->state_saved = false;
1059
1060         return error;
1061 }
1062
1063 static int pci_pm_poweroff(struct device *dev)
1064 {
1065         struct pci_dev *pci_dev = to_pci_dev(dev);
1066         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1067
1068         if (pci_has_legacy_pm_support(pci_dev))
1069                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
1070
1071         if (!pm) {
1072                 pci_pm_default_suspend(pci_dev);
1073                 return 0;
1074         }
1075
1076         /* The reason to do that is the same as in pci_pm_suspend(). */
1077         if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1078             !pci_dev_keep_suspended(pci_dev))
1079                 pm_runtime_resume(dev);
1080
1081         pci_dev->state_saved = false;
1082         if (pm->poweroff) {
1083                 int error;
1084
1085                 error = pm->poweroff(dev);
1086                 suspend_report_result(pm->poweroff, error);
1087                 if (error)
1088                         return error;
1089         }
1090
1091         return 0;
1092 }
1093
1094 static int pci_pm_poweroff_late(struct device *dev)
1095 {
1096         if (dev_pm_smart_suspend_and_suspended(dev))
1097                 return 0;
1098
1099         pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
1100
1101         return pm_generic_poweroff_late(dev);
1102 }
1103
1104 static int pci_pm_poweroff_noirq(struct device *dev)
1105 {
1106         struct pci_dev *pci_dev = to_pci_dev(dev);
1107         struct device_driver *drv = dev->driver;
1108
1109         if (dev_pm_smart_suspend_and_suspended(dev))
1110                 return 0;
1111
1112         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
1113                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
1114
1115         if (!drv || !drv->pm) {
1116                 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
1117                 return 0;
1118         }
1119
1120         if (drv->pm->poweroff_noirq) {
1121                 int error;
1122
1123                 error = drv->pm->poweroff_noirq(dev);
1124                 suspend_report_result(drv->pm->poweroff_noirq, error);
1125                 if (error)
1126                         return error;
1127         }
1128
1129         if (!pci_dev->state_saved && !pci_has_subordinate(pci_dev))
1130                 pci_prepare_to_sleep(pci_dev);
1131
1132         /*
1133          * The reason for doing this here is the same as for the analogous code
1134          * in pci_pm_suspend_noirq().
1135          */
1136         if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
1137                 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
1138
1139         pci_fixup_device(pci_fixup_suspend_late, pci_dev);
1140
1141         if (pcibios_pm_ops.poweroff_noirq)
1142                 return pcibios_pm_ops.poweroff_noirq(dev);
1143
1144         return 0;
1145 }
1146
1147 static int pci_pm_restore_noirq(struct device *dev)
1148 {
1149         struct pci_dev *pci_dev = to_pci_dev(dev);
1150         struct device_driver *drv = dev->driver;
1151         int error = 0;
1152
1153         /* This is analogous to the pci_pm_resume_noirq() case. */
1154         if (dev_pm_smart_suspend_and_suspended(dev))
1155                 pm_runtime_set_active(dev);
1156
1157         if (pcibios_pm_ops.restore_noirq) {
1158                 error = pcibios_pm_ops.restore_noirq(dev);
1159                 if (error)
1160                         return error;
1161         }
1162
1163         pci_pm_default_resume_early(pci_dev);
1164
1165         if (pci_has_legacy_pm_support(pci_dev))
1166                 return pci_legacy_resume_early(dev);
1167
1168         if (drv && drv->pm && drv->pm->restore_noirq)
1169                 error = drv->pm->restore_noirq(dev);
1170
1171         return error;
1172 }
1173
1174 static int pci_pm_restore(struct device *dev)
1175 {
1176         struct pci_dev *pci_dev = to_pci_dev(dev);
1177         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1178         int error = 0;
1179
1180         /*
1181          * This is necessary for the hibernation error path in which restore is
1182          * called without restoring the standard config registers of the device.
1183          */
1184         if (pci_dev->state_saved)
1185                 pci_restore_standard_config(pci_dev);
1186
1187         if (pci_has_legacy_pm_support(pci_dev))
1188                 return pci_legacy_resume(dev);
1189
1190         pci_pm_default_resume(pci_dev);
1191
1192         if (pm) {
1193                 if (pm->restore)
1194                         error = pm->restore(dev);
1195         } else {
1196                 pci_pm_reenable_device(pci_dev);
1197         }
1198
1199         return error;
1200 }
1201
1202 #else /* !CONFIG_HIBERNATE_CALLBACKS */
1203
1204 #define pci_pm_freeze           NULL
1205 #define pci_pm_freeze_late      NULL
1206 #define pci_pm_freeze_noirq     NULL
1207 #define pci_pm_thaw             NULL
1208 #define pci_pm_thaw_noirq       NULL
1209 #define pci_pm_poweroff         NULL
1210 #define pci_pm_poweroff_late    NULL
1211 #define pci_pm_poweroff_noirq   NULL
1212 #define pci_pm_restore          NULL
1213 #define pci_pm_restore_noirq    NULL
1214
1215 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
1216
1217 #ifdef CONFIG_PM
1218
1219 static int pci_pm_runtime_suspend(struct device *dev)
1220 {
1221         struct pci_dev *pci_dev = to_pci_dev(dev);
1222         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1223         pci_power_t prev = pci_dev->current_state;
1224         int error;
1225
1226         /*
1227          * If pci_dev->driver is not set (unbound), the device should
1228          * always remain in D0 regardless of the runtime PM status
1229          */
1230         if (!pci_dev->driver)
1231                 return 0;
1232
1233         if (!pm || !pm->runtime_suspend)
1234                 return -ENOSYS;
1235
1236         pci_dev->state_saved = false;
1237         error = pm->runtime_suspend(dev);
1238         if (error) {
1239                 /*
1240                  * -EBUSY and -EAGAIN is used to request the runtime PM core
1241                  * to schedule a new suspend, so log the event only with debug
1242                  * log level.
1243                  */
1244                 if (error == -EBUSY || error == -EAGAIN)
1245                         dev_dbg(dev, "can't suspend now (%pf returned %d)\n",
1246                                 pm->runtime_suspend, error);
1247                 else
1248                         dev_err(dev, "can't suspend (%pf returned %d)\n",
1249                                 pm->runtime_suspend, error);
1250
1251                 return error;
1252         }
1253
1254         pci_fixup_device(pci_fixup_suspend, pci_dev);
1255
1256         if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1257             && pci_dev->current_state != PCI_UNKNOWN) {
1258                 WARN_ONCE(pci_dev->current_state != prev,
1259                         "PCI PM: State of device not saved by %pF\n",
1260                         pm->runtime_suspend);
1261                 return 0;
1262         }
1263
1264         if (!pci_dev->state_saved) {
1265                 pci_save_state(pci_dev);
1266                 pci_finish_runtime_suspend(pci_dev);
1267         }
1268
1269         return 0;
1270 }
1271
1272 static int pci_pm_runtime_resume(struct device *dev)
1273 {
1274         int rc;
1275         struct pci_dev *pci_dev = to_pci_dev(dev);
1276         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1277
1278         /*
1279          * If pci_dev->driver is not set (unbound), the device should
1280          * always remain in D0 regardless of the runtime PM status
1281          */
1282         if (!pci_dev->driver)
1283                 return 0;
1284
1285         if (!pm || !pm->runtime_resume)
1286                 return -ENOSYS;
1287
1288         pci_restore_standard_config(pci_dev);
1289         pci_fixup_device(pci_fixup_resume_early, pci_dev);
1290         pci_enable_wake(pci_dev, PCI_D0, false);
1291         pci_fixup_device(pci_fixup_resume, pci_dev);
1292
1293         rc = pm->runtime_resume(dev);
1294
1295         pci_dev->runtime_d3cold = false;
1296
1297         return rc;
1298 }
1299
1300 static int pci_pm_runtime_idle(struct device *dev)
1301 {
1302         struct pci_dev *pci_dev = to_pci_dev(dev);
1303         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1304         int ret = 0;
1305
1306         /*
1307          * If pci_dev->driver is not set (unbound), the device should
1308          * always remain in D0 regardless of the runtime PM status
1309          */
1310         if (!pci_dev->driver)
1311                 return 0;
1312
1313         if (!pm)
1314                 return -ENOSYS;
1315
1316         if (pm->runtime_idle)
1317                 ret = pm->runtime_idle(dev);
1318
1319         return ret;
1320 }
1321
1322 static const struct dev_pm_ops pci_dev_pm_ops = {
1323         .prepare = pci_pm_prepare,
1324         .complete = pci_pm_complete,
1325         .suspend = pci_pm_suspend,
1326         .suspend_late = pci_pm_suspend_late,
1327         .resume = pci_pm_resume,
1328         .freeze = pci_pm_freeze,
1329         .freeze_late = pci_pm_freeze_late,
1330         .thaw = pci_pm_thaw,
1331         .poweroff = pci_pm_poweroff,
1332         .poweroff_late = pci_pm_poweroff_late,
1333         .restore = pci_pm_restore,
1334         .suspend_noirq = pci_pm_suspend_noirq,
1335         .resume_noirq = pci_pm_resume_noirq,
1336         .freeze_noirq = pci_pm_freeze_noirq,
1337         .thaw_noirq = pci_pm_thaw_noirq,
1338         .poweroff_noirq = pci_pm_poweroff_noirq,
1339         .restore_noirq = pci_pm_restore_noirq,
1340         .runtime_suspend = pci_pm_runtime_suspend,
1341         .runtime_resume = pci_pm_runtime_resume,
1342         .runtime_idle = pci_pm_runtime_idle,
1343 };
1344
1345 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
1346
1347 #else /* !CONFIG_PM */
1348
1349 #define pci_pm_runtime_suspend  NULL
1350 #define pci_pm_runtime_resume   NULL
1351 #define pci_pm_runtime_idle     NULL
1352
1353 #define PCI_PM_OPS_PTR  NULL
1354
1355 #endif /* !CONFIG_PM */
1356
1357 /**
1358  * __pci_register_driver - register a new pci driver
1359  * @drv: the driver structure to register
1360  * @owner: owner module of drv
1361  * @mod_name: module name string
1362  *
1363  * Adds the driver structure to the list of registered drivers.
1364  * Returns a negative value on error, otherwise 0.
1365  * If no error occurred, the driver remains registered even if
1366  * no device was claimed during registration.
1367  */
1368 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1369                           const char *mod_name)
1370 {
1371         /* initialize common driver fields */
1372         drv->driver.name = drv->name;
1373         drv->driver.bus = &pci_bus_type;
1374         drv->driver.owner = owner;
1375         drv->driver.mod_name = mod_name;
1376         drv->driver.groups = drv->groups;
1377
1378         spin_lock_init(&drv->dynids.lock);
1379         INIT_LIST_HEAD(&drv->dynids.list);
1380
1381         /* register with core */
1382         return driver_register(&drv->driver);
1383 }
1384 EXPORT_SYMBOL(__pci_register_driver);
1385
1386 /**
1387  * pci_unregister_driver - unregister a pci driver
1388  * @drv: the driver structure to unregister
1389  *
1390  * Deletes the driver structure from the list of registered PCI drivers,
1391  * gives it a chance to clean up by calling its remove() function for
1392  * each device it was responsible for, and marks those devices as
1393  * driverless.
1394  */
1395
1396 void pci_unregister_driver(struct pci_driver *drv)
1397 {
1398         driver_unregister(&drv->driver);
1399         pci_free_dynids(drv);
1400 }
1401 EXPORT_SYMBOL(pci_unregister_driver);
1402
1403 static struct pci_driver pci_compat_driver = {
1404         .name = "compat"
1405 };
1406
1407 /**
1408  * pci_dev_driver - get the pci_driver of a device
1409  * @dev: the device to query
1410  *
1411  * Returns the appropriate pci_driver structure or %NULL if there is no
1412  * registered driver for the device.
1413  */
1414 struct pci_driver *pci_dev_driver(const struct pci_dev *dev)
1415 {
1416         if (dev->driver)
1417                 return dev->driver;
1418         else {
1419                 int i;
1420                 for (i = 0; i <= PCI_ROM_RESOURCE; i++)
1421                         if (dev->resource[i].flags & IORESOURCE_BUSY)
1422                                 return &pci_compat_driver;
1423         }
1424         return NULL;
1425 }
1426 EXPORT_SYMBOL(pci_dev_driver);
1427
1428 /**
1429  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1430  * @dev: the PCI device structure to match against
1431  * @drv: the device driver to search for matching PCI device id structures
1432  *
1433  * Used by a driver to check whether a PCI device present in the
1434  * system is in its list of supported devices. Returns the matching
1435  * pci_device_id structure or %NULL if there is no match.
1436  */
1437 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1438 {
1439         struct pci_dev *pci_dev = to_pci_dev(dev);
1440         struct pci_driver *pci_drv;
1441         const struct pci_device_id *found_id;
1442
1443         if (!pci_dev->match_driver)
1444                 return 0;
1445
1446         pci_drv = to_pci_driver(drv);
1447         found_id = pci_match_device(pci_drv, pci_dev);
1448         if (found_id)
1449                 return 1;
1450
1451         return 0;
1452 }
1453
1454 /**
1455  * pci_dev_get - increments the reference count of the pci device structure
1456  * @dev: the device being referenced
1457  *
1458  * Each live reference to a device should be refcounted.
1459  *
1460  * Drivers for PCI devices should normally record such references in
1461  * their probe() methods, when they bind to a device, and release
1462  * them by calling pci_dev_put(), in their disconnect() methods.
1463  *
1464  * A pointer to the device with the incremented reference counter is returned.
1465  */
1466 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1467 {
1468         if (dev)
1469                 get_device(&dev->dev);
1470         return dev;
1471 }
1472 EXPORT_SYMBOL(pci_dev_get);
1473
1474 /**
1475  * pci_dev_put - release a use of the pci device structure
1476  * @dev: device that's been disconnected
1477  *
1478  * Must be called when a user of a device is finished with it.  When the last
1479  * user of the device calls this function, the memory of the device is freed.
1480  */
1481 void pci_dev_put(struct pci_dev *dev)
1482 {
1483         if (dev)
1484                 put_device(&dev->dev);
1485 }
1486 EXPORT_SYMBOL(pci_dev_put);
1487
1488 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1489 {
1490         struct pci_dev *pdev;
1491
1492         if (!dev)
1493                 return -ENODEV;
1494
1495         pdev = to_pci_dev(dev);
1496
1497         if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1498                 return -ENOMEM;
1499
1500         if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1501                 return -ENOMEM;
1502
1503         if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1504                            pdev->subsystem_device))
1505                 return -ENOMEM;
1506
1507         if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1508                 return -ENOMEM;
1509
1510         if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X",
1511                            pdev->vendor, pdev->device,
1512                            pdev->subsystem_vendor, pdev->subsystem_device,
1513                            (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1514                            (u8)(pdev->class)))
1515                 return -ENOMEM;
1516
1517         return 0;
1518 }
1519
1520 #if defined(CONFIG_PCIEAER) || defined(CONFIG_EEH)
1521 /**
1522  * pci_uevent_ers - emit a uevent during recovery path of PCI device
1523  * @pdev: PCI device undergoing error recovery
1524  * @err_type: type of error event
1525  */
1526 void pci_uevent_ers(struct pci_dev *pdev, enum pci_ers_result err_type)
1527 {
1528         int idx = 0;
1529         char *envp[3];
1530
1531         switch (err_type) {
1532         case PCI_ERS_RESULT_NONE:
1533         case PCI_ERS_RESULT_CAN_RECOVER:
1534                 envp[idx++] = "ERROR_EVENT=BEGIN_RECOVERY";
1535                 envp[idx++] = "DEVICE_ONLINE=0";
1536                 break;
1537         case PCI_ERS_RESULT_RECOVERED:
1538                 envp[idx++] = "ERROR_EVENT=SUCCESSFUL_RECOVERY";
1539                 envp[idx++] = "DEVICE_ONLINE=1";
1540                 break;
1541         case PCI_ERS_RESULT_DISCONNECT:
1542                 envp[idx++] = "ERROR_EVENT=FAILED_RECOVERY";
1543                 envp[idx++] = "DEVICE_ONLINE=0";
1544                 break;
1545         default:
1546                 break;
1547         }
1548
1549         if (idx > 0) {
1550                 envp[idx++] = NULL;
1551                 kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp);
1552         }
1553 }
1554 #endif
1555
1556 static int pci_bus_num_vf(struct device *dev)
1557 {
1558         return pci_num_vf(to_pci_dev(dev));
1559 }
1560
1561 struct bus_type pci_bus_type = {
1562         .name           = "pci",
1563         .match          = pci_bus_match,
1564         .uevent         = pci_uevent,
1565         .probe          = pci_device_probe,
1566         .remove         = pci_device_remove,
1567         .shutdown       = pci_device_shutdown,
1568         .dev_groups     = pci_dev_groups,
1569         .bus_groups     = pci_bus_groups,
1570         .drv_groups     = pci_drv_groups,
1571         .pm             = PCI_PM_OPS_PTR,
1572         .num_vf         = pci_bus_num_vf,
1573         .force_dma      = true,
1574 };
1575 EXPORT_SYMBOL(pci_bus_type);
1576
1577 static int __init pci_driver_init(void)
1578 {
1579         return bus_register(&pci_bus_type);
1580 }
1581 postcore_initcall(pci_driver_init);