blob: 004bc248727096b3702b5b8e3f02fc89b6cb8ef1 [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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
18 */
19
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070020struct pci_dynid {
21 struct list_head node;
22 struct pci_device_id id;
23};
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Greg KH3d3c2ae2005-07-06 09:09:38 -070025#ifdef CONFIG_HOTPLUG
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027/**
Randy Dunlap8f7020d2005-10-23 11:57:38 -070028 * store_new_id - add a new PCI device ID to this driver and re-probe devices
29 * @driver: target device driver
30 * @buf: buffer for scanning device ID data
31 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 *
33 * Adds a new dynamic pci device ID to this driver,
34 * and causes the driver to probe for all devices again.
35 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -070036static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -070037store_new_id(struct device_driver *driver, const char *buf, size_t count)
38{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070039 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvare6ba18632007-04-07 17:21:28 +020041 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 subdevice=PCI_ANY_ID, class=0, class_mask=0;
43 unsigned long driver_data=0;
44 int fields=0;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070045 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
48 &vendor, &device, &subvendor, &subdevice,
49 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +020050 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 return -EINVAL;
52
Eric Sesterhennf5afe802006-02-28 15:34:49 +010053 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 if (!dynid)
55 return -ENOMEM;
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 INIT_LIST_HEAD(&dynid->node);
58 dynid->id.vendor = vendor;
59 dynid->id.device = device;
60 dynid->id.subvendor = subvendor;
61 dynid->id.subdevice = subdevice;
62 dynid->id.class = class;
63 dynid->id.class_mask = class_mask;
64 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
65 driver_data : 0UL;
66
67 spin_lock(&pdrv->dynids.lock);
68 list_add_tail(&pdrv->dynids.list, &dynid->node);
69 spin_unlock(&pdrv->dynids.lock);
70
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070071 if (get_driver(&pdrv->driver)) {
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070072 retval = driver_attach(&pdrv->driver);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070073 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 }
75
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070076 if (retval)
77 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 return count;
79}
Linus Torvalds1da177e2005-04-16 15:20:36 -070080static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82static void
83pci_free_dynids(struct pci_driver *drv)
84{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070085 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070088 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 list_del(&dynid->node);
90 kfree(dynid);
91 }
92 spin_unlock(&drv->dynids.lock);
93}
94
95static int
96pci_create_newid_file(struct pci_driver *drv)
97{
98 int error = 0;
99 if (drv->probe != NULL)
100 error = sysfs_create_file(&drv->driver.kobj,
101 &driver_attr_new_id.attr);
102 return error;
103}
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106static inline void pci_free_dynids(struct pci_driver *drv) {}
107static inline int pci_create_newid_file(struct pci_driver *drv)
108{
109 return 0;
110}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111#endif
112
113/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700114 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700116 * @dev: the PCI device structure to match against.
117 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700119 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700121 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200122 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700123 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700125const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
126 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700128 if (ids) {
129 while (ids->vendor || ids->subvendor || ids->class_mask) {
130 if (pci_match_one_device(ids, dev))
131 return ids;
132 ids++;
133 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 }
135 return NULL;
136}
137
138/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800139 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700140 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200141 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700142 *
143 * Used by a driver to check whether a PCI device present in the
144 * system is in its list of supported devices. Returns the matching
145 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700147const struct pci_device_id *pci_match_device(struct pci_driver *drv,
148 struct pci_dev *dev)
149{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700150 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Russell King7461b602006-11-29 21:18:04 +0000152 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700153 spin_lock(&drv->dynids.lock);
154 list_for_each_entry(dynid, &drv->dynids.list, node) {
155 if (pci_match_one_device(&dynid->id, dev)) {
156 spin_unlock(&drv->dynids.lock);
157 return &dynid->id;
158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700160 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000161
162 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
Andi Kleend42c6992005-07-06 19:56:03 +0200165static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
166 const struct pci_device_id *id)
167{
168 int error;
169#ifdef CONFIG_NUMA
170 /* Execute driver initialization on node where the
171 device's bus is attached to. This way the driver likely
172 allocates its local memory on the right node without
173 any need to change it. */
174 struct mempolicy *oldpol;
175 cpumask_t oldmask = current->cpus_allowed;
176 int node = pcibus_to_node(dev->bus);
177 if (node >= 0 && node_online(node))
178 set_cpus_allowed(current, node_to_cpumask(node));
179 /* And set default memory allocation policy */
180 oldpol = current->mempolicy;
181 current->mempolicy = &default_policy;
182 mpol_get(current->mempolicy);
183#endif
184 error = drv->probe(dev, id);
185#ifdef CONFIG_NUMA
186 set_cpus_allowed(current, oldmask);
187 mpol_free(current->mempolicy);
188 current->mempolicy = oldpol;
189#endif
190 return error;
191}
192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193/**
194 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700195 * @drv: driver to call to check if it wants the PCI device
196 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700198 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
200 */
201static int
202__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700203{
204 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 int error = 0;
206
207 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700208 error = -ENODEV;
209
210 id = pci_match_device(drv, pci_dev);
211 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200212 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700213 if (error >= 0) {
214 pci_dev->driver = drv;
215 error = 0;
216 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 }
218 return error;
219}
220
221static int pci_device_probe(struct device * dev)
222{
223 int error = 0;
224 struct pci_driver *drv;
225 struct pci_dev *pci_dev;
226
227 drv = to_pci_driver(dev->driver);
228 pci_dev = to_pci_dev(dev);
229 pci_dev_get(pci_dev);
230 error = __pci_device_probe(drv, pci_dev);
231 if (error)
232 pci_dev_put(pci_dev);
233
234 return error;
235}
236
237static int pci_device_remove(struct device * dev)
238{
239 struct pci_dev * pci_dev = to_pci_dev(dev);
240 struct pci_driver * drv = pci_dev->driver;
241
242 if (drv) {
243 if (drv->remove)
244 drv->remove(pci_dev);
245 pci_dev->driver = NULL;
246 }
247
248 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700249 * If the device is still on, set the power state as "unknown",
250 * since it might change by the next time we load the driver.
251 */
252 if (pci_dev->current_state == PCI_D0)
253 pci_dev->current_state = PCI_UNKNOWN;
254
255 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 * We would love to complain here if pci_dev->is_enabled is set, that
257 * the driver should have called pci_disable_device(), but the
258 * unfortunate fact is there are too many odd BIOS and bridge setups
259 * that don't like drivers doing that all of the time.
260 * Oh well, we can dream of sane hardware when we sleep, no matter how
261 * horrible the crap we have to deal with is when we are awake...
262 */
263
264 pci_dev_put(pci_dev);
265 return 0;
266}
267
268static int pci_device_suspend(struct device * dev, pm_message_t state)
269{
270 struct pci_dev * pci_dev = to_pci_dev(dev);
271 struct pci_driver * drv = pci_dev->driver;
272 int i = 0;
273
Andrew Morton02669492006-03-23 01:38:34 -0800274 if (drv && drv->suspend) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800276 suspend_report_result(drv->suspend, i);
277 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 pci_save_state(pci_dev);
Shaohua Li2449e062006-10-20 14:45:32 -0700279 /*
280 * mark its power state as "unknown", since we don't know if
281 * e.g. the BIOS will change its device state when we suspend.
282 */
283 if (pci_dev->current_state == PCI_D0)
284 pci_dev->current_state = PCI_UNKNOWN;
Andrew Morton02669492006-03-23 01:38:34 -0800285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return i;
287}
288
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700289static int pci_device_suspend_late(struct device * dev, pm_message_t state)
290{
291 struct pci_dev * pci_dev = to_pci_dev(dev);
292 struct pci_driver * drv = pci_dev->driver;
293 int i = 0;
294
295 if (drv && drv->suspend_late) {
296 i = drv->suspend_late(pci_dev, state);
297 suspend_report_result(drv->suspend_late, i);
298 }
299 return i;
300}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700302/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 * Default resume method for devices that have no driver provided resume,
304 * or not even a driver at all.
305 */
Jean Delvare8d92bc22006-04-18 14:49:56 +0200306static int pci_default_resume(struct pci_dev *pci_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200308 int retval = 0;
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /* restore the PCI config space */
311 pci_restore_state(pci_dev);
312 /* if the device was enabled before suspend, reenable */
Tejun Heo0b62e132007-07-27 14:43:35 +0900313 retval = pci_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 /* if the device was busmaster before the suspend, make it busmaster again */
315 if (pci_dev->is_busmaster)
316 pci_set_master(pci_dev);
Jean Delvare8d92bc22006-04-18 14:49:56 +0200317
318 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319}
320
321static int pci_device_resume(struct device * dev)
322{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200323 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 struct pci_dev * pci_dev = to_pci_dev(dev);
325 struct pci_driver * drv = pci_dev->driver;
326
327 if (drv && drv->resume)
Jean Delvare8d92bc22006-04-18 14:49:56 +0200328 error = drv->resume(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 else
Jean Delvare8d92bc22006-04-18 14:49:56 +0200330 error = pci_default_resume(pci_dev);
331 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332}
333
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700334static int pci_device_resume_early(struct device * dev)
335{
336 int error = 0;
337 struct pci_dev * pci_dev = to_pci_dev(dev);
338 struct pci_driver * drv = pci_dev->driver;
339
Alan Cox1597cac2006-12-04 15:14:45 -0800340 pci_fixup_device(pci_fixup_resume, pci_dev);
341
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700342 if (drv && drv->resume_early)
343 error = drv->resume_early(pci_dev);
344 return error;
345}
346
Greg KHc8958172005-04-08 14:53:31 +0900347static void pci_device_shutdown(struct device *dev)
348{
349 struct pci_dev *pci_dev = to_pci_dev(dev);
350 struct pci_driver *drv = pci_dev->driver;
351
352 if (drv && drv->shutdown)
353 drv->shutdown(pci_dev);
354}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
356#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
357#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
358
359static ssize_t
360pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
361{
362 struct device_driver *driver = kobj_to_pci_driver(kobj);
363 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500364 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500366 if (!get_driver(driver))
367 return -ENODEV;
368
369 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
370
371 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return ret;
373}
374
375static ssize_t
376pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
377 const char *buf, size_t count)
378{
379 struct device_driver *driver = kobj_to_pci_driver(kobj);
380 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500381 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500383 if (!get_driver(driver))
384 return -ENODEV;
385
386 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
387
388 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 return ret;
390}
391
392static struct sysfs_ops pci_driver_sysfs_ops = {
393 .show = pci_driver_attr_show,
394 .store = pci_driver_attr_store,
395};
396static struct kobj_type pci_driver_kobj_type = {
397 .sysfs_ops = &pci_driver_sysfs_ops,
398};
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200401 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200403 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800404 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 *
406 * Adds the driver structure to the list of registered drivers.
407 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600408 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 * no device was claimed during registration.
410 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800411int __pci_register_driver(struct pci_driver *drv, struct module *owner,
412 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413{
414 int error;
415
416 /* initialize common driver fields */
417 drv->driver.name = drv->name;
418 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200419 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800420 drv->driver.mod_name = mod_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 drv->driver.kobj.ktype = &pci_driver_kobj_type;
Alan Cox50b00752006-08-16 17:42:18 +0100422
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700423 spin_lock_init(&drv->dynids.lock);
424 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 /* register with core */
427 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800428 if (error)
429 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800431 error = pci_create_newid_file(drv);
432 if (error)
433 driver_unregister(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435 return error;
436}
437
438/**
439 * pci_unregister_driver - unregister a pci driver
440 * @drv: the driver structure to unregister
441 *
442 * Deletes the driver structure from the list of registered PCI drivers,
443 * gives it a chance to clean up by calling its remove() function for
444 * each device it was responsible for, and marks those devices as
445 * driverless.
446 */
447
448void
449pci_unregister_driver(struct pci_driver *drv)
450{
451 driver_unregister(&drv->driver);
452 pci_free_dynids(drv);
453}
454
455static struct pci_driver pci_compat_driver = {
456 .name = "compat"
457};
458
459/**
460 * pci_dev_driver - get the pci_driver of a device
461 * @dev: the device to query
462 *
463 * Returns the appropriate pci_driver structure or %NULL if there is no
464 * registered driver for the device.
465 */
466struct pci_driver *
467pci_dev_driver(const struct pci_dev *dev)
468{
469 if (dev->driver)
470 return dev->driver;
471 else {
472 int i;
473 for(i=0; i<=PCI_ROM_RESOURCE; i++)
474 if (dev->resource[i].flags & IORESOURCE_BUSY)
475 return &pci_compat_driver;
476 }
477 return NULL;
478}
479
480/**
481 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700483 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 *
485 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700486 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 * pci_device_id structure or %NULL if there is no match.
488 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700489static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700491 struct pci_dev *pci_dev = to_pci_dev(dev);
492 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 const struct pci_device_id *found_id;
494
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700495 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 if (found_id)
497 return 1;
498
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700499 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
501
502/**
503 * pci_dev_get - increments the reference count of the pci device structure
504 * @dev: the device being referenced
505 *
506 * Each live reference to a device should be refcounted.
507 *
508 * Drivers for PCI devices should normally record such references in
509 * their probe() methods, when they bind to a device, and release
510 * them by calling pci_dev_put(), in their disconnect() methods.
511 *
512 * A pointer to the device with the incremented reference counter is returned.
513 */
514struct pci_dev *pci_dev_get(struct pci_dev *dev)
515{
516 if (dev)
517 get_device(&dev->dev);
518 return dev;
519}
520
521/**
522 * pci_dev_put - release a use of the pci device structure
523 * @dev: device that's been disconnected
524 *
525 * Must be called when a user of a device is finished with it. When the last
526 * user of the device calls this function, the memory of the device is freed.
527 */
528void pci_dev_put(struct pci_dev *dev)
529{
530 if (dev)
531 put_device(&dev->dev);
532}
533
534#ifndef CONFIG_HOTPLUG
Kay Sievers312c0042005-11-16 09:00:00 +0100535int pci_uevent(struct device *dev, char **envp, int num_envp,
536 char *buffer, int buffer_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
538 return -ENODEV;
539}
540#endif
541
542struct bus_type pci_bus_type = {
543 .name = "pci",
544 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100545 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000546 .probe = pci_device_probe,
547 .remove = pci_device_remove,
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);