blob: f9a0aec3abcf68c1594ee99d082dcab4a6560ff8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/pci/pci-driver.c
3 *
Greg Kroah-Hartman2b937302007-11-28 12:23:18 -08004 * (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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
11#include <linux/pci.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/device.h>
Andi Kleend42c6992005-07-06 19:56:03 +020015#include <linux/mempolicy.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080016#include <linux/string.h>
17#include <linux/slab.h>
Tim Schmielau8c65b4a2005-11-07 00:59:43 -080018#include <linux/sched.h>
Rusty Russell873392c2008-12-31 23:54:56 +103019#include <linux/cpu.h>
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +010020#include <linux/pm_runtime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "pci.h"
22
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070023struct pci_dynid {
24 struct list_head node;
25 struct pci_device_id id;
26};
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
28/**
Tejun Heo9dba9102009-09-03 15:26:36 +090029 * 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 */
49int 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
81static 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()
Randy Dunlap8f7020d2005-10-23 11:57:38 -070099 * @driver: target device driver
100 * @buf: buffer for scanning device ID data
101 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 *
Tejun Heo9dba9102009-09-03 15:26:36 +0900103 * Allow PCI IDs to be added to an existing driver via sysfs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -0700105static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106store_new_id(struct device_driver *driver, const char *buf, size_t count)
107{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200109 const struct pci_device_id *ids = pdrv->id_table;
Jean Delvare6ba18632007-04-07 17:21:28 +0200110 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 subdevice=PCI_ANY_ID, class=0, class_mask=0;
112 unsigned long driver_data=0;
113 int fields=0;
Tejun Heo9dba9102009-09-03 15:26:36 +0900114 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200116 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 &vendor, &device, &subvendor, &subdevice,
118 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +0200119 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 return -EINVAL;
121
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200122 /* Only accept driver_data values that match an existing id_table
123 entry */
Chris Wright2debb4d2008-11-25 19:36:10 -0800124 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++;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200132 }
Chris Wright2debb4d2008-11-25 19:36:10 -0800133 if (retval) /* No match */
134 return retval;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200135 }
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200136
Tejun Heo9dba9102009-09-03 15:26:36 +0900137 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
138 class, class_mask, driver_data);
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700139 if (retval)
140 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 return count;
142}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Chris Wright09943752009-02-23 21:52:23 -0800145/**
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 */
153static ssize_t
154store_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}
189static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191static int
192pci_create_newid_file(struct pci_driver *drv)
193{
194 int error = 0;
195 if (drv->probe != NULL)
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800196 error = driver_create_file(&drv->driver, &driver_attr_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return error;
198}
199
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800200static void pci_remove_newid_file(struct pci_driver *drv)
201{
202 driver_remove_file(&drv->driver, &driver_attr_new_id);
203}
Chris Wright09943752009-02-23 21:52:23 -0800204
205static int
206pci_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
214static void pci_remove_removeid_file(struct pci_driver *drv)
215{
216 driver_remove_file(&drv->driver, &driver_attr_remove_id);
217}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219static inline int pci_create_newid_file(struct pci_driver *drv)
220{
221 return 0;
222}
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800223static inline void pci_remove_newid_file(struct pci_driver *drv) {}
Chris Wright09943752009-02-23 21:52:23 -0800224static inline int pci_create_removeid_file(struct pci_driver *drv)
225{
226 return 0;
227}
228static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229#endif
230
231/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700232 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700234 * @dev: the PCI device structure to match against.
235 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700237 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700239 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200240 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700241 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700243const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
244 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700246 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253 return NULL;
254}
255
256/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800257 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700258 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200259 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700260 *
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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200265static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
266 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700267{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700268 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Russell King7461b602006-11-29 21:18:04 +0000270 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700271 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700278 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000279
280 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281}
282
Rusty Russell873392c2008-12-31 23:54:56 +1030283struct drv_dev_and_id {
284 struct pci_driver *drv;
285 struct pci_dev *dev;
286 const struct pci_device_id *id;
287};
288
289static long local_pci_probe(void *_ddi)
290{
291 struct drv_dev_and_id *ddi = _ddi;
292
293 return ddi->drv->probe(ddi->dev, ddi->id);
294}
295
Andi Kleend42c6992005-07-06 19:56:03 +0200296static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
297 const struct pci_device_id *id)
298{
Rusty Russell873392c2008-12-31 23:54:56 +1030299 int error, node;
300 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700301
Rusty Russell873392c2008-12-31 23:54:56 +1030302 /* Execute driver initialization on node where the device's
303 bus is attached to. This way the driver likely allocates
304 its local memory on the right node without any need to
305 change it. */
306 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700307 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030308 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030309
310 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030311 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030312 if (cpu < nr_cpu_ids)
313 error = work_on_cpu(cpu, local_pci_probe, &ddi);
314 else
315 error = local_pci_probe(&ddi);
316 put_online_cpus();
317 } else
318 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200319 return error;
320}
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322/**
323 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700324 * @drv: driver to call to check if it wants the PCI device
325 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700327 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
329 */
330static int
331__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700332{
333 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 int error = 0;
335
336 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700337 error = -ENODEV;
338
339 id = pci_match_device(drv, pci_dev);
340 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200341 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700342 if (error >= 0) {
343 pci_dev->driver = drv;
344 error = 0;
345 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
347 return error;
348}
349
350static int pci_device_probe(struct device * dev)
351{
352 int error = 0;
353 struct pci_driver *drv;
354 struct pci_dev *pci_dev;
355
356 drv = to_pci_driver(dev->driver);
357 pci_dev = to_pci_dev(dev);
358 pci_dev_get(pci_dev);
359 error = __pci_device_probe(drv, pci_dev);
360 if (error)
361 pci_dev_put(pci_dev);
362
363 return error;
364}
365
366static int pci_device_remove(struct device * dev)
367{
368 struct pci_dev * pci_dev = to_pci_dev(dev);
369 struct pci_driver * drv = pci_dev->driver;
370
371 if (drv) {
372 if (drv->remove)
373 drv->remove(pci_dev);
374 pci_dev->driver = NULL;
375 }
376
377 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700378 * If the device is still on, set the power state as "unknown",
379 * since it might change by the next time we load the driver.
380 */
381 if (pci_dev->current_state == PCI_D0)
382 pci_dev->current_state = PCI_UNKNOWN;
383
384 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 * We would love to complain here if pci_dev->is_enabled is set, that
386 * the driver should have called pci_disable_device(), but the
387 * unfortunate fact is there are too many odd BIOS and bridge setups
388 * that don't like drivers doing that all of the time.
389 * Oh well, we can dream of sane hardware when we sleep, no matter how
390 * horrible the crap we have to deal with is when we are awake...
391 */
392
393 pci_dev_put(pci_dev);
394 return 0;
395}
396
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200397static void pci_device_shutdown(struct device *dev)
398{
399 struct pci_dev *pci_dev = to_pci_dev(dev);
400 struct pci_driver *drv = pci_dev->driver;
401
402 if (drv && drv->shutdown)
403 drv->shutdown(pci_dev);
404 pci_msi_shutdown(pci_dev);
405 pci_msix_shutdown(pci_dev);
406}
407
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100408#ifdef CONFIG_PM_OPS
409
410/* Auxiliary functions used for system resume and run-time resume. */
411
412/**
413 * pci_restore_standard_config - restore standard config registers of PCI device
414 * @pci_dev: PCI device to handle
415 */
416static int pci_restore_standard_config(struct pci_dev *pci_dev)
417{
418 pci_update_current_state(pci_dev, PCI_UNKNOWN);
419
420 if (pci_dev->current_state != PCI_D0) {
421 int error = pci_set_power_state(pci_dev, PCI_D0);
422 if (error)
423 return error;
424 }
425
426 return pci_restore_state(pci_dev);
427}
428
429static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
430{
431 pci_restore_standard_config(pci_dev);
432 pci_fixup_device(pci_fixup_resume_early, pci_dev);
433}
434
435#endif
436
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200437#ifdef CONFIG_PM_SLEEP
438
439/*
440 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100441 * or not even a driver at all (second part).
442 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100443static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200444{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200445 /*
446 * mark its power state as "unknown", since we don't know if
447 * e.g. the BIOS will change its device state when we suspend.
448 */
449 if (pci_dev->current_state == PCI_D0)
450 pci_dev->current_state = PCI_UNKNOWN;
451}
452
453/*
454 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100455 * or not even a driver at all (second part).
456 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100457static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100458{
459 int retval;
460
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200461 /* if the device was enabled before suspend, reenable */
462 retval = pci_reenable_device(pci_dev);
463 /*
464 * if the device was busmaster before the suspend, make it busmaster
465 * again
466 */
467 if (pci_dev->is_busmaster)
468 pci_set_master(pci_dev);
469
470 return retval;
471}
472
473static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
475 struct pci_dev * pci_dev = to_pci_dev(dev);
476 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100477
Andrew Morton02669492006-03-23 01:38:34 -0800478 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100479 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100480 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100481
Frans Pop57ef8022009-03-16 22:39:56 +0100482 error = drv->suspend(pci_dev, state);
483 suspend_report_result(drv->suspend, error);
484 if (error)
485 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100486
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100487 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100488 && pci_dev->current_state != PCI_UNKNOWN) {
489 WARN_ONCE(pci_dev->current_state != prev,
490 "PCI PM: Device state not saved by %pF\n",
491 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100492 }
Andrew Morton02669492006-03-23 01:38:34 -0800493 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100494
495 pci_fixup_device(pci_fixup_suspend, pci_dev);
496
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100497 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498}
499
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200500static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700501{
502 struct pci_dev * pci_dev = to_pci_dev(dev);
503 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700504
505 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100506 pci_power_t prev = pci_dev->current_state;
507 int error;
508
Frans Pop57ef8022009-03-16 22:39:56 +0100509 error = drv->suspend_late(pci_dev, state);
510 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100511 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_late);
519 return 0;
520 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700521 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100522
523 if (!pci_dev->state_saved)
524 pci_save_state(pci_dev);
525
526 pci_pm_set_unknown_state(pci_dev);
527
528 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700529}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100531static int pci_legacy_resume_early(struct device *dev)
532{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100533 struct pci_dev * pci_dev = to_pci_dev(dev);
534 struct pci_driver * drv = pci_dev->driver;
535
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100536 return drv && drv->resume_early ?
537 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100538}
539
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200540static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
542 struct pci_dev * pci_dev = to_pci_dev(dev);
543 struct pci_driver * drv = pci_dev->driver;
544
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100545 pci_fixup_device(pci_fixup_resume, pci_dev);
546
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100547 return drv && drv->resume ?
548 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549}
550
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100551/* Auxiliary functions used by the new power management framework */
552
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100553static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100554{
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100555 pci_fixup_device(pci_fixup_resume, pci_dev);
556
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100557 if (!pci_is_bridge(pci_dev))
558 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100559}
560
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100561static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100562{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100563 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100564 if (!pci_is_bridge(pci_dev))
565 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100566}
567
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100568static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
569{
570 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100571 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100572 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100573
574 /*
575 * Legacy PM support is used by default, so warn if the new framework is
576 * supported as well. Drivers are supposed to support either the
577 * former, or the latter, but not both at the same time.
578 */
579 WARN_ON(ret && drv->driver.pm);
580
581 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100582}
583
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100584/* New power management framework */
585
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200586static int pci_pm_prepare(struct device *dev)
587{
588 struct device_driver *drv = dev->driver;
589 int error = 0;
590
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100591 /*
592 * PCI devices suspended at run time need to be resumed at this
593 * point, because in general it is necessary to reconfigure them for
594 * system suspend. Namely, if the device is supposed to wake up the
595 * system from the sleep state, we may need to reconfigure it for this
596 * purpose. In turn, if the device is not supposed to wake up the
597 * system from the sleep state, we'll have to prevent it from signaling
598 * wake-up.
599 */
600 pm_runtime_resume(dev);
601
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200602 if (drv && drv->pm && drv->pm->prepare)
603 error = drv->pm->prepare(dev);
604
605 return error;
606}
607
608static void pci_pm_complete(struct device *dev)
609{
610 struct device_driver *drv = dev->driver;
611
612 if (drv && drv->pm && drv->pm->complete)
613 drv->pm->complete(dev);
614}
615
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100616#else /* !CONFIG_PM_SLEEP */
617
618#define pci_pm_prepare NULL
619#define pci_pm_complete NULL
620
621#endif /* !CONFIG_PM_SLEEP */
622
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200623#ifdef CONFIG_SUSPEND
624
625static int pci_pm_suspend(struct device *dev)
626{
627 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700628 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200629
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100630 if (pci_has_legacy_pm_support(pci_dev))
631 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100632
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100633 if (!pm) {
634 pci_pm_default_suspend(pci_dev);
635 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200636 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100637
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100638 if (pm->suspend) {
639 pci_power_t prev = pci_dev->current_state;
640 int error;
641
642 error = pm->suspend(dev);
643 suspend_report_result(pm->suspend, error);
644 if (error)
645 return error;
646
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100647 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100648 && pci_dev->current_state != PCI_UNKNOWN) {
649 WARN_ONCE(pci_dev->current_state != prev,
650 "PCI PM: State of device not saved by %pF\n",
651 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100652 }
653 }
654
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100655 Fixup:
656 pci_fixup_device(pci_fixup_suspend, pci_dev);
657
658 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200659}
660
661static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900662{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100663 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700664 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900665
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100666 if (pci_has_legacy_pm_support(pci_dev))
667 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
668
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100669 if (!pm) {
670 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100671 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100672 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100673
674 if (pm->suspend_noirq) {
675 pci_power_t prev = pci_dev->current_state;
676 int error;
677
678 error = pm->suspend_noirq(dev);
679 suspend_report_result(pm->suspend_noirq, error);
680 if (error)
681 return error;
682
683 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
684 && pci_dev->current_state != PCI_UNKNOWN) {
685 WARN_ONCE(pci_dev->current_state != prev,
686 "PCI PM: State of device not saved by %pF\n",
687 pm->suspend_noirq);
688 return 0;
689 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200690 }
691
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100692 if (!pci_dev->state_saved) {
693 pci_save_state(pci_dev);
694 if (!pci_is_bridge(pci_dev))
695 pci_prepare_to_sleep(pci_dev);
696 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100697
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100698 pci_pm_set_unknown_state(pci_dev);
699
700 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900701}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200703static int pci_pm_resume_noirq(struct device *dev)
704{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100705 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200706 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200707 int error = 0;
708
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100709 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100710
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100711 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100712 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100713
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100714 if (drv && drv->pm && drv->pm->resume_noirq)
715 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200716
717 return error;
718}
719
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100720static int pci_pm_resume(struct device *dev)
721{
722 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700723 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100724 int error = 0;
725
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100726 /*
727 * This is necessary for the suspend error path in which resume is
728 * called without restoring the standard config registers of the device.
729 */
730 if (pci_dev->state_saved)
731 pci_restore_standard_config(pci_dev);
732
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100733 if (pci_has_legacy_pm_support(pci_dev))
734 return pci_legacy_resume(dev);
735
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100736 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100737
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100738 if (pm) {
739 if (pm->resume)
740 error = pm->resume(dev);
741 } else {
742 pci_pm_reenable_device(pci_dev);
743 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100744
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200745 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100746}
747
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200748#else /* !CONFIG_SUSPEND */
749
750#define pci_pm_suspend NULL
751#define pci_pm_suspend_noirq NULL
752#define pci_pm_resume NULL
753#define pci_pm_resume_noirq NULL
754
755#endif /* !CONFIG_SUSPEND */
756
757#ifdef CONFIG_HIBERNATION
758
759static int pci_pm_freeze(struct device *dev)
760{
761 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700762 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200763
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100764 if (pci_has_legacy_pm_support(pci_dev))
765 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100766
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100767 if (!pm) {
768 pci_pm_default_suspend(pci_dev);
769 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200770 }
771
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100772 if (pm->freeze) {
773 int error;
774
775 error = pm->freeze(dev);
776 suspend_report_result(pm->freeze, error);
777 if (error)
778 return error;
779 }
780
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100781 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200782}
783
784static int pci_pm_freeze_noirq(struct device *dev)
785{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100786 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200787 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200788
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100789 if (pci_has_legacy_pm_support(pci_dev))
790 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
791
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100792 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100793 int error;
794
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100795 error = drv->pm->freeze_noirq(dev);
796 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100797 if (error)
798 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200799 }
800
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100801 if (!pci_dev->state_saved)
802 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100803
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100804 pci_pm_set_unknown_state(pci_dev);
805
806 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200807}
808
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200809static int pci_pm_thaw_noirq(struct device *dev)
810{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100811 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200812 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200813 int error = 0;
814
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100815 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100816 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100817
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100818 pci_update_current_state(pci_dev, PCI_D0);
819
820 if (drv && drv->pm && drv->pm->thaw_noirq)
821 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200822
823 return error;
824}
825
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100826static int pci_pm_thaw(struct device *dev)
827{
828 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700829 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100830 int error = 0;
831
832 if (pci_has_legacy_pm_support(pci_dev))
833 return pci_legacy_resume(dev);
834
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100835 if (pm) {
836 if (pm->thaw)
837 error = pm->thaw(dev);
838 } else {
839 pci_pm_reenable_device(pci_dev);
840 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100841
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200842 pci_dev->state_saved = false;
843
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100844 return error;
845}
846
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200847static int pci_pm_poweroff(struct device *dev)
848{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100849 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700850 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200851
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100852 if (pci_has_legacy_pm_support(pci_dev))
853 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100854
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100855 if (!pm) {
856 pci_pm_default_suspend(pci_dev);
857 goto Fixup;
858 }
859
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100860 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100861 int error;
862
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100863 error = pm->poweroff(dev);
864 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100865 if (error)
866 return error;
867 }
868
869 Fixup:
870 pci_fixup_device(pci_fixup_suspend, pci_dev);
871
872 return 0;
873}
874
875static int pci_pm_poweroff_noirq(struct device *dev)
876{
877 struct pci_dev *pci_dev = to_pci_dev(dev);
878 struct device_driver *drv = dev->driver;
879
880 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
881 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
882
883 if (!drv || !drv->pm)
884 return 0;
885
886 if (drv->pm->poweroff_noirq) {
887 int error;
888
889 error = drv->pm->poweroff_noirq(dev);
890 suspend_report_result(drv->pm->poweroff_noirq, error);
891 if (error)
892 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200893 }
894
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100895 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
896 pci_prepare_to_sleep(pci_dev);
897
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100898 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200899}
900
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200901static int pci_pm_restore_noirq(struct device *dev)
902{
903 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200904 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200905 int error = 0;
906
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100907 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100908
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100909 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100910 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100911
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100912 if (drv && drv->pm && drv->pm->restore_noirq)
913 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200914
915 return error;
916}
917
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100918static int pci_pm_restore(struct device *dev)
919{
920 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700921 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100922 int error = 0;
923
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100924 /*
925 * This is necessary for the hibernation error path in which restore is
926 * called without restoring the standard config registers of the device.
927 */
928 if (pci_dev->state_saved)
929 pci_restore_standard_config(pci_dev);
930
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100931 if (pci_has_legacy_pm_support(pci_dev))
932 return pci_legacy_resume(dev);
933
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100934 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100935
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100936 if (pm) {
937 if (pm->restore)
938 error = pm->restore(dev);
939 } else {
940 pci_pm_reenable_device(pci_dev);
941 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100942
943 return error;
944}
945
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200946#else /* !CONFIG_HIBERNATION */
947
948#define pci_pm_freeze NULL
949#define pci_pm_freeze_noirq NULL
950#define pci_pm_thaw NULL
951#define pci_pm_thaw_noirq NULL
952#define pci_pm_poweroff NULL
953#define pci_pm_poweroff_noirq NULL
954#define pci_pm_restore NULL
955#define pci_pm_restore_noirq NULL
956
957#endif /* !CONFIG_HIBERNATION */
958
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100959#ifdef CONFIG_PM_RUNTIME
960
961static int pci_pm_runtime_suspend(struct device *dev)
962{
963 struct pci_dev *pci_dev = to_pci_dev(dev);
964 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
965 pci_power_t prev = pci_dev->current_state;
966 int error;
967
968 if (!pm || !pm->runtime_suspend)
969 return -ENOSYS;
970
971 error = pm->runtime_suspend(dev);
972 suspend_report_result(pm->runtime_suspend, error);
973 if (error)
974 return error;
975
976 pci_fixup_device(pci_fixup_suspend, pci_dev);
977
978 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
979 && pci_dev->current_state != PCI_UNKNOWN) {
980 WARN_ONCE(pci_dev->current_state != prev,
981 "PCI PM: State of device not saved by %pF\n",
982 pm->runtime_suspend);
983 return 0;
984 }
985
986 if (!pci_dev->state_saved)
987 pci_save_state(pci_dev);
988
989 pci_finish_runtime_suspend(pci_dev);
990
991 return 0;
992}
993
994static int pci_pm_runtime_resume(struct device *dev)
995{
996 struct pci_dev *pci_dev = to_pci_dev(dev);
997 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
998
999 if (!pm || !pm->runtime_resume)
1000 return -ENOSYS;
1001
1002 pci_pm_default_resume_early(pci_dev);
1003 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1004 pci_fixup_device(pci_fixup_resume, pci_dev);
1005
1006 return pm->runtime_resume(dev);
1007}
1008
1009static int pci_pm_runtime_idle(struct device *dev)
1010{
1011 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1012
1013 if (!pm)
1014 return -ENOSYS;
1015
1016 if (pm->runtime_idle) {
1017 int ret = pm->runtime_idle(dev);
1018 if (ret)
1019 return ret;
1020 }
1021
1022 pm_runtime_suspend(dev);
1023
1024 return 0;
1025}
1026
1027#else /* !CONFIG_PM_RUNTIME */
1028
1029#define pci_pm_runtime_suspend NULL
1030#define pci_pm_runtime_resume NULL
1031#define pci_pm_runtime_idle NULL
1032
1033#endif /* !CONFIG_PM_RUNTIME */
1034
1035#ifdef CONFIG_PM_OPS
1036
Dmitry Torokhov8150f322009-07-24 22:11:32 -07001037const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001038 .prepare = pci_pm_prepare,
1039 .complete = pci_pm_complete,
1040 .suspend = pci_pm_suspend,
1041 .resume = pci_pm_resume,
1042 .freeze = pci_pm_freeze,
1043 .thaw = pci_pm_thaw,
1044 .poweroff = pci_pm_poweroff,
1045 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001046 .suspend_noirq = pci_pm_suspend_noirq,
1047 .resume_noirq = pci_pm_resume_noirq,
1048 .freeze_noirq = pci_pm_freeze_noirq,
1049 .thaw_noirq = pci_pm_thaw_noirq,
1050 .poweroff_noirq = pci_pm_poweroff_noirq,
1051 .restore_noirq = pci_pm_restore_noirq,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001052 .runtime_suspend = pci_pm_runtime_suspend,
1053 .runtime_resume = pci_pm_runtime_resume,
1054 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001055};
1056
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001057#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001058
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001059#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001060
1061#define PCI_PM_OPS_PTR NULL
1062
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001063#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001066 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001068 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001069 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 *
1071 * Adds the driver structure to the list of registered drivers.
1072 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -06001073 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 * no device was claimed during registration.
1075 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001076int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1077 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078{
1079 int error;
1080
1081 /* initialize common driver fields */
1082 drv->driver.name = drv->name;
1083 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001084 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001085 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001086
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001087 spin_lock_init(&drv->dynids.lock);
1088 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
1090 /* register with core */
1091 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001092 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001093 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001095 error = pci_create_newid_file(drv);
1096 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001097 goto out_newid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
Chris Wright09943752009-02-23 21:52:23 -08001099 error = pci_create_removeid_file(drv);
1100 if (error)
1101 goto out_removeid;
1102out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 return error;
Chris Wright09943752009-02-23 21:52:23 -08001104
1105out_removeid:
1106 pci_remove_newid_file(drv);
1107out_newid:
1108 driver_unregister(&drv->driver);
1109 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110}
1111
1112/**
1113 * pci_unregister_driver - unregister a pci driver
1114 * @drv: the driver structure to unregister
1115 *
1116 * Deletes the driver structure from the list of registered PCI drivers,
1117 * gives it a chance to clean up by calling its remove() function for
1118 * each device it was responsible for, and marks those devices as
1119 * driverless.
1120 */
1121
1122void
1123pci_unregister_driver(struct pci_driver *drv)
1124{
Chris Wright09943752009-02-23 21:52:23 -08001125 pci_remove_removeid_file(drv);
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -08001126 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 driver_unregister(&drv->driver);
1128 pci_free_dynids(drv);
1129}
1130
1131static struct pci_driver pci_compat_driver = {
1132 .name = "compat"
1133};
1134
1135/**
1136 * pci_dev_driver - get the pci_driver of a device
1137 * @dev: the device to query
1138 *
1139 * Returns the appropriate pci_driver structure or %NULL if there is no
1140 * registered driver for the device.
1141 */
1142struct pci_driver *
1143pci_dev_driver(const struct pci_dev *dev)
1144{
1145 if (dev->driver)
1146 return dev->driver;
1147 else {
1148 int i;
1149 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1150 if (dev->resource[i].flags & IORESOURCE_BUSY)
1151 return &pci_compat_driver;
1152 }
1153 return NULL;
1154}
1155
1156/**
1157 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001159 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 *
1161 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001162 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 * pci_device_id structure or %NULL if there is no match.
1164 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001165static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001167 struct pci_dev *pci_dev = to_pci_dev(dev);
1168 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 const struct pci_device_id *found_id;
1170
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001171 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 if (found_id)
1173 return 1;
1174
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001175 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176}
1177
1178/**
1179 * pci_dev_get - increments the reference count of the pci device structure
1180 * @dev: the device being referenced
1181 *
1182 * Each live reference to a device should be refcounted.
1183 *
1184 * Drivers for PCI devices should normally record such references in
1185 * their probe() methods, when they bind to a device, and release
1186 * them by calling pci_dev_put(), in their disconnect() methods.
1187 *
1188 * A pointer to the device with the incremented reference counter is returned.
1189 */
1190struct pci_dev *pci_dev_get(struct pci_dev *dev)
1191{
1192 if (dev)
1193 get_device(&dev->dev);
1194 return dev;
1195}
1196
1197/**
1198 * pci_dev_put - release a use of the pci device structure
1199 * @dev: device that's been disconnected
1200 *
1201 * Must be called when a user of a device is finished with it. When the last
1202 * user of the device calls this function, the memory of the device is freed.
1203 */
1204void pci_dev_put(struct pci_dev *dev)
1205{
1206 if (dev)
1207 put_device(&dev->dev);
1208}
1209
1210#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001211int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212{
1213 return -ENODEV;
1214}
1215#endif
1216
1217struct bus_type pci_bus_type = {
1218 .name = "pci",
1219 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001220 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001221 .probe = pci_device_probe,
1222 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001223 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001225 .bus_attrs = pci_bus_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001226 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227};
1228
1229static int __init pci_driver_init(void)
1230{
1231 return bus_register(&pci_bus_type);
1232}
1233
1234postcore_initcall(pci_driver_init);
1235
Tejun Heo9dba9102009-09-03 15:26:36 +09001236EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001237EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001238EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239EXPORT_SYMBOL(pci_unregister_driver);
1240EXPORT_SYMBOL(pci_dev_driver);
1241EXPORT_SYMBOL(pci_bus_type);
1242EXPORT_SYMBOL(pci_dev_get);
1243EXPORT_SYMBOL(pci_dev_put);