2 * drivers/pci/pci-driver.c
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/device.h>
10 #include <linux/pci-dynids.h>
14 * Registration of PCI drivers and handling of hot-pluggable devices.
18 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
23 * pci_device_probe_dynamic()
25 * Walk the dynamic ID list looking for a match.
26 * returns 0 and sets pci_dev->driver when drv claims pci_dev, else error.
29 pci_device_probe_dynamic(struct pci_driver
*drv
, struct pci_dev
*pci_dev
)
32 struct list_head
*pos
;
35 spin_lock(&drv
->dynids
.lock
);
36 list_for_each(pos
, &drv
->dynids
.list
) {
37 dynid
= list_entry(pos
, struct dynid
, node
);
38 if (pci_match_one_device(&dynid
->id
, pci_dev
)) {
39 spin_unlock(&drv
->dynids
.lock
);
40 error
= drv
->probe(pci_dev
, &dynid
->id
);
42 pci_dev
->driver
= drv
;
48 spin_unlock(&drv
->dynids
.lock
);
55 * Adds a new dynamic pci device ID to this driver,
56 * and causes the driver to probe for all devices again.
59 store_new_id(struct device_driver
*driver
, const char *buf
, size_t count
)
62 struct bus_type
* bus
;
63 struct pci_driver
*pdrv
= to_pci_driver(driver
);
64 __u32 vendor
=PCI_ANY_ID
, device
=PCI_ANY_ID
, subvendor
=PCI_ANY_ID
,
65 subdevice
=PCI_ANY_ID
, class=0, class_mask
=0;
66 unsigned long driver_data
=0;
69 fields
= sscanf(buf
, "%x %x %x %x %x %x %lux",
70 &vendor
, &device
, &subvendor
, &subdevice
,
71 &class, &class_mask
, &driver_data
);
75 dynid
= kmalloc(sizeof(*dynid
), GFP_KERNEL
);
79 memset(dynid
, 0, sizeof(*dynid
));
80 INIT_LIST_HEAD(&dynid
->node
);
81 dynid
->id
.vendor
= vendor
;
82 dynid
->id
.device
= device
;
83 dynid
->id
.subvendor
= subvendor
;
84 dynid
->id
.subdevice
= subdevice
;
85 dynid
->id
.class = class;
86 dynid
->id
.class_mask
= class_mask
;
87 dynid
->id
.driver_data
= pdrv
->dynids
.use_driver_data
?
90 spin_lock(&pdrv
->dynids
.lock
);
91 list_add_tail(&pdrv
->dynids
.list
, &dynid
->node
);
92 spin_unlock(&pdrv
->dynids
.lock
);
94 bus
= get_bus(pdrv
->driver
.bus
);
96 if (get_driver(&pdrv
->driver
)) {
97 down_write(&bus
->subsys
.rwsem
);
98 driver_attach(&pdrv
->driver
);
99 up_write(&bus
->subsys
.rwsem
);
100 put_driver(&pdrv
->driver
);
108 static DRIVER_ATTR(new_id
, S_IWUSR
, NULL
, store_new_id
);
110 pci_init_dynids(struct pci_dynids
*dynids
)
112 spin_lock_init(&dynids
->lock
);
113 INIT_LIST_HEAD(&dynids
->list
);
117 pci_free_dynids(struct pci_driver
*drv
)
119 struct list_head
*pos
, *n
;
122 spin_lock(&drv
->dynids
.lock
);
123 list_for_each_safe(pos
, n
, &drv
->dynids
.list
) {
124 dynid
= list_entry(pos
, struct dynid
, node
);
125 list_del(&dynid
->node
);
128 spin_unlock(&drv
->dynids
.lock
);
132 pci_create_newid_file(struct pci_driver
*drv
)
135 if (drv
->probe
!= NULL
)
136 error
= sysfs_create_file(&drv
->driver
.kobj
,
137 &driver_attr_new_id
.attr
);
142 pci_bus_match_dynids(const struct pci_dev
*pci_dev
, struct pci_driver
*pci_drv
)
144 struct list_head
*pos
;
147 spin_lock(&pci_drv
->dynids
.lock
);
148 list_for_each(pos
, &pci_drv
->dynids
.list
) {
149 dynid
= list_entry(pos
, struct dynid
, node
);
150 if (pci_match_one_device(&dynid
->id
, pci_dev
)) {
151 spin_unlock(&pci_drv
->dynids
.lock
);
155 spin_unlock(&pci_drv
->dynids
.lock
);
159 #else /* !CONFIG_HOTPLUG */
160 static inline int pci_device_probe_dynamic(struct pci_driver
*drv
, struct pci_dev
*pci_dev
)
164 static inline void pci_init_dynids(struct pci_dynids
*dynids
) {}
165 static inline void pci_free_dynids(struct pci_driver
*drv
) {}
166 static inline int pci_create_newid_file(struct pci_driver
*drv
)
170 static inline int pci_bus_match_dynids(const struct pci_dev
*pci_dev
, struct pci_driver
*pci_drv
)
177 * pci_match_device - Tell if a PCI device structure has a matching
178 * PCI device id structure
179 * @ids: array of PCI device id structures to search in
180 * @dev: the PCI device structure to match against
182 * Used by a driver to check whether a PCI device present in the
183 * system is in its list of supported devices.Returns the matching
184 * pci_device_id structure or %NULL if there is no match.
186 const struct pci_device_id
*
187 pci_match_device(const struct pci_device_id
*ids
, const struct pci_dev
*dev
)
189 while (ids
->vendor
|| ids
->subvendor
|| ids
->class_mask
) {
190 if (pci_match_one_device(ids
, dev
))
198 * pci_device_probe_static()
200 * returns 0 and sets pci_dev->driver when drv claims pci_dev, else error.
203 pci_device_probe_static(struct pci_driver
*drv
, struct pci_dev
*pci_dev
)
206 const struct pci_device_id
*id
;
210 id
= pci_match_device(drv
->id_table
, pci_dev
);
212 error
= drv
->probe(pci_dev
, id
);
214 pci_dev
->driver
= drv
;
221 * __pci_device_probe()
223 * returns 0 on success, else error.
224 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
227 __pci_device_probe(struct pci_driver
*drv
, struct pci_dev
*pci_dev
)
231 if (!pci_dev
->driver
&& drv
->probe
) {
232 error
= pci_device_probe_static(drv
, pci_dev
);
233 if (error
== -ENODEV
)
234 error
= pci_device_probe_dynamic(drv
, pci_dev
);
239 static int pci_device_probe(struct device
* dev
)
242 struct pci_driver
*drv
;
243 struct pci_dev
*pci_dev
;
245 drv
= to_pci_driver(dev
->driver
);
246 pci_dev
= to_pci_dev(dev
);
247 pci_dev_get(pci_dev
);
248 error
= __pci_device_probe(drv
, pci_dev
);
250 pci_dev_put(pci_dev
);
255 static int pci_device_remove(struct device
* dev
)
257 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
258 struct pci_driver
* drv
= pci_dev
->driver
;
262 drv
->remove(pci_dev
);
263 pci_dev
->driver
= NULL
;
267 * We would love to complain here if pci_dev->is_enabled is set, that
268 * the driver should have called pci_disable_device(), but the
269 * unfortunate fact is there are too many odd BIOS and bridge setups
270 * that don't like drivers doing that all of the time.
271 * Oh well, we can dream of sane hardware when we sleep, no matter how
272 * horrible the crap we have to deal with is when we are awake...
275 pci_dev_put(pci_dev
);
279 static int pci_device_suspend(struct device
* dev
, pm_message_t state
)
281 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
282 struct pci_driver
* drv
= pci_dev
->driver
;
285 if (drv
&& drv
->suspend
)
286 i
= drv
->suspend(pci_dev
, state
);
288 pci_save_state(pci_dev
);
294 * Default resume method for devices that have no driver provided resume,
295 * or not even a driver at all.
297 static void pci_default_resume(struct pci_dev
*pci_dev
)
299 /* restore the PCI config space */
300 pci_restore_state(pci_dev
);
301 /* if the device was enabled before suspend, reenable */
302 if (pci_dev
->is_enabled
)
303 pci_enable_device(pci_dev
);
304 /* if the device was busmaster before the suspend, make it busmaster again */
305 if (pci_dev
->is_busmaster
)
306 pci_set_master(pci_dev
);
309 static int pci_device_resume(struct device
* dev
)
311 struct pci_dev
* pci_dev
= to_pci_dev(dev
);
312 struct pci_driver
* drv
= pci_dev
->driver
;
314 if (drv
&& drv
->resume
)
315 drv
->resume(pci_dev
);
317 pci_default_resume(pci_dev
);
321 static void pci_device_shutdown(struct device
*dev
)
323 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
324 struct pci_driver
*drv
= pci_dev
->driver
;
326 if (drv
&& drv
->shutdown
)
327 drv
->shutdown(pci_dev
);
330 #define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
331 #define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
334 pci_driver_attr_show(struct kobject
* kobj
, struct attribute
*attr
, char *buf
)
336 struct device_driver
*driver
= kobj_to_pci_driver(kobj
);
337 struct driver_attribute
*dattr
= attr_to_driver_attribute(attr
);
340 if (!get_driver(driver
))
343 ret
= dattr
->show
? dattr
->show(driver
, buf
) : -EIO
;
350 pci_driver_attr_store(struct kobject
* kobj
, struct attribute
*attr
,
351 const char *buf
, size_t count
)
353 struct device_driver
*driver
= kobj_to_pci_driver(kobj
);
354 struct driver_attribute
*dattr
= attr_to_driver_attribute(attr
);
357 if (!get_driver(driver
))
360 ret
= dattr
->store
? dattr
->store(driver
, buf
, count
) : -EIO
;
366 static struct sysfs_ops pci_driver_sysfs_ops
= {
367 .show
= pci_driver_attr_show
,
368 .store
= pci_driver_attr_store
,
370 static struct kobj_type pci_driver_kobj_type
= {
371 .sysfs_ops
= &pci_driver_sysfs_ops
,
375 pci_populate_driver_dir(struct pci_driver
*drv
)
377 return pci_create_newid_file(drv
);
381 * pci_register_driver - register a new pci driver
382 * @drv: the driver structure to register
384 * Adds the driver structure to the list of registered drivers.
385 * Returns a negative value on error, otherwise 0.
386 * If no error occurred, the driver remains registered even if
387 * no device was claimed during registration.
389 int pci_register_driver(struct pci_driver
*drv
)
393 /* initialize common driver fields */
394 drv
->driver
.name
= drv
->name
;
395 drv
->driver
.bus
= &pci_bus_type
;
396 drv
->driver
.probe
= pci_device_probe
;
397 drv
->driver
.remove
= pci_device_remove
;
398 /* FIXME, once all of the existing PCI drivers have been fixed to set
399 * the pci shutdown function, this test can go away. */
400 if (!drv
->driver
.shutdown
)
401 drv
->driver
.shutdown
= pci_device_shutdown
;
402 drv
->driver
.owner
= drv
->owner
;
403 drv
->driver
.kobj
.ktype
= &pci_driver_kobj_type
;
404 pci_init_dynids(&drv
->dynids
);
406 /* register with core */
407 error
= driver_register(&drv
->driver
);
410 pci_populate_driver_dir(drv
);
416 * pci_unregister_driver - unregister a pci driver
417 * @drv: the driver structure to unregister
419 * Deletes the driver structure from the list of registered PCI drivers,
420 * gives it a chance to clean up by calling its remove() function for
421 * each device it was responsible for, and marks those devices as
426 pci_unregister_driver(struct pci_driver
*drv
)
428 driver_unregister(&drv
->driver
);
429 pci_free_dynids(drv
);
432 static struct pci_driver pci_compat_driver
= {
437 * pci_dev_driver - get the pci_driver of a device
438 * @dev: the device to query
440 * Returns the appropriate pci_driver structure or %NULL if there is no
441 * registered driver for the device.
444 pci_dev_driver(const struct pci_dev
*dev
)
450 for(i
=0; i
<=PCI_ROM_RESOURCE
; i
++)
451 if (dev
->resource
[i
].flags
& IORESOURCE_BUSY
)
452 return &pci_compat_driver
;
458 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
459 * @ids: array of PCI device id structures to search in
460 * @dev: the PCI device structure to match against
462 * Used by a driver to check whether a PCI device present in the
463 * system is in its list of supported devices.Returns the matching
464 * pci_device_id structure or %NULL if there is no match.
466 static int pci_bus_match(struct device
* dev
, struct device_driver
* drv
)
468 const struct pci_dev
* pci_dev
= to_pci_dev(dev
);
469 struct pci_driver
* pci_drv
= to_pci_driver(drv
);
470 const struct pci_device_id
* ids
= pci_drv
->id_table
;
471 const struct pci_device_id
*found_id
;
476 found_id
= pci_match_device(ids
, pci_dev
);
480 return pci_bus_match_dynids(pci_dev
, pci_drv
);
484 * pci_dev_get - increments the reference count of the pci device structure
485 * @dev: the device being referenced
487 * Each live reference to a device should be refcounted.
489 * Drivers for PCI devices should normally record such references in
490 * their probe() methods, when they bind to a device, and release
491 * them by calling pci_dev_put(), in their disconnect() methods.
493 * A pointer to the device with the incremented reference counter is returned.
495 struct pci_dev
*pci_dev_get(struct pci_dev
*dev
)
498 get_device(&dev
->dev
);
503 * pci_dev_put - release a use of the pci device structure
504 * @dev: device that's been disconnected
506 * Must be called when a user of a device is finished with it. When the last
507 * user of the device calls this function, the memory of the device is freed.
509 void pci_dev_put(struct pci_dev
*dev
)
512 put_device(&dev
->dev
);
515 #ifndef CONFIG_HOTPLUG
516 int pci_hotplug (struct device
*dev
, char **envp
, int num_envp
,
517 char *buffer
, int buffer_size
)
523 struct bus_type pci_bus_type
= {
525 .match
= pci_bus_match
,
526 .hotplug
= pci_hotplug
,
527 .suspend
= pci_device_suspend
,
528 .resume
= pci_device_resume
,
529 .dev_attrs
= pci_dev_attrs
,
532 static int __init
pci_driver_init(void)
534 return bus_register(&pci_bus_type
);
537 postcore_initcall(pci_driver_init
);
539 EXPORT_SYMBOL(pci_match_device
);
540 EXPORT_SYMBOL(pci_register_driver
);
541 EXPORT_SYMBOL(pci_unregister_driver
);
542 EXPORT_SYMBOL(pci_dev_driver
);
543 EXPORT_SYMBOL(pci_bus_type
);
544 EXPORT_SYMBOL(pci_dev_get
);
545 EXPORT_SYMBOL(pci_dev_put
);