blob: 135df164a4c1e897e4d36a7d5a49336518669480 [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;
Alan Sternf3ec4f82010-06-08 15:23:51 -0400292 struct device *dev = &ddi->dev->dev;
293 int rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030294
Alan Sternf3ec4f82010-06-08 15:23:51 -0400295 /* 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;
Rusty Russell873392c2008-12-31 23:54:56 +1030312}
313
Andi Kleend42c6992005-07-06 19:56:03 +0200314static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
315 const struct pci_device_id *id)
316{
Rusty Russell873392c2008-12-31 23:54:56 +1030317 int error, node;
318 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700319
Rusty Russell873392c2008-12-31 23:54:56 +1030320 /* 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);
Mike Travisf70316d2008-04-04 18:11:06 -0700325 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030326 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030327
328 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030329 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030330 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);
Andi Kleend42c6992005-07-06 19:56:03 +0200337 return error;
338}
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340/**
Randy Dunlap23ea3792010-11-18 15:02:31 -0800341 * __pci_device_probe - check if a driver wants to claim a specific PCI device
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700342 * @drv: driver to call to check if it wants the PCI device
343 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700345 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
347 */
348static int
349__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700350{
351 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 int error = 0;
353
354 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700355 error = -ENODEV;
356
357 id = pci_match_device(drv, pci_dev);
358 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200359 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700360 if (error >= 0) {
361 pci_dev->driver = drv;
362 error = 0;
363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
365 return error;
366}
367
368static 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
384static 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) {
Alan Sternf3ec4f82010-06-08 15:23:51 -0400390 if (drv->remove) {
391 pm_runtime_get_sync(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 drv->remove(pci_dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400393 pm_runtime_put_noidle(dev);
394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 pci_dev->driver = NULL;
396 }
397
Alan Sternf3ec4f82010-06-08 15:23:51 -0400398 /* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700404 * 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 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 * 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
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200423static 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
Rafael J. Wysockiaa338602011-02-11 00:06:54 +0100434#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100435
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 */
442static 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
Jon Mason1d3c16a2010-11-30 17:43:26 -0600452 pci_restore_state(pci_dev);
453 return 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100454}
455
456static 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
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200464#ifdef CONFIG_PM_SLEEP
465
466/*
467 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100468 * or not even a driver at all (second part).
469 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100470static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200471{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200472 /*
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,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100482 * or not even a driver at all (second part).
483 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100484static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100485{
486 int retval;
487
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200488 /* 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
500static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
502 struct pci_dev * pci_dev = to_pci_dev(dev);
503 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100504
Andrew Morton02669492006-03-23 01:38:34 -0800505 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100506 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100507 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100508
Frans Pop57ef8022009-03-16 22:39:56 +0100509 error = drv->suspend(pci_dev, state);
510 suspend_report_result(drv->suspend, error);
511 if (error)
512 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100513
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100514 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100515 && 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);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100519 }
Andrew Morton02669492006-03-23 01:38:34 -0800520 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100521
522 pci_fixup_device(pci_fixup_suspend, pci_dev);
523
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100524 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525}
526
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200527static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700528{
529 struct pci_dev * pci_dev = to_pci_dev(dev);
530 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700531
532 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100533 pci_power_t prev = pci_dev->current_state;
534 int error;
535
Frans Pop57ef8022009-03-16 22:39:56 +0100536 error = drv->suspend_late(pci_dev, state);
537 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100538 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 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700548 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100549
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;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700556}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100558static int pci_legacy_resume_early(struct device *dev)
559{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100560 struct pci_dev * pci_dev = to_pci_dev(dev);
561 struct pci_driver * drv = pci_dev->driver;
562
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100563 return drv && drv->resume_early ?
564 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100565}
566
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200567static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
569 struct pci_dev * pci_dev = to_pci_dev(dev);
570 struct pci_driver * drv = pci_dev->driver;
571
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100572 pci_fixup_device(pci_fixup_resume, pci_dev);
573
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100574 return drv && drv->resume ?
575 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
577
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100578/* Auxiliary functions used by the new power management framework */
579
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100580static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100581{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100582 pci_fixup_device(pci_fixup_resume, pci_dev);
583
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100584 if (!pci_is_bridge(pci_dev))
585 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100586}
587
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100588static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100589{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100590 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100591 if (!pci_is_bridge(pci_dev))
592 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100593}
594
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100595static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
596{
597 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100598 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100599 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100600
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;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100609}
610
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100611/* New power management framework */
612
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200613static int pci_pm_prepare(struct device *dev)
614{
615 struct device_driver *drv = dev->driver;
616 int error = 0;
617
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100618 /*
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
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200629 if (drv && drv->pm && drv->pm->prepare)
630 error = drv->pm->prepare(dev);
631
632 return error;
633}
634
635static 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
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100643#else /* !CONFIG_PM_SLEEP */
644
645#define pci_pm_prepare NULL
646#define pci_pm_complete NULL
647
648#endif /* !CONFIG_PM_SLEEP */
649
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200650#ifdef CONFIG_SUSPEND
651
652static int pci_pm_suspend(struct device *dev)
653{
654 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700655 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200656
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100657 if (pci_has_legacy_pm_support(pci_dev))
658 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100659
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100660 if (!pm) {
661 pci_pm_default_suspend(pci_dev);
662 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200663 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100664
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100665 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
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100674 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100675 && 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);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100679 }
680 }
681
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100682 Fixup:
683 pci_fixup_device(pci_fixup_suspend, pci_dev);
684
685 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200686}
687
688static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900689{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100690 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700691 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900692
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100693 if (pci_has_legacy_pm_support(pci_dev))
694 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
695
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100696 if (!pm) {
697 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100698 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100699 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100700
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 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200717 }
718
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100719 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 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100724
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100725 pci_pm_set_unknown_state(pci_dev);
726
727 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900728}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200730static int pci_pm_resume_noirq(struct device *dev)
731{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100732 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200733 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200734 int error = 0;
735
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100736 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100737
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100738 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100739 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100740
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100741 if (drv && drv->pm && drv->pm->resume_noirq)
742 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200743
744 return error;
745}
746
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100747static int pci_pm_resume(struct device *dev)
748{
749 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700750 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100751 int error = 0;
752
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100753 /*
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
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100760 if (pci_has_legacy_pm_support(pci_dev))
761 return pci_legacy_resume(dev);
762
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100763 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100764
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100765 if (pm) {
766 if (pm->resume)
767 error = pm->resume(dev);
768 } else {
769 pci_pm_reenable_device(pci_dev);
770 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100771
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200772 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100773}
774
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200775#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
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200784#ifdef CONFIG_HIBERNATE_CALLBACKS
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200785
786static int pci_pm_freeze(struct device *dev)
787{
788 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700789 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200790
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100791 if (pci_has_legacy_pm_support(pci_dev))
792 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100793
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100794 if (!pm) {
795 pci_pm_default_suspend(pci_dev);
796 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200797 }
798
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100799 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
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100808 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200809}
810
811static int pci_pm_freeze_noirq(struct device *dev)
812{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100813 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200814 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200815
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100816 if (pci_has_legacy_pm_support(pci_dev))
817 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
818
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100819 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100820 int error;
821
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100822 error = drv->pm->freeze_noirq(dev);
823 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100824 if (error)
825 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200826 }
827
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100828 if (!pci_dev->state_saved)
829 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100830
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100831 pci_pm_set_unknown_state(pci_dev);
832
833 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200834}
835
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200836static int pci_pm_thaw_noirq(struct device *dev)
837{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100838 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200839 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200840 int error = 0;
841
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100842 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100843 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100844
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100845 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);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200849
850 return error;
851}
852
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100853static int pci_pm_thaw(struct device *dev)
854{
855 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700856 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100857 int error = 0;
858
859 if (pci_has_legacy_pm_support(pci_dev))
860 return pci_legacy_resume(dev);
861
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100862 if (pm) {
863 if (pm->thaw)
864 error = pm->thaw(dev);
865 } else {
866 pci_pm_reenable_device(pci_dev);
867 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100868
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200869 pci_dev->state_saved = false;
870
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100871 return error;
872}
873
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200874static int pci_pm_poweroff(struct device *dev)
875{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100876 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700877 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200878
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100879 if (pci_has_legacy_pm_support(pci_dev))
880 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100881
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100882 if (!pm) {
883 pci_pm_default_suspend(pci_dev);
884 goto Fixup;
885 }
886
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100887 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100888 int error;
889
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100890 error = pm->poweroff(dev);
891 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100892 if (error)
893 return error;
894 }
895
896 Fixup:
897 pci_fixup_device(pci_fixup_suspend, pci_dev);
898
899 return 0;
900}
901
902static 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;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200920 }
921
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100922 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
923 pci_prepare_to_sleep(pci_dev);
924
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100925 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200926}
927
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200928static int pci_pm_restore_noirq(struct device *dev)
929{
930 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200931 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200932 int error = 0;
933
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100934 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100935
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100936 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100937 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100938
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100939 if (drv && drv->pm && drv->pm->restore_noirq)
940 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200941
942 return error;
943}
944
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100945static int pci_pm_restore(struct device *dev)
946{
947 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700948 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100949 int error = 0;
950
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100951 /*
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
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100958 if (pci_has_legacy_pm_support(pci_dev))
959 return pci_legacy_resume(dev);
960
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100961 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100962
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100963 if (pm) {
964 if (pm->restore)
965 error = pm->restore(dev);
966 } else {
967 pci_pm_reenable_device(pci_dev);
968 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100969
970 return error;
971}
972
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200973#else /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200974
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
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200984#endif /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200985
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100986#ifdef CONFIG_PM_RUNTIME
987
988static 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
1021static 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
1036static 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
Rafael J. Wysockiaa338602011-02-11 00:06:54 +01001062#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001063
Dmitry Torokhov8150f322009-07-24 22:11:32 -07001064const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001065 .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,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001073 .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,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001079 .runtime_suspend = pci_pm_runtime_suspend,
1080 .runtime_resume = pci_pm_runtime_resume,
1081 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001082};
1083
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001084#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001085
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001086#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001087
1088#define PCI_PM_OPS_PTR NULL
1089
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001090#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001093 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001095 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001096 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 *
1098 * Adds the driver structure to the list of registered drivers.
1099 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -06001100 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 * no device was claimed during registration.
1102 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001103int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1104 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105{
1106 int error;
1107
1108 /* initialize common driver fields */
1109 drv->driver.name = drv->name;
1110 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001111 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001112 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001113
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001114 spin_lock_init(&drv->dynids.lock);
1115 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
1117 /* register with core */
1118 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001119 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001120 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001122 error = pci_create_newid_file(drv);
1123 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001124 goto out_newid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
Chris Wright09943752009-02-23 21:52:23 -08001126 error = pci_create_removeid_file(drv);
1127 if (error)
1128 goto out_removeid;
1129out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 return error;
Chris Wright09943752009-02-23 21:52:23 -08001131
1132out_removeid:
1133 pci_remove_newid_file(drv);
1134out_newid:
1135 driver_unregister(&drv->driver);
1136 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137}
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
1149void
1150pci_unregister_driver(struct pci_driver *drv)
1151{
Chris Wright09943752009-02-23 21:52:23 -08001152 pci_remove_removeid_file(drv);
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -08001153 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 driver_unregister(&drv->driver);
1155 pci_free_dynids(drv);
1156}
1157
1158static 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 */
1169struct pci_driver *
1170pci_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
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001186 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 *
1188 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001189 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 * pci_device_id structure or %NULL if there is no match.
1191 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001192static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001194 struct pci_dev *pci_dev = to_pci_dev(dev);
1195 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 const struct pci_device_id *found_id;
1197
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001198 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 if (found_id)
1200 return 1;
1201
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001202 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203}
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 */
1217struct 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 */
1231void pci_dev_put(struct pci_dev *dev)
1232{
1233 if (dev)
1234 put_device(&dev->dev);
1235}
1236
1237#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001238int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239{
1240 return -ENODEV;
1241}
1242#endif
1243
1244struct bus_type pci_bus_type = {
1245 .name = "pci",
1246 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001247 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001248 .probe = pci_device_probe,
1249 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001250 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001252 .bus_attrs = pci_bus_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001253 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254};
1255
1256static int __init pci_driver_init(void)
1257{
1258 return bus_register(&pci_bus_type);
1259}
1260
1261postcore_initcall(pci_driver_init);
1262
Tejun Heo9dba9102009-09-03 15:26:36 +09001263EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001264EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001265EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266EXPORT_SYMBOL(pci_unregister_driver);
1267EXPORT_SYMBOL(pci_dev_driver);
1268EXPORT_SYMBOL(pci_bus_type);
1269EXPORT_SYMBOL(pci_dev_get);
1270EXPORT_SYMBOL(pci_dev_put);