blob: 02bf4d4125e41c44bdb1befb85d8b8ad049c317f [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) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800359 suspend_report_result(drv->suspend, i);
360 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100361 pci_save_state(pci_dev);
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100362 /*
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100363 * This is for compatibility with existing code with legacy PM
364 * support.
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100365 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100366 pci_pm_set_unknown_state(pci_dev);
Andrew Morton02669492006-03-23 01:38:34 -0800367 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100368
369 pci_fixup_device(pci_fixup_suspend, pci_dev);
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 return i;
372}
373
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200374static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700375{
376 struct pci_dev * pci_dev = to_pci_dev(dev);
377 struct pci_driver * drv = pci_dev->driver;
378 int i = 0;
379
380 if (drv && drv->suspend_late) {
381 i = drv->suspend_late(pci_dev, state);
382 suspend_report_result(drv->suspend_late, i);
383 }
384 return i;
385}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200387static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200389 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 struct pci_dev * pci_dev = to_pci_dev(dev);
391 struct pci_driver * drv = pci_dev->driver;
392
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100393 pci_fixup_device(pci_fixup_resume, pci_dev);
394
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100395 if (drv && drv->resume) {
Jean Delvare8d92bc22006-04-18 14:49:56 +0200396 error = drv->resume(pci_dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100397 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100398 /* restore the PCI config space */
399 pci_restore_state(pci_dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100400 error = pci_pm_reenable_device(pci_dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100401 }
Jean Delvare8d92bc22006-04-18 14:49:56 +0200402 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403}
404
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200405static int pci_legacy_resume_early(struct device *dev)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700406{
407 int error = 0;
408 struct pci_dev * pci_dev = to_pci_dev(dev);
409 struct pci_driver * drv = pci_dev->driver;
410
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100411 pci_fixup_device(pci_fixup_resume_early, pci_dev);
412
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700413 if (drv && drv->resume_early)
414 error = drv->resume_early(pci_dev);
415 return error;
416}
417
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100418/* Auxiliary functions used by the new power management framework */
419
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100420static int pci_restore_standard_config(struct pci_dev *pci_dev)
421{
422 struct pci_dev *parent = pci_dev->bus->self;
423 int error = 0;
424
425 /* Check if the device's bus is operational */
426 if (!parent || parent->current_state == PCI_D0) {
427 pci_restore_state(pci_dev);
428 pci_update_current_state(pci_dev, PCI_D0);
429 } else {
430 dev_warn(&pci_dev->dev, "unable to restore config, "
431 "bridge %s in low power state D%d\n", pci_name(parent),
432 parent->current_state);
433 pci_dev->current_state = PCI_UNKNOWN;
434 error = -EAGAIN;
435 }
436
437 return error;
438}
439
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100440static bool pci_is_bridge(struct pci_dev *pci_dev)
441{
442 return !!(pci_dev->subordinate);
443}
444
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100445static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
446{
447 if (pci_restore_standard_config(pci_dev))
448 pci_fixup_device(pci_fixup_resume_early, pci_dev);
449}
450
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100451static int pci_pm_default_resume(struct pci_dev *pci_dev)
452{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100453 /*
454 * pci_restore_standard_config() should have been called once already,
455 * but it would have failed if the device's parent bridge had not been
456 * in power state D0 at that time. Check it and try again if necessary.
457 */
458 if (pci_dev->current_state == PCI_UNKNOWN) {
459 int error = pci_restore_standard_config(pci_dev);
460 if (error)
461 return error;
462 }
463
464 pci_fixup_device(pci_fixup_resume, pci_dev);
465
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100466 if (!pci_is_bridge(pci_dev))
467 pci_enable_wake(pci_dev, PCI_D0, false);
468
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100469 return pci_pm_reenable_device(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100470}
471
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100472static void pci_pm_default_suspend_generic(struct pci_dev *pci_dev)
473{
474 /* If device is enabled at this point, disable it */
475 pci_disable_enabled_device(pci_dev);
476 /*
477 * Save state with interrupts enabled, because in principle the bus the
478 * device is on may be put into a low power state after this code runs.
479 */
480 pci_save_state(pci_dev);
481}
482
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100483static void pci_pm_default_suspend(struct pci_dev *pci_dev)
484{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100485 pci_pm_default_suspend_generic(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100486
487 if (!pci_is_bridge(pci_dev))
488 pci_prepare_to_sleep(pci_dev);
489}
490
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100491static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
492{
493 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100494 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100495 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100496
497 /*
498 * Legacy PM support is used by default, so warn if the new framework is
499 * supported as well. Drivers are supposed to support either the
500 * former, or the latter, but not both at the same time.
501 */
502 WARN_ON(ret && drv->driver.pm);
503
504 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100505}
506
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100507/* New power management framework */
508
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200509static int pci_pm_prepare(struct device *dev)
510{
511 struct device_driver *drv = dev->driver;
512 int error = 0;
513
514 if (drv && drv->pm && drv->pm->prepare)
515 error = drv->pm->prepare(dev);
516
517 return error;
518}
519
520static void pci_pm_complete(struct device *dev)
521{
522 struct device_driver *drv = dev->driver;
523
524 if (drv && drv->pm && drv->pm->complete)
525 drv->pm->complete(dev);
526}
527
528#ifdef CONFIG_SUSPEND
529
530static int pci_pm_suspend(struct device *dev)
531{
532 struct pci_dev *pci_dev = to_pci_dev(dev);
533 struct device_driver *drv = dev->driver;
534 int error = 0;
535
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100536 if (pci_has_legacy_pm_support(pci_dev))
537 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100538
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200539 if (drv && drv->pm) {
540 if (drv->pm->suspend) {
541 error = drv->pm->suspend(dev);
542 suspend_report_result(drv->pm->suspend, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200543 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100544 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100545 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200546 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100547
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200548 pci_fixup_device(pci_fixup_suspend, pci_dev);
549
550 return error;
551}
552
553static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900554{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100555 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200556 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200557 int error = 0;
Greg KHc8958172005-04-08 14:53:31 +0900558
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100559 if (pci_has_legacy_pm_support(pci_dev))
560 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
561
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200562 if (drv && drv->pm) {
563 if (drv->pm->suspend_noirq) {
564 error = drv->pm->suspend_noirq(dev);
565 suspend_report_result(drv->pm->suspend_noirq, error);
566 }
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100567 } else {
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100568 pci_pm_set_unknown_state(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200569 }
570
571 return error;
Greg KHc8958172005-04-08 14:53:31 +0900572}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200574static int pci_pm_resume(struct device *dev)
575{
576 struct pci_dev *pci_dev = to_pci_dev(dev);
577 struct device_driver *drv = dev->driver;
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100578 int error = 0;
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))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100581 return pci_legacy_resume(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100582
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200583 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100584 pci_fixup_device(pci_fixup_resume, pci_dev);
585
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100586 if (drv->pm->resume)
587 error = drv->pm->resume(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100588 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100589 error = pci_pm_default_resume(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200590 }
591
592 return error;
593}
594
595static int pci_pm_resume_noirq(struct device *dev)
596{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100597 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200598 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200599 int error = 0;
600
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100601 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100602 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100603
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200604 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100605 pci_fixup_device(pci_fixup_resume_early, pci_dev);
606
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200607 if (drv->pm->resume_noirq)
608 error = drv->pm->resume_noirq(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100609 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100610 pci_pm_default_resume_noirq(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200611 }
612
613 return error;
614}
615
616#else /* !CONFIG_SUSPEND */
617
618#define pci_pm_suspend NULL
619#define pci_pm_suspend_noirq NULL
620#define pci_pm_resume NULL
621#define pci_pm_resume_noirq NULL
622
623#endif /* !CONFIG_SUSPEND */
624
625#ifdef CONFIG_HIBERNATION
626
627static int pci_pm_freeze(struct device *dev)
628{
629 struct pci_dev *pci_dev = to_pci_dev(dev);
630 struct device_driver *drv = dev->driver;
631 int error = 0;
632
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100633 if (pci_has_legacy_pm_support(pci_dev))
634 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100635
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200636 if (drv && drv->pm) {
637 if (drv->pm->freeze) {
638 error = drv->pm->freeze(dev);
639 suspend_report_result(drv->pm->freeze, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200640 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100641 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100642 pci_pm_default_suspend_generic(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200643 }
644
645 return error;
646}
647
648static int pci_pm_freeze_noirq(struct device *dev)
649{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100650 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200651 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200652 int error = 0;
653
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100654 if (pci_has_legacy_pm_support(pci_dev))
655 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
656
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200657 if (drv && drv->pm) {
658 if (drv->pm->freeze_noirq) {
659 error = drv->pm->freeze_noirq(dev);
660 suspend_report_result(drv->pm->freeze_noirq, error);
661 }
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100662 } else {
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100663 pci_pm_set_unknown_state(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200664 }
665
666 return error;
667}
668
669static int pci_pm_thaw(struct device *dev)
670{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100671 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200672 struct device_driver *drv = dev->driver;
673 int error = 0;
674
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100675 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100676 return pci_legacy_resume(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100677
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200678 if (drv && drv->pm) {
679 if (drv->pm->thaw)
680 error = drv->pm->thaw(dev);
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100681 } else {
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100682 pci_pm_reenable_device(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200683 }
684
685 return error;
686}
687
688static int pci_pm_thaw_noirq(struct device *dev)
689{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100690 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200691 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200692 int error = 0;
693
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100694 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100695 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100696
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200697 if (drv && drv->pm) {
698 if (drv->pm->thaw_noirq)
699 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100700 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100701 pci_update_current_state(pci_dev, PCI_D0);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200702 }
703
704 return error;
705}
706
707static int pci_pm_poweroff(struct device *dev)
708{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100709 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200710 struct device_driver *drv = dev->driver;
711 int error = 0;
712
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100713 if (pci_has_legacy_pm_support(pci_dev))
714 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100715
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200716 if (drv && drv->pm) {
717 if (drv->pm->poweroff) {
718 error = drv->pm->poweroff(dev);
719 suspend_report_result(drv->pm->poweroff, error);
720 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100721 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100722 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200723 }
724
Rafael J. Wysockic9b99722009-01-07 13:02:36 +0100725 pci_fixup_device(pci_fixup_suspend, pci_dev);
726
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200727 return error;
728}
729
730static int pci_pm_poweroff_noirq(struct device *dev)
731{
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200732 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200733 int error = 0;
734
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100735 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
736 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
737
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200738 if (drv && drv->pm) {
739 if (drv->pm->poweroff_noirq) {
740 error = drv->pm->poweroff_noirq(dev);
741 suspend_report_result(drv->pm->poweroff_noirq, error);
742 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200743 }
744
745 return error;
746}
747
748static int pci_pm_restore(struct device *dev)
749{
750 struct pci_dev *pci_dev = to_pci_dev(dev);
751 struct device_driver *drv = dev->driver;
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100752 int error = 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200753
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100754 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100755 return pci_legacy_resume(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100756
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200757 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100758 pci_fixup_device(pci_fixup_resume, pci_dev);
759
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100760 if (drv->pm->restore)
761 error = drv->pm->restore(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100762 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100763 error = pci_pm_default_resume(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200764 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200765
766 return error;
767}
768
769static int pci_pm_restore_noirq(struct device *dev)
770{
771 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200772 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200773 int error = 0;
774
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100775 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100776 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100777
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200778 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100779 pci_fixup_device(pci_fixup_resume_early, pci_dev);
780
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200781 if (drv->pm->restore_noirq)
782 error = drv->pm->restore_noirq(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100783 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100784 pci_pm_default_resume_noirq(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200785 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200786
787 return error;
788}
789
790#else /* !CONFIG_HIBERNATION */
791
792#define pci_pm_freeze NULL
793#define pci_pm_freeze_noirq NULL
794#define pci_pm_thaw NULL
795#define pci_pm_thaw_noirq NULL
796#define pci_pm_poweroff NULL
797#define pci_pm_poweroff_noirq NULL
798#define pci_pm_restore NULL
799#define pci_pm_restore_noirq NULL
800
801#endif /* !CONFIG_HIBERNATION */
802
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200803struct dev_pm_ops pci_dev_pm_ops = {
804 .prepare = pci_pm_prepare,
805 .complete = pci_pm_complete,
806 .suspend = pci_pm_suspend,
807 .resume = pci_pm_resume,
808 .freeze = pci_pm_freeze,
809 .thaw = pci_pm_thaw,
810 .poweroff = pci_pm_poweroff,
811 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200812 .suspend_noirq = pci_pm_suspend_noirq,
813 .resume_noirq = pci_pm_resume_noirq,
814 .freeze_noirq = pci_pm_freeze_noirq,
815 .thaw_noirq = pci_pm_thaw_noirq,
816 .poweroff_noirq = pci_pm_poweroff_noirq,
817 .restore_noirq = pci_pm_restore_noirq,
818};
819
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200820#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200821
822#else /* !CONFIG_PM_SLEEP */
823
824#define PCI_PM_OPS_PTR NULL
825
826#endif /* !CONFIG_PM_SLEEP */
827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200829 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200831 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800832 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 *
834 * Adds the driver structure to the list of registered drivers.
835 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600836 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 * no device was claimed during registration.
838 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800839int __pci_register_driver(struct pci_driver *drv, struct module *owner,
840 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841{
842 int error;
843
844 /* initialize common driver fields */
845 drv->driver.name = drv->name;
846 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200847 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800848 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100849
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700850 spin_lock_init(&drv->dynids.lock);
851 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853 /* register with core */
854 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800855 if (error)
856 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800858 error = pci_create_newid_file(drv);
859 if (error)
860 driver_unregister(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
862 return error;
863}
864
865/**
866 * pci_unregister_driver - unregister a pci driver
867 * @drv: the driver structure to unregister
868 *
869 * Deletes the driver structure from the list of registered PCI drivers,
870 * gives it a chance to clean up by calling its remove() function for
871 * each device it was responsible for, and marks those devices as
872 * driverless.
873 */
874
875void
876pci_unregister_driver(struct pci_driver *drv)
877{
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800878 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 driver_unregister(&drv->driver);
880 pci_free_dynids(drv);
881}
882
883static struct pci_driver pci_compat_driver = {
884 .name = "compat"
885};
886
887/**
888 * pci_dev_driver - get the pci_driver of a device
889 * @dev: the device to query
890 *
891 * Returns the appropriate pci_driver structure or %NULL if there is no
892 * registered driver for the device.
893 */
894struct pci_driver *
895pci_dev_driver(const struct pci_dev *dev)
896{
897 if (dev->driver)
898 return dev->driver;
899 else {
900 int i;
901 for(i=0; i<=PCI_ROM_RESOURCE; i++)
902 if (dev->resource[i].flags & IORESOURCE_BUSY)
903 return &pci_compat_driver;
904 }
905 return NULL;
906}
907
908/**
909 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700911 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 *
913 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700914 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 * pci_device_id structure or %NULL if there is no match.
916 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700917static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700919 struct pci_dev *pci_dev = to_pci_dev(dev);
920 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 const struct pci_device_id *found_id;
922
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700923 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 if (found_id)
925 return 1;
926
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700927 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928}
929
930/**
931 * pci_dev_get - increments the reference count of the pci device structure
932 * @dev: the device being referenced
933 *
934 * Each live reference to a device should be refcounted.
935 *
936 * Drivers for PCI devices should normally record such references in
937 * their probe() methods, when they bind to a device, and release
938 * them by calling pci_dev_put(), in their disconnect() methods.
939 *
940 * A pointer to the device with the incremented reference counter is returned.
941 */
942struct pci_dev *pci_dev_get(struct pci_dev *dev)
943{
944 if (dev)
945 get_device(&dev->dev);
946 return dev;
947}
948
949/**
950 * pci_dev_put - release a use of the pci device structure
951 * @dev: device that's been disconnected
952 *
953 * Must be called when a user of a device is finished with it. When the last
954 * user of the device calls this function, the memory of the device is freed.
955 */
956void pci_dev_put(struct pci_dev *dev)
957{
958 if (dev)
959 put_device(&dev->dev);
960}
961
962#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200963int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964{
965 return -ENODEV;
966}
967#endif
968
969struct bus_type pci_bus_type = {
970 .name = "pci",
971 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100972 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000973 .probe = pci_device_probe,
974 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700975 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 .dev_attrs = pci_dev_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200977 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978};
979
980static int __init pci_driver_init(void)
981{
982 return bus_register(&pci_bus_type);
983}
984
985postcore_initcall(pci_driver_init);
986
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700987EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +0200988EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989EXPORT_SYMBOL(pci_unregister_driver);
990EXPORT_SYMBOL(pci_dev_driver);
991EXPORT_SYMBOL(pci_bus_type);
992EXPORT_SYMBOL(pci_dev_get);
993EXPORT_SYMBOL(pci_dev_put);