blob: 87a5ddbb324fd8c192e6edfa93ff109f9d08136c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/pci/pci-driver.c
3 *
Greg Kroah-Hartman2b937302007-11-28 12:23:18 -08004 * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com>
5 * (C) Copyright 2007 Novell Inc.
6 *
7 * Released under the GPL v2 only.
8 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
11#include <linux/pci.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/device.h>
Andi Kleend42c6992005-07-06 19:56:03 +020015#include <linux/mempolicy.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080016#include <linux/string.h>
17#include <linux/slab.h>
Tim Schmielau8c65b4a2005-11-07 00:59:43 -080018#include <linux/sched.h>
Rusty Russell873392c2008-12-31 23:54:56 +103019#include <linux/cpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "pci.h"
21
22/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
24 */
25
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070026struct pci_dynid {
27 struct list_head node;
28 struct pci_device_id id;
29};
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Greg KH3d3c2ae2005-07-06 09:09:38 -070031#ifdef CONFIG_HOTPLUG
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/**
Randy Dunlap8f7020d2005-10-23 11:57:38 -070034 * store_new_id - add a new PCI device ID to this driver and re-probe devices
35 * @driver: target device driver
36 * @buf: buffer for scanning device ID data
37 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 *
39 * Adds a new dynamic pci device ID to this driver,
40 * and causes the driver to probe for all devices again.
41 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -070042static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -070043store_new_id(struct device_driver *driver, const char *buf, size_t count)
44{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070045 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvareb41d6cf2008-08-17 21:06:59 +020047 const struct pci_device_id *ids = pdrv->id_table;
Jean Delvare6ba18632007-04-07 17:21:28 +020048 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 subdevice=PCI_ANY_ID, class=0, class_mask=0;
50 unsigned long driver_data=0;
51 int fields=0;
Chris Wright2debb4d2008-11-25 19:36:10 -080052 int retval=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Jean Delvareb41d6cf2008-08-17 21:06:59 +020054 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 &vendor, &device, &subvendor, &subdevice,
56 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +020057 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 return -EINVAL;
59
Jean Delvareb41d6cf2008-08-17 21:06:59 +020060 /* Only accept driver_data values that match an existing id_table
61 entry */
Chris Wright2debb4d2008-11-25 19:36:10 -080062 if (ids) {
63 retval = -EINVAL;
64 while (ids->vendor || ids->subvendor || ids->class_mask) {
65 if (driver_data == ids->driver_data) {
66 retval = 0;
67 break;
68 }
69 ids++;
Jean Delvareb41d6cf2008-08-17 21:06:59 +020070 }
Chris Wright2debb4d2008-11-25 19:36:10 -080071 if (retval) /* No match */
72 return retval;
Jean Delvareb41d6cf2008-08-17 21:06:59 +020073 }
Jean Delvareb41d6cf2008-08-17 21:06:59 +020074
Eric Sesterhennf5afe802006-02-28 15:34:49 +010075 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 if (!dynid)
77 return -ENOMEM;
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 dynid->id.vendor = vendor;
80 dynid->id.device = device;
81 dynid->id.subvendor = subvendor;
82 dynid->id.subdevice = subdevice;
83 dynid->id.class = class;
84 dynid->id.class_mask = class_mask;
Milton Milleredbc25c2008-07-10 16:29:37 -050085 dynid->id.driver_data = driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87 spin_lock(&pdrv->dynids.lock);
Michael Ellermana56bc692007-09-14 15:33:13 +100088 list_add_tail(&dynid->node, &pdrv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 spin_unlock(&pdrv->dynids.lock);
90
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070091 if (get_driver(&pdrv->driver)) {
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070092 retval = driver_attach(&pdrv->driver);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070093 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 }
95
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070096 if (retval)
97 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 return count;
99}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Chris Wright09943752009-02-23 21:52:23 -0800102/**
103 * store_remove_id - remove a PCI device ID from this driver
104 * @driver: target device driver
105 * @buf: buffer for scanning device ID data
106 * @count: input size
107 *
108 * Removes a dynamic pci device ID to this driver.
109 */
110static ssize_t
111store_remove_id(struct device_driver *driver, const char *buf, size_t count)
112{
113 struct pci_dynid *dynid, *n;
114 struct pci_driver *pdrv = to_pci_driver(driver);
115 __u32 vendor, device, subvendor = PCI_ANY_ID,
116 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
117 int fields = 0;
118 int retval = -ENODEV;
119
120 fields = sscanf(buf, "%x %x %x %x %x %x",
121 &vendor, &device, &subvendor, &subdevice,
122 &class, &class_mask);
123 if (fields < 2)
124 return -EINVAL;
125
126 spin_lock(&pdrv->dynids.lock);
127 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
128 struct pci_device_id *id = &dynid->id;
129 if ((id->vendor == vendor) &&
130 (id->device == device) &&
131 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
132 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
133 !((id->class ^ class) & class_mask)) {
134 list_del(&dynid->node);
135 kfree(dynid);
136 retval = 0;
137 break;
138 }
139 }
140 spin_unlock(&pdrv->dynids.lock);
141
142 if (retval)
143 return retval;
144 return count;
145}
146static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148static void
149pci_free_dynids(struct pci_driver *drv)
150{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700151 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700154 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 list_del(&dynid->node);
156 kfree(dynid);
157 }
158 spin_unlock(&drv->dynids.lock);
159}
160
161static int
162pci_create_newid_file(struct pci_driver *drv)
163{
164 int error = 0;
165 if (drv->probe != NULL)
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800166 error = driver_create_file(&drv->driver, &driver_attr_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return error;
168}
169
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800170static void pci_remove_newid_file(struct pci_driver *drv)
171{
172 driver_remove_file(&drv->driver, &driver_attr_new_id);
173}
Chris Wright09943752009-02-23 21:52:23 -0800174
175static int
176pci_create_removeid_file(struct pci_driver *drv)
177{
178 int error = 0;
179 if (drv->probe != NULL)
180 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
181 return error;
182}
183
184static void pci_remove_removeid_file(struct pci_driver *drv)
185{
186 driver_remove_file(&drv->driver, &driver_attr_remove_id);
187}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189static inline void pci_free_dynids(struct pci_driver *drv) {}
190static inline int pci_create_newid_file(struct pci_driver *drv)
191{
192 return 0;
193}
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800194static inline void pci_remove_newid_file(struct pci_driver *drv) {}
Chris Wright09943752009-02-23 21:52:23 -0800195static inline int pci_create_removeid_file(struct pci_driver *drv)
196{
197 return 0;
198}
199static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200#endif
201
202/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700203 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700205 * @dev: the PCI device structure to match against.
206 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700208 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700210 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200211 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700212 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700214const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
215 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700217 if (ids) {
218 while (ids->vendor || ids->subvendor || ids->class_mask) {
219 if (pci_match_one_device(ids, dev))
220 return ids;
221 ids++;
222 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 }
224 return NULL;
225}
226
227/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800228 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700229 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200230 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700231 *
232 * Used by a driver to check whether a PCI device present in the
233 * system is in its list of supported devices. Returns the matching
234 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200236static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
237 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700238{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700239 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Russell King7461b602006-11-29 21:18:04 +0000241 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700242 spin_lock(&drv->dynids.lock);
243 list_for_each_entry(dynid, &drv->dynids.list, node) {
244 if (pci_match_one_device(&dynid->id, dev)) {
245 spin_unlock(&drv->dynids.lock);
246 return &dynid->id;
247 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700249 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000250
251 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252}
253
Rusty Russell873392c2008-12-31 23:54:56 +1030254struct drv_dev_and_id {
255 struct pci_driver *drv;
256 struct pci_dev *dev;
257 const struct pci_device_id *id;
258};
259
260static long local_pci_probe(void *_ddi)
261{
262 struct drv_dev_and_id *ddi = _ddi;
263
264 return ddi->drv->probe(ddi->dev, ddi->id);
265}
266
Andi Kleend42c6992005-07-06 19:56:03 +0200267static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
268 const struct pci_device_id *id)
269{
Rusty Russell873392c2008-12-31 23:54:56 +1030270 int error, node;
271 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700272
Rusty Russell873392c2008-12-31 23:54:56 +1030273 /* Execute driver initialization on node where the device's
274 bus is attached to. This way the driver likely allocates
275 its local memory on the right node without any need to
276 change it. */
277 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700278 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030279 int cpu;
Mike Travisf70316d2008-04-04 18:11:06 -0700280 node_to_cpumask_ptr(nodecpumask, node);
Rusty Russell873392c2008-12-31 23:54:56 +1030281
282 get_online_cpus();
283 cpu = cpumask_any_and(nodecpumask, cpu_online_mask);
284 if (cpu < nr_cpu_ids)
285 error = work_on_cpu(cpu, local_pci_probe, &ddi);
286 else
287 error = local_pci_probe(&ddi);
288 put_online_cpus();
289 } else
290 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200291 return error;
292}
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294/**
295 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700296 * @drv: driver to call to check if it wants the PCI device
297 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700299 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
301 */
302static int
303__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700304{
305 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 int error = 0;
307
308 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700309 error = -ENODEV;
310
311 id = pci_match_device(drv, pci_dev);
312 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200313 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700314 if (error >= 0) {
315 pci_dev->driver = drv;
316 error = 0;
317 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
319 return error;
320}
321
322static int pci_device_probe(struct device * dev)
323{
324 int error = 0;
325 struct pci_driver *drv;
326 struct pci_dev *pci_dev;
327
328 drv = to_pci_driver(dev->driver);
329 pci_dev = to_pci_dev(dev);
330 pci_dev_get(pci_dev);
331 error = __pci_device_probe(drv, pci_dev);
332 if (error)
333 pci_dev_put(pci_dev);
334
335 return error;
336}
337
338static int pci_device_remove(struct device * dev)
339{
340 struct pci_dev * pci_dev = to_pci_dev(dev);
341 struct pci_driver * drv = pci_dev->driver;
342
343 if (drv) {
344 if (drv->remove)
345 drv->remove(pci_dev);
346 pci_dev->driver = NULL;
347 }
348
349 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700350 * If the device is still on, set the power state as "unknown",
351 * since it might change by the next time we load the driver.
352 */
353 if (pci_dev->current_state == PCI_D0)
354 pci_dev->current_state = PCI_UNKNOWN;
355
356 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 * We would love to complain here if pci_dev->is_enabled is set, that
358 * the driver should have called pci_disable_device(), but the
359 * unfortunate fact is there are too many odd BIOS and bridge setups
360 * that don't like drivers doing that all of the time.
361 * Oh well, we can dream of sane hardware when we sleep, no matter how
362 * horrible the crap we have to deal with is when we are awake...
363 */
364
365 pci_dev_put(pci_dev);
366 return 0;
367}
368
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200369static void pci_device_shutdown(struct device *dev)
370{
371 struct pci_dev *pci_dev = to_pci_dev(dev);
372 struct pci_driver *drv = pci_dev->driver;
373
374 if (drv && drv->shutdown)
375 drv->shutdown(pci_dev);
376 pci_msi_shutdown(pci_dev);
377 pci_msix_shutdown(pci_dev);
378}
379
380#ifdef CONFIG_PM_SLEEP
381
382/*
383 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100384 * or not even a driver at all (second part).
385 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100386static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200387{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200388 /*
389 * mark its power state as "unknown", since we don't know if
390 * e.g. the BIOS will change its device state when we suspend.
391 */
392 if (pci_dev->current_state == PCI_D0)
393 pci_dev->current_state = PCI_UNKNOWN;
394}
395
396/*
397 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100398 * or not even a driver at all (second part).
399 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100400static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100401{
402 int retval;
403
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200404 /* if the device was enabled before suspend, reenable */
405 retval = pci_reenable_device(pci_dev);
406 /*
407 * if the device was busmaster before the suspend, make it busmaster
408 * again
409 */
410 if (pci_dev->is_busmaster)
411 pci_set_master(pci_dev);
412
413 return retval;
414}
415
416static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417{
418 struct pci_dev * pci_dev = to_pci_dev(dev);
419 struct pci_driver * drv = pci_dev->driver;
420 int i = 0;
421
Andrew Morton02669492006-03-23 01:38:34 -0800422 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100423 pci_power_t prev = pci_dev->current_state;
424
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100425 pci_dev->state_saved = false;
426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800428 suspend_report_result(drv->suspend, i);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100429 if (i)
430 return i;
431
432 if (pci_dev->state_saved)
433 goto Fixup;
434
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100435 if (pci_dev->current_state != PCI_D0
436 && pci_dev->current_state != PCI_UNKNOWN) {
437 WARN_ONCE(pci_dev->current_state != prev,
438 "PCI PM: Device state not saved by %pF\n",
439 drv->suspend);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100440 goto Fixup;
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100441 }
Andrew Morton02669492006-03-23 01:38:34 -0800442 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100443
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100444 pci_save_state(pci_dev);
445 /*
446 * This is for compatibility with existing code with legacy PM support.
447 */
448 pci_pm_set_unknown_state(pci_dev);
449
450 Fixup:
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100451 pci_fixup_device(pci_fixup_suspend, pci_dev);
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return i;
454}
455
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200456static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700457{
458 struct pci_dev * pci_dev = to_pci_dev(dev);
459 struct pci_driver * drv = pci_dev->driver;
460 int i = 0;
461
462 if (drv && drv->suspend_late) {
463 i = drv->suspend_late(pci_dev, state);
464 suspend_report_result(drv->suspend_late, i);
465 }
466 return i;
467}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100469static int pci_legacy_resume_early(struct device *dev)
470{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100471 struct pci_dev * pci_dev = to_pci_dev(dev);
472 struct pci_driver * drv = pci_dev->driver;
473
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100474 return drv && drv->resume_early ?
475 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100476}
477
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200478static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
480 struct pci_dev * pci_dev = to_pci_dev(dev);
481 struct pci_driver * drv = pci_dev->driver;
482
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100483 pci_fixup_device(pci_fixup_resume, pci_dev);
484
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100485 return drv && drv->resume ?
486 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487}
488
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100489/* Auxiliary functions used by the new power management framework */
490
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100491static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
492{
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100493 pci_restore_standard_config(pci_dev);
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100494 pci_dev->state_saved = false;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100495 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100496}
497
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100498static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100499{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100500 pci_fixup_device(pci_fixup_resume, pci_dev);
501
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100502 if (!pci_is_bridge(pci_dev))
503 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100504}
505
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100506static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100507{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100508 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100509 if (!pci_is_bridge(pci_dev))
510 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100511 pci_save_state(pci_dev);
512}
513
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100514static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
515{
516 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100517 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100518 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100519
520 /*
521 * Legacy PM support is used by default, so warn if the new framework is
522 * supported as well. Drivers are supposed to support either the
523 * former, or the latter, but not both at the same time.
524 */
525 WARN_ON(ret && drv->driver.pm);
526
527 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100528}
529
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100530/* New power management framework */
531
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200532static int pci_pm_prepare(struct device *dev)
533{
534 struct device_driver *drv = dev->driver;
535 int error = 0;
536
537 if (drv && drv->pm && drv->pm->prepare)
538 error = drv->pm->prepare(dev);
539
540 return error;
541}
542
543static void pci_pm_complete(struct device *dev)
544{
545 struct device_driver *drv = dev->driver;
546
547 if (drv && drv->pm && drv->pm->complete)
548 drv->pm->complete(dev);
549}
550
551#ifdef CONFIG_SUSPEND
552
553static int pci_pm_suspend(struct device *dev)
554{
555 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100556 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200557
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100558 if (pci_has_legacy_pm_support(pci_dev))
559 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100560
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100561 if (!pm) {
562 pci_pm_default_suspend(pci_dev);
563 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200564 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100565
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100566 pci_dev->state_saved = false;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200567
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100568 if (pm->suspend) {
569 pci_power_t prev = pci_dev->current_state;
570 int error;
571
572 error = pm->suspend(dev);
573 suspend_report_result(pm->suspend, error);
574 if (error)
575 return error;
576
577 if (pci_dev->state_saved)
578 goto Fixup;
579
580 if (pci_dev->current_state != PCI_D0
581 && pci_dev->current_state != PCI_UNKNOWN) {
582 WARN_ONCE(pci_dev->current_state != prev,
583 "PCI PM: State of device not saved by %pF\n",
584 pm->suspend);
585 goto Fixup;
586 }
587 }
588
589 if (!pci_dev->state_saved) {
590 pci_save_state(pci_dev);
591 if (!pci_is_bridge(pci_dev))
592 pci_prepare_to_sleep(pci_dev);
593 }
594
595 Fixup:
596 pci_fixup_device(pci_fixup_suspend, pci_dev);
597
598 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200599}
600
601static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900602{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100603 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200604 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200605 int error = 0;
Greg KHc8958172005-04-08 14:53:31 +0900606
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100607 if (pci_has_legacy_pm_support(pci_dev))
608 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
609
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100610 if (drv && drv->pm && drv->pm->suspend_noirq) {
611 error = drv->pm->suspend_noirq(dev);
612 suspend_report_result(drv->pm->suspend_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200613 }
614
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100615 if (!error)
616 pci_pm_set_unknown_state(pci_dev);
617
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200618 return error;
Greg KHc8958172005-04-08 14:53:31 +0900619}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200621static int pci_pm_resume_noirq(struct device *dev)
622{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100623 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200624 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200625 int error = 0;
626
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100627 pci_pm_default_resume_noirq(pci_dev);
628
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100629 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100630 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100631
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100632 if (drv && drv->pm && drv->pm->resume_noirq)
633 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200634
635 return error;
636}
637
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100638static int pci_pm_resume(struct device *dev)
639{
640 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100641 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100642 int error = 0;
643
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100644 /*
645 * This is necessary for the suspend error path in which resume is
646 * called without restoring the standard config registers of the device.
647 */
648 if (pci_dev->state_saved)
649 pci_restore_standard_config(pci_dev);
650
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100651 if (pci_has_legacy_pm_support(pci_dev))
652 return pci_legacy_resume(dev);
653
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100654 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100655
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100656 if (pm) {
657 if (pm->resume)
658 error = pm->resume(dev);
659 } else {
660 pci_pm_reenable_device(pci_dev);
661 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100662
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100663 return 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100664}
665
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200666#else /* !CONFIG_SUSPEND */
667
668#define pci_pm_suspend NULL
669#define pci_pm_suspend_noirq NULL
670#define pci_pm_resume NULL
671#define pci_pm_resume_noirq NULL
672
673#endif /* !CONFIG_SUSPEND */
674
675#ifdef CONFIG_HIBERNATION
676
677static int pci_pm_freeze(struct device *dev)
678{
679 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100680 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200681
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100682 if (pci_has_legacy_pm_support(pci_dev))
683 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100684
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100685 if (!pm) {
686 pci_pm_default_suspend(pci_dev);
687 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200688 }
689
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100690 pci_dev->state_saved = false;
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100691
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100692 if (pm->freeze) {
693 int error;
694
695 error = pm->freeze(dev);
696 suspend_report_result(pm->freeze, error);
697 if (error)
698 return error;
699 }
700
701 if (!pci_dev->state_saved)
702 pci_save_state(pci_dev);
703
704 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200705}
706
707static int pci_pm_freeze_noirq(struct device *dev)
708{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100709 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200710 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200711 int error = 0;
712
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100713 if (pci_has_legacy_pm_support(pci_dev))
714 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
715
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100716 if (drv && drv->pm && drv->pm->freeze_noirq) {
717 error = drv->pm->freeze_noirq(dev);
718 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200719 }
720
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100721 if (!error)
722 pci_pm_set_unknown_state(pci_dev);
723
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200724 return error;
725}
726
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200727static int pci_pm_thaw_noirq(struct device *dev)
728{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100729 struct pci_dev *pci_dev = to_pci_dev(dev);
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. Wysockiad8cfa12009-01-07 13:09:37 +0100733 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100734 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100735
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100736 pci_update_current_state(pci_dev, PCI_D0);
737
738 if (drv && drv->pm && drv->pm->thaw_noirq)
739 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200740
741 return error;
742}
743
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100744static int pci_pm_thaw(struct device *dev)
745{
746 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100747 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100748 int error = 0;
749
750 if (pci_has_legacy_pm_support(pci_dev))
751 return pci_legacy_resume(dev);
752
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100753 if (pm) {
754 if (pm->thaw)
755 error = pm->thaw(dev);
756 } else {
757 pci_pm_reenable_device(pci_dev);
758 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100759
760 return error;
761}
762
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200763static int pci_pm_poweroff(struct device *dev)
764{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100765 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100766 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200767 int error = 0;
768
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100769 if (pci_has_legacy_pm_support(pci_dev))
770 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100771
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100772 if (!pm) {
773 pci_pm_default_suspend(pci_dev);
774 goto Fixup;
775 }
776
777 pci_dev->state_saved = false;
778
779 if (pm->poweroff) {
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100780 error = pm->poweroff(dev);
781 suspend_report_result(pm->poweroff, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200782 }
783
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100784 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
785 pci_prepare_to_sleep(pci_dev);
786
787 Fixup:
788 pci_fixup_device(pci_fixup_suspend, pci_dev);
Rafael J. Wysockic9b99722009-01-07 13:02:36 +0100789
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200790 return error;
791}
792
793static int pci_pm_poweroff_noirq(struct device *dev)
794{
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200795 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200796 int error = 0;
797
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100798 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
799 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
800
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100801 if (drv && drv->pm && drv->pm->poweroff_noirq) {
802 error = drv->pm->poweroff_noirq(dev);
803 suspend_report_result(drv->pm->poweroff_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200804 }
805
806 return error;
807}
808
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200809static int pci_pm_restore_noirq(struct device *dev)
810{
811 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200812 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200813 int error = 0;
814
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100815 pci_pm_default_resume_noirq(pci_dev);
816
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100817 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100818 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100819
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100820 if (drv && drv->pm && drv->pm->restore_noirq)
821 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200822
823 return error;
824}
825
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100826static int pci_pm_restore(struct device *dev)
827{
828 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100829 struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100830 int error = 0;
831
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100832 /*
833 * This is necessary for the hibernation error path in which restore is
834 * called without restoring the standard config registers of the device.
835 */
836 if (pci_dev->state_saved)
837 pci_restore_standard_config(pci_dev);
838
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100839 if (pci_has_legacy_pm_support(pci_dev))
840 return pci_legacy_resume(dev);
841
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100842 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100843
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100844 if (pm) {
845 if (pm->restore)
846 error = pm->restore(dev);
847 } else {
848 pci_pm_reenable_device(pci_dev);
849 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100850
851 return error;
852}
853
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200854#else /* !CONFIG_HIBERNATION */
855
856#define pci_pm_freeze NULL
857#define pci_pm_freeze_noirq NULL
858#define pci_pm_thaw NULL
859#define pci_pm_thaw_noirq NULL
860#define pci_pm_poweroff NULL
861#define pci_pm_poweroff_noirq NULL
862#define pci_pm_restore NULL
863#define pci_pm_restore_noirq NULL
864
865#endif /* !CONFIG_HIBERNATION */
866
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200867struct dev_pm_ops pci_dev_pm_ops = {
868 .prepare = pci_pm_prepare,
869 .complete = pci_pm_complete,
870 .suspend = pci_pm_suspend,
871 .resume = pci_pm_resume,
872 .freeze = pci_pm_freeze,
873 .thaw = pci_pm_thaw,
874 .poweroff = pci_pm_poweroff,
875 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200876 .suspend_noirq = pci_pm_suspend_noirq,
877 .resume_noirq = pci_pm_resume_noirq,
878 .freeze_noirq = pci_pm_freeze_noirq,
879 .thaw_noirq = pci_pm_thaw_noirq,
880 .poweroff_noirq = pci_pm_poweroff_noirq,
881 .restore_noirq = pci_pm_restore_noirq,
882};
883
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200884#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200885
886#else /* !CONFIG_PM_SLEEP */
887
888#define PCI_PM_OPS_PTR NULL
889
890#endif /* !CONFIG_PM_SLEEP */
891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200893 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200895 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800896 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 *
898 * Adds the driver structure to the list of registered drivers.
899 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600900 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 * no device was claimed during registration.
902 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800903int __pci_register_driver(struct pci_driver *drv, struct module *owner,
904 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905{
906 int error;
907
908 /* initialize common driver fields */
909 drv->driver.name = drv->name;
910 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200911 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800912 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100913
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700914 spin_lock_init(&drv->dynids.lock);
915 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916
917 /* register with core */
918 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800919 if (error)
Chris Wright09943752009-02-23 21:52:23 -0800920 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800922 error = pci_create_newid_file(drv);
923 if (error)
Chris Wright09943752009-02-23 21:52:23 -0800924 goto out_newid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
Chris Wright09943752009-02-23 21:52:23 -0800926 error = pci_create_removeid_file(drv);
927 if (error)
928 goto out_removeid;
929out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 return error;
Chris Wright09943752009-02-23 21:52:23 -0800931
932out_removeid:
933 pci_remove_newid_file(drv);
934out_newid:
935 driver_unregister(&drv->driver);
936 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937}
938
939/**
940 * pci_unregister_driver - unregister a pci driver
941 * @drv: the driver structure to unregister
942 *
943 * Deletes the driver structure from the list of registered PCI drivers,
944 * gives it a chance to clean up by calling its remove() function for
945 * each device it was responsible for, and marks those devices as
946 * driverless.
947 */
948
949void
950pci_unregister_driver(struct pci_driver *drv)
951{
Chris Wright09943752009-02-23 21:52:23 -0800952 pci_remove_removeid_file(drv);
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800953 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 driver_unregister(&drv->driver);
955 pci_free_dynids(drv);
956}
957
958static struct pci_driver pci_compat_driver = {
959 .name = "compat"
960};
961
962/**
963 * pci_dev_driver - get the pci_driver of a device
964 * @dev: the device to query
965 *
966 * Returns the appropriate pci_driver structure or %NULL if there is no
967 * registered driver for the device.
968 */
969struct pci_driver *
970pci_dev_driver(const struct pci_dev *dev)
971{
972 if (dev->driver)
973 return dev->driver;
974 else {
975 int i;
976 for(i=0; i<=PCI_ROM_RESOURCE; i++)
977 if (dev->resource[i].flags & IORESOURCE_BUSY)
978 return &pci_compat_driver;
979 }
980 return NULL;
981}
982
983/**
984 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700986 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 *
988 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700989 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 * pci_device_id structure or %NULL if there is no match.
991 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700992static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700994 struct pci_dev *pci_dev = to_pci_dev(dev);
995 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 const struct pci_device_id *found_id;
997
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700998 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 if (found_id)
1000 return 1;
1001
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001002 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003}
1004
1005/**
1006 * pci_dev_get - increments the reference count of the pci device structure
1007 * @dev: the device being referenced
1008 *
1009 * Each live reference to a device should be refcounted.
1010 *
1011 * Drivers for PCI devices should normally record such references in
1012 * their probe() methods, when they bind to a device, and release
1013 * them by calling pci_dev_put(), in their disconnect() methods.
1014 *
1015 * A pointer to the device with the incremented reference counter is returned.
1016 */
1017struct pci_dev *pci_dev_get(struct pci_dev *dev)
1018{
1019 if (dev)
1020 get_device(&dev->dev);
1021 return dev;
1022}
1023
1024/**
1025 * pci_dev_put - release a use of the pci device structure
1026 * @dev: device that's been disconnected
1027 *
1028 * Must be called when a user of a device is finished with it. When the last
1029 * user of the device calls this function, the memory of the device is freed.
1030 */
1031void pci_dev_put(struct pci_dev *dev)
1032{
1033 if (dev)
1034 put_device(&dev->dev);
1035}
1036
1037#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001038int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039{
1040 return -ENODEV;
1041}
1042#endif
1043
1044struct bus_type pci_bus_type = {
1045 .name = "pci",
1046 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001047 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001048 .probe = pci_device_probe,
1049 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001050 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 .dev_attrs = pci_dev_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001052 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053};
1054
1055static int __init pci_driver_init(void)
1056{
1057 return bus_register(&pci_bus_type);
1058}
1059
1060postcore_initcall(pci_driver_init);
1061
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001062EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001063EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064EXPORT_SYMBOL(pci_unregister_driver);
1065EXPORT_SYMBOL(pci_dev_driver);
1066EXPORT_SYMBOL(pci_bus_type);
1067EXPORT_SYMBOL(pci_dev_get);
1068EXPORT_SYMBOL(pci_dev_put);