xref: /openbmc/linux/drivers/pci/pci-driver.c (revision 9ac8d3fb)
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);
853