blob: f99bc7f089f1ab8c0839775c58f2cabc487e37cf [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "pci.h"
21
22/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
24 */
25
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070026struct pci_dynid {
27 struct list_head node;
28 struct pci_device_id id;
29};
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Greg KH3d3c2ae2005-07-06 09:09:38 -070031#ifdef CONFIG_HOTPLUG
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/**
Randy Dunlap8f7020d2005-10-23 11:57:38 -070034 * store_new_id - add a new PCI device ID to this driver and re-probe devices
35 * @driver: target device driver
36 * @buf: buffer for scanning device ID data
37 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 *
39 * Adds a new dynamic pci device ID to this driver,
40 * and causes the driver to probe for all devices again.
41 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -070042static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -070043store_new_id(struct device_driver *driver, const char *buf, size_t count)
44{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070045 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvareb41d6cf2008-08-17 21:06:59 +020047 const struct pci_device_id *ids = pdrv->id_table;
Jean Delvare6ba18632007-04-07 17:21:28 +020048 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 subdevice=PCI_ANY_ID, class=0, class_mask=0;
50 unsigned long driver_data=0;
51 int fields=0;
Chris Wright2debb4d2008-11-25 19:36:10 -080052 int retval=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Jean Delvareb41d6cf2008-08-17 21:06:59 +020054 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 &vendor, &device, &subvendor, &subdevice,
56 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +020057 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 return -EINVAL;
59
Jean Delvareb41d6cf2008-08-17 21:06:59 +020060 /* Only accept driver_data values that match an existing id_table
61 entry */
Chris Wright2debb4d2008-11-25 19:36:10 -080062 if (ids) {
63 retval = -EINVAL;
64 while (ids->vendor || ids->subvendor || ids->class_mask) {
65 if (driver_data == ids->driver_data) {
66 retval = 0;
67 break;
68 }
69 ids++;
Jean Delvareb41d6cf2008-08-17 21:06:59 +020070 }
Chris Wright2debb4d2008-11-25 19:36:10 -080071 if (retval) /* No match */
72 return retval;
Jean Delvareb41d6cf2008-08-17 21:06:59 +020073 }
Jean Delvareb41d6cf2008-08-17 21:06:59 +020074
Eric Sesterhennf5afe802006-02-28 15:34:49 +010075 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 if (!dynid)
77 return -ENOMEM;
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 dynid->id.vendor = vendor;
80 dynid->id.device = device;
81 dynid->id.subvendor = subvendor;
82 dynid->id.subdevice = subdevice;
83 dynid->id.class = class;
84 dynid->id.class_mask = class_mask;
Milton Milleredbc25c2008-07-10 16:29:37 -050085 dynid->id.driver_data = driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87 spin_lock(&pdrv->dynids.lock);
Michael Ellermana56bc692007-09-14 15:33:13 +100088 list_add_tail(&dynid->node, &pdrv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 spin_unlock(&pdrv->dynids.lock);
90
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070091 if (get_driver(&pdrv->driver)) {
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070092 retval = driver_attach(&pdrv->driver);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070093 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 }
95
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070096 if (retval)
97 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 return count;
99}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Chris Wright09943752009-02-23 21:52:23 -0800102/**
103 * store_remove_id - remove a PCI device ID from this driver
104 * @driver: target device driver
105 * @buf: buffer for scanning device ID data
106 * @count: input size
107 *
108 * Removes a dynamic pci device ID to this driver.
109 */
110static ssize_t
111store_remove_id(struct device_driver *driver, const char *buf, size_t count)
112{
113 struct pci_dynid *dynid, *n;
114 struct pci_driver *pdrv = to_pci_driver(driver);
115 __u32 vendor, device, subvendor = PCI_ANY_ID,
116 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
117 int fields = 0;
118 int retval = -ENODEV;
119
120 fields = sscanf(buf, "%x %x %x %x %x %x",
121 &vendor, &device, &subvendor, &subdevice,
122 &class, &class_mask);
123 if (fields < 2)
124 return -EINVAL;
125
126 spin_lock(&pdrv->dynids.lock);
127 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
128 struct pci_device_id *id = &dynid->id;
129 if ((id->vendor == vendor) &&
130 (id->device == device) &&
131 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
132 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
133 !((id->class ^ class) & class_mask)) {
134 list_del(&dynid->node);
135 kfree(dynid);
136 retval = 0;
137 break;
138 }
139 }
140 spin_unlock(&pdrv->dynids.lock);
141
142 if (retval)
143 return retval;
144 return count;
145}
146static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148static void
149pci_free_dynids(struct pci_driver *drv)
150{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700151 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700154 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 list_del(&dynid->node);
156 kfree(dynid);
157 }
158 spin_unlock(&drv->dynids.lock);
159}
160
161static int
162pci_create_newid_file(struct pci_driver *drv)
163{
164 int error = 0;
165 if (drv->probe != NULL)
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800166 error = driver_create_file(&drv->driver, &driver_attr_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return error;
168}
169
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800170static void pci_remove_newid_file(struct pci_driver *drv)
171{
172 driver_remove_file(&drv->driver, &driver_attr_new_id);
173}
Chris Wright09943752009-02-23 21:52:23 -0800174
175static int
176pci_create_removeid_file(struct pci_driver *drv)
177{
178 int error = 0;
179 if (drv->probe != NULL)
180 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
181 return error;
182}
183
184static void pci_remove_removeid_file(struct pci_driver *drv)
185{
186 driver_remove_file(&drv->driver, &driver_attr_remove_id);
187}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189static inline void pci_free_dynids(struct pci_driver *drv) {}
190static inline int pci_create_newid_file(struct pci_driver *drv)
191{
192 return 0;
193}
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800194static inline void pci_remove_newid_file(struct pci_driver *drv) {}
Chris Wright09943752009-02-23 21:52:23 -0800195static inline int pci_create_removeid_file(struct pci_driver *drv)
196{
197 return 0;
198}
199static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200#endif
201
202/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700203 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700205 * @dev: the PCI device structure to match against.
206 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700208 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700210 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200211 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700212 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700214const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
215 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700217 if (ids) {
218 while (ids->vendor || ids->subvendor || ids->class_mask) {
219 if (pci_match_one_device(ids, dev))
220 return ids;
221 ids++;
222 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 }
224 return NULL;
225}
226
227/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800228 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700229 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200230 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700231 *
232 * Used by a driver to check whether a PCI device present in the
233 * system is in its list of supported devices. Returns the matching
234 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200236static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
237 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700238{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700239 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Russell King7461b602006-11-29 21:18:04 +0000241 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700242 spin_lock(&drv->dynids.lock);
243 list_for_each_entry(dynid, &drv->dynids.list, node) {
244 if (pci_match_one_device(&dynid->id, dev)) {
245 spin_unlock(&drv->dynids.lock);
246 return &dynid->id;
247 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700249 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000250
251 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252}
253
Rusty Russell873392c2008-12-31 23:54:56 +1030254struct drv_dev_and_id {
255 struct pci_driver *drv;
256 struct pci_dev *dev;
257 const struct pci_device_id *id;
258};
259
260static long local_pci_probe(void *_ddi)
261{
262 struct drv_dev_and_id *ddi = _ddi;
263
264 return ddi->drv->probe(ddi->dev, ddi->id);
265}
266
Andi Kleend42c6992005-07-06 19:56:03 +0200267static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
268 const struct pci_device_id *id)
269{
Rusty Russell873392c2008-12-31 23:54:56 +1030270 int error, node;
271 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700272
Rusty Russell873392c2008-12-31 23:54:56 +1030273 /* Execute driver initialization on node where the device's
274 bus is attached to. This way the driver likely allocates
275 its local memory on the right node without any need to
276 change it. */
277 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700278 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030279 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030280
281 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030282 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030283 if (cpu < nr_cpu_ids)
284 error = work_on_cpu(cpu, local_pci_probe, &ddi);
285 else
286 error = local_pci_probe(&ddi);
287 put_online_cpus();
288 } else
289 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200290 return error;
291}
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293/**
294 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700295 * @drv: driver to call to check if it wants the PCI device
296 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700298 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
300 */
301static int
302__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700303{
304 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 int error = 0;
306
307 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700308 error = -ENODEV;
309
310 id = pci_match_device(drv, pci_dev);
311 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200312 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700313 if (error >= 0) {
314 pci_dev->driver = drv;
315 error = 0;
316 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 }
318 return error;
319}
320
321static int pci_device_probe(struct device * dev)
322{
323 int error = 0;
324 struct pci_driver *drv;
325 struct pci_dev *pci_dev;
326
327 drv = to_pci_driver(dev->driver);
328 pci_dev = to_pci_dev(dev);
329 pci_dev_get(pci_dev);
330 error = __pci_device_probe(drv, pci_dev);
331 if (error)
332 pci_dev_put(pci_dev);
333
334 return error;
335}
336
337static int pci_device_remove(struct device * dev)
338{
339 struct pci_dev * pci_dev = to_pci_dev(dev);
340 struct pci_driver * drv = pci_dev->driver;
341
342 if (drv) {
343 if (drv->remove)
344 drv->remove(pci_dev);
345 pci_dev->driver = NULL;
346 }
347
348 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700349 * If the device is still on, set the power state as "unknown",
350 * since it might change by the next time we load the driver.
351 */
352 if (pci_dev->current_state == PCI_D0)
353 pci_dev->current_state = PCI_UNKNOWN;
354
355 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 * We would love to complain here if pci_dev->is_enabled is set, that
357 * the driver should have called pci_disable_device(), but the
358 * unfortunate fact is there are too many odd BIOS and bridge setups
359 * that don't like drivers doing that all of the time.
360 * Oh well, we can dream of sane hardware when we sleep, no matter how
361 * horrible the crap we have to deal with is when we are awake...
362 */
363
364 pci_dev_put(pci_dev);
365 return 0;
366}
367
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200368static void pci_device_shutdown(struct device *dev)
369{
370 struct pci_dev *pci_dev = to_pci_dev(dev);
371 struct pci_driver *drv = pci_dev->driver;
372
373 if (drv && drv->shutdown)
374 drv->shutdown(pci_dev);
375 pci_msi_shutdown(pci_dev);
376 pci_msix_shutdown(pci_dev);
377}
378
379#ifdef CONFIG_PM_SLEEP
380
381/*
382 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100383 * or not even a driver at all (second part).
384 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100385static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200386{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200387 /*
388 * mark its power state as "unknown", since we don't know if
389 * e.g. the BIOS will change its device state when we suspend.
390 */
391 if (pci_dev->current_state == PCI_D0)
392 pci_dev->current_state = PCI_UNKNOWN;
393}
394
395/*
396 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100397 * or not even a driver at all (second part).
398 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100399static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100400{
401 int retval;
402
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200403 /* if the device was enabled before suspend, reenable */
404 retval = pci_reenable_device(pci_dev);
405 /*
406 * if the device was busmaster before the suspend, make it busmaster
407 * again
408 */
409 if (pci_dev->is_busmaster)
410 pci_set_master(pci_dev);
411
412 return retval;
413}
414
415static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
417 struct pci_dev * pci_dev = to_pci_dev(dev);
418 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100419
420 pci_dev->state_saved = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Andrew Morton02669492006-03-23 01:38:34 -0800422 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100423 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100424 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100425
Frans Pop57ef8022009-03-16 22:39:56 +0100426 error = drv->suspend(pci_dev, state);
427 suspend_report_result(drv->suspend, error);
428 if (error)
429 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100430
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100431 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100432 && pci_dev->current_state != PCI_UNKNOWN) {
433 WARN_ONCE(pci_dev->current_state != prev,
434 "PCI PM: Device state not saved by %pF\n",
435 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100436 }
Andrew Morton02669492006-03-23 01:38:34 -0800437 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100438
439 pci_fixup_device(pci_fixup_suspend, pci_dev);
440
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100441 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442}
443
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200444static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700445{
446 struct pci_dev * pci_dev = to_pci_dev(dev);
447 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700448
449 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100450 pci_power_t prev = pci_dev->current_state;
451 int error;
452
Frans Pop57ef8022009-03-16 22:39:56 +0100453 error = drv->suspend_late(pci_dev, state);
454 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100455 if (error)
456 return error;
457
458 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
459 && pci_dev->current_state != PCI_UNKNOWN) {
460 WARN_ONCE(pci_dev->current_state != prev,
461 "PCI PM: Device state not saved by %pF\n",
462 drv->suspend_late);
463 return 0;
464 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700465 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100466
467 if (!pci_dev->state_saved)
468 pci_save_state(pci_dev);
469
470 pci_pm_set_unknown_state(pci_dev);
471
472 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700473}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100475static int pci_legacy_resume_early(struct device *dev)
476{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100477 struct pci_dev * pci_dev = to_pci_dev(dev);
478 struct pci_driver * drv = pci_dev->driver;
479
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100480 return drv && drv->resume_early ?
481 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100482}
483
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200484static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485{
486 struct pci_dev * pci_dev = to_pci_dev(dev);
487 struct pci_driver * drv = pci_dev->driver;
488
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100489 pci_fixup_device(pci_fixup_resume, pci_dev);
490
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100491 return drv && drv->resume ?
492 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493}
494
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100495/* Auxiliary functions used by the new power management framework */
496
Rafael J. Wysocki0128a892009-03-16 22:40:18 +0100497/**
498 * pci_restore_standard_config - restore standard config registers of PCI device
499 * @pci_dev: PCI device to handle
500 */
501static int pci_restore_standard_config(struct pci_dev *pci_dev)
502{
503 pci_update_current_state(pci_dev, PCI_UNKNOWN);
504
505 if (pci_dev->current_state != PCI_D0) {
506 int error = pci_set_power_state(pci_dev, PCI_D0);
507 if (error)
508 return error;
509 }
510
Alek Duc82f63e2009-08-08 08:46:19 +0800511 return pci_restore_state(pci_dev);
Rafael J. Wysocki0128a892009-03-16 22:40:18 +0100512}
513
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100514static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
515{
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100516 pci_restore_standard_config(pci_dev);
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100517 pci_dev->state_saved = false;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100518 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100519}
520
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100521static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100522{
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100523 pci_fixup_device(pci_fixup_resume, pci_dev);
524
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100525 if (!pci_is_bridge(pci_dev))
526 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100527}
528
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100529static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100530{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100531 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100532 if (!pci_is_bridge(pci_dev))
533 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki73410422009-01-07 13:07:15 +0100534}
535
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100536static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
537{
538 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100539 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100540 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100541
542 /*
543 * Legacy PM support is used by default, so warn if the new framework is
544 * supported as well. Drivers are supposed to support either the
545 * former, or the latter, but not both at the same time.
546 */
547 WARN_ON(ret && drv->driver.pm);
548
549 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100550}
551
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100552/* New power management framework */
553
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200554static int pci_pm_prepare(struct device *dev)
555{
556 struct device_driver *drv = dev->driver;
557 int error = 0;
558
559 if (drv && drv->pm && drv->pm->prepare)
560 error = drv->pm->prepare(dev);
561
562 return error;
563}
564
565static void pci_pm_complete(struct device *dev)
566{
567 struct device_driver *drv = dev->driver;
568
569 if (drv && drv->pm && drv->pm->complete)
570 drv->pm->complete(dev);
571}
572
573#ifdef CONFIG_SUSPEND
574
575static int pci_pm_suspend(struct device *dev)
576{
577 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100578 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200579
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100580 if (pci_has_legacy_pm_support(pci_dev))
581 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100582
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100583 pci_dev->state_saved = false;
584
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100585 if (!pm) {
586 pci_pm_default_suspend(pci_dev);
587 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200588 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100589
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100590 if (pm->suspend) {
591 pci_power_t prev = pci_dev->current_state;
592 int error;
593
594 error = pm->suspend(dev);
595 suspend_report_result(pm->suspend, error);
596 if (error)
597 return error;
598
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100599 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100600 && pci_dev->current_state != PCI_UNKNOWN) {
601 WARN_ONCE(pci_dev->current_state != prev,
602 "PCI PM: State of device not saved by %pF\n",
603 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100604 }
605 }
606
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100607 Fixup:
608 pci_fixup_device(pci_fixup_suspend, pci_dev);
609
610 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200611}
612
613static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900614{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100615 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100616 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900617
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100618 if (pci_has_legacy_pm_support(pci_dev))
619 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
620
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100621 if (!pm) {
622 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100623 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100624 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100625
626 if (pm->suspend_noirq) {
627 pci_power_t prev = pci_dev->current_state;
628 int error;
629
630 error = pm->suspend_noirq(dev);
631 suspend_report_result(pm->suspend_noirq, error);
632 if (error)
633 return error;
634
635 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
636 && pci_dev->current_state != PCI_UNKNOWN) {
637 WARN_ONCE(pci_dev->current_state != prev,
638 "PCI PM: State of device not saved by %pF\n",
639 pm->suspend_noirq);
640 return 0;
641 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200642 }
643
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100644 if (!pci_dev->state_saved) {
645 pci_save_state(pci_dev);
646 if (!pci_is_bridge(pci_dev))
647 pci_prepare_to_sleep(pci_dev);
648 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100649
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100650 pci_pm_set_unknown_state(pci_dev);
651
652 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900653}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200655static int pci_pm_resume_noirq(struct device *dev)
656{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100657 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200658 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200659 int error = 0;
660
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100661 pci_pm_default_resume_noirq(pci_dev);
662
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100663 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100664 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100665
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100666 if (drv && drv->pm && drv->pm->resume_noirq)
667 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200668
669 return error;
670}
671
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100672static int pci_pm_resume(struct device *dev)
673{
674 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100675 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100676 int error = 0;
677
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100678 /*
679 * This is necessary for the suspend error path in which resume is
680 * called without restoring the standard config registers of the device.
681 */
682 if (pci_dev->state_saved)
683 pci_restore_standard_config(pci_dev);
684
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100685 if (pci_has_legacy_pm_support(pci_dev))
686 return pci_legacy_resume(dev);
687
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100688 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100689
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100690 if (pm) {
691 if (pm->resume)
692 error = pm->resume(dev);
693 } else {
694 pci_pm_reenable_device(pci_dev);
695 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100696
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100697 return 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100698}
699
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200700#else /* !CONFIG_SUSPEND */
701
702#define pci_pm_suspend NULL
703#define pci_pm_suspend_noirq NULL
704#define pci_pm_resume NULL
705#define pci_pm_resume_noirq NULL
706
707#endif /* !CONFIG_SUSPEND */
708
709#ifdef CONFIG_HIBERNATION
710
711static int pci_pm_freeze(struct device *dev)
712{
713 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100714 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200715
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100716 if (pci_has_legacy_pm_support(pci_dev))
717 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100718
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100719 pci_dev->state_saved = false;
720
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100721 if (!pm) {
722 pci_pm_default_suspend(pci_dev);
723 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200724 }
725
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100726 if (pm->freeze) {
727 int error;
728
729 error = pm->freeze(dev);
730 suspend_report_result(pm->freeze, error);
731 if (error)
732 return error;
733 }
734
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100735 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200736}
737
738static int pci_pm_freeze_noirq(struct device *dev)
739{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100740 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200741 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200742
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100743 if (pci_has_legacy_pm_support(pci_dev))
744 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
745
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100746 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100747 int error;
748
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100749 error = drv->pm->freeze_noirq(dev);
750 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100751 if (error)
752 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200753 }
754
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100755 if (!pci_dev->state_saved)
756 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100757
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100758 pci_pm_set_unknown_state(pci_dev);
759
760 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200761}
762
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200763static int pci_pm_thaw_noirq(struct device *dev)
764{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100765 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200766 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200767 int error = 0;
768
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100769 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100770 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100771
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100772 pci_update_current_state(pci_dev, PCI_D0);
773
774 if (drv && drv->pm && drv->pm->thaw_noirq)
775 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200776
777 return error;
778}
779
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100780static int pci_pm_thaw(struct device *dev)
781{
782 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100783 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100784 int error = 0;
785
786 if (pci_has_legacy_pm_support(pci_dev))
787 return pci_legacy_resume(dev);
788
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100789 if (pm) {
790 if (pm->thaw)
791 error = pm->thaw(dev);
792 } else {
793 pci_pm_reenable_device(pci_dev);
794 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100795
796 return error;
797}
798
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200799static int pci_pm_poweroff(struct device *dev)
800{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100801 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100802 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200803
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100804 if (pci_has_legacy_pm_support(pci_dev))
805 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100806
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100807 pci_dev->state_saved = false;
808
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100809 if (!pm) {
810 pci_pm_default_suspend(pci_dev);
811 goto Fixup;
812 }
813
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100814 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100815 int error;
816
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100817 error = pm->poweroff(dev);
818 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100819 if (error)
820 return error;
821 }
822
823 Fixup:
824 pci_fixup_device(pci_fixup_suspend, pci_dev);
825
826 return 0;
827}
828
829static int pci_pm_poweroff_noirq(struct device *dev)
830{
831 struct pci_dev *pci_dev = to_pci_dev(dev);
832 struct device_driver *drv = dev->driver;
833
834 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
835 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
836
837 if (!drv || !drv->pm)
838 return 0;
839
840 if (drv->pm->poweroff_noirq) {
841 int error;
842
843 error = drv->pm->poweroff_noirq(dev);
844 suspend_report_result(drv->pm->poweroff_noirq, error);
845 if (error)
846 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200847 }
848
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100849 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
850 pci_prepare_to_sleep(pci_dev);
851
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100852 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200853}
854
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200855static int pci_pm_restore_noirq(struct device *dev)
856{
857 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200858 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200859 int error = 0;
860
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100861 pci_pm_default_resume_noirq(pci_dev);
862
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100863 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100864 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100865
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100866 if (drv && drv->pm && drv->pm->restore_noirq)
867 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200868
869 return error;
870}
871
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100872static int pci_pm_restore(struct device *dev)
873{
874 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100875 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100876 int error = 0;
877
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100878 /*
879 * This is necessary for the hibernation error path in which restore is
880 * called without restoring the standard config registers of the device.
881 */
882 if (pci_dev->state_saved)
883 pci_restore_standard_config(pci_dev);
884
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100885 if (pci_has_legacy_pm_support(pci_dev))
886 return pci_legacy_resume(dev);
887
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100888 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100889
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100890 if (pm) {
891 if (pm->restore)
892 error = pm->restore(dev);
893 } else {
894 pci_pm_reenable_device(pci_dev);
895 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100896
897 return error;
898}
899
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200900#else /* !CONFIG_HIBERNATION */
901
902#define pci_pm_freeze NULL
903#define pci_pm_freeze_noirq NULL
904#define pci_pm_thaw NULL
905#define pci_pm_thaw_noirq NULL
906#define pci_pm_poweroff NULL
907#define pci_pm_poweroff_noirq NULL
908#define pci_pm_restore NULL
909#define pci_pm_restore_noirq NULL
910
911#endif /* !CONFIG_HIBERNATION */
912
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200913struct dev_pm_ops pci_dev_pm_ops = {
914 .prepare = pci_pm_prepare,
915 .complete = pci_pm_complete,
916 .suspend = pci_pm_suspend,
917 .resume = pci_pm_resume,
918 .freeze = pci_pm_freeze,
919 .thaw = pci_pm_thaw,
920 .poweroff = pci_pm_poweroff,
921 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200922 .suspend_noirq = pci_pm_suspend_noirq,
923 .resume_noirq = pci_pm_resume_noirq,
924 .freeze_noirq = pci_pm_freeze_noirq,
925 .thaw_noirq = pci_pm_thaw_noirq,
926 .poweroff_noirq = pci_pm_poweroff_noirq,
927 .restore_noirq = pci_pm_restore_noirq,
928};
929
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200930#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200931
932#else /* !CONFIG_PM_SLEEP */
933
934#define PCI_PM_OPS_PTR NULL
935
936#endif /* !CONFIG_PM_SLEEP */
937
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200939 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200941 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800942 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 *
944 * Adds the driver structure to the list of registered drivers.
945 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600946 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 * no device was claimed during registration.
948 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800949int __pci_register_driver(struct pci_driver *drv, struct module *owner,
950 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951{
952 int error;
953
954 /* initialize common driver fields */
955 drv->driver.name = drv->name;
956 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200957 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800958 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100959
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700960 spin_lock_init(&drv->dynids.lock);
961 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
963 /* register with core */
964 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800965 if (error)
Chris Wright09943752009-02-23 21:52:23 -0800966 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800968 error = pci_create_newid_file(drv);
969 if (error)
Chris Wright09943752009-02-23 21:52:23 -0800970 goto out_newid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
Chris Wright09943752009-02-23 21:52:23 -0800972 error = pci_create_removeid_file(drv);
973 if (error)
974 goto out_removeid;
975out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 return error;
Chris Wright09943752009-02-23 21:52:23 -0800977
978out_removeid:
979 pci_remove_newid_file(drv);
980out_newid:
981 driver_unregister(&drv->driver);
982 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983}
984
985/**
986 * pci_unregister_driver - unregister a pci driver
987 * @drv: the driver structure to unregister
988 *
989 * Deletes the driver structure from the list of registered PCI drivers,
990 * gives it a chance to clean up by calling its remove() function for
991 * each device it was responsible for, and marks those devices as
992 * driverless.
993 */
994
995void
996pci_unregister_driver(struct pci_driver *drv)
997{
Chris Wright09943752009-02-23 21:52:23 -0800998 pci_remove_removeid_file(drv);
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800999 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 driver_unregister(&drv->driver);
1001 pci_free_dynids(drv);
1002}
1003
1004static struct pci_driver pci_compat_driver = {
1005 .name = "compat"
1006};
1007
1008/**
1009 * pci_dev_driver - get the pci_driver of a device
1010 * @dev: the device to query
1011 *
1012 * Returns the appropriate pci_driver structure or %NULL if there is no
1013 * registered driver for the device.
1014 */
1015struct pci_driver *
1016pci_dev_driver(const struct pci_dev *dev)
1017{
1018 if (dev->driver)
1019 return dev->driver;
1020 else {
1021 int i;
1022 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1023 if (dev->resource[i].flags & IORESOURCE_BUSY)
1024 return &pci_compat_driver;
1025 }
1026 return NULL;
1027}
1028
1029/**
1030 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001032 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 *
1034 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001035 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 * pci_device_id structure or %NULL if there is no match.
1037 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001038static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001040 struct pci_dev *pci_dev = to_pci_dev(dev);
1041 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 const struct pci_device_id *found_id;
1043
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001044 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 if (found_id)
1046 return 1;
1047
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001048 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
1050
1051/**
1052 * pci_dev_get - increments the reference count of the pci device structure
1053 * @dev: the device being referenced
1054 *
1055 * Each live reference to a device should be refcounted.
1056 *
1057 * Drivers for PCI devices should normally record such references in
1058 * their probe() methods, when they bind to a device, and release
1059 * them by calling pci_dev_put(), in their disconnect() methods.
1060 *
1061 * A pointer to the device with the incremented reference counter is returned.
1062 */
1063struct pci_dev *pci_dev_get(struct pci_dev *dev)
1064{
1065 if (dev)
1066 get_device(&dev->dev);
1067 return dev;
1068}
1069
1070/**
1071 * pci_dev_put - release a use of the pci device structure
1072 * @dev: device that's been disconnected
1073 *
1074 * Must be called when a user of a device is finished with it. When the last
1075 * user of the device calls this function, the memory of the device is freed.
1076 */
1077void pci_dev_put(struct pci_dev *dev)
1078{
1079 if (dev)
1080 put_device(&dev->dev);
1081}
1082
1083#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001084int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085{
1086 return -ENODEV;
1087}
1088#endif
1089
1090struct bus_type pci_bus_type = {
1091 .name = "pci",
1092 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001093 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001094 .probe = pci_device_probe,
1095 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001096 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001098 .bus_attrs = pci_bus_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001099 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100};
1101
1102static int __init pci_driver_init(void)
1103{
1104 return bus_register(&pci_bus_type);
1105}
1106
1107postcore_initcall(pci_driver_init);
1108
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001109EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001110EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111EXPORT_SYMBOL(pci_unregister_driver);
1112EXPORT_SYMBOL(pci_dev_driver);
1113EXPORT_SYMBOL(pci_bus_type);
1114EXPORT_SYMBOL(pci_dev_get);
1115EXPORT_SYMBOL(pci_dev_put);