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