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