blob: 93eac14235854c648e6e895c51f063b8af68e152 [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
102static void
103pci_free_dynids(struct pci_driver *drv)
104{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700105 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700108 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 list_del(&dynid->node);
110 kfree(dynid);
111 }
112 spin_unlock(&drv->dynids.lock);
113}
114
115static int
116pci_create_newid_file(struct pci_driver *drv)
117{
118 int error = 0;
119 if (drv->probe != NULL)
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800120 error = driver_create_file(&drv->driver, &driver_attr_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 return error;
122}
123
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800124static void pci_remove_newid_file(struct pci_driver *drv)
125{
126 driver_remove_file(&drv->driver, &driver_attr_new_id);
127}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129static inline void pci_free_dynids(struct pci_driver *drv) {}
130static inline int pci_create_newid_file(struct pci_driver *drv)
131{
132 return 0;
133}
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800134static inline void pci_remove_newid_file(struct pci_driver *drv) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135#endif
136
137/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700138 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700140 * @dev: the PCI device structure to match against.
141 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700143 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700145 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200146 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700147 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700149const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
150 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700152 if (ids) {
153 while (ids->vendor || ids->subvendor || ids->class_mask) {
154 if (pci_match_one_device(ids, dev))
155 return ids;
156 ids++;
157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
159 return NULL;
160}
161
162/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800163 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700164 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200165 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700166 *
167 * Used by a driver to check whether a PCI device present in the
168 * system is in its list of supported devices. Returns the matching
169 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200171static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
172 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700173{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700174 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Russell King7461b602006-11-29 21:18:04 +0000176 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700177 spin_lock(&drv->dynids.lock);
178 list_for_each_entry(dynid, &drv->dynids.list, node) {
179 if (pci_match_one_device(&dynid->id, dev)) {
180 spin_unlock(&drv->dynids.lock);
181 return &dynid->id;
182 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700184 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000185
186 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187}
188
Rusty Russell873392c2008-12-31 23:54:56 +1030189struct drv_dev_and_id {
190 struct pci_driver *drv;
191 struct pci_dev *dev;
192 const struct pci_device_id *id;
193};
194
195static long local_pci_probe(void *_ddi)
196{
197 struct drv_dev_and_id *ddi = _ddi;
198
199 return ddi->drv->probe(ddi->dev, ddi->id);
200}
201
Andi Kleend42c6992005-07-06 19:56:03 +0200202static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
203 const struct pci_device_id *id)
204{
Rusty Russell873392c2008-12-31 23:54:56 +1030205 int error, node;
206 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700207
Rusty Russell873392c2008-12-31 23:54:56 +1030208 /* Execute driver initialization on node where the device's
209 bus is attached to. This way the driver likely allocates
210 its local memory on the right node without any need to
211 change it. */
212 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700213 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030214 int cpu;
Mike Travisf70316d2008-04-04 18:11:06 -0700215 node_to_cpumask_ptr(nodecpumask, node);
Rusty Russell873392c2008-12-31 23:54:56 +1030216
217 get_online_cpus();
218 cpu = cpumask_any_and(nodecpumask, cpu_online_mask);
219 if (cpu < nr_cpu_ids)
220 error = work_on_cpu(cpu, local_pci_probe, &ddi);
221 else
222 error = local_pci_probe(&ddi);
223 put_online_cpus();
224 } else
225 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200226 return error;
227}
228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229/**
230 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700231 * @drv: driver to call to check if it wants the PCI device
232 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700234 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
236 */
237static int
238__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700239{
240 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 int error = 0;
242
243 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700244 error = -ENODEV;
245
246 id = pci_match_device(drv, pci_dev);
247 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200248 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700249 if (error >= 0) {
250 pci_dev->driver = drv;
251 error = 0;
252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 }
254 return error;
255}
256
257static int pci_device_probe(struct device * dev)
258{
259 int error = 0;
260 struct pci_driver *drv;
261 struct pci_dev *pci_dev;
262
263 drv = to_pci_driver(dev->driver);
264 pci_dev = to_pci_dev(dev);
265 pci_dev_get(pci_dev);
266 error = __pci_device_probe(drv, pci_dev);
267 if (error)
268 pci_dev_put(pci_dev);
269
270 return error;
271}
272
273static int pci_device_remove(struct device * dev)
274{
275 struct pci_dev * pci_dev = to_pci_dev(dev);
276 struct pci_driver * drv = pci_dev->driver;
277
278 if (drv) {
279 if (drv->remove)
280 drv->remove(pci_dev);
281 pci_dev->driver = NULL;
282 }
283
284 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700285 * If the device is still on, set the power state as "unknown",
286 * since it might change by the next time we load the driver.
287 */
288 if (pci_dev->current_state == PCI_D0)
289 pci_dev->current_state = PCI_UNKNOWN;
290
291 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 * We would love to complain here if pci_dev->is_enabled is set, that
293 * the driver should have called pci_disable_device(), but the
294 * unfortunate fact is there are too many odd BIOS and bridge setups
295 * that don't like drivers doing that all of the time.
296 * Oh well, we can dream of sane hardware when we sleep, no matter how
297 * horrible the crap we have to deal with is when we are awake...
298 */
299
300 pci_dev_put(pci_dev);
301 return 0;
302}
303
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200304static void pci_device_shutdown(struct device *dev)
305{
306 struct pci_dev *pci_dev = to_pci_dev(dev);
307 struct pci_driver *drv = pci_dev->driver;
308
309 if (drv && drv->shutdown)
310 drv->shutdown(pci_dev);
311 pci_msi_shutdown(pci_dev);
312 pci_msix_shutdown(pci_dev);
313}
314
315#ifdef CONFIG_PM_SLEEP
316
317/*
318 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100319 * or not even a driver at all (second part).
320 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100321static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200322{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200323 /*
324 * mark its power state as "unknown", since we don't know if
325 * e.g. the BIOS will change its device state when we suspend.
326 */
327 if (pci_dev->current_state == PCI_D0)
328 pci_dev->current_state = PCI_UNKNOWN;
329}
330
331/*
332 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100333 * or not even a driver at all (second part).
334 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100335static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100336{
337 int retval;
338
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200339 /* if the device was enabled before suspend, reenable */
340 retval = pci_reenable_device(pci_dev);
341 /*
342 * if the device was busmaster before the suspend, make it busmaster
343 * again
344 */
345 if (pci_dev->is_busmaster)
346 pci_set_master(pci_dev);
347
348 return retval;
349}
350
351static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
353 struct pci_dev * pci_dev = to_pci_dev(dev);
354 struct pci_driver * drv = pci_dev->driver;
355 int i = 0;
356
Andrew Morton02669492006-03-23 01:38:34 -0800357 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100358 pci_power_t prev = pci_dev->current_state;
359
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100360 pci_dev->state_saved = false;
361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800363 suspend_report_result(drv->suspend, i);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100364 if (i)
365 return i;
366
367 if (pci_dev->state_saved)
368 goto Fixup;
369
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100370 if (pci_dev->current_state != PCI_D0
371 && pci_dev->current_state != PCI_UNKNOWN) {
372 WARN_ONCE(pci_dev->current_state != prev,
373 "PCI PM: Device state not saved by %pF\n",
374 drv->suspend);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100375 goto Fixup;
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100376 }
Andrew Morton02669492006-03-23 01:38:34 -0800377 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100378
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100379 pci_save_state(pci_dev);
380 /*
381 * This is for compatibility with existing code with legacy PM support.
382 */
383 pci_pm_set_unknown_state(pci_dev);
384
385 Fixup:
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100386 pci_fixup_device(pci_fixup_suspend, pci_dev);
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return i;
389}
390
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200391static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700392{
393 struct pci_dev * pci_dev = to_pci_dev(dev);
394 struct pci_driver * drv = pci_dev->driver;
395 int i = 0;
396
397 if (drv && drv->suspend_late) {
398 i = drv->suspend_late(pci_dev, state);
399 suspend_report_result(drv->suspend_late, i);
400 }
401 return i;
402}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100404static int pci_legacy_resume_early(struct device *dev)
405{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100406 struct pci_dev * pci_dev = to_pci_dev(dev);
407 struct pci_driver * drv = pci_dev->driver;
408
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100409 return drv && drv->resume_early ?
410 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100411}
412
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200413static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414{
415 struct pci_dev * pci_dev = to_pci_dev(dev);
416 struct pci_driver * drv = pci_dev->driver;
417
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100418 pci_fixup_device(pci_fixup_resume, pci_dev);
419
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100420 return drv && drv->resume ?
421 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422}
423
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100424/* Auxiliary functions used by the new power management framework */
425
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100426static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
427{
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100428 pci_restore_standard_config(pci_dev);
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100429 pci_dev->state_saved = false;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100430 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100431}
432
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100433static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100434{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100435 pci_fixup_device(pci_fixup_resume, pci_dev);
436
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100437 if (!pci_is_bridge(pci_dev))
438 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100439}
440
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100441static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100442{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100443 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100444 if (!pci_is_bridge(pci_dev))
445 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100446 pci_save_state(pci_dev);
447}
448
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100449static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
450{
451 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100452 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100453 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100454
455 /*
456 * Legacy PM support is used by default, so warn if the new framework is
457 * supported as well. Drivers are supposed to support either the
458 * former, or the latter, but not both at the same time.
459 */
460 WARN_ON(ret && drv->driver.pm);
461
462 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100463}
464
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100465/* New power management framework */
466
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200467static int pci_pm_prepare(struct device *dev)
468{
469 struct device_driver *drv = dev->driver;
470 int error = 0;
471
472 if (drv && drv->pm && drv->pm->prepare)
473 error = drv->pm->prepare(dev);
474
475 return error;
476}
477
478static void pci_pm_complete(struct device *dev)
479{
480 struct device_driver *drv = dev->driver;
481
482 if (drv && drv->pm && drv->pm->complete)
483 drv->pm->complete(dev);
484}
485
486#ifdef CONFIG_SUSPEND
487
488static int pci_pm_suspend(struct device *dev)
489{
490 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100491 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200492
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100493 if (pci_has_legacy_pm_support(pci_dev))
494 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100495
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100496 if (!pm) {
497 pci_pm_default_suspend(pci_dev);
498 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200499 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100500
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100501 pci_dev->state_saved = false;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200502
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100503 if (pm->suspend) {
504 pci_power_t prev = pci_dev->current_state;
505 int error;
506
507 error = pm->suspend(dev);
508 suspend_report_result(pm->suspend, error);
509 if (error)
510 return error;
511
512 if (pci_dev->state_saved)
513 goto Fixup;
514
515 if (pci_dev->current_state != PCI_D0
516 && pci_dev->current_state != PCI_UNKNOWN) {
517 WARN_ONCE(pci_dev->current_state != prev,
518 "PCI PM: State of device not saved by %pF\n",
519 pm->suspend);
520 goto Fixup;
521 }
522 }
523
524 if (!pci_dev->state_saved) {
525 pci_save_state(pci_dev);
526 if (!pci_is_bridge(pci_dev))
527 pci_prepare_to_sleep(pci_dev);
528 }
529
530 Fixup:
531 pci_fixup_device(pci_fixup_suspend, pci_dev);
532
533 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200534}
535
536static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900537{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100538 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200539 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200540 int error = 0;
Greg KHc8958172005-04-08 14:53:31 +0900541
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100542 if (pci_has_legacy_pm_support(pci_dev))
543 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
544
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100545 if (drv && drv->pm && drv->pm->suspend_noirq) {
546 error = drv->pm->suspend_noirq(dev);
547 suspend_report_result(drv->pm->suspend_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200548 }
549
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100550 if (!error)
551 pci_pm_set_unknown_state(pci_dev);
552
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200553 return error;
Greg KHc8958172005-04-08 14:53:31 +0900554}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200556static int pci_pm_resume_noirq(struct device *dev)
557{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100558 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200559 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200560 int error = 0;
561
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100562 pci_pm_default_resume_noirq(pci_dev);
563
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100564 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100565 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100566
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100567 if (drv && drv->pm && drv->pm->resume_noirq)
568 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200569
570 return error;
571}
572
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100573static int pci_pm_resume(struct device *dev)
574{
575 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100576 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100577 int error = 0;
578
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100579 /*
580 * This is necessary for the suspend error path in which resume is
581 * called without restoring the standard config registers of the device.
582 */
583 if (pci_dev->state_saved)
584 pci_restore_standard_config(pci_dev);
585
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100586 if (pci_has_legacy_pm_support(pci_dev))
587 return pci_legacy_resume(dev);
588
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100589 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100590
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100591 if (pm) {
592 if (pm->resume)
593 error = pm->resume(dev);
594 } else {
595 pci_pm_reenable_device(pci_dev);
596 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100597
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100598 return 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100599}
600
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200601#else /* !CONFIG_SUSPEND */
602
603#define pci_pm_suspend NULL
604#define pci_pm_suspend_noirq NULL
605#define pci_pm_resume NULL
606#define pci_pm_resume_noirq NULL
607
608#endif /* !CONFIG_SUSPEND */
609
610#ifdef CONFIG_HIBERNATION
611
612static int pci_pm_freeze(struct device *dev)
613{
614 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100615 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200616
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100617 if (pci_has_legacy_pm_support(pci_dev))
618 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100619
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100620 if (!pm) {
621 pci_pm_default_suspend(pci_dev);
622 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200623 }
624
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100625 pci_dev->state_saved = false;
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100626
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100627 if (pm->freeze) {
628 int error;
629
630 error = pm->freeze(dev);
631 suspend_report_result(pm->freeze, error);
632 if (error)
633 return error;
634 }
635
636 if (!pci_dev->state_saved)
637 pci_save_state(pci_dev);
638
639 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200640}
641
642static int pci_pm_freeze_noirq(struct device *dev)
643{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100644 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200645 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200646 int error = 0;
647
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100648 if (pci_has_legacy_pm_support(pci_dev))
649 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
650
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100651 if (drv && drv->pm && drv->pm->freeze_noirq) {
652 error = drv->pm->freeze_noirq(dev);
653 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200654 }
655
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100656 if (!error)
657 pci_pm_set_unknown_state(pci_dev);
658
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200659 return error;
660}
661
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200662static int pci_pm_thaw_noirq(struct device *dev)
663{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100664 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200665 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200666 int error = 0;
667
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100668 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100669 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100670
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100671 pci_update_current_state(pci_dev, PCI_D0);
672
673 if (drv && drv->pm && drv->pm->thaw_noirq)
674 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200675
676 return error;
677}
678
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100679static int pci_pm_thaw(struct device *dev)
680{
681 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100682 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100683 int error = 0;
684
685 if (pci_has_legacy_pm_support(pci_dev))
686 return pci_legacy_resume(dev);
687
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100688 if (pm) {
689 if (pm->thaw)
690 error = pm->thaw(dev);
691 } else {
692 pci_pm_reenable_device(pci_dev);
693 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100694
695 return error;
696}
697
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200698static int pci_pm_poweroff(struct device *dev)
699{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100700 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100701 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200702 int error = 0;
703
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100704 if (pci_has_legacy_pm_support(pci_dev))
705 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100706
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100707 if (!pm) {
708 pci_pm_default_suspend(pci_dev);
709 goto Fixup;
710 }
711
712 pci_dev->state_saved = false;
713
714 if (pm->poweroff) {
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100715 error = pm->poweroff(dev);
716 suspend_report_result(pm->poweroff, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200717 }
718
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100719 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
720 pci_prepare_to_sleep(pci_dev);
721
722 Fixup:
723 pci_fixup_device(pci_fixup_suspend, pci_dev);
Rafael J. Wysockic9b99722009-01-07 13:02:36 +0100724
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200725 return error;
726}
727
728static int pci_pm_poweroff_noirq(struct device *dev)
729{
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200730 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200731 int error = 0;
732
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100733 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
734 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
735
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100736 if (drv && drv->pm && drv->pm->poweroff_noirq) {
737 error = drv->pm->poweroff_noirq(dev);
738 suspend_report_result(drv->pm->poweroff_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200739 }
740
741 return error;
742}
743
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200744static int pci_pm_restore_noirq(struct device *dev)
745{
746 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200747 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200748 int error = 0;
749
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100750 pci_pm_default_resume_noirq(pci_dev);
751
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100752 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100753 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100754
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100755 if (drv && drv->pm && drv->pm->restore_noirq)
756 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200757
758 return error;
759}
760
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100761static int pci_pm_restore(struct device *dev)
762{
763 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100764 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100765 int error = 0;
766
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100767 /*
768 * This is necessary for the hibernation error path in which restore is
769 * called without restoring the standard config registers of the device.
770 */
771 if (pci_dev->state_saved)
772 pci_restore_standard_config(pci_dev);
773
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100774 if (pci_has_legacy_pm_support(pci_dev))
775 return pci_legacy_resume(dev);
776
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100777 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100778
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100779 if (pm) {
780 if (pm->restore)
781 error = pm->restore(dev);
782 } else {
783 pci_pm_reenable_device(pci_dev);
784 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100785
786 return error;
787}
788
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200789#else /* !CONFIG_HIBERNATION */
790
791#define pci_pm_freeze NULL
792#define pci_pm_freeze_noirq NULL
793#define pci_pm_thaw NULL
794#define pci_pm_thaw_noirq NULL
795#define pci_pm_poweroff NULL
796#define pci_pm_poweroff_noirq NULL
797#define pci_pm_restore NULL
798#define pci_pm_restore_noirq NULL
799
800#endif /* !CONFIG_HIBERNATION */
801
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200802struct dev_pm_ops pci_dev_pm_ops = {
803 .prepare = pci_pm_prepare,
804 .complete = pci_pm_complete,
805 .suspend = pci_pm_suspend,
806 .resume = pci_pm_resume,
807 .freeze = pci_pm_freeze,
808 .thaw = pci_pm_thaw,
809 .poweroff = pci_pm_poweroff,
810 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200811 .suspend_noirq = pci_pm_suspend_noirq,
812 .resume_noirq = pci_pm_resume_noirq,
813 .freeze_noirq = pci_pm_freeze_noirq,
814 .thaw_noirq = pci_pm_thaw_noirq,
815 .poweroff_noirq = pci_pm_poweroff_noirq,
816 .restore_noirq = pci_pm_restore_noirq,
817};
818
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200819#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200820
821#else /* !CONFIG_PM_SLEEP */
822
823#define PCI_PM_OPS_PTR NULL
824
825#endif /* !CONFIG_PM_SLEEP */
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200828 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200830 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800831 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 *
833 * Adds the driver structure to the list of registered drivers.
834 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600835 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 * no device was claimed during registration.
837 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800838int __pci_register_driver(struct pci_driver *drv, struct module *owner,
839 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
841 int error;
842
843 /* initialize common driver fields */
844 drv->driver.name = drv->name;
845 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200846 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800847 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100848
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700849 spin_lock_init(&drv->dynids.lock);
850 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
852 /* register with core */
853 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800854 if (error)
855 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800857 error = pci_create_newid_file(drv);
858 if (error)
859 driver_unregister(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
861 return error;
862}
863
864/**
865 * pci_unregister_driver - unregister a pci driver
866 * @drv: the driver structure to unregister
867 *
868 * Deletes the driver structure from the list of registered PCI drivers,
869 * gives it a chance to clean up by calling its remove() function for
870 * each device it was responsible for, and marks those devices as
871 * driverless.
872 */
873
874void
875pci_unregister_driver(struct pci_driver *drv)
876{
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800877 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 driver_unregister(&drv->driver);
879 pci_free_dynids(drv);
880}
881
882static struct pci_driver pci_compat_driver = {
883 .name = "compat"
884};
885
886/**
887 * pci_dev_driver - get the pci_driver of a device
888 * @dev: the device to query
889 *
890 * Returns the appropriate pci_driver structure or %NULL if there is no
891 * registered driver for the device.
892 */
893struct pci_driver *
894pci_dev_driver(const struct pci_dev *dev)
895{
896 if (dev->driver)
897 return dev->driver;
898 else {
899 int i;
900 for(i=0; i<=PCI_ROM_RESOURCE; i++)
901 if (dev->resource[i].flags & IORESOURCE_BUSY)
902 return &pci_compat_driver;
903 }
904 return NULL;
905}
906
907/**
908 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700910 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 *
912 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700913 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 * pci_device_id structure or %NULL if there is no match.
915 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700916static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700918 struct pci_dev *pci_dev = to_pci_dev(dev);
919 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 const struct pci_device_id *found_id;
921
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700922 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 if (found_id)
924 return 1;
925
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700926 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
929/**
930 * pci_dev_get - increments the reference count of the pci device structure
931 * @dev: the device being referenced
932 *
933 * Each live reference to a device should be refcounted.
934 *
935 * Drivers for PCI devices should normally record such references in
936 * their probe() methods, when they bind to a device, and release
937 * them by calling pci_dev_put(), in their disconnect() methods.
938 *
939 * A pointer to the device with the incremented reference counter is returned.
940 */
941struct pci_dev *pci_dev_get(struct pci_dev *dev)
942{
943 if (dev)
944 get_device(&dev->dev);
945 return dev;
946}
947
948/**
949 * pci_dev_put - release a use of the pci device structure
950 * @dev: device that's been disconnected
951 *
952 * Must be called when a user of a device is finished with it. When the last
953 * user of the device calls this function, the memory of the device is freed.
954 */
955void pci_dev_put(struct pci_dev *dev)
956{
957 if (dev)
958 put_device(&dev->dev);
959}
960
961#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200962int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963{
964 return -ENODEV;
965}
966#endif
967
968struct bus_type pci_bus_type = {
969 .name = "pci",
970 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100971 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000972 .probe = pci_device_probe,
973 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700974 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 .dev_attrs = pci_dev_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200976 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977};
978
979static int __init pci_driver_init(void)
980{
981 return bus_register(&pci_bus_type);
982}
983
984postcore_initcall(pci_driver_init);
985
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700986EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +0200987EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988EXPORT_SYMBOL(pci_unregister_driver);
989EXPORT_SYMBOL(pci_dev_driver);
990EXPORT_SYMBOL(pci_bus_type);
991EXPORT_SYMBOL(pci_dev_get);
992EXPORT_SYMBOL(pci_dev_put);