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