Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6
[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 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
304 {
305         struct pci_driver *drv = pci_dev->driver;
306
307         return drv && (drv->suspend || drv->suspend_late || drv->resume
308                 || drv->resume_early);
309 }
310
311 /*
312  * Default "suspend" method for devices that have no driver provided suspend,
313  * or not even a driver at all.
314  */
315 static void pci_default_pm_suspend(struct pci_dev *pci_dev)
316 {
317         pci_save_state(pci_dev);
318         /*
319          * mark its power state as "unknown", since we don't know if
320          * e.g. the BIOS will change its device state when we suspend.
321          */
322         if (pci_dev->current_state == PCI_D0)
323                 pci_dev->current_state = PCI_UNKNOWN;
324 }
325
326 /*
327  * Default "resume" method for devices that have no driver provided resume,
328  * or not even a driver at all (first part).
329  */
330 static void pci_default_pm_resume_early(struct pci_dev *pci_dev)
331 {
332         /* restore the PCI config space */
333         pci_restore_state(pci_dev);
334 }
335
336 /*
337  * Default "resume" method for devices that have no driver provided resume,
338  * or not even a driver at all (second part).
339  */
340 static int pci_default_pm_resume_late(struct pci_dev *pci_dev)
341 {
342         int retval;
343
344         /* if the device was enabled before suspend, reenable */
345         retval = pci_reenable_device(pci_dev);
346         /*
347          * if the device was busmaster before the suspend, make it busmaster
348          * again
349          */
350         if (pci_dev->is_busmaster)
351                 pci_set_master(pci_dev);
352
353         return retval;
354 }
355
356 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
357 {
358         struct pci_dev * pci_dev = to_pci_dev(dev);
359         struct pci_driver * drv = pci_dev->driver;
360         int i = 0;
361
362         if (drv && drv->suspend) {
363                 i = drv->suspend(pci_dev, state);
364                 suspend_report_result(drv->suspend, i);
365         } else {
366                 pci_default_pm_suspend(pci_dev);
367         }
368         return i;
369 }
370
371 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
372 {
373         struct pci_dev * pci_dev = to_pci_dev(dev);
374         struct pci_driver * drv = pci_dev->driver;
375         int i = 0;
376
377         if (drv && drv->suspend_late) {
378                 i = drv->suspend_late(pci_dev, state);
379                 suspend_report_result(drv->suspend_late, i);
380         }
381         return i;
382 }
383
384 static int pci_legacy_resume(struct device *dev)
385 {
386         int error;
387         struct pci_dev * pci_dev = to_pci_dev(dev);
388         struct pci_driver * drv = pci_dev->driver;
389
390         if (drv && drv->resume) {
391                 error = drv->resume(pci_dev);
392         } else {
393                 pci_default_pm_resume_early(pci_dev);
394                 error = pci_default_pm_resume_late(pci_dev);
395         }
396         return error;
397 }
398
399 static int pci_legacy_resume_early(struct device *dev)
400 {
401         int error = 0;
402         struct pci_dev * pci_dev = to_pci_dev(dev);
403         struct pci_driver * drv = pci_dev->driver;
404
405         if (drv && drv->resume_early)
406                 error = drv->resume_early(pci_dev);
407         return error;
408 }
409
410 static int pci_pm_prepare(struct device *dev)
411 {
412         struct device_driver *drv = dev->driver;
413         int error = 0;
414
415         if (drv && drv->pm && drv->pm->prepare)
416                 error = drv->pm->prepare(dev);
417
418         return error;
419 }
420
421 static void pci_pm_complete(struct device *dev)
422 {
423         struct device_driver *drv = dev->driver;
424
425         if (drv && drv->pm && drv->pm->complete)
426                 drv->pm->complete(dev);
427 }
428
429 #ifdef CONFIG_SUSPEND
430
431 static int pci_pm_suspend(struct device *dev)
432 {
433         struct pci_dev *pci_dev = to_pci_dev(dev);
434         struct device_driver *drv = dev->driver;
435         int error = 0;
436
437         if (drv && drv->pm) {
438                 if (drv->pm->suspend) {
439                         error = drv->pm->suspend(dev);
440                         suspend_report_result(drv->pm->suspend, error);
441                 }
442         } else if (pci_has_legacy_pm_support(pci_dev)) {
443                 error = pci_legacy_suspend(dev, PMSG_SUSPEND);
444         }
445         pci_fixup_device(pci_fixup_suspend, pci_dev);
446
447         return error;
448 }
449
450 static int pci_pm_suspend_noirq(struct device *dev)
451 {
452         struct pci_dev *pci_dev = to_pci_dev(dev);
453         struct device_driver *drv = dev->driver;
454         int error = 0;
455
456         if (drv && drv->pm) {
457                 if (drv->pm->suspend_noirq) {
458                         error = drv->pm->suspend_noirq(dev);
459                         suspend_report_result(drv->pm->suspend_noirq, error);
460                 }
461         } else if (pci_has_legacy_pm_support(pci_dev)) {
462                 error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
463         } else {
464                 pci_default_pm_suspend(pci_dev);
465         }
466
467         return error;
468 }
469
470 static int pci_pm_resume(struct device *dev)
471 {
472         struct pci_dev *pci_dev = to_pci_dev(dev);
473         struct device_driver *drv = dev->driver;
474         int error = 0;
475
476         pci_fixup_device(pci_fixup_resume, pci_dev);
477
478         if (drv && drv->pm) {
479                 if (drv->pm->resume)
480                         error = drv->pm->resume(dev);
481         } else if (pci_has_legacy_pm_support(pci_dev)) {
482                 error = pci_legacy_resume(dev);
483         } else {
484                 error = pci_default_pm_resume_late(pci_dev);
485         }
486
487         return error;
488 }
489
490 static int pci_pm_resume_noirq(struct device *dev)
491 {
492         struct pci_dev *pci_dev = to_pci_dev(dev);
493         struct device_driver *drv = dev->driver;
494         int error = 0;
495
496         pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
497
498         if (drv && drv->pm) {
499                 if (drv->pm->resume_noirq)
500                         error = drv->pm->resume_noirq(dev);
501         } else if (pci_has_legacy_pm_support(pci_dev)) {
502                 error = pci_legacy_resume_early(dev);
503         } else {
504                 pci_default_pm_resume_early(pci_dev);
505         }
506
507         return error;
508 }
509
510 #else /* !CONFIG_SUSPEND */
511
512 #define pci_pm_suspend          NULL
513 #define pci_pm_suspend_noirq    NULL
514 #define pci_pm_resume           NULL
515 #define pci_pm_resume_noirq     NULL
516
517 #endif /* !CONFIG_SUSPEND */
518
519 #ifdef CONFIG_HIBERNATION
520
521 static int pci_pm_freeze(struct device *dev)
522 {
523         struct pci_dev *pci_dev = to_pci_dev(dev);
524         struct device_driver *drv = dev->driver;
525         int error = 0;
526
527         if (drv && drv->pm) {
528                 if (drv->pm->freeze) {
529                         error = drv->pm->freeze(dev);
530                         suspend_report_result(drv->pm->freeze, error);
531                 }
532         } else if (pci_has_legacy_pm_support(pci_dev)) {
533                 error = pci_legacy_suspend(dev, PMSG_FREEZE);
534                 pci_fixup_device(pci_fixup_suspend, pci_dev);
535         }
536
537         return error;
538 }
539
540 static int pci_pm_freeze_noirq(struct device *dev)
541 {
542         struct pci_dev *pci_dev = to_pci_dev(dev);
543         struct device_driver *drv = dev->driver;
544         int error = 0;
545
546         if (drv && drv->pm) {
547                 if (drv->pm->freeze_noirq) {
548                         error = drv->pm->freeze_noirq(dev);
549                         suspend_report_result(drv->pm->freeze_noirq, error);
550                 }
551         } else if (pci_has_legacy_pm_support(pci_dev)) {
552                 error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
553         } else {
554                 pci_default_pm_suspend(pci_dev);
555         }
556
557         return error;
558 }
559
560 static int pci_pm_thaw(struct device *dev)
561 {
562         struct pci_dev *pci_dev = to_pci_dev(dev);
563         struct device_driver *drv = dev->driver;
564         int error = 0;
565
566         if (drv && drv->pm) {
567                 if (drv->pm->thaw)
568                         error =  drv->pm->thaw(dev);
569         } else if (pci_has_legacy_pm_support(pci_dev)) {
570                 pci_fixup_device(pci_fixup_resume, pci_dev);
571                 error = pci_legacy_resume(dev);
572         }
573
574         return error;
575 }
576
577 static int pci_pm_thaw_noirq(struct device *dev)
578 {
579         struct pci_dev *pci_dev = to_pci_dev(dev);
580         struct device_driver *drv = dev->driver;
581         int error = 0;
582
583         if (drv && drv->pm) {
584                 if (drv->pm->thaw_noirq)
585                         error = drv->pm->thaw_noirq(dev);
586         } else if (pci_has_legacy_pm_support(pci_dev)) {
587                 pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
588                 error = pci_legacy_resume_early(dev);
589         }
590
591         return error;
592 }
593
594 static int pci_pm_poweroff(struct device *dev)
595 {
596         struct pci_dev *pci_dev = to_pci_dev(dev);
597         struct device_driver *drv = dev->driver;
598         int error = 0;
599
600         pci_fixup_device(pci_fixup_suspend, pci_dev);
601
602         if (drv && drv->pm) {
603                 if (drv->pm->poweroff) {
604                         error = drv->pm->poweroff(dev);
605                         suspend_report_result(drv->pm->poweroff, error);
606                 }
607         } else if (pci_has_legacy_pm_support(pci_dev)) {
608                 error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
609         }
610
611         return error;
612 }
613
614 static int pci_pm_poweroff_noirq(struct device *dev)
615 {
616         struct device_driver *drv = dev->driver;
617         int error = 0;
618
619         if (drv && drv->pm) {
620                 if (drv->pm->poweroff_noirq) {
621                         error = drv->pm->poweroff_noirq(dev);
622                         suspend_report_result(drv->pm->poweroff_noirq, error);
623                 }
624         } else if (pci_has_legacy_pm_support(to_pci_dev(dev))) {
625                 error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
626         }
627
628         return error;
629 }
630
631 static int pci_pm_restore(struct device *dev)
632 {
633         struct pci_dev *pci_dev = to_pci_dev(dev);
634         struct device_driver *drv = dev->driver;
635         int error = 0;
636
637         if (drv && drv->pm) {
638                 if (drv->pm->restore)
639                         error = drv->pm->restore(dev);
640         } else if (pci_has_legacy_pm_support(pci_dev)) {
641                 error = pci_legacy_resume(dev);
642         } else {
643                 error = pci_default_pm_resume_late(pci_dev);
644         }
645         pci_fixup_device(pci_fixup_resume, pci_dev);
646
647         return error;
648 }
649
650 static int pci_pm_restore_noirq(struct device *dev)
651 {
652         struct pci_dev *pci_dev = to_pci_dev(dev);
653         struct device_driver *drv = dev->driver;
654         int error = 0;
655
656         pci_fixup_device(pci_fixup_resume, pci_dev);
657
658         if (drv && drv->pm) {
659                 if (drv->pm->restore_noirq)
660                         error = drv->pm->restore_noirq(dev);
661         } else if (pci_has_legacy_pm_support(pci_dev)) {
662                 error = pci_legacy_resume_early(dev);
663         } else {
664                 pci_default_pm_resume_early(pci_dev);
665         }
666         pci_fixup_device(pci_fixup_resume_early, pci_dev);
667
668         return error;
669 }
670
671 #else /* !CONFIG_HIBERNATION */
672
673 #define pci_pm_freeze           NULL
674 #define pci_pm_freeze_noirq     NULL
675 #define pci_pm_thaw             NULL
676 #define pci_pm_thaw_noirq       NULL
677 #define pci_pm_poweroff         NULL
678 #define pci_pm_poweroff_noirq   NULL
679 #define pci_pm_restore          NULL
680 #define pci_pm_restore_noirq    NULL
681
682 #endif /* !CONFIG_HIBERNATION */
683
684 struct dev_pm_ops pci_dev_pm_ops = {
685         .prepare = pci_pm_prepare,
686         .complete = pci_pm_complete,
687         .suspend = pci_pm_suspend,
688         .resume = pci_pm_resume,
689         .freeze = pci_pm_freeze,
690         .thaw = pci_pm_thaw,
691         .poweroff = pci_pm_poweroff,
692         .restore = pci_pm_restore,
693         .suspend_noirq = pci_pm_suspend_noirq,
694         .resume_noirq = pci_pm_resume_noirq,
695         .freeze_noirq = pci_pm_freeze_noirq,
696         .thaw_noirq = pci_pm_thaw_noirq,
697         .poweroff_noirq = pci_pm_poweroff_noirq,
698         .restore_noirq = pci_pm_restore_noirq,
699 };
700
701 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
702
703 #else /* !CONFIG_PM_SLEEP */
704
705 #define PCI_PM_OPS_PTR  NULL
706
707 #endif /* !CONFIG_PM_SLEEP */
708
709 /**
710  * __pci_register_driver - register a new pci driver
711  * @drv: the driver structure to register
712  * @owner: owner module of drv
713  * @mod_name: module name string
714  * 
715  * Adds the driver structure to the list of registered drivers.
716  * Returns a negative value on error, otherwise 0. 
717  * If no error occurred, the driver remains registered even if 
718  * no device was claimed during registration.
719  */
720 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
721                           const char *mod_name)
722 {
723         int error;
724
725         /* initialize common driver fields */
726         drv->driver.name = drv->name;
727         drv->driver.bus = &pci_bus_type;
728         drv->driver.owner = owner;
729         drv->driver.mod_name = mod_name;
730
731         spin_lock_init(&drv->dynids.lock);
732         INIT_LIST_HEAD(&drv->dynids.list);
733
734         /* register with core */
735         error = driver_register(&drv->driver);
736         if (error)
737                 return error;
738
739         error = pci_create_newid_file(drv);
740         if (error)
741                 driver_unregister(&drv->driver);
742
743         return error;
744 }
745
746 /**
747  * pci_unregister_driver - unregister a pci driver
748  * @drv: the driver structure to unregister
749  * 
750  * Deletes the driver structure from the list of registered PCI drivers,
751  * gives it a chance to clean up by calling its remove() function for
752  * each device it was responsible for, and marks those devices as
753  * driverless.
754  */
755
756 void
757 pci_unregister_driver(struct pci_driver *drv)
758 {
759         pci_remove_newid_file(drv);
760         driver_unregister(&drv->driver);
761         pci_free_dynids(drv);
762 }
763
764 static struct pci_driver pci_compat_driver = {
765         .name = "compat"
766 };
767
768 /**
769  * pci_dev_driver - get the pci_driver of a device
770  * @dev: the device to query
771  *
772  * Returns the appropriate pci_driver structure or %NULL if there is no 
773  * registered driver for the device.
774  */
775 struct pci_driver *
776 pci_dev_driver(const struct pci_dev *dev)
777 {
778         if (dev->driver)
779                 return dev->driver;
780         else {
781                 int i;
782                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
783                         if (dev->resource[i].flags & IORESOURCE_BUSY)
784                                 return &pci_compat_driver;
785         }
786         return NULL;
787 }
788
789 /**
790  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
791  * @dev: the PCI device structure to match against
792  * @drv: the device driver to search for matching PCI device id structures
793  * 
794  * Used by a driver to check whether a PCI device present in the
795  * system is in its list of supported devices. Returns the matching
796  * pci_device_id structure or %NULL if there is no match.
797  */
798 static int pci_bus_match(struct device *dev, struct device_driver *drv)
799 {
800         struct pci_dev *pci_dev = to_pci_dev(dev);
801         struct pci_driver *pci_drv = to_pci_driver(drv);
802         const struct pci_device_id *found_id;
803
804         found_id = pci_match_device(pci_drv, pci_dev);
805         if (found_id)
806                 return 1;
807
808         return 0;
809 }
810
811 /**
812  * pci_dev_get - increments the reference count of the pci device structure
813  * @dev: the device being referenced
814  *
815  * Each live reference to a device should be refcounted.
816  *
817  * Drivers for PCI devices should normally record such references in
818  * their probe() methods, when they bind to a device, and release
819  * them by calling pci_dev_put(), in their disconnect() methods.
820  *
821  * A pointer to the device with the incremented reference counter is returned.
822  */
823 struct pci_dev *pci_dev_get(struct pci_dev *dev)
824 {
825         if (dev)
826                 get_device(&dev->dev);
827         return dev;
828 }
829
830 /**
831  * pci_dev_put - release a use of the pci device structure
832  * @dev: device that's been disconnected
833  *
834  * Must be called when a user of a device is finished with it.  When the last
835  * user of the device calls this function, the memory of the device is freed.
836  */
837 void pci_dev_put(struct pci_dev *dev)
838 {
839         if (dev)
840                 put_device(&dev->dev);
841 }
842
843 #ifndef CONFIG_HOTPLUG
844 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
845 {
846         return -ENODEV;
847 }
848 #endif
849
850 struct bus_type pci_bus_type = {
851         .name           = "pci",
852         .match          = pci_bus_match,
853         .uevent         = pci_uevent,
854         .probe          = pci_device_probe,
855         .remove         = pci_device_remove,
856         .shutdown       = pci_device_shutdown,
857         .dev_attrs      = pci_dev_attrs,
858         .pm             = PCI_PM_OPS_PTR,
859 };
860
861 static int __init pci_driver_init(void)
862 {
863         return bus_register(&pci_bus_type);
864 }
865
866 postcore_initcall(pci_driver_init);
867
868 EXPORT_SYMBOL(pci_match_id);
869 EXPORT_SYMBOL(__pci_register_driver);
870 EXPORT_SYMBOL(pci_unregister_driver);
871 EXPORT_SYMBOL(pci_dev_driver);
872 EXPORT_SYMBOL(pci_bus_type);
873 EXPORT_SYMBOL(pci_dev_get);
874 EXPORT_SYMBOL(pci_dev_put);