blob: 9e7d6ceb38057beb48134c2931b68dc227160474 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/pci/pci-driver.c
3 *
4 */
5
6#include <linux/pci.h>
7#include <linux/module.h>
8#include <linux/init.h>
9#include <linux/device.h>
Andi Kleend42c6992005-07-06 19:56:03 +020010#include <linux/mempolicy.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080011#include <linux/string.h>
12#include <linux/slab.h>
Tim Schmielau8c65b4a2005-11-07 00:59:43 -080013#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include "pci.h"
15
16/*
17 * Registration of PCI drivers and handling of hot-pluggable devices.
18 */
19
20/*
21 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
22 */
23
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070024struct pci_dynid {
25 struct list_head node;
26 struct pci_device_id id;
27};
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Greg KH3d3c2ae2005-07-06 09:09:38 -070029#ifdef CONFIG_HOTPLUG
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031/**
Randy Dunlap8f7020d2005-10-23 11:57:38 -070032 * store_new_id - add a new PCI device ID to this driver and re-probe devices
33 * @driver: target device driver
34 * @buf: buffer for scanning device ID data
35 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 *
37 * Adds a new dynamic pci device ID to this driver,
38 * and causes the driver to probe for all devices again.
39 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -070040static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -070041store_new_id(struct device_driver *driver, const char *buf, size_t count)
42{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070043 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 struct pci_driver *pdrv = to_pci_driver(driver);
45 __u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
46 subdevice=PCI_ANY_ID, class=0, class_mask=0;
47 unsigned long driver_data=0;
48 int fields=0;
49
50 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
51 &vendor, &device, &subvendor, &subdevice,
52 &class, &class_mask, &driver_data);
53 if (fields < 0)
54 return -EINVAL;
55
Eric Sesterhennf5afe802006-02-28 15:34:49 +010056 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 if (!dynid)
58 return -ENOMEM;
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 INIT_LIST_HEAD(&dynid->node);
61 dynid->id.vendor = vendor;
62 dynid->id.device = device;
63 dynid->id.subvendor = subvendor;
64 dynid->id.subdevice = subdevice;
65 dynid->id.class = class;
66 dynid->id.class_mask = class_mask;
67 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
68 driver_data : 0UL;
69
70 spin_lock(&pdrv->dynids.lock);
71 list_add_tail(&pdrv->dynids.list, &dynid->node);
72 spin_unlock(&pdrv->dynids.lock);
73
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070074 if (get_driver(&pdrv->driver)) {
75 driver_attach(&pdrv->driver);
76 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 }
78
79 return count;
80}
Linus Torvalds1da177e2005-04-16 15:20:36 -070081static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83static void
84pci_free_dynids(struct pci_driver *drv)
85{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070086 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070089 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 list_del(&dynid->node);
91 kfree(dynid);
92 }
93 spin_unlock(&drv->dynids.lock);
94}
95
96static int
97pci_create_newid_file(struct pci_driver *drv)
98{
99 int error = 0;
100 if (drv->probe != NULL)
101 error = sysfs_create_file(&drv->driver.kobj,
102 &driver_attr_new_id.attr);
103 return error;
104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107static inline void pci_free_dynids(struct pci_driver *drv) {}
108static inline int pci_create_newid_file(struct pci_driver *drv)
109{
110 return 0;
111}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112#endif
113
114/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700115 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700117 * @dev: the PCI device structure to match against.
118 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700120 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700122 *
123 * Depreciated, don't use this as it will not catch any dynamic ids
124 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700126const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
127 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700129 if (ids) {
130 while (ids->vendor || ids->subvendor || ids->class_mask) {
131 if (pci_match_one_device(ids, dev))
132 return ids;
133 ids++;
134 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 }
136 return NULL;
137}
138
139/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700140 * pci_match_device - Tell if a PCI device structure has a matching
141 * PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700142 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200143 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700144 *
145 * Used by a driver to check whether a PCI device present in the
146 * system is in its list of supported devices. Returns the matching
147 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700149const struct pci_device_id *pci_match_device(struct pci_driver *drv,
150 struct pci_dev *dev)
151{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 const struct pci_device_id *id;
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700153 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700155 id = pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 if (id)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700157 return id;
158
159 /* static ids didn't match, lets look at the dynamic ones */
160 spin_lock(&drv->dynids.lock);
161 list_for_each_entry(dynid, &drv->dynids.list, node) {
162 if (pci_match_one_device(&dynid->id, dev)) {
163 spin_unlock(&drv->dynids.lock);
164 return &dynid->id;
165 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700167 spin_unlock(&drv->dynids.lock);
168 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
170
Andi Kleend42c6992005-07-06 19:56:03 +0200171static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
172 const struct pci_device_id *id)
173{
174 int error;
175#ifdef CONFIG_NUMA
176 /* Execute driver initialization on node where the
177 device's bus is attached to. This way the driver likely
178 allocates its local memory on the right node without
179 any need to change it. */
180 struct mempolicy *oldpol;
181 cpumask_t oldmask = current->cpus_allowed;
182 int node = pcibus_to_node(dev->bus);
183 if (node >= 0 && node_online(node))
184 set_cpus_allowed(current, node_to_cpumask(node));
185 /* And set default memory allocation policy */
186 oldpol = current->mempolicy;
187 current->mempolicy = &default_policy;
188 mpol_get(current->mempolicy);
189#endif
190 error = drv->probe(dev, id);
191#ifdef CONFIG_NUMA
192 set_cpus_allowed(current, oldmask);
193 mpol_free(current->mempolicy);
194 current->mempolicy = oldpol;
195#endif
196 return error;
197}
198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199/**
200 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700201 * @drv: driver to call to check if it wants the PCI device
202 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700204 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
206 */
207static int
208__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700209{
210 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 int error = 0;
212
213 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700214 error = -ENODEV;
215
216 id = pci_match_device(drv, pci_dev);
217 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200218 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700219 if (error >= 0) {
220 pci_dev->driver = drv;
221 error = 0;
222 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 }
224 return error;
225}
226
227static int pci_device_probe(struct device * dev)
228{
229 int error = 0;
230 struct pci_driver *drv;
231 struct pci_dev *pci_dev;
232
233 drv = to_pci_driver(dev->driver);
234 pci_dev = to_pci_dev(dev);
235 pci_dev_get(pci_dev);
236 error = __pci_device_probe(drv, pci_dev);
237 if (error)
238 pci_dev_put(pci_dev);
239
240 return error;
241}
242
243static int pci_device_remove(struct device * dev)
244{
245 struct pci_dev * pci_dev = to_pci_dev(dev);
246 struct pci_driver * drv = pci_dev->driver;
247
248 if (drv) {
249 if (drv->remove)
250 drv->remove(pci_dev);
251 pci_dev->driver = NULL;
252 }
253
254 /*
255 * We would love to complain here if pci_dev->is_enabled is set, that
256 * the driver should have called pci_disable_device(), but the
257 * unfortunate fact is there are too many odd BIOS and bridge setups
258 * that don't like drivers doing that all of the time.
259 * Oh well, we can dream of sane hardware when we sleep, no matter how
260 * horrible the crap we have to deal with is when we are awake...
261 */
262
263 pci_dev_put(pci_dev);
264 return 0;
265}
266
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700267static int pci_device_suspend_prepare(struct device * dev, pm_message_t state)
268{
269 struct pci_dev * pci_dev = to_pci_dev(dev);
270 struct pci_driver * drv = pci_dev->driver;
271 int i = 0;
272
273 if (drv && drv->suspend_prepare) {
274 i = drv->suspend_prepare(pci_dev, state);
275 suspend_report_result(drv->suspend_prepare, i);
276 }
277 return i;
278}
279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280static int pci_device_suspend(struct device * dev, pm_message_t state)
281{
282 struct pci_dev * pci_dev = to_pci_dev(dev);
283 struct pci_driver * drv = pci_dev->driver;
284 int i = 0;
285
Andrew Morton02669492006-03-23 01:38:34 -0800286 if (drv && drv->suspend) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800288 suspend_report_result(drv->suspend, i);
289 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 pci_save_state(pci_dev);
Andrew Morton02669492006-03-23 01:38:34 -0800291 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 return i;
293}
294
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700295static int pci_device_suspend_late(struct device * dev, pm_message_t state)
296{
297 struct pci_dev * pci_dev = to_pci_dev(dev);
298 struct pci_driver * drv = pci_dev->driver;
299 int i = 0;
300
301 if (drv && drv->suspend_late) {
302 i = drv->suspend_late(pci_dev, state);
303 suspend_report_result(drv->suspend_late, i);
304 }
305 return i;
306}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700308/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 * Default resume method for devices that have no driver provided resume,
310 * or not even a driver at all.
311 */
Jean Delvare8d92bc22006-04-18 14:49:56 +0200312static int pci_default_resume(struct pci_dev *pci_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200314 int retval = 0;
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 /* restore the PCI config space */
317 pci_restore_state(pci_dev);
318 /* if the device was enabled before suspend, reenable */
319 if (pci_dev->is_enabled)
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700320 retval = pci_enable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 /* if the device was busmaster before the suspend, make it busmaster again */
322 if (pci_dev->is_busmaster)
323 pci_set_master(pci_dev);
Jean Delvare8d92bc22006-04-18 14:49:56 +0200324
325 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
328static int pci_device_resume(struct device * dev)
329{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200330 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 struct pci_dev * pci_dev = to_pci_dev(dev);
332 struct pci_driver * drv = pci_dev->driver;
333
334 if (drv && drv->resume)
Jean Delvare8d92bc22006-04-18 14:49:56 +0200335 error = drv->resume(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 else
Jean Delvare8d92bc22006-04-18 14:49:56 +0200337 error = pci_default_resume(pci_dev);
338 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339}
340
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700341static int pci_device_resume_early(struct device * dev)
342{
343 int error = 0;
344 struct pci_dev * pci_dev = to_pci_dev(dev);
345 struct pci_driver * drv = pci_dev->driver;
346
347 if (drv && drv->resume_early)
348 error = drv->resume_early(pci_dev);
349 return error;
350}
351
Greg KHc8958172005-04-08 14:53:31 +0900352static void pci_device_shutdown(struct device *dev)
353{
354 struct pci_dev *pci_dev = to_pci_dev(dev);
355 struct pci_driver *drv = pci_dev->driver;
356
357 if (drv && drv->shutdown)
358 drv->shutdown(pci_dev);
359}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
362#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
363
364static ssize_t
365pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
366{
367 struct device_driver *driver = kobj_to_pci_driver(kobj);
368 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500369 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500371 if (!get_driver(driver))
372 return -ENODEV;
373
374 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
375
376 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return ret;
378}
379
380static ssize_t
381pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
382 const char *buf, size_t count)
383{
384 struct device_driver *driver = kobj_to_pci_driver(kobj);
385 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500386 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500388 if (!get_driver(driver))
389 return -ENODEV;
390
391 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
392
393 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return ret;
395}
396
397static struct sysfs_ops pci_driver_sysfs_ops = {
398 .show = pci_driver_attr_show,
399 .store = pci_driver_attr_store,
400};
401static struct kobj_type pci_driver_kobj_type = {
402 .sysfs_ops = &pci_driver_sysfs_ops,
403};
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200406 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200408 * @owner: owner module of drv
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 *
410 * Adds the driver structure to the list of registered drivers.
411 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600412 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 * no device was claimed during registration.
414 */
Laurent riffard863b18f2005-10-27 23:12:54 +0200415int __pci_register_driver(struct pci_driver *drv, struct module *owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
417 int error;
418
419 /* initialize common driver fields */
420 drv->driver.name = drv->name;
421 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200422 drv->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 drv->driver.kobj.ktype = &pci_driver_kobj_type;
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700424
425 spin_lock_init(&drv->dynids.lock);
426 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428 /* register with core */
429 error = driver_register(&drv->driver);
430
431 if (!error)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700432 error = pci_create_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 return error;
435}
436
437/**
438 * pci_unregister_driver - unregister a pci driver
439 * @drv: the driver structure to unregister
440 *
441 * Deletes the driver structure from the list of registered PCI drivers,
442 * gives it a chance to clean up by calling its remove() function for
443 * each device it was responsible for, and marks those devices as
444 * driverless.
445 */
446
447void
448pci_unregister_driver(struct pci_driver *drv)
449{
450 driver_unregister(&drv->driver);
451 pci_free_dynids(drv);
452}
453
454static struct pci_driver pci_compat_driver = {
455 .name = "compat"
456};
457
458/**
459 * pci_dev_driver - get the pci_driver of a device
460 * @dev: the device to query
461 *
462 * Returns the appropriate pci_driver structure or %NULL if there is no
463 * registered driver for the device.
464 */
465struct pci_driver *
466pci_dev_driver(const struct pci_dev *dev)
467{
468 if (dev->driver)
469 return dev->driver;
470 else {
471 int i;
472 for(i=0; i<=PCI_ROM_RESOURCE; i++)
473 if (dev->resource[i].flags & IORESOURCE_BUSY)
474 return &pci_compat_driver;
475 }
476 return NULL;
477}
478
479/**
480 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700482 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 *
484 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700485 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 * pci_device_id structure or %NULL if there is no match.
487 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700488static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700490 struct pci_dev *pci_dev = to_pci_dev(dev);
491 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 const struct pci_device_id *found_id;
493
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700494 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (found_id)
496 return 1;
497
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700498 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
500
501/**
502 * pci_dev_get - increments the reference count of the pci device structure
503 * @dev: the device being referenced
504 *
505 * Each live reference to a device should be refcounted.
506 *
507 * Drivers for PCI devices should normally record such references in
508 * their probe() methods, when they bind to a device, and release
509 * them by calling pci_dev_put(), in their disconnect() methods.
510 *
511 * A pointer to the device with the incremented reference counter is returned.
512 */
513struct pci_dev *pci_dev_get(struct pci_dev *dev)
514{
515 if (dev)
516 get_device(&dev->dev);
517 return dev;
518}
519
520/**
521 * pci_dev_put - release a use of the pci device structure
522 * @dev: device that's been disconnected
523 *
524 * Must be called when a user of a device is finished with it. When the last
525 * user of the device calls this function, the memory of the device is freed.
526 */
527void pci_dev_put(struct pci_dev *dev)
528{
529 if (dev)
530 put_device(&dev->dev);
531}
532
533#ifndef CONFIG_HOTPLUG
Kay Sievers312c0042005-11-16 09:00:00 +0100534int pci_uevent(struct device *dev, char **envp, int num_envp,
535 char *buffer, int buffer_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
537 return -ENODEV;
538}
539#endif
540
541struct bus_type pci_bus_type = {
542 .name = "pci",
543 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100544 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000545 .probe = pci_device_probe,
546 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700547 .suspend_prepare= pci_device_suspend_prepare,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 .suspend = pci_device_suspend,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700549 .suspend_late = pci_device_suspend_late,
550 .resume_early = pci_device_resume_early,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 .resume = pci_device_resume,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700552 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 .dev_attrs = pci_dev_attrs,
554};
555
556static int __init pci_driver_init(void)
557{
558 return bus_register(&pci_bus_type);
559}
560
561postcore_initcall(pci_driver_init);
562
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700563EXPORT_SYMBOL(pci_match_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564EXPORT_SYMBOL(pci_match_device);
Laurent riffard863b18f2005-10-27 23:12:54 +0200565EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566EXPORT_SYMBOL(pci_unregister_driver);
567EXPORT_SYMBOL(pci_dev_driver);
568EXPORT_SYMBOL(pci_bus_type);
569EXPORT_SYMBOL(pci_dev_get);
570EXPORT_SYMBOL(pci_dev_put);