Merge branch 'irq-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip...
[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                 node_to_cpumask_ptr(nodecpumask, node);
216
217                 get_online_cpus();
218                 cpu = cpumask_any_and(nodecpumask, cpu_online_mask);
219                 if (cpu < nr_cpu_ids)
220                         error = work_on_cpu(cpu, local_pci_probe, &ddi);
221                 else
222                         error = local_pci_probe(&ddi);
223                 put_online_cpus();
224         } else
225                 error = local_pci_probe(&ddi);
226         return error;
227 }
228
229 /**
230  * __pci_device_probe()
231  * @drv: driver to call to check if it wants the PCI device
232  * @pci_dev: PCI device being probed
233  * 
234  * returns 0 on success, else error.
235  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
236  */
237 static int
238 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
239 {
240         const struct pci_device_id *id;
241         int error = 0;
242
243         if (!pci_dev->driver && drv->probe) {
244                 error = -ENODEV;
245
246                 id = pci_match_device(drv, pci_dev);
247                 if (id)
248                         error = pci_call_probe(drv, pci_dev, id);
249                 if (error >= 0) {
250                         pci_dev->driver = drv;
251                         error = 0;
252                 }
253         }
254         return error;
255 }
256
257 static int pci_device_probe(struct device * dev)
258 {
259         int error = 0;
260         struct pci_driver *drv;
261         struct pci_dev *pci_dev;
262
263         drv = to_pci_driver(dev->driver);
264         pci_dev = to_pci_dev(dev);
265         pci_dev_get(pci_dev);
266         error = __pci_device_probe(drv, pci_dev);
267         if (error)
268                 pci_dev_put(pci_dev);
269
270         return error;
271 }
272
273 static int pci_device_remove(struct device * dev)
274 {
275         struct pci_dev * pci_dev = to_pci_dev(dev);
276         struct pci_driver * drv = pci_dev->driver;
277
278         if (drv) {
279                 if (drv->remove)
280                         drv->remove(pci_dev);
281                 pci_dev->driver = NULL;
282         }
283
284         /*
285          * If the device is still on, set the power state as "unknown",
286          * since it might change by the next time we load the driver.
287          */
288         if (pci_dev->current_state == PCI_D0)
289                 pci_dev->current_state = PCI_UNKNOWN;
290
291         /*
292          * We would love to complain here if pci_dev->is_enabled is set, that
293          * the driver should have called pci_disable_device(), but the
294          * unfortunate fact is there are too many odd BIOS and bridge setups
295          * that don't like drivers doing that all of the time.  
296          * Oh well, we can dream of sane hardware when we sleep, no matter how
297          * horrible the crap we have to deal with is when we are awake...
298          */
299
300         pci_dev_put(pci_dev);
301         return 0;
302 }
303
304 static void pci_device_shutdown(struct device *dev)
305 {
306         struct pci_dev *pci_dev = to_pci_dev(dev);
307         struct pci_driver *drv = pci_dev->driver;
308
309         if (drv && drv->shutdown)
310                 drv->shutdown(pci_dev);
311         pci_msi_shutdown(pci_dev);
312         pci_msix_shutdown(pci_dev);
313 }
314
315 #ifdef CONFIG_PM_SLEEP
316
317 /*
318  * Default "suspend" method for devices that have no driver provided suspend,
319  * or not even a driver at all (second part).
320  */
321 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
322 {
323         /*
324          * mark its power state as "unknown", since we don't know if
325          * e.g. the BIOS will change its device state when we suspend.
326          */
327         if (pci_dev->current_state == PCI_D0)
328                 pci_dev->current_state = PCI_UNKNOWN;
329 }
330
331 /*
332  * Default "resume" method for devices that have no driver provided resume,
333  * or not even a driver at all (second part).
334  */
335 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
336 {
337         int retval;
338
339         /* if the device was enabled before suspend, reenable */
340         retval = pci_reenable_device(pci_dev);
341         /*
342          * if the device was busmaster before the suspend, make it busmaster
343          * again
344          */
345         if (pci_dev->is_busmaster)
346                 pci_set_master(pci_dev);
347
348         return retval;
349 }
350
351 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
352 {
353         struct pci_dev * pci_dev = to_pci_dev(dev);
354         struct pci_driver * drv = pci_dev->driver;
355         int i = 0;
356
357         if (drv && drv->suspend) {
358                 pci_power_t prev = pci_dev->current_state;
359
360                 pci_dev->state_saved = false;
361
362                 i = drv->suspend(pci_dev, state);
363                 suspend_report_result(drv->suspend, i);
364                 if (i)
365                         return i;
366
367                 if (pci_dev->state_saved)
368                         goto Fixup;
369
370                 if (pci_dev->current_state != PCI_D0
371                     && pci_dev->current_state != PCI_UNKNOWN) {
372                         WARN_ONCE(pci_dev->current_state != prev,
373                                 "PCI PM: Device state not saved by %pF\n",
374                                 drv->suspend);
375                         goto Fixup;
376                 }
377         }
378
379         pci_save_state(pci_dev);
380         /*
381          * This is for compatibility with existing code with legacy PM support.
382          */
383         pci_pm_set_unknown_state(pci_dev);
384
385  Fixup:
386         pci_fixup_device(pci_fixup_suspend, pci_dev);
387
388         return i;
389 }
390
391 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
392 {
393         struct pci_dev * pci_dev = to_pci_dev(dev);
394         struct pci_driver * drv = pci_dev->driver;
395         int i = 0;
396
397         if (drv && drv->suspend_late) {
398                 i = drv->suspend_late(pci_dev, state);
399                 suspend_report_result(drv->suspend_late, i);
400         }
401         return i;
402 }
403
404 static int pci_legacy_resume_early(struct device *dev)
405 {
406         struct pci_dev * pci_dev = to_pci_dev(dev);
407         struct pci_driver * drv = pci_dev->driver;
408
409         return drv && drv->resume_early ?
410                         drv->resume_early(pci_dev) : 0;
411 }
412
413 static int pci_legacy_resume(struct device *dev)
414 {
415         struct pci_dev * pci_dev = to_pci_dev(dev);
416         struct pci_driver * drv = pci_dev->driver;
417
418         pci_fixup_device(pci_fixup_resume, pci_dev);
419
420         return drv && drv->resume ?
421                         drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
422 }
423
424 /* Auxiliary functions used by the new power management framework */
425
426 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
427 {
428         pci_restore_standard_config(pci_dev);
429         pci_dev->state_saved = false;
430         pci_fixup_device(pci_fixup_resume_early, pci_dev);
431 }
432
433 static void pci_pm_default_resume(struct pci_dev *pci_dev)
434 {
435         pci_fixup_device(pci_fixup_resume, pci_dev);
436
437         if (!pci_is_bridge(pci_dev))
438                 pci_enable_wake(pci_dev, PCI_D0, false);
439 }
440
441 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
442 {
443         /* Disable non-bridge devices without PM support */
444         if (!pci_is_bridge(pci_dev))
445                 pci_disable_enabled_device(pci_dev);
446         pci_save_state(pci_dev);
447 }
448
449 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
450 {
451         struct pci_driver *drv = pci_dev->driver;
452         bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
453                 || drv->resume_early);
454
455         /*
456          * Legacy PM support is used by default, so warn if the new framework is
457          * supported as well.  Drivers are supposed to support either the
458          * former, or the latter, but not both at the same time.
459          */
460         WARN_ON(ret && drv->driver.pm);
461
462         return ret;
463 }
464
465 /* New power management framework */
466
467 static int pci_pm_prepare(struct device *dev)
468 {
469         struct device_driver *drv = dev->driver;
470         int error = 0;
471
472         if (drv && drv->pm && drv->pm->prepare)
473                 error = drv->pm->prepare(dev);
474
475         return error;
476 }
477
478 static void pci_pm_complete(struct device *dev)
479 {
480         struct device_driver *drv = dev->driver;
481
482         if (drv && drv->pm && drv->pm->complete)
483                 drv->pm->complete(dev);
484 }
485
486 #ifdef CONFIG_SUSPEND
487
488 static int pci_pm_suspend(struct device *dev)
489 {
490         struct pci_dev *pci_dev = to_pci_dev(dev);
491         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
492
493         if (pci_has_legacy_pm_support(pci_dev))
494                 return pci_legacy_suspend(dev, PMSG_SUSPEND);
495
496         if (!pm) {
497                 pci_pm_default_suspend(pci_dev);
498                 goto Fixup;
499         }
500
501         pci_dev->state_saved = false;
502
503         if (pm->suspend) {
504                 pci_power_t prev = pci_dev->current_state;
505                 int error;
506
507                 error = pm->suspend(dev);
508                 suspend_report_result(pm->suspend, error);
509                 if (error)
510                         return error;
511
512                 if (pci_dev->state_saved)
513                         goto Fixup;
514
515                 if (pci_dev->current_state != PCI_D0
516                     && pci_dev->current_state != PCI_UNKNOWN) {
517                         WARN_ONCE(pci_dev->current_state != prev,
518                                 "PCI PM: State of device not saved by %pF\n",
519                                 pm->suspend);
520                         goto Fixup;
521                 }
522         }
523
524         if (!pci_dev->state_saved) {
525                 pci_save_state(pci_dev);
526                 if (!pci_is_bridge(pci_dev))
527                         pci_prepare_to_sleep(pci_dev);
528         }
529
530  Fixup:
531         pci_fixup_device(pci_fixup_suspend, pci_dev);
532
533         return 0;
534 }
535
536 static int pci_pm_suspend_noirq(struct device *dev)
537 {
538         struct pci_dev *pci_dev = to_pci_dev(dev);
539         struct device_driver *drv = dev->driver;
540         int error = 0;
541
542         if (pci_has_legacy_pm_support(pci_dev))
543                 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
544
545         if (drv && drv->pm && drv->pm->suspend_noirq) {
546                 error = drv->pm->suspend_noirq(dev);
547                 suspend_report_result(drv->pm->suspend_noirq, error);
548         }
549
550         if (!error)
551                 pci_pm_set_unknown_state(pci_dev);
552
553         return error;
554 }
555
556 static int pci_pm_resume_noirq(struct device *dev)
557 {
558         struct pci_dev *pci_dev = to_pci_dev(dev);
559         struct device_driver *drv = dev->driver;
560         int error = 0;
561
562         pci_pm_default_resume_noirq(pci_dev);
563
564         if (pci_has_legacy_pm_support(pci_dev))
565                 return pci_legacy_resume_early(dev);
566
567         if (drv && drv->pm && drv->pm->resume_noirq)
568                 error = drv->pm->resume_noirq(dev);
569
570         return error;
571 }
572
573 static int pci_pm_resume(struct device *dev)
574 {
575         struct pci_dev *pci_dev = to_pci_dev(dev);
576         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
577         int error = 0;
578
579         /*
580          * This is necessary for the suspend error path in which resume is
581          * called without restoring the standard config registers of the device.
582          */
583         if (pci_dev->state_saved)
584                 pci_restore_standard_config(pci_dev);
585
586         if (pci_has_legacy_pm_support(pci_dev))
587                 return pci_legacy_resume(dev);
588
589         pci_pm_default_resume(pci_dev);
590
591         if (pm) {
592                 if (pm->resume)
593                         error = pm->resume(dev);
594         } else {
595                 pci_pm_reenable_device(pci_dev);
596         }
597
598         return 0;
599 }
600
601 #else /* !CONFIG_SUSPEND */
602
603 #define pci_pm_suspend          NULL
604 #define pci_pm_suspend_noirq    NULL
605 #define pci_pm_resume           NULL
606 #define pci_pm_resume_noirq     NULL
607
608 #endif /* !CONFIG_SUSPEND */
609
610 #ifdef CONFIG_HIBERNATION
611
612 static int pci_pm_freeze(struct device *dev)
613 {
614         struct pci_dev *pci_dev = to_pci_dev(dev);
615         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
616
617         if (pci_has_legacy_pm_support(pci_dev))
618                 return pci_legacy_suspend(dev, PMSG_FREEZE);
619
620         if (!pm) {
621                 pci_pm_default_suspend(pci_dev);
622                 return 0;
623         }
624
625         pci_dev->state_saved = false;
626
627         if (pm->freeze) {
628                 int error;
629
630                 error = pm->freeze(dev);
631                 suspend_report_result(pm->freeze, error);
632                 if (error)
633                         return error;
634         }
635
636         if (!pci_dev->state_saved)
637                 pci_save_state(pci_dev);
638
639         return 0;
640 }
641
642 static int pci_pm_freeze_noirq(struct device *dev)
643 {
644         struct pci_dev *pci_dev = to_pci_dev(dev);
645         struct device_driver *drv = dev->driver;
646         int error = 0;
647
648         if (pci_has_legacy_pm_support(pci_dev))
649                 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
650
651         if (drv && drv->pm && drv->pm->freeze_noirq) {
652                 error = drv->pm->freeze_noirq(dev);
653                 suspend_report_result(drv->pm->freeze_noirq, error);
654         }
655
656         if (!error)
657                 pci_pm_set_unknown_state(pci_dev);
658
659         return error;
660 }
661
662 static int pci_pm_thaw_noirq(struct device *dev)
663 {
664         struct pci_dev *pci_dev = to_pci_dev(dev);
665         struct device_driver *drv = dev->driver;
666         int error = 0;
667
668         if (pci_has_legacy_pm_support(pci_dev))
669                 return pci_legacy_resume_early(dev);
670
671         pci_update_current_state(pci_dev, PCI_D0);
672
673         if (drv && drv->pm && drv->pm->thaw_noirq)
674                 error = drv->pm->thaw_noirq(dev);
675
676         return error;
677 }
678
679 static int pci_pm_thaw(struct device *dev)
680 {
681         struct pci_dev *pci_dev = to_pci_dev(dev);
682         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
683         int error = 0;
684
685         if (pci_has_legacy_pm_support(pci_dev))
686                 return pci_legacy_resume(dev);
687
688         if (pm) {
689                 if (pm->thaw)
690                         error = pm->thaw(dev);
691         } else {
692                 pci_pm_reenable_device(pci_dev);
693         }
694
695         return error;
696 }
697
698 static int pci_pm_poweroff(struct device *dev)
699 {
700         struct pci_dev *pci_dev = to_pci_dev(dev);
701         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
702         int error = 0;
703
704         if (pci_has_legacy_pm_support(pci_dev))
705                 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
706
707         if (!pm) {
708                 pci_pm_default_suspend(pci_dev);
709                 goto Fixup;
710         }
711
712         pci_dev->state_saved = false;
713
714         if (pm->poweroff) {
715                 error = pm->poweroff(dev);
716                 suspend_report_result(pm->poweroff, error);
717         }
718
719         if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
720                 pci_prepare_to_sleep(pci_dev);
721
722  Fixup:
723         pci_fixup_device(pci_fixup_suspend, pci_dev);
724
725         return error;
726 }
727
728 static int pci_pm_poweroff_noirq(struct device *dev)
729 {
730         struct device_driver *drv = dev->driver;
731         int error = 0;
732
733         if (pci_has_legacy_pm_support(to_pci_dev(dev)))
734                 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
735
736         if (drv && drv->pm && drv->pm->poweroff_noirq) {
737                 error = drv->pm->poweroff_noirq(dev);
738                 suspend_report_result(drv->pm->poweroff_noirq, error);
739         }
740
741         return error;
742 }
743
744 static int pci_pm_restore_noirq(struct device *dev)
745 {
746         struct pci_dev *pci_dev = to_pci_dev(dev);
747         struct device_driver *drv = dev->driver;
748         int error = 0;
749
750         pci_pm_default_resume_noirq(pci_dev);
751
752         if (pci_has_legacy_pm_support(pci_dev))
753                 return pci_legacy_resume_early(dev);
754
755         if (drv && drv->pm && drv->pm->restore_noirq)
756                 error = drv->pm->restore_noirq(dev);
757
758         return error;
759 }
760
761 static int pci_pm_restore(struct device *dev)
762 {
763         struct pci_dev *pci_dev = to_pci_dev(dev);
764         struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
765         int error = 0;
766
767         /*
768          * This is necessary for the hibernation error path in which restore is
769          * called without restoring the standard config registers of the device.
770          */
771         if (pci_dev->state_saved)
772                 pci_restore_standard_config(pci_dev);
773
774         if (pci_has_legacy_pm_support(pci_dev))
775                 return pci_legacy_resume(dev);
776
777         pci_pm_default_resume(pci_dev);
778
779         if (pm) {
780                 if (pm->restore)
781                         error = pm->restore(dev);
782         } else {
783                 pci_pm_reenable_device(pci_dev);
784         }
785
786         return error;
787 }
788
789 #else /* !CONFIG_HIBERNATION */
790
791 #define pci_pm_freeze           NULL
792 #define pci_pm_freeze_noirq     NULL
793 #define pci_pm_thaw             NULL
794 #define pci_pm_thaw_noirq       NULL
795 #define pci_pm_poweroff         NULL
796 #define pci_pm_poweroff_noirq   NULL
797 #define pci_pm_restore          NULL
798 #define pci_pm_restore_noirq    NULL
799
800 #endif /* !CONFIG_HIBERNATION */
801
802 struct dev_pm_ops pci_dev_pm_ops = {
803         .prepare = pci_pm_prepare,
804         .complete = pci_pm_complete,
805         .suspend = pci_pm_suspend,
806         .resume = pci_pm_resume,
807         .freeze = pci_pm_freeze,
808         .thaw = pci_pm_thaw,
809         .poweroff = pci_pm_poweroff,
810         .restore = pci_pm_restore,
811         .suspend_noirq = pci_pm_suspend_noirq,
812         .resume_noirq = pci_pm_resume_noirq,
813         .freeze_noirq = pci_pm_freeze_noirq,
814         .thaw_noirq = pci_pm_thaw_noirq,
815         .poweroff_noirq = pci_pm_poweroff_noirq,
816         .restore_noirq = pci_pm_restore_noirq,
817 };
818
819 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
820
821 #else /* !CONFIG_PM_SLEEP */
822
823 #define PCI_PM_OPS_PTR  NULL
824
825 #endif /* !CONFIG_PM_SLEEP */
826
827 /**
828  * __pci_register_driver - register a new pci driver
829  * @drv: the driver structure to register
830  * @owner: owner module of drv
831  * @mod_name: module name string
832  * 
833  * Adds the driver structure to the list of registered drivers.
834  * Returns a negative value on error, otherwise 0. 
835  * If no error occurred, the driver remains registered even if 
836  * no device was claimed during registration.
837  */
838 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
839                           const char *mod_name)
840 {
841         int error;
842
843         /* initialize common driver fields */
844         drv->driver.name = drv->name;
845         drv->driver.bus = &pci_bus_type;
846         drv->driver.owner = owner;
847         drv->driver.mod_name = mod_name;
848
849         spin_lock_init(&drv->dynids.lock);
850         INIT_LIST_HEAD(&drv->dynids.list);
851
852         /* register with core */
853         error = driver_register(&drv->driver);
854         if (error)
855                 return error;
856
857         error = pci_create_newid_file(drv);
858         if (error)
859                 driver_unregister(&drv->driver);
860
861         return error;
862 }
863
864 /**
865  * pci_unregister_driver - unregister a pci driver
866  * @drv: the driver structure to unregister
867  * 
868  * Deletes the driver structure from the list of registered PCI drivers,
869  * gives it a chance to clean up by calling its remove() function for
870  * each device it was responsible for, and marks those devices as
871  * driverless.
872  */
873
874 void
875 pci_unregister_driver(struct pci_driver *drv)
876 {
877         pci_remove_newid_file(drv);
878         driver_unregister(&drv->driver);
879         pci_free_dynids(drv);
880 }
881
882 static struct pci_driver pci_compat_driver = {
883         .name = "compat"
884 };
885
886 /**
887  * pci_dev_driver - get the pci_driver of a device
888  * @dev: the device to query
889  *
890  * Returns the appropriate pci_driver structure or %NULL if there is no 
891  * registered driver for the device.
892  */
893 struct pci_driver *
894 pci_dev_driver(const struct pci_dev *dev)
895 {
896         if (dev->driver)
897                 return dev->driver;
898         else {
899                 int i;
900                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
901                         if (dev->resource[i].flags & IORESOURCE_BUSY)
902                                 return &pci_compat_driver;
903         }
904         return NULL;
905 }
906
907 /**
908  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
909  * @dev: the PCI device structure to match against
910  * @drv: the device driver to search for matching PCI device id structures
911  * 
912  * Used by a driver to check whether a PCI device present in the
913  * system is in its list of supported devices. Returns the matching
914  * pci_device_id structure or %NULL if there is no match.
915  */
916 static int pci_bus_match(struct device *dev, struct device_driver *drv)
917 {
918         struct pci_dev *pci_dev = to_pci_dev(dev);
919         struct pci_driver *pci_drv = to_pci_driver(drv);
920         const struct pci_device_id *found_id;
921
922         found_id = pci_match_device(pci_drv, pci_dev);
923         if (found_id)
924                 return 1;
925
926         return 0;
927 }
928
929 /**
930  * pci_dev_get - increments the reference count of the pci device structure
931  * @dev: the device being referenced
932  *
933  * Each live reference to a device should be refcounted.
934  *
935  * Drivers for PCI devices should normally record such references in
936  * their probe() methods, when they bind to a device, and release
937  * them by calling pci_dev_put(), in their disconnect() methods.
938  *
939  * A pointer to the device with the incremented reference counter is returned.
940  */
941 struct pci_dev *pci_dev_get(struct pci_dev *dev)
942 {
943         if (dev)
944                 get_device(&dev->dev);
945         return dev;
946 }
947
948 /**
949  * pci_dev_put - release a use of the pci device structure
950  * @dev: device that's been disconnected
951  *
952  * Must be called when a user of a device is finished with it.  When the last
953  * user of the device calls this function, the memory of the device is freed.
954  */
955 void pci_dev_put(struct pci_dev *dev)
956 {
957         if (dev)
958                 put_device(&dev->dev);
959 }
960
961 #ifndef CONFIG_HOTPLUG
962 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
963 {
964         return -ENODEV;
965 }
966 #endif
967
968 struct bus_type pci_bus_type = {
969         .name           = "pci",
970         .match          = pci_bus_match,
971         .uevent         = pci_uevent,
972         .probe          = pci_device_probe,
973         .remove         = pci_device_remove,
974         .shutdown       = pci_device_shutdown,
975         .dev_attrs      = pci_dev_attrs,
976         .pm             = PCI_PM_OPS_PTR,
977 };
978
979 static int __init pci_driver_init(void)
980 {
981         return bus_register(&pci_bus_type);
982 }
983
984 postcore_initcall(pci_driver_init);
985
986 EXPORT_SYMBOL(pci_match_id);
987 EXPORT_SYMBOL(__pci_register_driver);
988 EXPORT_SYMBOL(pci_unregister_driver);
989 EXPORT_SYMBOL(pci_dev_driver);
990 EXPORT_SYMBOL(pci_bus_type);
991 EXPORT_SYMBOL(pci_dev_get);
992 EXPORT_SYMBOL(pci_dev_put);