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