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