blob: 7146b69b812cff19ad6ff2f8bd80acea4a971a91 [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
56 dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
57 if (!dynid)
58 return -ENOMEM;
59
60 memset(dynid, 0, sizeof(*dynid));
61 INIT_LIST_HEAD(&dynid->node);
62 dynid->id.vendor = vendor;
63 dynid->id.device = device;
64 dynid->id.subvendor = subvendor;
65 dynid->id.subdevice = subdevice;
66 dynid->id.class = class;
67 dynid->id.class_mask = class_mask;
68 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
69 driver_data : 0UL;
70
71 spin_lock(&pdrv->dynids.lock);
72 list_add_tail(&pdrv->dynids.list, &dynid->node);
73 spin_unlock(&pdrv->dynids.lock);
74
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070075 if (get_driver(&pdrv->driver)) {
76 driver_attach(&pdrv->driver);
77 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 }
79
80 return count;
81}
Linus Torvalds1da177e2005-04-16 15:20:36 -070082static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84static void
85pci_free_dynids(struct pci_driver *drv)
86{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070087 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070090 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 list_del(&dynid->node);
92 kfree(dynid);
93 }
94 spin_unlock(&drv->dynids.lock);
95}
96
97static int
98pci_create_newid_file(struct pci_driver *drv)
99{
100 int error = 0;
101 if (drv->probe != NULL)
102 error = sysfs_create_file(&drv->driver.kobj,
103 &driver_attr_new_id.attr);
104 return error;
105}
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static inline void pci_free_dynids(struct pci_driver *drv) {}
109static inline int pci_create_newid_file(struct pci_driver *drv)
110{
111 return 0;
112}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#endif
114
115/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700116 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700118 * @dev: the PCI device structure to match against.
119 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700121 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700123 *
124 * Depreciated, don't use this as it will not catch any dynamic ids
125 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700127const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
128 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700130 if (ids) {
131 while (ids->vendor || ids->subvendor || ids->class_mask) {
132 if (pci_match_one_device(ids, dev))
133 return ids;
134 ids++;
135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137 return NULL;
138}
139
140/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700141 * pci_match_device - Tell if a PCI device structure has a matching
142 * PCI device id structure
143 * @ids: array of PCI device id structures to search in
144 * @dev: the PCI device structure to match against
145 * @drv: the PCI driver to match against
146 *
147 * Used by a driver to check whether a PCI device present in the
148 * system is in its list of supported devices. Returns the matching
149 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700151const struct pci_device_id *pci_match_device(struct pci_driver *drv,
152 struct pci_dev *dev)
153{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 const struct pci_device_id *id;
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700155 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700157 id = pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (id)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700159 return id;
160
161 /* static ids didn't match, lets look at the dynamic ones */
162 spin_lock(&drv->dynids.lock);
163 list_for_each_entry(dynid, &drv->dynids.list, node) {
164 if (pci_match_one_device(&dynid->id, dev)) {
165 spin_unlock(&drv->dynids.lock);
166 return &dynid->id;
167 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700169 spin_unlock(&drv->dynids.lock);
170 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Andi Kleend42c6992005-07-06 19:56:03 +0200173static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
174 const struct pci_device_id *id)
175{
176 int error;
177#ifdef CONFIG_NUMA
178 /* Execute driver initialization on node where the
179 device's bus is attached to. This way the driver likely
180 allocates its local memory on the right node without
181 any need to change it. */
182 struct mempolicy *oldpol;
183 cpumask_t oldmask = current->cpus_allowed;
184 int node = pcibus_to_node(dev->bus);
185 if (node >= 0 && node_online(node))
186 set_cpus_allowed(current, node_to_cpumask(node));
187 /* And set default memory allocation policy */
188 oldpol = current->mempolicy;
189 current->mempolicy = &default_policy;
190 mpol_get(current->mempolicy);
191#endif
192 error = drv->probe(dev, id);
193#ifdef CONFIG_NUMA
194 set_cpus_allowed(current, oldmask);
195 mpol_free(current->mempolicy);
196 current->mempolicy = oldpol;
197#endif
198 return error;
199}
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201/**
202 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700203 * @drv: driver to call to check if it wants the PCI device
204 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700206 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
208 */
209static int
210__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700211{
212 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 int error = 0;
214
215 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700216 error = -ENODEV;
217
218 id = pci_match_device(drv, pci_dev);
219 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200220 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700221 if (error >= 0) {
222 pci_dev->driver = drv;
223 error = 0;
224 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 }
226 return error;
227}
228
229static int pci_device_probe(struct device * dev)
230{
231 int error = 0;
232 struct pci_driver *drv;
233 struct pci_dev *pci_dev;
234
235 drv = to_pci_driver(dev->driver);
236 pci_dev = to_pci_dev(dev);
237 pci_dev_get(pci_dev);
238 error = __pci_device_probe(drv, pci_dev);
239 if (error)
240 pci_dev_put(pci_dev);
241
242 return error;
243}
244
245static int pci_device_remove(struct device * dev)
246{
247 struct pci_dev * pci_dev = to_pci_dev(dev);
248 struct pci_driver * drv = pci_dev->driver;
249
250 if (drv) {
251 if (drv->remove)
252 drv->remove(pci_dev);
253 pci_dev->driver = NULL;
254 }
255
256 /*
257 * We would love to complain here if pci_dev->is_enabled is set, that
258 * the driver should have called pci_disable_device(), but the
259 * unfortunate fact is there are too many odd BIOS and bridge setups
260 * that don't like drivers doing that all of the time.
261 * Oh well, we can dream of sane hardware when we sleep, no matter how
262 * horrible the crap we have to deal with is when we are awake...
263 */
264
265 pci_dev_put(pci_dev);
266 return 0;
267}
268
269static int pci_device_suspend(struct device * dev, pm_message_t state)
270{
271 struct pci_dev * pci_dev = to_pci_dev(dev);
272 struct pci_driver * drv = pci_dev->driver;
273 int i = 0;
274
275 if (drv && drv->suspend)
276 i = drv->suspend(pci_dev, state);
277 else
278 pci_save_state(pci_dev);
279 return i;
280}
281
282
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700283/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 * Default resume method for devices that have no driver provided resume,
285 * or not even a driver at all.
286 */
287static void pci_default_resume(struct pci_dev *pci_dev)
288{
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700289 int retval;
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 /* restore the PCI config space */
292 pci_restore_state(pci_dev);
293 /* if the device was enabled before suspend, reenable */
294 if (pci_dev->is_enabled)
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700295 retval = pci_enable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 /* if the device was busmaster before the suspend, make it busmaster again */
297 if (pci_dev->is_busmaster)
298 pci_set_master(pci_dev);
299}
300
301static int pci_device_resume(struct device * dev)
302{
303 struct pci_dev * pci_dev = to_pci_dev(dev);
304 struct pci_driver * drv = pci_dev->driver;
305
306 if (drv && drv->resume)
307 drv->resume(pci_dev);
308 else
309 pci_default_resume(pci_dev);
310 return 0;
311}
312
Greg KHc8958172005-04-08 14:53:31 +0900313static void pci_device_shutdown(struct device *dev)
314{
315 struct pci_dev *pci_dev = to_pci_dev(dev);
316 struct pci_driver *drv = pci_dev->driver;
317
318 if (drv && drv->shutdown)
319 drv->shutdown(pci_dev);
320}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
323#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
324
325static ssize_t
326pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
327{
328 struct device_driver *driver = kobj_to_pci_driver(kobj);
329 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500330 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500332 if (!get_driver(driver))
333 return -ENODEV;
334
335 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
336
337 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 return ret;
339}
340
341static ssize_t
342pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
343 const char *buf, size_t count)
344{
345 struct device_driver *driver = kobj_to_pci_driver(kobj);
346 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500347 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500349 if (!get_driver(driver))
350 return -ENODEV;
351
352 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
353
354 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return ret;
356}
357
358static struct sysfs_ops pci_driver_sysfs_ops = {
359 .show = pci_driver_attr_show,
360 .store = pci_driver_attr_store,
361};
362static struct kobj_type pci_driver_kobj_type = {
363 .sysfs_ops = &pci_driver_sysfs_ops,
364};
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200367 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200369 * @owner: owner module of drv
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 *
371 * Adds the driver structure to the list of registered drivers.
372 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600373 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 * no device was claimed during registration.
375 */
Laurent riffard863b18f2005-10-27 23:12:54 +0200376int __pci_register_driver(struct pci_driver *drv, struct module *owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{
378 int error;
379
380 /* initialize common driver fields */
381 drv->driver.name = drv->name;
382 drv->driver.bus = &pci_bus_type;
383 drv->driver.probe = pci_device_probe;
384 drv->driver.remove = pci_device_remove;
Christoph Hellwig794f5bf2005-06-17 12:25:25 -0700385 /* FIXME, once all of the existing PCI drivers have been fixed to set
386 * the pci shutdown function, this test can go away. */
387 if (!drv->driver.shutdown)
Mika Kukkonenc83d99452005-06-18 22:49:56 +0300388 drv->driver.shutdown = pci_device_shutdown;
Russell Kinga1720fd2005-10-16 21:31:36 +0100389 else
390 printk(KERN_WARNING "Warning: PCI driver %s has a struct "
391 "device_driver shutdown method, please update!\n",
392 drv->name);
Laurent riffard863b18f2005-10-27 23:12:54 +0200393 drv->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 drv->driver.kobj.ktype = &pci_driver_kobj_type;
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700395
396 spin_lock_init(&drv->dynids.lock);
397 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 /* register with core */
400 error = driver_register(&drv->driver);
401
402 if (!error)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700403 error = pci_create_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 return error;
406}
407
408/**
409 * pci_unregister_driver - unregister a pci driver
410 * @drv: the driver structure to unregister
411 *
412 * Deletes the driver structure from the list of registered PCI drivers,
413 * gives it a chance to clean up by calling its remove() function for
414 * each device it was responsible for, and marks those devices as
415 * driverless.
416 */
417
418void
419pci_unregister_driver(struct pci_driver *drv)
420{
421 driver_unregister(&drv->driver);
422 pci_free_dynids(drv);
423}
424
425static struct pci_driver pci_compat_driver = {
426 .name = "compat"
427};
428
429/**
430 * pci_dev_driver - get the pci_driver of a device
431 * @dev: the device to query
432 *
433 * Returns the appropriate pci_driver structure or %NULL if there is no
434 * registered driver for the device.
435 */
436struct pci_driver *
437pci_dev_driver(const struct pci_dev *dev)
438{
439 if (dev->driver)
440 return dev->driver;
441 else {
442 int i;
443 for(i=0; i<=PCI_ROM_RESOURCE; i++)
444 if (dev->resource[i].flags & IORESOURCE_BUSY)
445 return &pci_compat_driver;
446 }
447 return NULL;
448}
449
450/**
451 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700453 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 *
455 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700456 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 * pci_device_id structure or %NULL if there is no match.
458 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700459static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700461 struct pci_dev *pci_dev = to_pci_dev(dev);
462 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 const struct pci_device_id *found_id;
464
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700465 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 if (found_id)
467 return 1;
468
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700469 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470}
471
472/**
473 * pci_dev_get - increments the reference count of the pci device structure
474 * @dev: the device being referenced
475 *
476 * Each live reference to a device should be refcounted.
477 *
478 * Drivers for PCI devices should normally record such references in
479 * their probe() methods, when they bind to a device, and release
480 * them by calling pci_dev_put(), in their disconnect() methods.
481 *
482 * A pointer to the device with the incremented reference counter is returned.
483 */
484struct pci_dev *pci_dev_get(struct pci_dev *dev)
485{
486 if (dev)
487 get_device(&dev->dev);
488 return dev;
489}
490
491/**
492 * pci_dev_put - release a use of the pci device structure
493 * @dev: device that's been disconnected
494 *
495 * Must be called when a user of a device is finished with it. When the last
496 * user of the device calls this function, the memory of the device is freed.
497 */
498void pci_dev_put(struct pci_dev *dev)
499{
500 if (dev)
501 put_device(&dev->dev);
502}
503
504#ifndef CONFIG_HOTPLUG
Kay Sievers312c0042005-11-16 09:00:00 +0100505int pci_uevent(struct device *dev, char **envp, int num_envp,
506 char *buffer, int buffer_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507{
508 return -ENODEV;
509}
510#endif
511
512struct bus_type pci_bus_type = {
513 .name = "pci",
514 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100515 .uevent = pci_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 .suspend = pci_device_suspend,
517 .resume = pci_device_resume,
518 .dev_attrs = pci_dev_attrs,
519};
520
521static int __init pci_driver_init(void)
522{
523 return bus_register(&pci_bus_type);
524}
525
526postcore_initcall(pci_driver_init);
527
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700528EXPORT_SYMBOL(pci_match_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529EXPORT_SYMBOL(pci_match_device);
Laurent riffard863b18f2005-10-27 23:12:54 +0200530EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531EXPORT_SYMBOL(pci_unregister_driver);
532EXPORT_SYMBOL(pci_dev_driver);
533EXPORT_SYMBOL(pci_bus_type);
534EXPORT_SYMBOL(pci_dev_get);
535EXPORT_SYMBOL(pci_dev_put);