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