blob: 8a6f797de8e55af1b3d0380aefb2173b58ab9fa5 [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/**
341 * __pci_device_probe()
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. Wysocki6cbf8212010-02-17 23:44:58 +0100434#ifdef CONFIG_PM_OPS
435
436/* Auxiliary functions used for system resume and run-time resume. */
437
438/**
439 * pci_restore_standard_config - restore standard config registers of PCI device
440 * @pci_dev: PCI device to handle
441 */
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
452 return pci_restore_state(pci_dev);
453}
454
455static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
456{
457 pci_restore_standard_config(pci_dev);
458 pci_fixup_device(pci_fixup_resume_early, pci_dev);
459}
460
461#endif
462
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200463#ifdef CONFIG_PM_SLEEP
464
465/*
466 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100467 * or not even a driver at all (second part).
468 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100469static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200470{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200471 /*
472 * mark its power state as "unknown", since we don't know if
473 * e.g. the BIOS will change its device state when we suspend.
474 */
475 if (pci_dev->current_state == PCI_D0)
476 pci_dev->current_state = PCI_UNKNOWN;
477}
478
479/*
480 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100481 * or not even a driver at all (second part).
482 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100483static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100484{
485 int retval;
486
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200487 /* if the device was enabled before suspend, reenable */
488 retval = pci_reenable_device(pci_dev);
489 /*
490 * if the device was busmaster before the suspend, make it busmaster
491 * again
492 */
493 if (pci_dev->is_busmaster)
494 pci_set_master(pci_dev);
495
496 return retval;
497}
498
499static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
501 struct pci_dev * pci_dev = to_pci_dev(dev);
502 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100503
Andrew Morton02669492006-03-23 01:38:34 -0800504 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100505 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100506 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100507
Frans Pop57ef8022009-03-16 22:39:56 +0100508 error = drv->suspend(pci_dev, state);
509 suspend_report_result(drv->suspend, error);
510 if (error)
511 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100512
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100513 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100514 && pci_dev->current_state != PCI_UNKNOWN) {
515 WARN_ONCE(pci_dev->current_state != prev,
516 "PCI PM: Device state not saved by %pF\n",
517 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100518 }
Andrew Morton02669492006-03-23 01:38:34 -0800519 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100520
521 pci_fixup_device(pci_fixup_suspend, pci_dev);
522
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100523 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200526static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700527{
528 struct pci_dev * pci_dev = to_pci_dev(dev);
529 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700530
531 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100532 pci_power_t prev = pci_dev->current_state;
533 int error;
534
Frans Pop57ef8022009-03-16 22:39:56 +0100535 error = drv->suspend_late(pci_dev, state);
536 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100537 if (error)
538 return error;
539
540 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
541 && pci_dev->current_state != PCI_UNKNOWN) {
542 WARN_ONCE(pci_dev->current_state != prev,
543 "PCI PM: Device state not saved by %pF\n",
544 drv->suspend_late);
545 return 0;
546 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700547 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100548
549 if (!pci_dev->state_saved)
550 pci_save_state(pci_dev);
551
552 pci_pm_set_unknown_state(pci_dev);
553
554 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700555}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100557static int pci_legacy_resume_early(struct device *dev)
558{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100559 struct pci_dev * pci_dev = to_pci_dev(dev);
560 struct pci_driver * drv = pci_dev->driver;
561
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100562 return drv && drv->resume_early ?
563 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100564}
565
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200566static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
568 struct pci_dev * pci_dev = to_pci_dev(dev);
569 struct pci_driver * drv = pci_dev->driver;
570
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100571 pci_fixup_device(pci_fixup_resume, pci_dev);
572
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100573 return drv && drv->resume ?
574 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575}
576
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100577/* Auxiliary functions used by the new power management framework */
578
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100579static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100580{
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100581 pci_fixup_device(pci_fixup_resume, pci_dev);
582
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100583 if (!pci_is_bridge(pci_dev))
584 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100585}
586
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100587static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100588{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100589 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100590 if (!pci_is_bridge(pci_dev))
591 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100592}
593
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100594static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
595{
596 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100597 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100598 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100599
600 /*
601 * Legacy PM support is used by default, so warn if the new framework is
602 * supported as well. Drivers are supposed to support either the
603 * former, or the latter, but not both at the same time.
604 */
605 WARN_ON(ret && drv->driver.pm);
606
607 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100608}
609
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100610/* New power management framework */
611
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200612static int pci_pm_prepare(struct device *dev)
613{
614 struct device_driver *drv = dev->driver;
615 int error = 0;
616
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100617 /*
618 * PCI devices suspended at run time need to be resumed at this
619 * point, because in general it is necessary to reconfigure them for
620 * system suspend. Namely, if the device is supposed to wake up the
621 * system from the sleep state, we may need to reconfigure it for this
622 * purpose. In turn, if the device is not supposed to wake up the
623 * system from the sleep state, we'll have to prevent it from signaling
624 * wake-up.
625 */
626 pm_runtime_resume(dev);
627
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200628 if (drv && drv->pm && drv->pm->prepare)
629 error = drv->pm->prepare(dev);
630
631 return error;
632}
633
634static void pci_pm_complete(struct device *dev)
635{
636 struct device_driver *drv = dev->driver;
637
638 if (drv && drv->pm && drv->pm->complete)
639 drv->pm->complete(dev);
640}
641
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100642#else /* !CONFIG_PM_SLEEP */
643
644#define pci_pm_prepare NULL
645#define pci_pm_complete NULL
646
647#endif /* !CONFIG_PM_SLEEP */
648
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200649#ifdef CONFIG_SUSPEND
650
651static int pci_pm_suspend(struct device *dev)
652{
653 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700654 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200655
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100656 if (pci_has_legacy_pm_support(pci_dev))
657 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100658
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100659 if (!pm) {
660 pci_pm_default_suspend(pci_dev);
661 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200662 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100663
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100664 if (pm->suspend) {
665 pci_power_t prev = pci_dev->current_state;
666 int error;
667
668 error = pm->suspend(dev);
669 suspend_report_result(pm->suspend, error);
670 if (error)
671 return error;
672
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100673 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100674 && pci_dev->current_state != PCI_UNKNOWN) {
675 WARN_ONCE(pci_dev->current_state != prev,
676 "PCI PM: State of device not saved by %pF\n",
677 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100678 }
679 }
680
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100681 Fixup:
682 pci_fixup_device(pci_fixup_suspend, pci_dev);
683
684 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200685}
686
687static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900688{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100689 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700690 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900691
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100692 if (pci_has_legacy_pm_support(pci_dev))
693 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
694
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100695 if (!pm) {
696 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100697 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100698 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100699
700 if (pm->suspend_noirq) {
701 pci_power_t prev = pci_dev->current_state;
702 int error;
703
704 error = pm->suspend_noirq(dev);
705 suspend_report_result(pm->suspend_noirq, error);
706 if (error)
707 return error;
708
709 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
710 && pci_dev->current_state != PCI_UNKNOWN) {
711 WARN_ONCE(pci_dev->current_state != prev,
712 "PCI PM: State of device not saved by %pF\n",
713 pm->suspend_noirq);
714 return 0;
715 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200716 }
717
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100718 if (!pci_dev->state_saved) {
719 pci_save_state(pci_dev);
720 if (!pci_is_bridge(pci_dev))
721 pci_prepare_to_sleep(pci_dev);
722 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100723
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100724 pci_pm_set_unknown_state(pci_dev);
725
726 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900727}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200729static int pci_pm_resume_noirq(struct device *dev)
730{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100731 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200732 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200733 int error = 0;
734
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100735 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100736
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100737 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100738 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100739
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100740 if (drv && drv->pm && drv->pm->resume_noirq)
741 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200742
743 return error;
744}
745
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100746static int pci_pm_resume(struct device *dev)
747{
748 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700749 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100750 int error = 0;
751
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100752 /*
753 * This is necessary for the suspend error path in which resume is
754 * called without restoring the standard config registers of the device.
755 */
756 if (pci_dev->state_saved)
757 pci_restore_standard_config(pci_dev);
758
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100759 if (pci_has_legacy_pm_support(pci_dev))
760 return pci_legacy_resume(dev);
761
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100762 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100763
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100764 if (pm) {
765 if (pm->resume)
766 error = pm->resume(dev);
767 } else {
768 pci_pm_reenable_device(pci_dev);
769 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100770
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200771 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100772}
773
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200774#else /* !CONFIG_SUSPEND */
775
776#define pci_pm_suspend NULL
777#define pci_pm_suspend_noirq NULL
778#define pci_pm_resume NULL
779#define pci_pm_resume_noirq NULL
780
781#endif /* !CONFIG_SUSPEND */
782
783#ifdef CONFIG_HIBERNATION
784
785static int pci_pm_freeze(struct device *dev)
786{
787 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700788 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200789
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100790 if (pci_has_legacy_pm_support(pci_dev))
791 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100792
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100793 if (!pm) {
794 pci_pm_default_suspend(pci_dev);
795 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200796 }
797
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100798 if (pm->freeze) {
799 int error;
800
801 error = pm->freeze(dev);
802 suspend_report_result(pm->freeze, error);
803 if (error)
804 return error;
805 }
806
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100807 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200808}
809
810static int pci_pm_freeze_noirq(struct device *dev)
811{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100812 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200813 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200814
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100815 if (pci_has_legacy_pm_support(pci_dev))
816 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
817
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100818 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100819 int error;
820
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100821 error = drv->pm->freeze_noirq(dev);
822 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100823 if (error)
824 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200825 }
826
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100827 if (!pci_dev->state_saved)
828 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100829
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100830 pci_pm_set_unknown_state(pci_dev);
831
832 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200833}
834
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200835static int pci_pm_thaw_noirq(struct device *dev)
836{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100837 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200838 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200839 int error = 0;
840
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100841 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100842 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100843
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100844 pci_update_current_state(pci_dev, PCI_D0);
845
846 if (drv && drv->pm && drv->pm->thaw_noirq)
847 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200848
849 return error;
850}
851
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100852static int pci_pm_thaw(struct device *dev)
853{
854 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700855 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100856 int error = 0;
857
858 if (pci_has_legacy_pm_support(pci_dev))
859 return pci_legacy_resume(dev);
860
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100861 if (pm) {
862 if (pm->thaw)
863 error = pm->thaw(dev);
864 } else {
865 pci_pm_reenable_device(pci_dev);
866 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100867
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200868 pci_dev->state_saved = false;
869
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100870 return error;
871}
872
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200873static int pci_pm_poweroff(struct device *dev)
874{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100875 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700876 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200877
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100878 if (pci_has_legacy_pm_support(pci_dev))
879 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100880
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100881 if (!pm) {
882 pci_pm_default_suspend(pci_dev);
883 goto Fixup;
884 }
885
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100886 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100887 int error;
888
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100889 error = pm->poweroff(dev);
890 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100891 if (error)
892 return error;
893 }
894
895 Fixup:
896 pci_fixup_device(pci_fixup_suspend, pci_dev);
897
898 return 0;
899}
900
901static int pci_pm_poweroff_noirq(struct device *dev)
902{
903 struct pci_dev *pci_dev = to_pci_dev(dev);
904 struct device_driver *drv = dev->driver;
905
906 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
907 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
908
909 if (!drv || !drv->pm)
910 return 0;
911
912 if (drv->pm->poweroff_noirq) {
913 int error;
914
915 error = drv->pm->poweroff_noirq(dev);
916 suspend_report_result(drv->pm->poweroff_noirq, error);
917 if (error)
918 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200919 }
920
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100921 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
922 pci_prepare_to_sleep(pci_dev);
923
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100924 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200925}
926
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200927static int pci_pm_restore_noirq(struct device *dev)
928{
929 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200930 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200931 int error = 0;
932
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100933 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100934
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100935 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100936 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100937
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100938 if (drv && drv->pm && drv->pm->restore_noirq)
939 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200940
941 return error;
942}
943
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100944static int pci_pm_restore(struct device *dev)
945{
946 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700947 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100948 int error = 0;
949
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100950 /*
951 * This is necessary for the hibernation error path in which restore is
952 * called without restoring the standard config registers of the device.
953 */
954 if (pci_dev->state_saved)
955 pci_restore_standard_config(pci_dev);
956
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100957 if (pci_has_legacy_pm_support(pci_dev))
958 return pci_legacy_resume(dev);
959
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100960 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100961
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100962 if (pm) {
963 if (pm->restore)
964 error = pm->restore(dev);
965 } else {
966 pci_pm_reenable_device(pci_dev);
967 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100968
969 return error;
970}
971
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200972#else /* !CONFIG_HIBERNATION */
973
974#define pci_pm_freeze NULL
975#define pci_pm_freeze_noirq NULL
976#define pci_pm_thaw NULL
977#define pci_pm_thaw_noirq NULL
978#define pci_pm_poweroff NULL
979#define pci_pm_poweroff_noirq NULL
980#define pci_pm_restore NULL
981#define pci_pm_restore_noirq NULL
982
983#endif /* !CONFIG_HIBERNATION */
984
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100985#ifdef CONFIG_PM_RUNTIME
986
987static int pci_pm_runtime_suspend(struct device *dev)
988{
989 struct pci_dev *pci_dev = to_pci_dev(dev);
990 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
991 pci_power_t prev = pci_dev->current_state;
992 int error;
993
994 if (!pm || !pm->runtime_suspend)
995 return -ENOSYS;
996
997 error = pm->runtime_suspend(dev);
998 suspend_report_result(pm->runtime_suspend, error);
999 if (error)
1000 return error;
1001
1002 pci_fixup_device(pci_fixup_suspend, pci_dev);
1003
1004 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1005 && pci_dev->current_state != PCI_UNKNOWN) {
1006 WARN_ONCE(pci_dev->current_state != prev,
1007 "PCI PM: State of device not saved by %pF\n",
1008 pm->runtime_suspend);
1009 return 0;
1010 }
1011
1012 if (!pci_dev->state_saved)
1013 pci_save_state(pci_dev);
1014
1015 pci_finish_runtime_suspend(pci_dev);
1016
1017 return 0;
1018}
1019
1020static int pci_pm_runtime_resume(struct device *dev)
1021{
1022 struct pci_dev *pci_dev = to_pci_dev(dev);
1023 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1024
1025 if (!pm || !pm->runtime_resume)
1026 return -ENOSYS;
1027
1028 pci_pm_default_resume_early(pci_dev);
1029 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1030 pci_fixup_device(pci_fixup_resume, pci_dev);
1031
1032 return pm->runtime_resume(dev);
1033}
1034
1035static int pci_pm_runtime_idle(struct device *dev)
1036{
1037 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1038
1039 if (!pm)
1040 return -ENOSYS;
1041
1042 if (pm->runtime_idle) {
1043 int ret = pm->runtime_idle(dev);
1044 if (ret)
1045 return ret;
1046 }
1047
1048 pm_runtime_suspend(dev);
1049
1050 return 0;
1051}
1052
1053#else /* !CONFIG_PM_RUNTIME */
1054
1055#define pci_pm_runtime_suspend NULL
1056#define pci_pm_runtime_resume NULL
1057#define pci_pm_runtime_idle NULL
1058
1059#endif /* !CONFIG_PM_RUNTIME */
1060
1061#ifdef CONFIG_PM_OPS
1062
Dmitry Torokhov8150f322009-07-24 22:11:32 -07001063const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001064 .prepare = pci_pm_prepare,
1065 .complete = pci_pm_complete,
1066 .suspend = pci_pm_suspend,
1067 .resume = pci_pm_resume,
1068 .freeze = pci_pm_freeze,
1069 .thaw = pci_pm_thaw,
1070 .poweroff = pci_pm_poweroff,
1071 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001072 .suspend_noirq = pci_pm_suspend_noirq,
1073 .resume_noirq = pci_pm_resume_noirq,
1074 .freeze_noirq = pci_pm_freeze_noirq,
1075 .thaw_noirq = pci_pm_thaw_noirq,
1076 .poweroff_noirq = pci_pm_poweroff_noirq,
1077 .restore_noirq = pci_pm_restore_noirq,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001078 .runtime_suspend = pci_pm_runtime_suspend,
1079 .runtime_resume = pci_pm_runtime_resume,
1080 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001081};
1082
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001083#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001084
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001085#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001086
1087#define PCI_PM_OPS_PTR NULL
1088
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001089#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001092 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001094 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001095 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 *
1097 * Adds the driver structure to the list of registered drivers.
1098 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -06001099 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 * no device was claimed during registration.
1101 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001102int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1103 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104{
1105 int error;
1106
1107 /* initialize common driver fields */
1108 drv->driver.name = drv->name;
1109 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001110 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001111 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001112
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001113 spin_lock_init(&drv->dynids.lock);
1114 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116 /* register with core */
1117 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001118 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001119 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001121 error = pci_create_newid_file(drv);
1122 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001123 goto out_newid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Chris Wright09943752009-02-23 21:52:23 -08001125 error = pci_create_removeid_file(drv);
1126 if (error)
1127 goto out_removeid;
1128out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 return error;
Chris Wright09943752009-02-23 21:52:23 -08001130
1131out_removeid:
1132 pci_remove_newid_file(drv);
1133out_newid:
1134 driver_unregister(&drv->driver);
1135 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136}
1137
1138/**
1139 * pci_unregister_driver - unregister a pci driver
1140 * @drv: the driver structure to unregister
1141 *
1142 * Deletes the driver structure from the list of registered PCI drivers,
1143 * gives it a chance to clean up by calling its remove() function for
1144 * each device it was responsible for, and marks those devices as
1145 * driverless.
1146 */
1147
1148void
1149pci_unregister_driver(struct pci_driver *drv)
1150{
Chris Wright09943752009-02-23 21:52:23 -08001151 pci_remove_removeid_file(drv);
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -08001152 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 driver_unregister(&drv->driver);
1154 pci_free_dynids(drv);
1155}
1156
1157static struct pci_driver pci_compat_driver = {
1158 .name = "compat"
1159};
1160
1161/**
1162 * pci_dev_driver - get the pci_driver of a device
1163 * @dev: the device to query
1164 *
1165 * Returns the appropriate pci_driver structure or %NULL if there is no
1166 * registered driver for the device.
1167 */
1168struct pci_driver *
1169pci_dev_driver(const struct pci_dev *dev)
1170{
1171 if (dev->driver)
1172 return dev->driver;
1173 else {
1174 int i;
1175 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1176 if (dev->resource[i].flags & IORESOURCE_BUSY)
1177 return &pci_compat_driver;
1178 }
1179 return NULL;
1180}
1181
1182/**
1183 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001185 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 *
1187 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001188 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 * pci_device_id structure or %NULL if there is no match.
1190 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001191static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001193 struct pci_dev *pci_dev = to_pci_dev(dev);
1194 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 const struct pci_device_id *found_id;
1196
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001197 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 if (found_id)
1199 return 1;
1200
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001201 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202}
1203
1204/**
1205 * pci_dev_get - increments the reference count of the pci device structure
1206 * @dev: the device being referenced
1207 *
1208 * Each live reference to a device should be refcounted.
1209 *
1210 * Drivers for PCI devices should normally record such references in
1211 * their probe() methods, when they bind to a device, and release
1212 * them by calling pci_dev_put(), in their disconnect() methods.
1213 *
1214 * A pointer to the device with the incremented reference counter is returned.
1215 */
1216struct pci_dev *pci_dev_get(struct pci_dev *dev)
1217{
1218 if (dev)
1219 get_device(&dev->dev);
1220 return dev;
1221}
1222
1223/**
1224 * pci_dev_put - release a use of the pci device structure
1225 * @dev: device that's been disconnected
1226 *
1227 * Must be called when a user of a device is finished with it. When the last
1228 * user of the device calls this function, the memory of the device is freed.
1229 */
1230void pci_dev_put(struct pci_dev *dev)
1231{
1232 if (dev)
1233 put_device(&dev->dev);
1234}
1235
1236#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001237int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238{
1239 return -ENODEV;
1240}
1241#endif
1242
1243struct bus_type pci_bus_type = {
1244 .name = "pci",
1245 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001246 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001247 .probe = pci_device_probe,
1248 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001249 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001251 .bus_attrs = pci_bus_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001252 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253};
1254
1255static int __init pci_driver_init(void)
1256{
1257 return bus_register(&pci_bus_type);
1258}
1259
1260postcore_initcall(pci_driver_init);
1261
Tejun Heo9dba9102009-09-03 15:26:36 +09001262EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001263EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001264EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265EXPORT_SYMBOL(pci_unregister_driver);
1266EXPORT_SYMBOL(pci_dev_driver);
1267EXPORT_SYMBOL(pci_bus_type);
1268EXPORT_SYMBOL(pci_dev_get);
1269EXPORT_SYMBOL(pci_dev_put);