blob: ffc15e97d11cd1765176489d12d8fa9cd9627df0 [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
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070022struct pci_dynid {
23 struct list_head node;
24 struct pci_device_id id;
25};
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27/**
Tejun Heo9dba9102009-09-03 15:26:36 +090028 * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
29 * @drv: target pci driver
30 * @vendor: PCI vendor ID
31 * @device: PCI device ID
32 * @subvendor: PCI subvendor ID
33 * @subdevice: PCI subdevice ID
34 * @class: PCI class
35 * @class_mask: PCI class mask
36 * @driver_data: private driver data
37 *
38 * Adds a new dynamic pci device ID to this driver and causes the
39 * driver to probe for all devices again. @drv must have been
40 * registered prior to calling this function.
41 *
42 * CONTEXT:
43 * Does GFP_KERNEL allocation.
44 *
45 * RETURNS:
46 * 0 on success, -errno on failure.
47 */
48int pci_add_dynid(struct pci_driver *drv,
49 unsigned int vendor, unsigned int device,
50 unsigned int subvendor, unsigned int subdevice,
51 unsigned int class, unsigned int class_mask,
52 unsigned long driver_data)
53{
54 struct pci_dynid *dynid;
55 int retval;
56
57 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
58 if (!dynid)
59 return -ENOMEM;
60
61 dynid->id.vendor = vendor;
62 dynid->id.device = device;
63 dynid->id.subvendor = subvendor;
64 dynid->id.subdevice = subdevice;
65 dynid->id.class = class;
66 dynid->id.class_mask = class_mask;
67 dynid->id.driver_data = driver_data;
68
69 spin_lock(&drv->dynids.lock);
70 list_add_tail(&dynid->node, &drv->dynids.list);
71 spin_unlock(&drv->dynids.lock);
72
73 get_driver(&drv->driver);
74 retval = driver_attach(&drv->driver);
75 put_driver(&drv->driver);
76
77 return retval;
78}
79
80static void pci_free_dynids(struct pci_driver *drv)
81{
82 struct pci_dynid *dynid, *n;
83
84 spin_lock(&drv->dynids.lock);
85 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
86 list_del(&dynid->node);
87 kfree(dynid);
88 }
89 spin_unlock(&drv->dynids.lock);
90}
91
92/*
93 * Dynamic device ID manipulation via sysfs is disabled for !CONFIG_HOTPLUG
94 */
95#ifdef CONFIG_HOTPLUG
96/**
97 * store_new_id - sysfs frontend to pci_add_dynid()
Randy Dunlap8f7020d2005-10-23 11:57:38 -070098 * @driver: target device driver
99 * @buf: buffer for scanning device ID data
100 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 *
Tejun Heo9dba9102009-09-03 15:26:36 +0900102 * Allow PCI IDs to be added to an existing driver via sysfs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -0700104static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105store_new_id(struct device_driver *driver, const char *buf, size_t count)
106{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200108 const struct pci_device_id *ids = pdrv->id_table;
Jean Delvare6ba18632007-04-07 17:21:28 +0200109 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 subdevice=PCI_ANY_ID, class=0, class_mask=0;
111 unsigned long driver_data=0;
112 int fields=0;
Tejun Heo9dba9102009-09-03 15:26:36 +0900113 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200115 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 &vendor, &device, &subvendor, &subdevice,
117 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +0200118 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 return -EINVAL;
120
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200121 /* Only accept driver_data values that match an existing id_table
122 entry */
Chris Wright2debb4d2008-11-25 19:36:10 -0800123 if (ids) {
124 retval = -EINVAL;
125 while (ids->vendor || ids->subvendor || ids->class_mask) {
126 if (driver_data == ids->driver_data) {
127 retval = 0;
128 break;
129 }
130 ids++;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200131 }
Chris Wright2debb4d2008-11-25 19:36:10 -0800132 if (retval) /* No match */
133 return retval;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200134 }
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200135
Tejun Heo9dba9102009-09-03 15:26:36 +0900136 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
137 class, class_mask, driver_data);
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700138 if (retval)
139 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 return count;
141}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Chris Wright09943752009-02-23 21:52:23 -0800144/**
145 * store_remove_id - remove a PCI device ID from this driver
146 * @driver: target device driver
147 * @buf: buffer for scanning device ID data
148 * @count: input size
149 *
150 * Removes a dynamic pci device ID to this driver.
151 */
152static ssize_t
153store_remove_id(struct device_driver *driver, const char *buf, size_t count)
154{
155 struct pci_dynid *dynid, *n;
156 struct pci_driver *pdrv = to_pci_driver(driver);
157 __u32 vendor, device, subvendor = PCI_ANY_ID,
158 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
159 int fields = 0;
160 int retval = -ENODEV;
161
162 fields = sscanf(buf, "%x %x %x %x %x %x",
163 &vendor, &device, &subvendor, &subdevice,
164 &class, &class_mask);
165 if (fields < 2)
166 return -EINVAL;
167
168 spin_lock(&pdrv->dynids.lock);
169 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
170 struct pci_device_id *id = &dynid->id;
171 if ((id->vendor == vendor) &&
172 (id->device == device) &&
173 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
174 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
175 !((id->class ^ class) & class_mask)) {
176 list_del(&dynid->node);
177 kfree(dynid);
178 retval = 0;
179 break;
180 }
181 }
182 spin_unlock(&pdrv->dynids.lock);
183
184 if (retval)
185 return retval;
186 return count;
187}
188static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190static int
191pci_create_newid_file(struct pci_driver *drv)
192{
193 int error = 0;
194 if (drv->probe != NULL)
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800195 error = driver_create_file(&drv->driver, &driver_attr_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 return error;
197}
198
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800199static void pci_remove_newid_file(struct pci_driver *drv)
200{
201 driver_remove_file(&drv->driver, &driver_attr_new_id);
202}
Chris Wright09943752009-02-23 21:52:23 -0800203
204static int
205pci_create_removeid_file(struct pci_driver *drv)
206{
207 int error = 0;
208 if (drv->probe != NULL)
209 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
210 return error;
211}
212
213static void pci_remove_removeid_file(struct pci_driver *drv)
214{
215 driver_remove_file(&drv->driver, &driver_attr_remove_id);
216}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218static inline int pci_create_newid_file(struct pci_driver *drv)
219{
220 return 0;
221}
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800222static inline void pci_remove_newid_file(struct pci_driver *drv) {}
Chris Wright09943752009-02-23 21:52:23 -0800223static inline int pci_create_removeid_file(struct pci_driver *drv)
224{
225 return 0;
226}
227static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228#endif
229
230/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700231 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700233 * @dev: the PCI device structure to match against.
234 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700236 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700238 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200239 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700240 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700242const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
243 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700245 if (ids) {
246 while (ids->vendor || ids->subvendor || ids->class_mask) {
247 if (pci_match_one_device(ids, dev))
248 return ids;
249 ids++;
250 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 }
252 return NULL;
253}
254
255/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800256 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700257 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200258 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700259 *
260 * Used by a driver to check whether a PCI device present in the
261 * system is in its list of supported devices. Returns the matching
262 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200264static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
265 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700266{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700267 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Russell King7461b602006-11-29 21:18:04 +0000269 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700270 spin_lock(&drv->dynids.lock);
271 list_for_each_entry(dynid, &drv->dynids.list, node) {
272 if (pci_match_one_device(&dynid->id, dev)) {
273 spin_unlock(&drv->dynids.lock);
274 return &dynid->id;
275 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700277 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000278
279 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280}
281
Rusty Russell873392c2008-12-31 23:54:56 +1030282struct drv_dev_and_id {
283 struct pci_driver *drv;
284 struct pci_dev *dev;
285 const struct pci_device_id *id;
286};
287
288static long local_pci_probe(void *_ddi)
289{
290 struct drv_dev_and_id *ddi = _ddi;
291
292 return ddi->drv->probe(ddi->dev, ddi->id);
293}
294
Andi Kleend42c6992005-07-06 19:56:03 +0200295static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
296 const struct pci_device_id *id)
297{
Rusty Russell873392c2008-12-31 23:54:56 +1030298 int error, node;
299 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700300
Rusty Russell873392c2008-12-31 23:54:56 +1030301 /* Execute driver initialization on node where the device's
302 bus is attached to. This way the driver likely allocates
303 its local memory on the right node without any need to
304 change it. */
305 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700306 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030307 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030308
309 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030310 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030311 if (cpu < nr_cpu_ids)
312 error = work_on_cpu(cpu, local_pci_probe, &ddi);
313 else
314 error = local_pci_probe(&ddi);
315 put_online_cpus();
316 } else
317 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200318 return error;
319}
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321/**
322 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700323 * @drv: driver to call to check if it wants the PCI device
324 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700326 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
328 */
329static int
330__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700331{
332 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 int error = 0;
334
335 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700336 error = -ENODEV;
337
338 id = pci_match_device(drv, pci_dev);
339 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200340 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700341 if (error >= 0) {
342 pci_dev->driver = drv;
343 error = 0;
344 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 }
346 return error;
347}
348
349static int pci_device_probe(struct device * dev)
350{
351 int error = 0;
352 struct pci_driver *drv;
353 struct pci_dev *pci_dev;
354
355 drv = to_pci_driver(dev->driver);
356 pci_dev = to_pci_dev(dev);
357 pci_dev_get(pci_dev);
358 error = __pci_device_probe(drv, pci_dev);
359 if (error)
360 pci_dev_put(pci_dev);
361
362 return error;
363}
364
365static int pci_device_remove(struct device * dev)
366{
367 struct pci_dev * pci_dev = to_pci_dev(dev);
368 struct pci_driver * drv = pci_dev->driver;
369
370 if (drv) {
371 if (drv->remove)
372 drv->remove(pci_dev);
373 pci_dev->driver = NULL;
374 }
375
376 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700377 * If the device is still on, set the power state as "unknown",
378 * since it might change by the next time we load the driver.
379 */
380 if (pci_dev->current_state == PCI_D0)
381 pci_dev->current_state = PCI_UNKNOWN;
382
383 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 * We would love to complain here if pci_dev->is_enabled is set, that
385 * the driver should have called pci_disable_device(), but the
386 * unfortunate fact is there are too many odd BIOS and bridge setups
387 * that don't like drivers doing that all of the time.
388 * Oh well, we can dream of sane hardware when we sleep, no matter how
389 * horrible the crap we have to deal with is when we are awake...
390 */
391
392 pci_dev_put(pci_dev);
393 return 0;
394}
395
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200396static void pci_device_shutdown(struct device *dev)
397{
398 struct pci_dev *pci_dev = to_pci_dev(dev);
399 struct pci_driver *drv = pci_dev->driver;
400
401 if (drv && drv->shutdown)
402 drv->shutdown(pci_dev);
403 pci_msi_shutdown(pci_dev);
404 pci_msix_shutdown(pci_dev);
405}
406
407#ifdef CONFIG_PM_SLEEP
408
409/*
410 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100411 * or not even a driver at all (second part).
412 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100413static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200414{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200415 /*
416 * mark its power state as "unknown", since we don't know if
417 * e.g. the BIOS will change its device state when we suspend.
418 */
419 if (pci_dev->current_state == PCI_D0)
420 pci_dev->current_state = PCI_UNKNOWN;
421}
422
423/*
424 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100425 * or not even a driver at all (second part).
426 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100427static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100428{
429 int retval;
430
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200431 /* if the device was enabled before suspend, reenable */
432 retval = pci_reenable_device(pci_dev);
433 /*
434 * if the device was busmaster before the suspend, make it busmaster
435 * again
436 */
437 if (pci_dev->is_busmaster)
438 pci_set_master(pci_dev);
439
440 return retval;
441}
442
443static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444{
445 struct pci_dev * pci_dev = to_pci_dev(dev);
446 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100447
Andrew Morton02669492006-03-23 01:38:34 -0800448 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100449 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100450 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100451
Frans Pop57ef8022009-03-16 22:39:56 +0100452 error = drv->suspend(pci_dev, state);
453 suspend_report_result(drv->suspend, error);
454 if (error)
455 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100456
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100457 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100458 && pci_dev->current_state != PCI_UNKNOWN) {
459 WARN_ONCE(pci_dev->current_state != prev,
460 "PCI PM: Device state not saved by %pF\n",
461 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100462 }
Andrew Morton02669492006-03-23 01:38:34 -0800463 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100464
465 pci_fixup_device(pci_fixup_suspend, pci_dev);
466
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100467 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468}
469
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200470static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700471{
472 struct pci_dev * pci_dev = to_pci_dev(dev);
473 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700474
475 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100476 pci_power_t prev = pci_dev->current_state;
477 int error;
478
Frans Pop57ef8022009-03-16 22:39:56 +0100479 error = drv->suspend_late(pci_dev, state);
480 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100481 if (error)
482 return error;
483
484 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
485 && pci_dev->current_state != PCI_UNKNOWN) {
486 WARN_ONCE(pci_dev->current_state != prev,
487 "PCI PM: Device state not saved by %pF\n",
488 drv->suspend_late);
489 return 0;
490 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700491 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100492
493 if (!pci_dev->state_saved)
494 pci_save_state(pci_dev);
495
496 pci_pm_set_unknown_state(pci_dev);
497
498 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700499}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100501static int pci_legacy_resume_early(struct device *dev)
502{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100503 struct pci_dev * pci_dev = to_pci_dev(dev);
504 struct pci_driver * drv = pci_dev->driver;
505
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100506 return drv && drv->resume_early ?
507 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100508}
509
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200510static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
512 struct pci_dev * pci_dev = to_pci_dev(dev);
513 struct pci_driver * drv = pci_dev->driver;
514
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100515 pci_fixup_device(pci_fixup_resume, pci_dev);
516
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100517 return drv && drv->resume ?
518 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519}
520
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100521/* Auxiliary functions used by the new power management framework */
522
Rafael J. Wysocki0128a892009-03-16 22:40:18 +0100523/**
524 * pci_restore_standard_config - restore standard config registers of PCI device
525 * @pci_dev: PCI device to handle
526 */
527static int pci_restore_standard_config(struct pci_dev *pci_dev)
528{
529 pci_update_current_state(pci_dev, PCI_UNKNOWN);
530
531 if (pci_dev->current_state != PCI_D0) {
532 int error = pci_set_power_state(pci_dev, PCI_D0);
533 if (error)
534 return error;
535 }
536
Alek Duc82f63e2009-08-08 08:46:19 +0800537 return pci_restore_state(pci_dev);
Rafael J. Wysocki0128a892009-03-16 22:40:18 +0100538}
539
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100540static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
541{
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100542 pci_restore_standard_config(pci_dev);
543 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100544}
545
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100546static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100547{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100548 pci_fixup_device(pci_fixup_resume, pci_dev);
549
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100550 if (!pci_is_bridge(pci_dev))
551 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100552}
553
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100554static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100555{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100556 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100557 if (!pci_is_bridge(pci_dev))
558 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100559}
560
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100561static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
562{
563 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100564 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100565 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100566
567 /*
568 * Legacy PM support is used by default, so warn if the new framework is
569 * supported as well. Drivers are supposed to support either the
570 * former, or the latter, but not both at the same time.
571 */
572 WARN_ON(ret && drv->driver.pm);
573
574 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100575}
576
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100577/* New power management framework */
578
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200579static int pci_pm_prepare(struct device *dev)
580{
581 struct device_driver *drv = dev->driver;
582 int error = 0;
583
584 if (drv && drv->pm && drv->pm->prepare)
585 error = drv->pm->prepare(dev);
586
587 return error;
588}
589
590static void pci_pm_complete(struct device *dev)
591{
592 struct device_driver *drv = dev->driver;
593
594 if (drv && drv->pm && drv->pm->complete)
595 drv->pm->complete(dev);
596}
597
598#ifdef CONFIG_SUSPEND
599
600static int pci_pm_suspend(struct device *dev)
601{
602 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100603 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200604
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100605 if (pci_has_legacy_pm_support(pci_dev))
606 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100607
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100608 if (!pm) {
609 pci_pm_default_suspend(pci_dev);
610 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200611 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100612
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100613 if (pm->suspend) {
614 pci_power_t prev = pci_dev->current_state;
615 int error;
616
617 error = pm->suspend(dev);
618 suspend_report_result(pm->suspend, error);
619 if (error)
620 return error;
621
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100622 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100623 && pci_dev->current_state != PCI_UNKNOWN) {
624 WARN_ONCE(pci_dev->current_state != prev,
625 "PCI PM: State of device not saved by %pF\n",
626 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100627 }
628 }
629
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100630 Fixup:
631 pci_fixup_device(pci_fixup_suspend, pci_dev);
632
633 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200634}
635
636static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900637{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100638 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100639 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900640
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100641 if (pci_has_legacy_pm_support(pci_dev))
642 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
643
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100644 if (!pm) {
645 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100646 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100647 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100648
649 if (pm->suspend_noirq) {
650 pci_power_t prev = pci_dev->current_state;
651 int error;
652
653 error = pm->suspend_noirq(dev);
654 suspend_report_result(pm->suspend_noirq, error);
655 if (error)
656 return error;
657
658 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
659 && pci_dev->current_state != PCI_UNKNOWN) {
660 WARN_ONCE(pci_dev->current_state != prev,
661 "PCI PM: State of device not saved by %pF\n",
662 pm->suspend_noirq);
663 return 0;
664 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200665 }
666
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100667 if (!pci_dev->state_saved) {
668 pci_save_state(pci_dev);
669 if (!pci_is_bridge(pci_dev))
670 pci_prepare_to_sleep(pci_dev);
671 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100672
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100673 pci_pm_set_unknown_state(pci_dev);
674
675 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900676}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200678static int pci_pm_resume_noirq(struct device *dev)
679{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100680 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200681 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200682 int error = 0;
683
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100684 pci_pm_default_resume_noirq(pci_dev);
685
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100686 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100687 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100688
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100689 if (drv && drv->pm && drv->pm->resume_noirq)
690 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200691
692 return error;
693}
694
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100695static int pci_pm_resume(struct device *dev)
696{
697 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100698 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100699 int error = 0;
700
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100701 /*
702 * This is necessary for the suspend error path in which resume is
703 * called without restoring the standard config registers of the device.
704 */
705 if (pci_dev->state_saved)
706 pci_restore_standard_config(pci_dev);
707
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100708 if (pci_has_legacy_pm_support(pci_dev))
709 return pci_legacy_resume(dev);
710
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100711 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100712
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100713 if (pm) {
714 if (pm->resume)
715 error = pm->resume(dev);
716 } else {
717 pci_pm_reenable_device(pci_dev);
718 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100719
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200720 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100721}
722
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200723#else /* !CONFIG_SUSPEND */
724
725#define pci_pm_suspend NULL
726#define pci_pm_suspend_noirq NULL
727#define pci_pm_resume NULL
728#define pci_pm_resume_noirq NULL
729
730#endif /* !CONFIG_SUSPEND */
731
732#ifdef CONFIG_HIBERNATION
733
734static int pci_pm_freeze(struct device *dev)
735{
736 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100737 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200738
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100739 if (pci_has_legacy_pm_support(pci_dev))
740 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100741
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100742 if (!pm) {
743 pci_pm_default_suspend(pci_dev);
744 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200745 }
746
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100747 if (pm->freeze) {
748 int error;
749
750 error = pm->freeze(dev);
751 suspend_report_result(pm->freeze, error);
752 if (error)
753 return error;
754 }
755
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100756 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200757}
758
759static int pci_pm_freeze_noirq(struct device *dev)
760{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100761 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200762 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200763
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100764 if (pci_has_legacy_pm_support(pci_dev))
765 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
766
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100767 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100768 int error;
769
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100770 error = drv->pm->freeze_noirq(dev);
771 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100772 if (error)
773 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200774 }
775
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100776 if (!pci_dev->state_saved)
777 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100778
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100779 pci_pm_set_unknown_state(pci_dev);
780
781 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200782}
783
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200784static int pci_pm_thaw_noirq(struct device *dev)
785{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100786 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200787 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200788 int error = 0;
789
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100790 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100791 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100792
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100793 pci_update_current_state(pci_dev, PCI_D0);
794
795 if (drv && drv->pm && drv->pm->thaw_noirq)
796 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200797
798 return error;
799}
800
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100801static int pci_pm_thaw(struct device *dev)
802{
803 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100804 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100805 int error = 0;
806
807 if (pci_has_legacy_pm_support(pci_dev))
808 return pci_legacy_resume(dev);
809
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100810 if (pm) {
811 if (pm->thaw)
812 error = pm->thaw(dev);
813 } else {
814 pci_pm_reenable_device(pci_dev);
815 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100816
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200817 pci_dev->state_saved = false;
818
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100819 return error;
820}
821
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200822static int pci_pm_poweroff(struct device *dev)
823{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100824 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100825 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200826
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100827 if (pci_has_legacy_pm_support(pci_dev))
828 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100829
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100830 if (!pm) {
831 pci_pm_default_suspend(pci_dev);
832 goto Fixup;
833 }
834
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100835 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100836 int error;
837
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100838 error = pm->poweroff(dev);
839 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100840 if (error)
841 return error;
842 }
843
844 Fixup:
845 pci_fixup_device(pci_fixup_suspend, pci_dev);
846
847 return 0;
848}
849
850static int pci_pm_poweroff_noirq(struct device *dev)
851{
852 struct pci_dev *pci_dev = to_pci_dev(dev);
853 struct device_driver *drv = dev->driver;
854
855 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
856 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
857
858 if (!drv || !drv->pm)
859 return 0;
860
861 if (drv->pm->poweroff_noirq) {
862 int error;
863
864 error = drv->pm->poweroff_noirq(dev);
865 suspend_report_result(drv->pm->poweroff_noirq, error);
866 if (error)
867 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200868 }
869
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100870 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
871 pci_prepare_to_sleep(pci_dev);
872
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100873 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200874}
875
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200876static int pci_pm_restore_noirq(struct device *dev)
877{
878 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200879 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200880 int error = 0;
881
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100882 pci_pm_default_resume_noirq(pci_dev);
883
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100884 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100885 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100886
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100887 if (drv && drv->pm && drv->pm->restore_noirq)
888 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200889
890 return error;
891}
892
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100893static int pci_pm_restore(struct device *dev)
894{
895 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100896 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100897 int error = 0;
898
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100899 /*
900 * This is necessary for the hibernation error path in which restore is
901 * called without restoring the standard config registers of the device.
902 */
903 if (pci_dev->state_saved)
904 pci_restore_standard_config(pci_dev);
905
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100906 if (pci_has_legacy_pm_support(pci_dev))
907 return pci_legacy_resume(dev);
908
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100909 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100910
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100911 if (pm) {
912 if (pm->restore)
913 error = pm->restore(dev);
914 } else {
915 pci_pm_reenable_device(pci_dev);
916 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100917
918 return error;
919}
920
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200921#else /* !CONFIG_HIBERNATION */
922
923#define pci_pm_freeze NULL
924#define pci_pm_freeze_noirq NULL
925#define pci_pm_thaw NULL
926#define pci_pm_thaw_noirq NULL
927#define pci_pm_poweroff NULL
928#define pci_pm_poweroff_noirq NULL
929#define pci_pm_restore NULL
930#define pci_pm_restore_noirq NULL
931
932#endif /* !CONFIG_HIBERNATION */
933
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200934struct dev_pm_ops pci_dev_pm_ops = {
935 .prepare = pci_pm_prepare,
936 .complete = pci_pm_complete,
937 .suspend = pci_pm_suspend,
938 .resume = pci_pm_resume,
939 .freeze = pci_pm_freeze,
940 .thaw = pci_pm_thaw,
941 .poweroff = pci_pm_poweroff,
942 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200943 .suspend_noirq = pci_pm_suspend_noirq,
944 .resume_noirq = pci_pm_resume_noirq,
945 .freeze_noirq = pci_pm_freeze_noirq,
946 .thaw_noirq = pci_pm_thaw_noirq,
947 .poweroff_noirq = pci_pm_poweroff_noirq,
948 .restore_noirq = pci_pm_restore_noirq,
949};
950
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200951#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200952
953#else /* !CONFIG_PM_SLEEP */
954
955#define PCI_PM_OPS_PTR NULL
956
957#endif /* !CONFIG_PM_SLEEP */
958
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200960 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200962 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800963 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 *
965 * Adds the driver structure to the list of registered drivers.
966 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600967 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 * no device was claimed during registration.
969 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800970int __pci_register_driver(struct pci_driver *drv, struct module *owner,
971 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972{
973 int error;
974
975 /* initialize common driver fields */
976 drv->driver.name = drv->name;
977 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200978 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800979 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100980
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700981 spin_lock_init(&drv->dynids.lock);
982 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984 /* register with core */
985 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800986 if (error)
Chris Wright09943752009-02-23 21:52:23 -0800987 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800989 error = pci_create_newid_file(drv);
990 if (error)
Chris Wright09943752009-02-23 21:52:23 -0800991 goto out_newid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
Chris Wright09943752009-02-23 21:52:23 -0800993 error = pci_create_removeid_file(drv);
994 if (error)
995 goto out_removeid;
996out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 return error;
Chris Wright09943752009-02-23 21:52:23 -0800998
999out_removeid:
1000 pci_remove_newid_file(drv);
1001out_newid:
1002 driver_unregister(&drv->driver);
1003 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004}
1005
1006/**
1007 * pci_unregister_driver - unregister a pci driver
1008 * @drv: the driver structure to unregister
1009 *
1010 * Deletes the driver structure from the list of registered PCI drivers,
1011 * gives it a chance to clean up by calling its remove() function for
1012 * each device it was responsible for, and marks those devices as
1013 * driverless.
1014 */
1015
1016void
1017pci_unregister_driver(struct pci_driver *drv)
1018{
Chris Wright09943752009-02-23 21:52:23 -08001019 pci_remove_removeid_file(drv);
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -08001020 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 driver_unregister(&drv->driver);
1022 pci_free_dynids(drv);
1023}
1024
1025static struct pci_driver pci_compat_driver = {
1026 .name = "compat"
1027};
1028
1029/**
1030 * pci_dev_driver - get the pci_driver of a device
1031 * @dev: the device to query
1032 *
1033 * Returns the appropriate pci_driver structure or %NULL if there is no
1034 * registered driver for the device.
1035 */
1036struct pci_driver *
1037pci_dev_driver(const struct pci_dev *dev)
1038{
1039 if (dev->driver)
1040 return dev->driver;
1041 else {
1042 int i;
1043 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1044 if (dev->resource[i].flags & IORESOURCE_BUSY)
1045 return &pci_compat_driver;
1046 }
1047 return NULL;
1048}
1049
1050/**
1051 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001053 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 *
1055 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001056 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 * pci_device_id structure or %NULL if there is no match.
1058 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001059static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001061 struct pci_dev *pci_dev = to_pci_dev(dev);
1062 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 const struct pci_device_id *found_id;
1064
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001065 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 if (found_id)
1067 return 1;
1068
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001069 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070}
1071
1072/**
1073 * pci_dev_get - increments the reference count of the pci device structure
1074 * @dev: the device being referenced
1075 *
1076 * Each live reference to a device should be refcounted.
1077 *
1078 * Drivers for PCI devices should normally record such references in
1079 * their probe() methods, when they bind to a device, and release
1080 * them by calling pci_dev_put(), in their disconnect() methods.
1081 *
1082 * A pointer to the device with the incremented reference counter is returned.
1083 */
1084struct pci_dev *pci_dev_get(struct pci_dev *dev)
1085{
1086 if (dev)
1087 get_device(&dev->dev);
1088 return dev;
1089}
1090
1091/**
1092 * pci_dev_put - release a use of the pci device structure
1093 * @dev: device that's been disconnected
1094 *
1095 * Must be called when a user of a device is finished with it. When the last
1096 * user of the device calls this function, the memory of the device is freed.
1097 */
1098void pci_dev_put(struct pci_dev *dev)
1099{
1100 if (dev)
1101 put_device(&dev->dev);
1102}
1103
1104#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001105int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106{
1107 return -ENODEV;
1108}
1109#endif
1110
1111struct bus_type pci_bus_type = {
1112 .name = "pci",
1113 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001114 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001115 .probe = pci_device_probe,
1116 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001117 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001119 .bus_attrs = pci_bus_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001120 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121};
1122
1123static int __init pci_driver_init(void)
1124{
1125 return bus_register(&pci_bus_type);
1126}
1127
1128postcore_initcall(pci_driver_init);
1129
Tejun Heo9dba9102009-09-03 15:26:36 +09001130EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001131EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001132EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133EXPORT_SYMBOL(pci_unregister_driver);
1134EXPORT_SYMBOL(pci_dev_driver);
1135EXPORT_SYMBOL(pci_bus_type);
1136EXPORT_SYMBOL(pci_dev_get);
1137EXPORT_SYMBOL(pci_dev_put);