Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi...
[linux-2.6.git] / drivers / pci / pci-driver.c
1 /*
2  * drivers/pci/pci-driver.c
3  *
4  * (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  *
9  */
10
11 #include <linux/pci.h>
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/device.h>
15 #include <linux/mempolicy.h>
16 #include <linux/string.h>
17 #include <linux/slab.h>
18 #include <linux/sched.h>
19 #include "pci.h"
20
21 /*
22  * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
23  */
24
25 struct pci_dynid {
26         struct list_head node;
27         struct pci_device_id id;
28 };
29
30 #ifdef CONFIG_HOTPLUG
31
32 /**
33  * store_new_id - add a new PCI device ID to this driver and re-probe devices
34  * @driver: target device driver
35  * @buf: buffer for scanning device ID data
36  * @count: input size
37  *
38  * Adds a new dynamic pci device ID to this driver,
39  * and causes the driver to probe for all devices again.
40  */
41 static ssize_t
42 store_new_id(struct device_driver *driver, const char *buf, size_t count)
43 {
44         struct pci_dynid *dynid;
45         struct pci_driver *pdrv = to_pci_driver(driver);
46         const struct pci_device_id *ids = pdrv->id_table;
47         __u32 vendor, device, subvendor=PCI_ANY_ID,
48                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
49         unsigned long driver_data=0;
50         int fields=0;
51         int retval;
52
53         fields = sscanf(buf, "%x %x %x %x %x %x %lx",
54                         &vendor, &device, &subvendor, &subdevice,
55                         &class, &class_mask, &driver_data);
56         if (fields < 2)
57                 return -EINVAL;
58
59         /* Only accept driver_data values that match an existing id_table
60            entry */
61         retval = -EINVAL;
62         while (ids->vendor || ids->subvendor || ids->class_mask) {
63                 if (driver_data == ids->driver_data) {
64                         retval = 0;
65                         break;
66                 }
67                 ids++;
68         }
69         if (retval)     /* No match */
70                 return retval;
71
72         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
73         if (!dynid)
74                 return -ENOMEM;
75
76         dynid->id.vendor = vendor;
77         dynid->id.device = device;
78         dynid->id.subvendor = subvendor;
79         dynid->id.subdevice = subdevice;
80         dynid->id.class = class;
81         dynid->id.class_mask = class_mask;
82         dynid->id.driver_data = driver_data;
83
84         spin_lock(&pdrv->dynids.lock);
85         list_add_tail(&dynid->node, &pdrv->dynids.list);
86         spin_unlock(&pdrv->dynids.lock);
87
88         if (get_driver(&pdrv->driver)) {
89                 retval = driver_attach(&pdrv->driver);
90                 put_driver(&pdrv->driver);
91         }
92
93         if (retval)
94                 return retval;
95         return count;
96 }
97 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
98
99 static void
100 pci_free_dynids(struct pci_driver *drv)
101 {
102         struct pci_dynid *dynid, *n;
103
104         spin_lock(&drv->dynids.lock);
105         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
106                 list_del(&dynid->node);
107                 kfree(dynid);
108         }
109         spin_unlock(&drv->dynids.lock);
110 }
111
112 static int
113 pci_create_newid_file(struct pci_driver *drv)
114 {
115         int error = 0;
116         if (drv->probe != NULL)
117                 error = driver_create_file(&drv->driver, &driver_attr_new_id);
118         return error;
119 }
120
121 static void pci_remove_newid_file(struct pci_driver *drv)
122 {
123         driver_remove_file(&drv->driver, &driver_attr_new_id);
124 }
125 #else /* !CONFIG_HOTPLUG */
126 static inline void pci_free_dynids(struct pci_driver *drv) {}
127 static inline int pci_create_newid_file(struct pci_driver *drv)
128 {
129         return 0;
130 }
131 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
132 #endif
133
134 /**
135  * pci_match_id - See if a pci device matches a given pci_id table
136  * @ids: array of PCI device id structures to search in
137  * @dev: the PCI device structure to match against.
138  *
139  * Used by a driver to check whether a PCI device present in the
140  * system is in its list of supported devices.  Returns the matching
141  * pci_device_id structure or %NULL if there is no match.
142  *
143  * Deprecated, don't use this as it will not catch any dynamic ids
144  * that a driver might want to check for.
145  */
146 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
147                                          struct pci_dev *dev)
148 {
149         if (ids) {
150                 while (ids->vendor || ids->subvendor || ids->class_mask) {
151                         if (pci_match_one_device(ids, dev))
152                                 return ids;
153                         ids++;
154                 }
155         }
156         return NULL;
157 }
158
159 /**
160  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
161  * @drv: the PCI driver to match against
162  * @dev: the PCI device structure to match against
163  *
164  * Used by a driver to check whether a PCI device present in the
165  * system is in its list of supported devices.  Returns the matching
166  * pci_device_id structure or %NULL if there is no match.
167  */
168 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
169                                                     struct pci_dev *dev)
170 {
171         struct pci_dynid *dynid;
172
173         /* Look at the dynamic ids first, before the static ones */
174         spin_lock(&drv->dynids.lock);
175         list_for_each_entry(dynid, &drv->dynids.list, node) {
176                 if (pci_match_one_device(&dynid->id, dev)) {
177                         spin_unlock(&drv->dynids.lock);
178                         return &dynid->id;
179                 }
180         }
181         spin_unlock(&drv->dynids.lock);
182
183         return pci_match_id(drv->id_table, dev);
184 }
185
186 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
187                           const struct pci_device_id *id)
188 {
189         int error;
190 #ifdef CONFIG_NUMA
191         /* Execute driver initialization on node where the
192            device's bus is attached to.  This way the driver likely
193            allocates its local memory on the right node without
194            any need to change it. */
195         struct mempolicy *oldpol;
196         cpumask_t oldmask = current->cpus_allowed;
197         int node = dev_to_node(&dev->dev);
198
199         if (node >= 0) {
200                 node_to_cpumask_ptr(nodecpumask, node);
201                 set_cpus_allowed_ptr(current, nodecpumask);
202         }
203         /* And set default memory allocation policy */
204         oldpol = current->mempolicy;
205         current->mempolicy = NULL;      /* fall back to system default policy */
206 #endif
207         error = drv->probe(dev, id);
208 #ifdef CONFIG_NUMA
209         set_cpus_allowed_ptr(current, &oldmask);
210         current->mempolicy = oldpol;
211 #endif
212         return error;
213 }
214
215 /**
216  * __pci_device_probe()
217  * @drv: driver to call to check if it wants the PCI device
218  * @pci_dev: PCI device being probed
219  * 
220  * returns 0 on success, else error.
221  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
222  */
223 static int
224 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
225 {
226         const struct pci_device_id *id;
227         int error = 0;
228
229         if (!pci_dev->driver && drv->probe) {
230                 error = -ENODEV;
231
232                 id = pci_match_device(drv, pci_dev);
233                 if (id)
234                         error = pci_call_probe(drv, pci_dev, id);
235                 if (error >= 0) {
236                         pci_dev->driver = drv;
237                         error = 0;
238                 }
239         }
240         return error;
241 }
242
243 static int pci_device_probe(struct device * dev)
244 {
245         int error = 0;
246         struct pci_driver *drv;
247         struct pci_dev *pci_dev;
248
249         drv = to_pci_driver(dev->driver);
250         pci_dev = to_pci_dev(dev);
251         pci_dev_get(pci_dev);
252         error = __pci_device_probe(drv, pci_dev);
253         if (error)
254                 pci_dev_put(pci_dev);
255
256         return error;
257 }
258
259 static int pci_device_remove(struct device * dev)
260 {
261         struct pci_dev * pci_dev = to_pci_dev(dev);
262         struct pci_driver * drv = pci_dev->driver;
263
264         if (drv) {
265                 if (drv->remove)
266                         drv->remove(pci_dev);
267                 pci_dev->driver = NULL;
268         }
269
270         /*
271          * If the device is still on, set the power state as "unknown",
272          * since it might change by the next time we load the driver.
273          */
274         if (pci_dev->current_state == PCI_D0)
275                 pci_dev->current_state = PCI_UNKNOWN;
276
277         /*
278          * We would love to complain here if pci_dev->is_enabled is set, that
279          * the driver should have called pci_disable_device(), but the
280          * unfortunate fact is there are too many odd BIOS and bridge setups
281          * that don't like drivers doing that all of the time.  
282          * Oh well, we can dream of sane hardware when we sleep, no matter how
283          * horrible the crap we have to deal with is when we are awake...
284          */
285
286         pci_dev_put(pci_dev);
287         return 0;
288 }
289
290 static void pci_device_shutdown(struct device *dev)
291 {
292         struct pci_dev *pci_dev = to_pci_dev(dev);
293         struct pci_driver *drv = pci_dev->driver;
294
295         if (drv && drv->shutdown)
296                 drv->shutdown(pci_dev);
297         pci_msi_shutdown(pci_dev);
298         pci_msix_shutdown(pci_dev);
299 }
300
301 #ifdef CONFIG_PM_SLEEP
302
303 /*
304  * Default "suspend" method for devices that have no driver provided suspend,
305  * or not even a driver at all.
306  */
307 static void pci_default_pm_suspend(struct pci_dev *pci_dev)
308 {
309         pci_save_state(pci_dev);
310         /*
311          * mark its power state as "unknown", since we don't know if
312          * e.g. the BIOS will change its device state when we suspend.
313          */
314         if (pci_dev->current_state == PCI_D0)
315                 pci_dev->current_state = PCI_UNKNOWN;
316 }
317
318 /*
319  * Default "resume" method for devices that have no driver provided resume,
320  * or not even a driver at all.
321  */
322 static int pci_default_pm_resume(struct pci_dev *pci_dev)
323 {
324         int retval = 0;
325
326         /* restore the PCI config space */
327         pci_restore_state(pci_dev);
328         /* if the device was enabled before suspend, reenable */
329         retval = pci_reenable_device(pci_dev);
330         /*
331          * if the device was busmaster before the suspend, make it busmaster
332          * again
333          */
334         if (pci_dev->is_busmaster)
335                 pci_set_master(pci_dev);
336
337         return retval;
338 }
339
340 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
341 {
342         struct pci_dev * pci_dev = to_pci_dev(dev);
343         struct pci_driver * drv = pci_dev->driver;
344         int i = 0;
345
346         if (drv && drv->suspend) {
347                 i = drv->suspend(pci_dev, state);
348                 suspend_report_result(drv->suspend, i);
349         } else {
350                 pci_default_pm_suspend(pci_dev);
351         }
352         return i;
353 }
354
355 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
356 {
357         struct pci_dev * pci_dev = to_pci_dev(dev);
358         struct pci_driver * drv = pci_dev->driver;
359         int i = 0;
360
361         if (drv && drv->suspend_late) {
362                 i = drv->suspend_late(pci_dev, state);
363                 suspend_report_result(drv->suspend_late, i);
364         }
365         return i;
366 }
367
368 static int pci_legacy_resume(struct device *dev)
369 {
370         int error;
371         struct pci_dev * pci_dev = to_pci_dev(dev);
372         struct pci_driver * drv = pci_dev->driver;
373
374         if (drv && drv->resume)
375                 error = drv->resume(pci_dev);
376         else
377                 error = pci_default_pm_resume(pci_dev);
378         return error;
379 }
380
381 static int pci_legacy_resume_early(struct device *dev)
382 {
383         int error = 0;
384         struct pci_dev * pci_dev = to_pci_dev(dev);
385         struct pci_driver * drv = pci_dev->driver;
386
387         if (drv && drv->resume_early)
388                 error = drv->resume_early(pci_dev);
389         return error;
390 }
391
392 static int pci_pm_prepare(struct device *dev)
393 {
394         struct device_driver *drv = dev->driver;
395         int error = 0;
396
397         if (drv && drv->pm && drv->pm->prepare)
398                 error = drv->pm->prepare(dev);
399
400         return error;
401 }
402
403 static void pci_pm_complete(struct device *dev)
404 {
405         struct device_driver *drv = dev->driver;
406
407         if (drv && drv->pm && drv->pm->complete)
408                 drv->pm->complete(dev);
409 }
410
411 #ifdef CONFIG_SUSPEND
412
413 static int pci_pm_suspend(struct device *dev)
414 {
415         struct pci_dev *pci_dev = to_pci_dev(dev);
416         struct device_driver *drv = dev->driver;
417         int error = 0;
418
419         if (drv && drv->pm) {
420                 if (drv->pm->suspend) {
421                         error = drv->pm->suspend(dev);
422                         suspend_report_result(drv->pm->suspend, error);
423                 } else {
424                         pci_default_pm_suspend(pci_dev);
425                 }
426         } else {
427                 error = pci_legacy_suspend(dev, PMSG_SUSPEND);
428         }
429         pci_fixup_device(pci_fixup_suspend, pci_dev);
430
431         return error;
432 }
433
434 static int pci_pm_suspend_noirq(struct device *dev)
435 {
436         struct pci_dev *pci_dev = to_pci_dev(dev);
437         struct pci_driver *drv = pci_dev->driver;
438         int error = 0;
439
440         if (drv && drv->pm) {
441                 if (drv->pm->suspend_noirq) {
442                         error = drv->pm->suspend_noirq(dev);
443                         suspend_report_result(drv->pm->suspend_noirq, error);
444                 }
445         } else {
446                 error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
447         }
448
449         return error;
450 }
451
452 static int pci_pm_resume(struct device *dev)
453 {
454         struct pci_dev *pci_dev = to_pci_dev(dev);
455         struct device_driver *drv = dev->driver;
456         int error;
457
458         pci_fixup_device(pci_fixup_resume, pci_dev);
459
460         if (drv && drv->pm) {
461                 error = drv->pm->resume ? drv->pm->resume(dev) :
462                         pci_default_pm_resume(pci_dev);
463         } else {
464                 error = pci_legacy_resume(dev);
465         }
466
467         return error;
468 }
469
470 static int pci_pm_resume_noirq(struct device *dev)
471 {
472         struct pci_dev *pci_dev = to_pci_dev(dev);
473         struct pci_driver *drv = pci_dev->driver;
474         int error = 0;
475
476         pci_fixup_device(pci_fixup_resume_early, pci_dev);
477
478         if (drv && drv->pm) {
479                 if (drv->pm->resume_noirq)
480                         error = drv->pm->resume_noirq(dev);
481         } else {
482                 error = pci_legacy_resume_early(dev);
483         }
484
485         return error;
486 }
487
488 #else /* !CONFIG_SUSPEND */
489
490 #define pci_pm_suspend          NULL
491 #define pci_pm_suspend_noirq    NULL
492 #define pci_pm_resume           NULL
493 #define pci_pm_resume_noirq     NULL
494
495 #endif /* !CONFIG_SUSPEND */
496
497 #ifdef CONFIG_HIBERNATION
498
499 static int pci_pm_freeze(struct device *dev)
500 {
501         struct pci_dev *pci_dev = to_pci_dev(dev);
502         struct device_driver *drv = dev->driver;
503         int error = 0;
504
505         if (drv && drv->pm) {
506                 if (drv->pm->freeze) {
507                         error = drv->pm->freeze(dev);
508                         suspend_report_result(drv->pm->freeze, error);
509                 } else {
510                         pci_default_pm_suspend(pci_dev);
511                 }
512         } else {
513                 error = pci_legacy_suspend(dev, PMSG_FREEZE);
514                 pci_fixup_device(pci_fixup_suspend, pci_dev);
515         }
516
517         return error;
518 }
519
520 static int pci_pm_freeze_noirq(struct device *dev)
521 {
522         struct pci_dev *pci_dev = to_pci_dev(dev);
523         struct pci_driver *drv = pci_dev->driver;
524         int error = 0;
525
526         if (drv && drv->pm) {
527                 if (drv->pm->freeze_noirq) {
528                         error = drv->pm->freeze_noirq(dev);
529                         suspend_report_result(drv->pm->freeze_noirq, error);
530                 }
531         } else {
532                 error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
533         }
534
535         return error;
536 }
537
538 static int pci_pm_thaw(struct device *dev)
539 {
540         struct device_driver *drv = dev->driver;
541         int error = 0;
542
543         if (drv && drv->pm) {
544                 if (drv->pm->thaw)
545                         error =  drv->pm->thaw(dev);
546         } else {
547                 pci_fixup_device(pci_fixup_resume, to_pci_dev(dev));
548                 error = pci_legacy_resume(dev);
549         }
550
551         return error;
552 }
553
554 static int pci_pm_thaw_noirq(struct device *dev)
555 {
556         struct pci_dev *pci_dev = to_pci_dev(dev);
557         struct pci_driver *drv = pci_dev->driver;
558         int error = 0;
559
560         if (drv && drv->pm) {
561                 if (drv->pm->thaw_noirq)
562                         error = drv->pm->thaw_noirq(dev);
563         } else {
564                 pci_fixup_device(pci_fixup_resume_early, pci_dev);
565                 error = pci_legacy_resume_early(dev);
566         }
567
568         return error;
569 }
570
571 static int pci_pm_poweroff(struct device *dev)
572 {
573         struct device_driver *drv = dev->driver;
574         int error = 0;
575
576         pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
577
578         if (drv && drv->pm) {
579                 if (drv->pm->poweroff) {
580                         error = drv->pm->poweroff(dev);
581                         suspend_report_result(drv->pm->poweroff, error);
582                 }
583         } else {
584                 error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
585         }
586
587         return error;
588 }
589
590 static int pci_pm_poweroff_noirq(struct device *dev)
591 {
592         struct pci_dev *pci_dev = to_pci_dev(dev);
593         struct pci_driver *drv = pci_dev->driver;
594         int error = 0;
595
596         if (drv && drv->pm) {
597                 if (drv->pm->poweroff_noirq) {
598                         error = drv->pm->poweroff_noirq(dev);
599                         suspend_report_result(drv->pm->poweroff_noirq, error);
600                 }
601         } else {
602                 error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
603         }
604
605         return error;
606 }
607
608 static int pci_pm_restore(struct device *dev)
609 {
610         struct pci_dev *pci_dev = to_pci_dev(dev);
611         struct device_driver *drv = dev->driver;
612         int error;
613
614         if (drv && drv->pm) {
615                 error = drv->pm->restore ? drv->pm->restore(dev) :
616                         pci_default_pm_resume(pci_dev);
617         } else {
618                 error = pci_legacy_resume(dev);
619         }
620         pci_fixup_device(pci_fixup_resume, pci_dev);
621
622         return error;
623 }
624
625 static int pci_pm_restore_noirq(struct device *dev)
626 {
627         struct pci_dev *pci_dev = to_pci_dev(dev);
628         struct pci_driver *drv = pci_dev->driver;
629         int error = 0;
630
631         pci_fixup_device(pci_fixup_resume, pci_dev);
632
633         if (drv && drv->pm) {
634                 if (drv->pm->restore_noirq)
635                         error = drv->pm->restore_noirq(dev);
636         } else {
637                 error = pci_legacy_resume_early(dev);
638         }
639         pci_fixup_device(pci_fixup_resume_early, pci_dev);
640
641         return error;
642 }
643
644 #else /* !CONFIG_HIBERNATION */
645
646 #define pci_pm_freeze           NULL
647 #define pci_pm_freeze_noirq     NULL
648 #define pci_pm_thaw             NULL
649 #define pci_pm_thaw_noirq       NULL
650 #define pci_pm_poweroff         NULL
651 #define pci_pm_poweroff_noirq   NULL
652 #define pci_pm_restore          NULL
653 #define pci_pm_restore_noirq    NULL
654
655 #endif /* !CONFIG_HIBERNATION */
656
657 struct pm_ext_ops pci_pm_ops = {
658         .base = {
659                 .prepare = pci_pm_prepare,
660                 .complete = pci_pm_complete,
661                 .suspend = pci_pm_suspend,
662                 .resume = pci_pm_resume,
663                 .freeze = pci_pm_freeze,
664                 .thaw = pci_pm_thaw,
665                 .poweroff = pci_pm_poweroff,
666                 .restore = pci_pm_restore,
667         },
668         .suspend_noirq = pci_pm_suspend_noirq,
669         .resume_noirq = pci_pm_resume_noirq,
670         .freeze_noirq = pci_pm_freeze_noirq,
671         .thaw_noirq = pci_pm_thaw_noirq,
672         .poweroff_noirq = pci_pm_poweroff_noirq,
673         .restore_noirq = pci_pm_restore_noirq,
674 };
675
676 #define PCI_PM_OPS_PTR  &pci_pm_ops
677
678 #else /* !CONFIG_PM_SLEEP */
679
680 #define PCI_PM_OPS_PTR  NULL
681
682 #endif /* !CONFIG_PM_SLEEP */
683
684 /**
685  * __pci_register_driver - register a new pci driver
686  * @drv: the driver structure to register
687  * @owner: owner module of drv
688  * @mod_name: module name string
689  * 
690  * Adds the driver structure to the list of registered drivers.
691  * Returns a negative value on error, otherwise 0. 
692  * If no error occurred, the driver remains registered even if 
693  * no device was claimed during registration.
694  */
695 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
696                           const char *mod_name)
697 {
698         int error;
699
700         /* initialize common driver fields */
701         drv->driver.name = drv->name;
702         drv->driver.bus = &pci_bus_type;
703         drv->driver.owner = owner;
704         drv->driver.mod_name = mod_name;
705
706         if (drv->pm)
707                 drv->driver.pm = &drv->pm->base;
708
709         spin_lock_init(&drv->dynids.lock);
710         INIT_LIST_HEAD(&drv->dynids.list);
711
712         /* register with core */
713         error = driver_register(&drv->driver);
714         if (error)
715                 return error;
716
717         error = pci_create_newid_file(drv);
718         if (error)
719                 driver_unregister(&drv->driver);
720
721         return error;
722 }
723
724 /**
725  * pci_unregister_driver - unregister a pci driver
726  * @drv: the driver structure to unregister
727  * 
728  * Deletes the driver structure from the list of registered PCI drivers,
729  * gives it a chance to clean up by calling its remove() function for
730  * each device it was responsible for, and marks those devices as
731  * driverless.
732  */
733
734 void
735 pci_unregister_driver(struct pci_driver *drv)
736 {
737         pci_remove_newid_file(drv);
738         driver_unregister(&drv->driver);
739         pci_free_dynids(drv);
740 }
741
742 static struct pci_driver pci_compat_driver = {
743         .name = "compat"
744 };
745
746 /**
747  * pci_dev_driver - get the pci_driver of a device
748  * @dev: the device to query
749  *
750  * Returns the appropriate pci_driver structure or %NULL if there is no 
751  * registered driver for the device.
752  */
753 struct pci_driver *
754 pci_dev_driver(const struct pci_dev *dev)
755 {
756         if (dev->driver)
757                 return dev->driver;
758         else {
759                 int i;
760                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
761                         if (dev->resource[i].flags & IORESOURCE_BUSY)
762                                 return &pci_compat_driver;
763         }
764         return NULL;
765 }
766
767 /**
768  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
769  * @dev: the PCI device structure to match against
770  * @drv: the device driver to search for matching PCI device id structures
771  * 
772  * Used by a driver to check whether a PCI device present in the
773  * system is in its list of supported devices. Returns the matching
774  * pci_device_id structure or %NULL if there is no match.
775  */
776 static int pci_bus_match(struct device *dev, struct device_driver *drv)
777 {
778         struct pci_dev *pci_dev = to_pci_dev(dev);
779         struct pci_driver *pci_drv = to_pci_driver(drv);
780         const struct pci_device_id *found_id;
781
782         found_id = pci_match_device(pci_drv, pci_dev);
783         if (found_id)
784                 return 1;
785
786         return 0;
787 }
788
789 /**
790  * pci_dev_get - increments the reference count of the pci device structure
791  * @dev: the device being referenced
792  *
793  * Each live reference to a device should be refcounted.
794  *
795  * Drivers for PCI devices should normally record such references in
796  * their probe() methods, when they bind to a device, and release
797  * them by calling pci_dev_put(), in their disconnect() methods.
798  *
799  * A pointer to the device with the incremented reference counter is returned.
800  */
801 struct pci_dev *pci_dev_get(struct pci_dev *dev)
802 {
803         if (dev)
804                 get_device(&dev->dev);
805         return dev;
806 }
807
808 /**
809  * pci_dev_put - release a use of the pci device structure
810  * @dev: device that's been disconnected
811  *
812  * Must be called when a user of a device is finished with it.  When the last
813  * user of the device calls this function, the memory of the device is freed.
814  */
815 void pci_dev_put(struct pci_dev *dev)
816 {
817         if (dev)
818                 put_device(&dev->dev);
819 }
820
821 #ifndef CONFIG_HOTPLUG
822 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
823 {
824         return -ENODEV;
825 }
826 #endif
827
828 struct bus_type pci_bus_type = {
829         .name           = "pci",
830         .match          = pci_bus_match,
831         .uevent         = pci_uevent,
832         .probe          = pci_device_probe,
833         .remove         = pci_device_remove,
834         .shutdown       = pci_device_shutdown,
835         .dev_attrs      = pci_dev_attrs,
836         .pm             = PCI_PM_OPS_PTR,
837 };
838
839 static int __init pci_driver_init(void)
840 {
841         return bus_register(&pci_bus_type);
842 }
843
844 postcore_initcall(pci_driver_init);
845
846 EXPORT_SYMBOL(pci_match_id);
847 EXPORT_SYMBOL(__pci_register_driver);
848 EXPORT_SYMBOL(pci_unregister_driver);
849 EXPORT_SYMBOL(pci_dev_driver);
850 EXPORT_SYMBOL(pci_bus_type);
851 EXPORT_SYMBOL(pci_dev_get);
852 EXPORT_SYMBOL(pci_dev_put);