16240390bcde2070de75c8162c4bd52666d07686
[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 "pci.h"
21
22 /*
23  * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
24  */
25
26 struct pci_dynid {
27         struct list_head node;
28         struct pci_device_id id;
29 };
30
31 #ifdef CONFIG_HOTPLUG
32
33 /**
34  * store_new_id - add a new PCI device ID to this driver and re-probe devices
35  * @driver: target device driver
36  * @buf: buffer for scanning device ID data
37  * @count: input size
38  *
39  * Adds a new dynamic pci device ID to this driver,
40  * and causes the driver to probe for all devices again.
41  */
42 static ssize_t
43 store_new_id(struct device_driver *driver, const char *buf, size_t count)
44 {
45         struct pci_dynid *dynid;
46         struct pci_driver *pdrv = to_pci_driver(driver);
47         const struct pci_device_id *ids = pdrv->id_table;
48         __u32 vendor, device, subvendor=PCI_ANY_ID,
49                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
50         unsigned long driver_data=0;
51         int fields=0;
52         int retval=0;
53
54         fields = sscanf(buf, "%x %x %x %x %x %x %lx",
55                         &vendor, &device, &subvendor, &subdevice,
56                         &class, &class_mask, &driver_data);
57         if (fields < 2)
58                 return -EINVAL;
59
60         /* Only accept driver_data values that match an existing id_table
61            entry */
62         if (ids) {
63                 retval = -EINVAL;
64                 while (ids->vendor || ids->subvendor || ids->class_mask) {
65                         if (driver_data == ids->driver_data) {
66                                 retval = 0;
67                                 break;
68                         }
69                         ids++;
70                 }
71                 if (retval)     /* No match */
72                         return retval;
73         }
74
75         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
76         if (!dynid)
77                 return -ENOMEM;
78
79         dynid->id.vendor = vendor;
80         dynid->id.device = device;
81         dynid->id.subvendor = subvendor;
82         dynid->id.subdevice = subdevice;
83         dynid->id.class = class;
84         dynid->id.class_mask = class_mask;
85         dynid->id.driver_data = driver_data;
86
87         spin_lock(&pdrv->dynids.lock);
88         list_add_tail(&dynid->node, &pdrv->dynids.list);
89         spin_unlock(&pdrv->dynids.lock);
90
91         if (get_driver(&pdrv->driver)) {
92                 retval = driver_attach(&pdrv->driver);
93                 put_driver(&pdrv->driver);
94         }
95
96         if (retval)
97                 return retval;
98         return count;
99 }
100 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
101
102 static void
103 pci_free_dynids(struct pci_driver *drv)
104 {
105         struct pci_dynid *dynid, *n;
106
107         spin_lock(&drv->dynids.lock);
108         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
109                 list_del(&dynid->node);
110                 kfree(dynid);
111         }
112         spin_unlock(&drv->dynids.lock);
113 }
114
115 static int
116 pci_create_newid_file(struct pci_driver *drv)
117 {
118         int error = 0;
119         if (drv->probe != NULL)
120                 error = driver_create_file(&drv->driver, &driver_attr_new_id);
121         return error;
122 }
123
124 static void pci_remove_newid_file(struct pci_driver *drv)
125 {
126         driver_remove_file(&drv->driver, &driver_attr_new_id);
127 }
128 #else /* !CONFIG_HOTPLUG */
129 static inline void pci_free_dynids(struct pci_driver *drv) {}
130 static inline int pci_create_newid_file(struct pci_driver *drv)
131 {
132         return 0;
133 }
134 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
135 #endif
136
137 /**
138  * pci_match_id - See if a pci device matches a given pci_id table
139  * @ids: array of PCI device id structures to search in
140  * @dev: the PCI device structure to match against.
141  *
142  * Used by a driver to check whether a PCI device present in the
143  * system is in its list of supported devices.  Returns the matching
144  * pci_device_id structure or %NULL if there is no match.
145  *
146  * Deprecated, don't use this as it will not catch any dynamic ids
147  * that a driver might want to check for.
148  */
149 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
150                                          struct pci_dev *dev)
151 {
152         if (ids) {
153                 while (ids->vendor || ids->subvendor || ids->class_mask) {
154                         if (pci_match_one_device(ids, dev))
155                                 return ids;
156                         ids++;
157                 }
158         }
159         return NULL;
160 }
161
162 /**
163  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
164  * @drv: the PCI driver to match against
165  * @dev: the PCI device structure to match against
166  *
167  * Used by a driver to check whether a PCI device present in the
168  * system is in its list of supported devices.  Returns the matching
169  * pci_device_id structure or %NULL if there is no match.
170  */
171 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
172                                                     struct pci_dev *dev)
173 {
174         struct pci_dynid *dynid;
175
176         /* Look at the dynamic ids first, before the static ones */
177         spin_lock(&drv->dynids.lock);
178         list_for_each_entry(dynid, &drv->dynids.list, node) {
179                 if (pci_match_one_device(&dynid->id, dev)) {
180                         spin_unlock(&drv->dynids.lock);
181                         return &dynid->id;
182                 }
183         }
184         spin_unlock(&drv->dynids.lock);
185
186         return pci_match_id(drv->id_table, dev);
187 }
188
189 struct drv_dev_and_id {
190         struct pci_driver *drv;
191         struct pci_dev *dev;
192         const struct pci_device_id *id;
193 };
194
195 static long local_pci_probe(void *_ddi)
196 {
197         struct drv_dev_and_id *ddi = _ddi;
198
199         return ddi->drv->probe(ddi->dev, ddi->id);
200 }
201
202 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
203                           const struct pci_device_id *id)
204 {
205         int error, node;
206         struct drv_dev_and_id ddi = { drv, dev, id };
207
208         /* Execute driver initialization on node where the device's
209            bus is attached to.  This way the driver likely allocates
210            its local memory on the right node without any need to
211            change it. */
212         node = dev_to_node(&dev->dev);
213         if (node >= 0) {
214                 int cpu;
215
216                 get_online_cpus();
217                 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
218                 if (cpu < nr_cpu_ids)
219                         error = work_on_cpu(cpu, local_pci_probe, &ddi);
220                 else
221                         error = local_pci_probe(&ddi);
222                 put_online_cpus();
223         } else
224                 error = local_pci_probe(&ddi);
225         return error;
226 }
227
228 /**
229  * __pci_device_probe()
230  * @drv: driver to call to check if it wants the PCI device
231  * @pci_dev: PCI device being probed
232  * 
233  * returns 0 on success, else error.
234  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
235  */
236 static int
237 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
238 {
239         const struct pci_device_id *id;
240         int error = 0;
241
242         if (!pci_dev->driver && drv->probe) {
243                 error = -ENODEV;
244
245                 id = pci_match_device(drv, pci_dev);
246                 if (id)
247                         error = pci_call_probe(drv, pci_dev, id);
248                 if (error >= 0) {
249                         pci_dev->driver = drv;
250                         error = 0;
251                 }
252         }
253         return error;
254 }
255
256 static int pci_device_probe(struct device * dev)
257 {
258         int error = 0;
259         struct pci_driver *drv;
260         struct pci_dev *pci_dev;
261
262         drv = to_pci_driver(dev->driver);
263         pci_dev = to_pci_dev(dev);
264         pci_dev_get(pci_dev);
265         error = __pci_device_probe(drv, pci_dev);
266         if (error)
267                 pci_dev_put(pci_dev);
268
269         return error;
270 }
271
272 static int pci_device_remove(struct device * dev)
273 {
274         struct pci_dev * pci_dev = to_pci_dev(dev);
275         struct pci_driver * drv = pci_dev->driver;
276
277         if (drv) {
278                 if (drv->remove)
279                         drv->remove(pci_dev);
280                 pci_dev->driver = NULL;
281         }
282
283         /*
284          * If the device is still on, set the power state as "unknown",
285          * since it might change by the next time we load the driver.
286          */
287         if (pci_dev->current_state == PCI_D0)
288                 pci_dev->current_state = PCI_UNKNOWN;
289
290         /*
291          * We would love to complain here if pci_dev->is_enabled is set, that
292          * the driver should have called pci_disable_device(), but the
293          * unfortunate fact is there are too many odd BIOS and bridge setups
294          * that don't like drivers doing that all of the time.  
295          * Oh well, we can dream of sane hardware when we sleep, no matter how
296          * horrible the crap we have to deal with is when we are awake...
297          */
298
299         pci_dev_put(pci_dev);
300         return 0;
301 }
302
303 static void pci_device_shutdown(struct device *dev)
304 {
305         struct pci_dev *pci_dev = to_pci_dev(dev);
306         struct pci_driver *drv = pci_dev->driver;
307
308         if (drv && drv->shutdown)
309                 drv->shutdown(pci_dev);
310         pci_msi_shutdown(pci_dev);
311         pci_msix_shutdown(pci_dev);
312 }
313
314 #ifdef CONFIG_PM_SLEEP
315
316 /*
317  * Default "suspend" method for devices that have no driver provided suspend,
318  * or not even a driver at all (second part).
319  */
320 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
321 {
322         /*
323          * mark its power state as "unknown", since we don't know if
324          * e.g. the BIOS will change its device state when we suspend.
325          */
326         if (pci_dev->current_state == PCI_D0)
327                 pci_dev->current_state = PCI_UNKNOWN;
328 }
329
330 /*
331  * Default "resume" method for devices that have no driver provided resume,
332  * or not even a driver at all (second part).
333  */
334 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
335 {
336         int retval;
337
338         /* if the device was enabled before suspend, reenable */
339         retval = pci_reenable_device(pci_dev);
340         /*
341          * if the device was busmaster before the suspend, make it busmaster
342          * again
343          */
344         if (pci_dev->is_busmaster)
345                 pci_set_master(pci_dev);
346
347         return retval;
348 }
349
350 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
351 {
352         struct pci_dev * pci_dev = to_pci_dev(dev);
353         struct pci_driver * drv = pci_dev->driver;
354
355         pci_dev->state_saved = false;
356
357         if (drv && drv->suspend) {
358                 pci_power_t prev = pci_dev->current_state;
359                 int error;
360
361                 error = drv->suspend(pci_dev, state);
362                 suspend_report_result(drv->suspend, error);
363                 if (error)
364                         return error;
365
366                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
367                     && pci_dev->current_state != PCI_UNKNOWN) {
368                         WARN_ONCE(pci_dev->current_state != prev,
369                                 "PCI PM: Device state not saved by %pF\n",
370                                 drv->suspend);
371                 }
372         }
373
374         pci_fixup_device(pci_fixup_suspend, pci_dev);
375
376         return 0;
377 }
378
379 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
380 {
381         struct pci_dev * pci_dev = to_pci_dev(dev);
382         struct pci_driver * drv = pci_dev->driver;
383
384         if (drv && drv->suspend_late) {
385                 pci_power_t prev = pci_dev->current_state;
386                 int error;
387
388                 error = drv->suspend_late(pci_dev, state);
389                 suspend_report_result(drv->suspend_late, error);
390                 if (error)
391                         return error;
392
393                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
394                     && pci_dev->current_state != PCI_UNKNOWN) {
395                         WARN_ONCE(pci_dev->current_state != prev,
396                                 "PCI PM: Device state not saved by %pF\n",
397                                 drv->suspend_late);
398                         return 0;
399                 }
400         }
401
402         if (!pci_dev->state_saved)
403                 pci_save_state(pci_dev);
404
405         pci_pm_set_unknown_state(pci_dev);
406
407         return 0;
408 }
409
410 static int pci_legacy_resume_early(struct device *dev)
411 {
412         struct pci_dev * pci_dev = to_pci_dev(dev);
413         struct pci_driver * drv = pci_dev->driver;
414
415         return drv && drv->resume_early ?
416                         drv->resume_early(pci_dev) : 0;
417 }
418
419 static int pci_legacy_resume(struct device *dev)
420 {
421         struct pci_dev * pci_dev = to_pci_dev(dev);
422         struct pci_driver * drv = pci_dev->driver;
423
424         pci_fixup_device(pci_fixup_resume, pci_dev);
425
426         return drv && drv->resume ?
427                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
428 }
429
430 /* Auxiliary functions used by the new power management framework */
431
432 /**
433  * pci_restore_standard_config - restore standard config registers of PCI device
434  * @pci_dev: PCI device to handle
435  */
436 static int pci_restore_standard_config(struct pci_dev *pci_dev)
437 {
438         pci_update_current_state(pci_dev, PCI_UNKNOWN);
439
440         if (pci_dev->current_state != PCI_D0) {
441                 int error = pci_set_power_state(pci_dev, PCI_D0);
442                 if (error)
443                         return error;
444         }
445
446         return pci_dev->state_saved ? pci_restore_state(pci_dev) : 0;
447 }
448
449 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
450 {
451         pci_restore_standard_config(pci_dev);
452         pci_dev->state_saved = false;
453         pci_fixup_device(pci_fixup_resume_early, pci_dev);
454 }
455
456 static void pci_pm_default_resume(struct pci_dev *pci_dev)
457 {
458         pci_fixup_device(pci_fixup_resume, pci_dev);
459
460         if (!pci_is_bridge(pci_dev))
461                 pci_enable_wake(pci_dev, PCI_D0, false);
462 }
463
464 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
465 {
466         /* Disable non-bridge devices without PM support */
467         if (!pci_is_bridge(pci_dev))
468                 pci_disable_enabled_device(pci_dev);
469 }
470
471 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
472 {
473         struct pci_driver *drv = pci_dev->driver;
474         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
475                 || drv->resume_early);
476
477         /*
478          * Legacy PM support is used by default, so warn if the new framework is
479          * supported as well.  Drivers are supposed to support either the
480          * former, or the latter, but not both at the same time.
481          */
482         WARN_ON(ret && drv->driver.pm);
483
484         return ret;
485 }
486
487 /* New power management framework */
488
489 static int pci_pm_prepare(struct device *dev)
490 {
491         struct device_driver *drv = dev->driver;
492         int error = 0;
493
494         if (drv && drv->pm && drv->pm->prepare)
495                 error = drv->pm->prepare(dev);
496
497         return error;
498 }
499
500 static void pci_pm_complete(struct device *dev)
501 {
502         struct device_driver *drv = dev->driver;
503
504         if (drv && drv->pm && drv->pm->complete)
505                 drv->pm->complete(dev);
506 }
507
508 #ifdef CONFIG_SUSPEND
509
510 static int pci_pm_suspend(struct device *dev)
511 {
512         struct pci_dev *pci_dev = to_pci_dev(dev);
513         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
514
515         if (pci_has_legacy_pm_support(pci_dev))
516                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
517
518         pci_dev->state_saved = false;
519
520         if (!pm) {
521                 pci_pm_default_suspend(pci_dev);
522                 goto Fixup;
523         }
524
525         if (pm->suspend) {
526                 pci_power_t prev = pci_dev->current_state;
527                 int error;
528
529                 error = pm->suspend(dev);
530                 suspend_report_result(pm->suspend, error);
531                 if (error)
532                         return error;
533
534                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
535                     && pci_dev->current_state != PCI_UNKNOWN) {
536                         WARN_ONCE(pci_dev->current_state != prev,
537                                 "PCI PM: State of device not saved by %pF\n",
538                                 pm->suspend);
539                 }
540         }
541
542  Fixup:
543         pci_fixup_device(pci_fixup_suspend, pci_dev);
544
545         return 0;
546 }
547
548 static int pci_pm_suspend_noirq(struct device *dev)
549 {
550         struct pci_dev *pci_dev = to_pci_dev(dev);
551         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
552
553         if (pci_has_legacy_pm_support(pci_dev))
554                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
555
556         if (!pm) {
557                 pci_save_state(pci_dev);
558                 return 0;
559         }
560
561         if (pm->suspend_noirq) {
562                 pci_power_t prev = pci_dev->current_state;
563                 int error;
564
565                 error = pm->suspend_noirq(dev);
566                 suspend_report_result(pm->suspend_noirq, error);
567                 if (error)
568                         return error;
569
570                 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
571                     && pci_dev->current_state != PCI_UNKNOWN) {
572                         WARN_ONCE(pci_dev->current_state != prev,
573                                 "PCI PM: State of device not saved by %pF\n",
574                                 pm->suspend_noirq);
575                         return 0;
576                 }
577         }
578
579         if (!pci_dev->state_saved) {
580                 pci_save_state(pci_dev);
581                 if (!pci_is_bridge(pci_dev))
582                         pci_prepare_to_sleep(pci_dev);
583         }
584
585         pci_pm_set_unknown_state(pci_dev);
586
587         return 0;
588 }
589
590 static int pci_pm_resume_noirq(struct device *dev)
591 {
592         struct pci_dev *pci_dev = to_pci_dev(dev);
593         struct device_driver *drv = dev->driver;
594         int error = 0;
595
596         pci_pm_default_resume_noirq(pci_dev);
597
598         if (pci_has_legacy_pm_support(pci_dev))
599                 return pci_legacy_resume_early(dev);
600
601         if (drv && drv->pm && drv->pm->resume_noirq)
602                 error = drv->pm->resume_noirq(dev);
603
604         return error;
605 }
606
607 static int pci_pm_resume(struct device *dev)
608 {
609         struct pci_dev *pci_dev = to_pci_dev(dev);
610         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
611         int error = 0;
612
613         /*
614          * This is necessary for the suspend error path in which resume is
615          * called without restoring the standard config registers of the device.
616          */
617         if (pci_dev->state_saved)
618                 pci_restore_standard_config(pci_dev);
619
620         if (pci_has_legacy_pm_support(pci_dev))
621                 return pci_legacy_resume(dev);
622
623         pci_pm_default_resume(pci_dev);
624
625         if (pm) {
626                 if (pm->resume)
627                         error = pm->resume(dev);
628         } else {
629                 pci_pm_reenable_device(pci_dev);
630         }
631
632         return 0;
633 }
634
635 #else /* !CONFIG_SUSPEND */
636
637 #define pci_pm_suspend          NULL
638 #define pci_pm_suspend_noirq    NULL
639 #define pci_pm_resume           NULL
640 #define pci_pm_resume_noirq     NULL
641
642 #endif /* !CONFIG_SUSPEND */
643
644 #ifdef CONFIG_HIBERNATION
645
646 static int pci_pm_freeze(struct device *dev)
647 {
648         struct pci_dev *pci_dev = to_pci_dev(dev);
649         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
650
651         if (pci_has_legacy_pm_support(pci_dev))
652                 return pci_legacy_suspend(dev, PMSG_FREEZE);
653
654         pci_dev->state_saved = false;
655
656         if (!pm) {
657                 pci_pm_default_suspend(pci_dev);
658                 return 0;
659         }
660
661         if (pm->freeze) {
662                 int error;
663
664                 error = pm->freeze(dev);
665                 suspend_report_result(pm->freeze, error);
666                 if (error)
667                         return error;
668         }
669
670         return 0;
671 }
672
673 static int pci_pm_freeze_noirq(struct device *dev)
674 {
675         struct pci_dev *pci_dev = to_pci_dev(dev);
676         struct device_driver *drv = dev->driver;
677
678         if (pci_has_legacy_pm_support(pci_dev))
679                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
680
681         if (drv && drv->pm && drv->pm->freeze_noirq) {
682                 int error;
683
684                 error = drv->pm->freeze_noirq(dev);
685                 suspend_report_result(drv->pm->freeze_noirq, error);
686                 if (error)
687                         return error;
688         }
689
690         if (!pci_dev->state_saved)
691                 pci_save_state(pci_dev);
692
693         pci_pm_set_unknown_state(pci_dev);
694
695         return 0;
696 }
697
698 static int pci_pm_thaw_noirq(struct device *dev)
699 {
700         struct pci_dev *pci_dev = to_pci_dev(dev);
701         struct device_driver *drv = dev->driver;
702         int error = 0;
703
704         if (pci_has_legacy_pm_support(pci_dev))
705                 return pci_legacy_resume_early(dev);
706
707         pci_update_current_state(pci_dev, PCI_D0);
708
709         if (drv && drv->pm && drv->pm->thaw_noirq)
710                 error = drv->pm->thaw_noirq(dev);
711
712         return error;
713 }
714
715 static int pci_pm_thaw(struct device *dev)
716 {
717         struct pci_dev *pci_dev = to_pci_dev(dev);
718         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
719         int error = 0;
720
721         if (pci_has_legacy_pm_support(pci_dev))
722                 return pci_legacy_resume(dev);
723
724         if (pm) {
725                 if (pm->thaw)
726                         error = pm->thaw(dev);
727         } else {
728                 pci_pm_reenable_device(pci_dev);
729         }
730
731         return error;
732 }
733
734 static int pci_pm_poweroff(struct device *dev)
735 {
736         struct pci_dev *pci_dev = to_pci_dev(dev);
737         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
738
739         if (pci_has_legacy_pm_support(pci_dev))
740                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
741
742         pci_dev->state_saved = false;
743
744         if (!pm) {
745                 pci_pm_default_suspend(pci_dev);
746                 goto Fixup;
747         }
748
749         if (pm->poweroff) {
750                 int error;
751
752                 error = pm->poweroff(dev);
753                 suspend_report_result(pm->poweroff, error);
754                 if (error)
755                         return error;
756         }
757
758  Fixup:
759         pci_fixup_device(pci_fixup_suspend, pci_dev);
760
761         return 0;
762 }
763
764 static int pci_pm_poweroff_noirq(struct device *dev)
765 {
766         struct pci_dev *pci_dev = to_pci_dev(dev);
767         struct device_driver *drv = dev->driver;
768
769         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
770                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
771
772         if (!drv || !drv->pm)
773                 return 0;
774
775         if (drv->pm->poweroff_noirq) {
776                 int error;
777
778                 error = drv->pm->poweroff_noirq(dev);
779                 suspend_report_result(drv->pm->poweroff_noirq, error);
780                 if (error)
781                         return error;
782         }
783
784         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
785                 pci_prepare_to_sleep(pci_dev);
786
787         return 0;
788 }
789
790 static int pci_pm_restore_noirq(struct device *dev)
791 {
792         struct pci_dev *pci_dev = to_pci_dev(dev);
793         struct device_driver *drv = dev->driver;
794         int error = 0;
795
796         pci_pm_default_resume_noirq(pci_dev);
797
798         if (pci_has_legacy_pm_support(pci_dev))
799                 return pci_legacy_resume_early(dev);
800
801         if (drv && drv->pm && drv->pm->restore_noirq)
802                 error = drv->pm->restore_noirq(dev);
803
804         return error;
805 }
806
807 static int pci_pm_restore(struct device *dev)
808 {
809         struct pci_dev *pci_dev = to_pci_dev(dev);
810         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
811         int error = 0;
812
813         /*
814          * This is necessary for the hibernation error path in which restore is
815          * called without restoring the standard config registers of the device.
816          */
817         if (pci_dev->state_saved)
818                 pci_restore_standard_config(pci_dev);
819
820         if (pci_has_legacy_pm_support(pci_dev))
821                 return pci_legacy_resume(dev);
822
823         pci_pm_default_resume(pci_dev);
824
825         if (pm) {
826                 if (pm->restore)
827                         error = pm->restore(dev);
828         } else {
829                 pci_pm_reenable_device(pci_dev);
830         }
831
832         return error;
833 }
834
835 #else /* !CONFIG_HIBERNATION */
836
837 #define pci_pm_freeze           NULL
838 #define pci_pm_freeze_noirq     NULL
839 #define pci_pm_thaw             NULL
840 #define pci_pm_thaw_noirq       NULL
841 #define pci_pm_poweroff         NULL
842 #define pci_pm_poweroff_noirq   NULL
843 #define pci_pm_restore          NULL
844 #define pci_pm_restore_noirq    NULL
845
846 #endif /* !CONFIG_HIBERNATION */
847
848 struct dev_pm_ops pci_dev_pm_ops = {
849         .prepare = pci_pm_prepare,
850         .complete = pci_pm_complete,
851         .suspend = pci_pm_suspend,
852         .resume = pci_pm_resume,
853         .freeze = pci_pm_freeze,
854         .thaw = pci_pm_thaw,
855         .poweroff = pci_pm_poweroff,
856         .restore = pci_pm_restore,
857         .suspend_noirq = pci_pm_suspend_noirq,
858         .resume_noirq = pci_pm_resume_noirq,
859         .freeze_noirq = pci_pm_freeze_noirq,
860         .thaw_noirq = pci_pm_thaw_noirq,
861         .poweroff_noirq = pci_pm_poweroff_noirq,
862         .restore_noirq = pci_pm_restore_noirq,
863 };
864
865 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
866
867 #else /* !CONFIG_PM_SLEEP */
868
869 #define PCI_PM_OPS_PTR  NULL
870
871 #endif /* !CONFIG_PM_SLEEP */
872
873 /**
874  * __pci_register_driver - register a new pci driver
875  * @drv: the driver structure to register
876  * @owner: owner module of drv
877  * @mod_name: module name string
878  * 
879  * Adds the driver structure to the list of registered drivers.
880  * Returns a negative value on error, otherwise 0. 
881  * If no error occurred, the driver remains registered even if 
882  * no device was claimed during registration.
883  */
884 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
885                           const char *mod_name)
886 {
887         int error;
888
889         /* initialize common driver fields */
890         drv->driver.name = drv->name;
891         drv->driver.bus = &pci_bus_type;
892         drv->driver.owner = owner;
893         drv->driver.mod_name = mod_name;
894
895         spin_lock_init(&drv->dynids.lock);
896         INIT_LIST_HEAD(&drv->dynids.list);
897
898         /* register with core */
899         error = driver_register(&drv->driver);
900         if (error)
901                 return error;
902
903         error = pci_create_newid_file(drv);
904         if (error)
905                 driver_unregister(&drv->driver);
906
907         return error;
908 }
909
910 /**
911  * pci_unregister_driver - unregister a pci driver
912  * @drv: the driver structure to unregister
913  * 
914  * Deletes the driver structure from the list of registered PCI drivers,
915  * gives it a chance to clean up by calling its remove() function for
916  * each device it was responsible for, and marks those devices as
917  * driverless.
918  */
919
920 void
921 pci_unregister_driver(struct pci_driver *drv)
922 {
923         pci_remove_newid_file(drv);
924         driver_unregister(&drv->driver);
925         pci_free_dynids(drv);
926 }
927
928 static struct pci_driver pci_compat_driver = {
929         .name = "compat"
930 };
931
932 /**
933  * pci_dev_driver - get the pci_driver of a device
934  * @dev: the device to query
935  *
936  * Returns the appropriate pci_driver structure or %NULL if there is no 
937  * registered driver for the device.
938  */
939 struct pci_driver *
940 pci_dev_driver(const struct pci_dev *dev)
941 {
942         if (dev->driver)
943                 return dev->driver;
944         else {
945                 int i;
946                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
947                         if (dev->resource[i].flags & IORESOURCE_BUSY)
948                                 return &pci_compat_driver;
949         }
950         return NULL;
951 }
952
953 /**
954  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
955  * @dev: the PCI device structure to match against
956  * @drv: the device driver to search for matching PCI device id structures
957  * 
958  * Used by a driver to check whether a PCI device present in the
959  * system is in its list of supported devices. Returns the matching
960  * pci_device_id structure or %NULL if there is no match.
961  */
962 static int pci_bus_match(struct device *dev, struct device_driver *drv)
963 {
964         struct pci_dev *pci_dev = to_pci_dev(dev);
965         struct pci_driver *pci_drv = to_pci_driver(drv);
966         const struct pci_device_id *found_id;
967
968         found_id = pci_match_device(pci_drv, pci_dev);
969         if (found_id)
970                 return 1;
971
972         return 0;
973 }
974
975 /**
976  * pci_dev_get - increments the reference count of the pci device structure
977  * @dev: the device being referenced
978  *
979  * Each live reference to a device should be refcounted.
980  *
981  * Drivers for PCI devices should normally record such references in
982  * their probe() methods, when they bind to a device, and release
983  * them by calling pci_dev_put(), in their disconnect() methods.
984  *
985  * A pointer to the device with the incremented reference counter is returned.
986  */
987 struct pci_dev *pci_dev_get(struct pci_dev *dev)
988 {
989         if (dev)
990                 get_device(&dev->dev);
991         return dev;
992 }
993
994 /**
995  * pci_dev_put - release a use of the pci device structure
996  * @dev: device that's been disconnected
997  *
998  * Must be called when a user of a device is finished with it.  When the last
999  * user of the device calls this function, the memory of the device is freed.
1000  */
1001 void pci_dev_put(struct pci_dev *dev)
1002 {
1003         if (dev)
1004                 put_device(&dev->dev);
1005 }
1006
1007 #ifndef CONFIG_HOTPLUG
1008 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1009 {
1010         return -ENODEV;
1011 }
1012 #endif
1013
1014 struct bus_type pci_bus_type = {
1015         .name           = "pci",
1016         .match          = pci_bus_match,
1017         .uevent         = pci_uevent,
1018         .probe          = pci_device_probe,
1019         .remove         = pci_device_remove,
1020         .shutdown       = pci_device_shutdown,
1021         .dev_attrs      = pci_dev_attrs,
1022         .pm             = PCI_PM_OPS_PTR,
1023 };
1024
1025 static int __init pci_driver_init(void)
1026 {
1027         return bus_register(&pci_bus_type);
1028 }
1029
1030 postcore_initcall(pci_driver_init);
1031
1032 EXPORT_SYMBOL(pci_match_id);
1033 EXPORT_SYMBOL(__pci_register_driver);
1034 EXPORT_SYMBOL(pci_unregister_driver);
1035 EXPORT_SYMBOL(pci_dev_driver);
1036 EXPORT_SYMBOL(pci_bus_type);
1037 EXPORT_SYMBOL(pci_dev_get);
1038 EXPORT_SYMBOL(pci_dev_put);