8a6f797de8e55af1b3d0380aefb2173b58ab9fa5
[linux-2.6.git] / drivers / pci / pci-driver.c
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 "pci.h"
22
23 struct pci_dynid {
24         struct list_head node;
25         struct pci_device_id id;
26 };
27
28 /**
29  * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
30  * @drv: target pci driver
31  * @vendor: PCI vendor ID
32  * @device: PCI device ID
33  * @subvendor: PCI subvendor ID
34  * @subdevice: PCI subdevice ID
35  * @class: PCI class
36  * @class_mask: PCI class mask
37  * @driver_data: private driver data
38  *
39  * Adds a new dynamic pci device ID to this driver and causes the
40  * driver to probe for all devices again.  @drv must have been
41  * registered prior to calling this function.
42  *
43  * CONTEXT:
44  * Does GFP_KERNEL allocation.
45  *
46  * RETURNS:
47  * 0 on success, -errno on failure.
48  */
49 int pci_add_dynid(struct pci_driver *drv,
50                   unsigned int vendor, unsigned int device,
51                   unsigned int subvendor, unsigned int subdevice,
52                   unsigned int class, unsigned int class_mask,
53                   unsigned long driver_data)
54 {
55         struct pci_dynid *dynid;
56         int retval;
57
58         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
59         if (!dynid)
60                 return -ENOMEM;
61
62         dynid->id.vendor = vendor;
63         dynid->id.device = device;
64         dynid->id.subvendor = subvendor;
65         dynid->id.subdevice = subdevice;
66         dynid->id.class = class;
67         dynid->id.class_mask = class_mask;
68         dynid->id.driver_data = driver_data;
69
70         spin_lock(&drv->dynids.lock);
71         list_add_tail(&dynid->node, &drv->dynids.list);
72         spin_unlock(&drv->dynids.lock);
73
74         get_driver(&drv->driver);
75         retval = driver_attach(&drv->driver);
76         put_driver(&drv->driver);
77
78         return retval;
79 }
80
81 static 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  * Dynamic device ID manipulation via sysfs is disabled for !CONFIG_HOTPLUG
95  */
96 #ifdef CONFIG_HOTPLUG
97 /**
98  * store_new_id - sysfs frontend to pci_add_dynid()
99  * @driver: target device driver
100  * @buf: buffer for scanning device ID data
101  * @count: input size
102  *
103  * Allow PCI IDs to be added to an existing driver via sysfs.
104  */
105 static ssize_t
106 store_new_id(struct device_driver *driver, const char *buf, size_t count)
107 {
108         struct pci_driver *pdrv = to_pci_driver(driver);
109         const struct pci_device_id *ids = pdrv->id_table;
110         __u32 vendor, device, subvendor=PCI_ANY_ID,
111                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
112         unsigned long driver_data=0;
113         int fields=0;
114         int retval;
115
116         fields = sscanf(buf, "%x %x %x %x %x %x %lx",
117                         &vendor, &device, &subvendor, &subdevice,
118                         &class, &class_mask, &driver_data);
119         if (fields < 2)
120                 return -EINVAL;
121
122         /* Only accept driver_data values that match an existing id_table
123            entry */
124         if (ids) {
125                 retval = -EINVAL;
126                 while (ids->vendor || ids->subvendor || ids->class_mask) {
127                         if (driver_data == ids->driver_data) {
128                                 retval = 0;
129                                 break;
130                         }
131                         ids++;
132                 }
133                 if (retval)     /* No match */
134                         return retval;
135         }
136
137         retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
138                                class, class_mask, driver_data);
139         if (retval)
140                 return retval;
141         return count;
142 }
143 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
144
145 /**
146  * store_remove_id - remove a PCI device ID from this driver
147  * @driver: target device driver
148  * @buf: buffer for scanning device ID data
149  * @count: input size
150  *
151  * Removes a dynamic pci device ID to this driver.
152  */
153 static ssize_t
154 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
155 {
156         struct pci_dynid *dynid, *n;
157         struct pci_driver *pdrv = to_pci_driver(driver);
158         __u32 vendor, device, subvendor = PCI_ANY_ID,
159                 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
160         int fields = 0;
161         int retval = -ENODEV;
162
163         fields = sscanf(buf, "%x %x %x %x %x %x",
164                         &vendor, &device, &subvendor, &subdevice,
165                         &class, &class_mask);
166         if (fields < 2)
167                 return -EINVAL;
168
169         spin_lock(&pdrv->dynids.lock);
170         list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
171                 struct pci_device_id *id = &dynid->id;
172                 if ((id->vendor == vendor) &&
173                     (id->device == device) &&
174                     (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
175                     (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
176                     !((id->class ^ class) & class_mask)) {
177                         list_del(&dynid->node);
178                         kfree(dynid);
179                         retval = 0;
180                         break;
181                 }
182         }
183         spin_unlock(&pdrv->dynids.lock);
184
185         if (retval)
186                 return retval;
187         return count;
188 }
189 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
190
191 static int
192 pci_create_newid_file(struct pci_driver *drv)
193 {
194         int error = 0;
195         if (drv->probe != NULL)
196                 error = driver_create_file(&drv->driver, &driver_attr_new_id);
197         return error;
198 }
199
200 static void pci_remove_newid_file(struct pci_driver *drv)
201 {
202         driver_remove_file(&drv->driver, &driver_attr_new_id);
203 }
204
205 static int
206 pci_create_removeid_file(struct pci_driver *drv)
207 {
208         int error = 0;
209         if (drv->probe != NULL)
210                 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
211         return error;
212 }
213
214 static void pci_remove_removeid_file(struct pci_driver *drv)
215 {
216         driver_remove_file(&drv->driver, &driver_attr_remove_id);
217 }
218 #else /* !CONFIG_HOTPLUG */
219 static inline int pci_create_newid_file(struct pci_driver *drv)
220 {
221         return 0;
222 }
223 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
224 static inline int pci_create_removeid_file(struct pci_driver *drv)
225 {
226         return 0;
227 }
228 static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
229 #endif
230
231 /**
232  * pci_match_id - See if a pci device matches a given pci_id table
233  * @ids: array of PCI device id structures to search in
234  * @dev: the PCI device structure to match against.
235  *
236  * Used by a driver to check whether a PCI device present in the
237  * system is in its list of supported devices.  Returns the matching
238  * pci_device_id structure or %NULL if there is no match.
239  *
240  * Deprecated, don't use this as it will not catch any dynamic ids
241  * that a driver might want to check for.
242  */
243 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
244                                          struct pci_dev *dev)
245 {
246         if (ids) {
247                 while (ids->vendor || ids->subvendor || ids->class_mask) {
248                         if (pci_match_one_device(ids, dev))
249                                 return ids;
250                         ids++;
251                 }
252         }
253         return NULL;
254 }
255
256 /**
257  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
258  * @drv: the PCI driver to match against
259  * @dev: the PCI device structure to match against
260  *
261  * Used by a driver to check whether a PCI device present in the
262  * system is in its list of supported devices.  Returns the matching
263  * pci_device_id structure or %NULL if there is no match.
264  */
265 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
266                                                     struct pci_dev *dev)
267 {
268         struct pci_dynid *dynid;
269
270         /* Look at the dynamic ids first, before the static ones */
271         spin_lock(&drv->dynids.lock);
272         list_for_each_entry(dynid, &drv->dynids.list, node) {
273                 if (pci_match_one_device(&dynid->id, dev)) {
274                         spin_unlock(&drv->dynids.lock);
275                         return &dynid->id;
276                 }
277         }
278         spin_unlock(&drv->dynids.lock);
279
280         return pci_match_id(drv->id_table, dev);
281 }
282
283 struct drv_dev_and_id {
284         struct pci_driver *drv;
285         struct pci_dev *dev;
286         const struct pci_device_id *id;
287 };
288
289 static long local_pci_probe(void *_ddi)
290 {
291         struct drv_dev_and_id *ddi = _ddi;
292         struct device *dev = &ddi->dev->dev;
293         int rc;
294
295         /* Unbound PCI devices are always set to disabled and suspended.
296          * During probe, the device is set to enabled and active and the
297          * usage count is incremented.  If the driver supports runtime PM,
298          * it should call pm_runtime_put_noidle() in its probe routine and
299          * pm_runtime_get_noresume() in its remove routine.
300          */
301         pm_runtime_get_noresume(dev);
302         pm_runtime_set_active(dev);
303         pm_runtime_enable(dev);
304
305         rc = ddi->drv->probe(ddi->dev, ddi->id);
306         if (rc) {
307                 pm_runtime_disable(dev);
308                 pm_runtime_set_suspended(dev);
309                 pm_runtime_put_noidle(dev);
310         }
311         return rc;
312 }
313
314 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
315                           const struct pci_device_id *id)
316 {
317         int error, node;
318         struct drv_dev_and_id ddi = { drv, dev, id };
319
320         /* Execute driver initialization on node where the device's
321            bus is attached to.  This way the driver likely allocates
322            its local memory on the right node without any need to
323            change it. */
324         node = dev_to_node(&dev->dev);
325         if (node >= 0) {
326                 int cpu;
327
328                 get_online_cpus();
329                 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
330                 if (cpu < nr_cpu_ids)
331                         error = work_on_cpu(cpu, local_pci_probe, &ddi);
332                 else
333                         error = local_pci_probe(&ddi);
334                 put_online_cpus();
335         } else
336                 error = local_pci_probe(&ddi);
337         return error;
338 }
339
340 /**
341  * __pci_device_probe()
342  * @drv: driver to call to check if it wants the PCI device
343  * @pci_dev: PCI device being probed
344  * 
345  * returns 0 on success, else error.
346  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
347  */
348 static int
349 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
350 {
351         const struct pci_device_id *id;
352         int error = 0;
353
354         if (!pci_dev->driver && drv->probe) {
355                 error = -ENODEV;
356
357                 id = pci_match_device(drv, pci_dev);
358                 if (id)
359                         error = pci_call_probe(drv, pci_dev, id);
360                 if (error >= 0) {
361                         pci_dev->driver = drv;
362                         error = 0;
363                 }
364         }
365         return error;
366 }
367
368 static int pci_device_probe(struct device * dev)
369 {
370         int error = 0;
371         struct pci_driver *drv;
372         struct pci_dev *pci_dev;
373
374         drv = to_pci_driver(dev->driver);
375         pci_dev = to_pci_dev(dev);
376         pci_dev_get(pci_dev);
377         error = __pci_device_probe(drv, pci_dev);
378         if (error)
379                 pci_dev_put(pci_dev);
380
381         return error;
382 }
383
384 static int pci_device_remove(struct device * dev)
385 {
386         struct pci_dev * pci_dev = to_pci_dev(dev);
387         struct pci_driver * drv = pci_dev->driver;
388
389         if (drv) {
390                 if (drv->remove) {
391                         pm_runtime_get_sync(dev);
392                         drv->remove(pci_dev);
393                         pm_runtime_put_noidle(dev);
394                 }
395                 pci_dev->driver = NULL;
396         }
397
398         /* Undo the runtime PM settings in local_pci_probe() */
399         pm_runtime_disable(dev);
400         pm_runtime_set_suspended(dev);
401         pm_runtime_put_noidle(dev);
402
403         /*
404          * If the device is still on, set the power state as "unknown",
405          * since it might change by the next time we load the driver.
406          */
407         if (pci_dev->current_state == PCI_D0)
408                 pci_dev->current_state = PCI_UNKNOWN;
409
410         /*
411          * We would love to complain here if pci_dev->is_enabled is set, that
412          * the driver should have called pci_disable_device(), but the
413          * unfortunate fact is there are too many odd BIOS and bridge setups
414          * that don't like drivers doing that all of the time.  
415          * Oh well, we can dream of sane hardware when we sleep, no matter how
416          * horrible the crap we have to deal with is when we are awake...
417          */
418
419         pci_dev_put(pci_dev);
420         return 0;
421 }
422
423 static void pci_device_shutdown(struct device *dev)
424 {
425         struct pci_dev *pci_dev = to_pci_dev(dev);
426         struct pci_driver *drv = pci_dev->driver;
427
428         if (drv && drv->shutdown)
429                 drv->shutdown(pci_dev);
430         pci_msi_shutdown(pci_dev);
431         pci_msix_shutdown(pci_dev);
432 }
433
434 #ifdef CONFIG_PM_OPS
435
436 /* Auxiliary functions used for system resume and run-time resume. */
437
438 /**
439  * pci_restore_standard_config - restore standard config registers of PCI device
440  * @pci_dev: PCI device to handle
441  */
442 static int pci_restore_standard_config(struct pci_dev *pci_dev)
443 {
444         pci_update_current_state(pci_dev, PCI_UNKNOWN);
445
446         if (pci_dev->current_state != PCI_D0) {
447                 int error = pci_set_power_state(pci_dev, PCI_D0);
448                 if (error)
449                         return error;
450         }
451
452         return pci_restore_state(pci_dev);
453 }
454
455 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
456 {
457         pci_restore_standard_config(pci_dev);
458         pci_fixup_device(pci_fixup_resume_early, pci_dev);
459 }
460
461 #endif
462
463 #ifdef CONFIG_PM_SLEEP
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  */
469 static 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  */
483 static 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
499 static 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
526 static 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
557 static 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
566 static 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
579 static 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
587 static 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
594 static 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_ON(ret && drv->driver.pm);
606
607         return ret;
608 }
609
610 /* New power management framework */
611
612 static int pci_pm_prepare(struct device *dev)
613 {
614         struct device_driver *drv = dev->driver;
615         int error = 0;
616
617         /*
618          * PCI devices suspended at run time need to be resumed at this
619          * point, because in general it is necessary to reconfigure them for
620          * system suspend.  Namely, if the device is supposed to wake up the
621          * system from the sleep state, we may need to reconfigure it for this
622          * purpose.  In turn, if the device is not supposed to wake up the
623          * system from the sleep state, we'll have to prevent it from signaling
624          * wake-up.
625          */
626         pm_runtime_resume(dev);
627
628         if (drv && drv->pm && drv->pm->prepare)
629                 error = drv->pm->prepare(dev);
630
631         return error;
632 }
633
634 static void pci_pm_complete(struct device *dev)
635 {
636         struct device_driver *drv = dev->driver;
637
638         if (drv && drv->pm && drv->pm->complete)
639                 drv->pm->complete(dev);
640 }
641
642 #else /* !CONFIG_PM_SLEEP */
643
644 #define pci_pm_prepare  NULL
645 #define pci_pm_complete NULL
646
647 #endif /* !CONFIG_PM_SLEEP */
648
649 #ifdef CONFIG_SUSPEND
650
651 static int pci_pm_suspend(struct device *dev)
652 {
653         struct pci_dev *pci_dev = to_pci_dev(dev);
654         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
655
656         if (pci_has_legacy_pm_support(pci_dev))
657                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
658
659         if (!pm) {
660                 pci_pm_default_suspend(pci_dev);
661                 goto Fixup;
662         }
663
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
687 static 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         return 0;
727 }
728
729 static int pci_pm_resume_noirq(struct device *dev)
730 {
731         struct pci_dev *pci_dev = to_pci_dev(dev);
732         struct device_driver *drv = dev->driver;
733         int error = 0;
734
735         pci_pm_default_resume_early(pci_dev);
736
737         if (pci_has_legacy_pm_support(pci_dev))
738                 return pci_legacy_resume_early(dev);
739
740         if (drv && drv->pm && drv->pm->resume_noirq)
741                 error = drv->pm->resume_noirq(dev);
742
743         return error;
744 }
745
746 static int pci_pm_resume(struct device *dev)
747 {
748         struct pci_dev *pci_dev = to_pci_dev(dev);
749         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
750         int error = 0;
751
752         /*
753          * This is necessary for the suspend error path in which resume is
754          * called without restoring the standard config registers of the device.
755          */
756         if (pci_dev->state_saved)
757                 pci_restore_standard_config(pci_dev);
758
759         if (pci_has_legacy_pm_support(pci_dev))
760                 return pci_legacy_resume(dev);
761
762         pci_pm_default_resume(pci_dev);
763
764         if (pm) {
765                 if (pm->resume)
766                         error = pm->resume(dev);
767         } else {
768                 pci_pm_reenable_device(pci_dev);
769         }
770
771         return error;
772 }
773
774 #else /* !CONFIG_SUSPEND */
775
776 #define pci_pm_suspend          NULL
777 #define pci_pm_suspend_noirq    NULL
778 #define pci_pm_resume           NULL
779 #define pci_pm_resume_noirq     NULL
780
781 #endif /* !CONFIG_SUSPEND */
782
783 #ifdef CONFIG_HIBERNATION
784
785 static int pci_pm_freeze(struct device *dev)
786 {
787         struct pci_dev *pci_dev = to_pci_dev(dev);
788         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
789
790         if (pci_has_legacy_pm_support(pci_dev))
791                 return pci_legacy_suspend(dev, PMSG_FREEZE);
792
793         if (!pm) {
794                 pci_pm_default_suspend(pci_dev);
795                 return 0;
796         }
797
798         if (pm->freeze) {
799                 int error;
800
801                 error = pm->freeze(dev);
802                 suspend_report_result(pm->freeze, error);
803                 if (error)
804                         return error;
805         }
806
807         return 0;
808 }
809
810 static int pci_pm_freeze_noirq(struct device *dev)
811 {
812         struct pci_dev *pci_dev = to_pci_dev(dev);
813         struct device_driver *drv = dev->driver;
814
815         if (pci_has_legacy_pm_support(pci_dev))
816                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
817
818         if (drv && drv->pm && drv->pm->freeze_noirq) {
819                 int error;
820
821                 error = drv->pm->freeze_noirq(dev);
822                 suspend_report_result(drv->pm->freeze_noirq, error);
823                 if (error)
824                         return error;
825         }
826
827         if (!pci_dev->state_saved)
828                 pci_save_state(pci_dev);
829
830         pci_pm_set_unknown_state(pci_dev);
831
832         return 0;
833 }
834
835 static int pci_pm_thaw_noirq(struct device *dev)
836 {
837         struct pci_dev *pci_dev = to_pci_dev(dev);
838         struct device_driver *drv = dev->driver;
839         int error = 0;
840
841         if (pci_has_legacy_pm_support(pci_dev))
842                 return pci_legacy_resume_early(dev);
843
844         pci_update_current_state(pci_dev, PCI_D0);
845
846         if (drv && drv->pm && drv->pm->thaw_noirq)
847                 error = drv->pm->thaw_noirq(dev);
848
849         return error;
850 }
851
852 static int pci_pm_thaw(struct device *dev)
853 {
854         struct pci_dev *pci_dev = to_pci_dev(dev);
855         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
856         int error = 0;
857
858         if (pci_has_legacy_pm_support(pci_dev))
859                 return pci_legacy_resume(dev);
860
861         if (pm) {
862                 if (pm->thaw)
863                         error = pm->thaw(dev);
864         } else {
865                 pci_pm_reenable_device(pci_dev);
866         }
867
868         pci_dev->state_saved = false;
869
870         return error;
871 }
872
873 static int pci_pm_poweroff(struct device *dev)
874 {
875         struct pci_dev *pci_dev = to_pci_dev(dev);
876         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
877
878         if (pci_has_legacy_pm_support(pci_dev))
879                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
880
881         if (!pm) {
882                 pci_pm_default_suspend(pci_dev);
883                 goto Fixup;
884         }
885
886         if (pm->poweroff) {
887                 int error;
888
889                 error = pm->poweroff(dev);
890                 suspend_report_result(pm->poweroff, error);
891                 if (error)
892                         return error;
893         }
894
895  Fixup:
896         pci_fixup_device(pci_fixup_suspend, pci_dev);
897
898         return 0;
899 }
900
901 static int pci_pm_poweroff_noirq(struct device *dev)
902 {
903         struct pci_dev *pci_dev = to_pci_dev(dev);
904         struct device_driver *drv = dev->driver;
905
906         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
907                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
908
909         if (!drv || !drv->pm)
910                 return 0;
911
912         if (drv->pm->poweroff_noirq) {
913                 int error;
914
915                 error = drv->pm->poweroff_noirq(dev);
916                 suspend_report_result(drv->pm->poweroff_noirq, error);
917                 if (error)
918                         return error;
919         }
920
921         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
922                 pci_prepare_to_sleep(pci_dev);
923
924         return 0;
925 }
926
927 static int pci_pm_restore_noirq(struct device *dev)
928 {
929         struct pci_dev *pci_dev = to_pci_dev(dev);
930         struct device_driver *drv = dev->driver;
931         int error = 0;
932
933         pci_pm_default_resume_early(pci_dev);
934
935         if (pci_has_legacy_pm_support(pci_dev))
936                 return pci_legacy_resume_early(dev);
937
938         if (drv && drv->pm && drv->pm->restore_noirq)
939                 error = drv->pm->restore_noirq(dev);
940
941         return error;
942 }
943
944 static int pci_pm_restore(struct device *dev)
945 {
946         struct pci_dev *pci_dev = to_pci_dev(dev);
947         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
948         int error = 0;
949
950         /*
951          * This is necessary for the hibernation error path in which restore is
952          * called without restoring the standard config registers of the device.
953          */
954         if (pci_dev->state_saved)
955                 pci_restore_standard_config(pci_dev);
956
957         if (pci_has_legacy_pm_support(pci_dev))
958                 return pci_legacy_resume(dev);
959
960         pci_pm_default_resume(pci_dev);
961
962         if (pm) {
963                 if (pm->restore)
964                         error = pm->restore(dev);
965         } else {
966                 pci_pm_reenable_device(pci_dev);
967         }
968
969         return error;
970 }
971
972 #else /* !CONFIG_HIBERNATION */
973
974 #define pci_pm_freeze           NULL
975 #define pci_pm_freeze_noirq     NULL
976 #define pci_pm_thaw             NULL
977 #define pci_pm_thaw_noirq       NULL
978 #define pci_pm_poweroff         NULL
979 #define pci_pm_poweroff_noirq   NULL
980 #define pci_pm_restore          NULL
981 #define pci_pm_restore_noirq    NULL
982
983 #endif /* !CONFIG_HIBERNATION */
984
985 #ifdef CONFIG_PM_RUNTIME
986
987 static int pci_pm_runtime_suspend(struct device *dev)
988 {
989         struct pci_dev *pci_dev = to_pci_dev(dev);
990         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
991         pci_power_t prev = pci_dev->current_state;
992         int error;
993
994         if (!pm || !pm->runtime_suspend)
995                 return -ENOSYS;
996
997         error = pm->runtime_suspend(dev);
998         suspend_report_result(pm->runtime_suspend, error);
999         if (error)
1000                 return error;
1001
1002         pci_fixup_device(pci_fixup_suspend, pci_dev);
1003
1004         if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1005             && pci_dev->current_state != PCI_UNKNOWN) {
1006                 WARN_ONCE(pci_dev->current_state != prev,
1007                         "PCI PM: State of device not saved by %pF\n",
1008                         pm->runtime_suspend);
1009                 return 0;
1010         }
1011
1012         if (!pci_dev->state_saved)
1013                 pci_save_state(pci_dev);
1014
1015         pci_finish_runtime_suspend(pci_dev);
1016
1017         return 0;
1018 }
1019
1020 static int pci_pm_runtime_resume(struct device *dev)
1021 {
1022         struct pci_dev *pci_dev = to_pci_dev(dev);
1023         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1024
1025         if (!pm || !pm->runtime_resume)
1026                 return -ENOSYS;
1027
1028         pci_pm_default_resume_early(pci_dev);
1029         __pci_enable_wake(pci_dev, PCI_D0, true, false);
1030         pci_fixup_device(pci_fixup_resume, pci_dev);
1031
1032         return pm->runtime_resume(dev);
1033 }
1034
1035 static int pci_pm_runtime_idle(struct device *dev)
1036 {
1037         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1038
1039         if (!pm)
1040                 return -ENOSYS;
1041
1042         if (pm->runtime_idle) {
1043                 int ret = pm->runtime_idle(dev);
1044                 if (ret)
1045                         return ret;
1046         }
1047
1048         pm_runtime_suspend(dev);
1049
1050         return 0;
1051 }
1052
1053 #else /* !CONFIG_PM_RUNTIME */
1054
1055 #define pci_pm_runtime_suspend  NULL
1056 #define pci_pm_runtime_resume   NULL
1057 #define pci_pm_runtime_idle     NULL
1058
1059 #endif /* !CONFIG_PM_RUNTIME */
1060
1061 #ifdef CONFIG_PM_OPS
1062
1063 const struct dev_pm_ops pci_dev_pm_ops = {
1064         .prepare = pci_pm_prepare,
1065         .complete = pci_pm_complete,
1066         .suspend = pci_pm_suspend,
1067         .resume = pci_pm_resume,
1068         .freeze = pci_pm_freeze,
1069         .thaw = pci_pm_thaw,
1070         .poweroff = pci_pm_poweroff,
1071         .restore = pci_pm_restore,
1072         .suspend_noirq = pci_pm_suspend_noirq,
1073         .resume_noirq = pci_pm_resume_noirq,
1074         .freeze_noirq = pci_pm_freeze_noirq,
1075         .thaw_noirq = pci_pm_thaw_noirq,
1076         .poweroff_noirq = pci_pm_poweroff_noirq,
1077         .restore_noirq = pci_pm_restore_noirq,
1078         .runtime_suspend = pci_pm_runtime_suspend,
1079         .runtime_resume = pci_pm_runtime_resume,
1080         .runtime_idle = pci_pm_runtime_idle,
1081 };
1082
1083 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
1084
1085 #else /* !COMFIG_PM_OPS */
1086
1087 #define PCI_PM_OPS_PTR  NULL
1088
1089 #endif /* !COMFIG_PM_OPS */
1090
1091 /**
1092  * __pci_register_driver - register a new pci driver
1093  * @drv: the driver structure to register
1094  * @owner: owner module of drv
1095  * @mod_name: module name string
1096  * 
1097  * Adds the driver structure to the list of registered drivers.
1098  * Returns a negative value on error, otherwise 0. 
1099  * If no error occurred, the driver remains registered even if 
1100  * no device was claimed during registration.
1101  */
1102 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1103                           const char *mod_name)
1104 {
1105         int error;
1106
1107         /* initialize common driver fields */
1108         drv->driver.name = drv->name;
1109         drv->driver.bus = &pci_bus_type;
1110         drv->driver.owner = owner;
1111         drv->driver.mod_name = mod_name;
1112
1113         spin_lock_init(&drv->dynids.lock);
1114         INIT_LIST_HEAD(&drv->dynids.list);
1115
1116         /* register with core */
1117         error = driver_register(&drv->driver);
1118         if (error)
1119                 goto out;
1120
1121         error = pci_create_newid_file(drv);
1122         if (error)
1123                 goto out_newid;
1124
1125         error = pci_create_removeid_file(drv);
1126         if (error)
1127                 goto out_removeid;
1128 out:
1129         return error;
1130
1131 out_removeid:
1132         pci_remove_newid_file(drv);
1133 out_newid:
1134         driver_unregister(&drv->driver);
1135         goto out;
1136 }
1137
1138 /**
1139  * pci_unregister_driver - unregister a pci driver
1140  * @drv: the driver structure to unregister
1141  * 
1142  * Deletes the driver structure from the list of registered PCI drivers,
1143  * gives it a chance to clean up by calling its remove() function for
1144  * each device it was responsible for, and marks those devices as
1145  * driverless.
1146  */
1147
1148 void
1149 pci_unregister_driver(struct pci_driver *drv)
1150 {
1151         pci_remove_removeid_file(drv);
1152         pci_remove_newid_file(drv);
1153         driver_unregister(&drv->driver);
1154         pci_free_dynids(drv);
1155 }
1156
1157 static struct pci_driver pci_compat_driver = {
1158         .name = "compat"
1159 };
1160
1161 /**
1162  * pci_dev_driver - get the pci_driver of a device
1163  * @dev: the device to query
1164  *
1165  * Returns the appropriate pci_driver structure or %NULL if there is no 
1166  * registered driver for the device.
1167  */
1168 struct pci_driver *
1169 pci_dev_driver(const struct pci_dev *dev)
1170 {
1171         if (dev->driver)
1172                 return dev->driver;
1173         else {
1174                 int i;
1175                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1176                         if (dev->resource[i].flags & IORESOURCE_BUSY)
1177                                 return &pci_compat_driver;
1178         }
1179         return NULL;
1180 }
1181
1182 /**
1183  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1184  * @dev: the PCI device structure to match against
1185  * @drv: the device driver to search for matching PCI device id structures
1186  * 
1187  * Used by a driver to check whether a PCI device present in the
1188  * system is in its list of supported devices. Returns the matching
1189  * pci_device_id structure or %NULL if there is no match.
1190  */
1191 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1192 {
1193         struct pci_dev *pci_dev = to_pci_dev(dev);
1194         struct pci_driver *pci_drv = to_pci_driver(drv);
1195         const struct pci_device_id *found_id;
1196
1197         found_id = pci_match_device(pci_drv, pci_dev);
1198         if (found_id)
1199                 return 1;
1200
1201         return 0;
1202 }
1203
1204 /**
1205  * pci_dev_get - increments the reference count of the pci device structure
1206  * @dev: the device being referenced
1207  *
1208  * Each live reference to a device should be refcounted.
1209  *
1210  * Drivers for PCI devices should normally record such references in
1211  * their probe() methods, when they bind to a device, and release
1212  * them by calling pci_dev_put(), in their disconnect() methods.
1213  *
1214  * A pointer to the device with the incremented reference counter is returned.
1215  */
1216 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1217 {
1218         if (dev)
1219                 get_device(&dev->dev);
1220         return dev;
1221 }
1222
1223 /**
1224  * pci_dev_put - release a use of the pci device structure
1225  * @dev: device that's been disconnected
1226  *
1227  * Must be called when a user of a device is finished with it.  When the last
1228  * user of the device calls this function, the memory of the device is freed.
1229  */
1230 void pci_dev_put(struct pci_dev *dev)
1231 {
1232         if (dev)
1233                 put_device(&dev->dev);
1234 }
1235
1236 #ifndef CONFIG_HOTPLUG
1237 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1238 {
1239         return -ENODEV;
1240 }
1241 #endif
1242
1243 struct bus_type pci_bus_type = {
1244         .name           = "pci",
1245         .match          = pci_bus_match,
1246         .uevent         = pci_uevent,
1247         .probe          = pci_device_probe,
1248         .remove         = pci_device_remove,
1249         .shutdown       = pci_device_shutdown,
1250         .dev_attrs      = pci_dev_attrs,
1251         .bus_attrs      = pci_bus_attrs,
1252         .pm             = PCI_PM_OPS_PTR,
1253 };
1254
1255 static int __init pci_driver_init(void)
1256 {
1257         return bus_register(&pci_bus_type);
1258 }
1259
1260 postcore_initcall(pci_driver_init);
1261
1262 EXPORT_SYMBOL_GPL(pci_add_dynid);
1263 EXPORT_SYMBOL(pci_match_id);
1264 EXPORT_SYMBOL(__pci_register_driver);
1265 EXPORT_SYMBOL(pci_unregister_driver);
1266 EXPORT_SYMBOL(pci_dev_driver);
1267 EXPORT_SYMBOL(pci_bus_type);
1268 EXPORT_SYMBOL(pci_dev_get);
1269 EXPORT_SYMBOL(pci_dev_put);