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