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