blob: e65bf2b395aab8f12ec033e9e33c53978942961b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/pci/pci-driver.c
3 *
4 */
5
6#include <linux/pci.h>
7#include <linux/module.h>
8#include <linux/init.h>
9#include <linux/device.h>
10#include <linux/pci-dynids.h>
11#include "pci.h"
12
13/*
14 * Registration of PCI drivers and handling of hot-pluggable devices.
15 */
16
17/*
18 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
19 */
20
21#ifdef CONFIG_HOTPLUG
22/**
23 * pci_device_probe_dynamic()
24 *
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.
27 */
28static int
29pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
30{
31 int error = -ENODEV;
32 struct list_head *pos;
33 struct dynid *dynid;
34
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);
41 if (error >= 0) {
42 pci_dev->driver = drv;
43 return 0;
44 }
45 return error;
46 }
47 }
48 spin_unlock(&drv->dynids.lock);
49 return error;
50}
51
52/**
53 * store_new_id
54 *
55 * Adds a new dynamic pci device ID to this driver,
56 * and causes the driver to probe for all devices again.
57 */
58static inline ssize_t
59store_new_id(struct device_driver *driver, const char *buf, size_t count)
60{
61 struct dynid *dynid;
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;
67 int fields=0;
68
69 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
70 &vendor, &device, &subvendor, &subdevice,
71 &class, &class_mask, &driver_data);
72 if (fields < 0)
73 return -EINVAL;
74
75 dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
76 if (!dynid)
77 return -ENOMEM;
78
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 ?
88 driver_data : 0UL;
89
90 spin_lock(&pdrv->dynids.lock);
91 list_add_tail(&pdrv->dynids.list, &dynid->node);
92 spin_unlock(&pdrv->dynids.lock);
93
94 bus = get_bus(pdrv->driver.bus);
95 if (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);
101 }
102 put_bus(bus);
103 }
104
105 return count;
106}
107
108static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
109static inline void
110pci_init_dynids(struct pci_dynids *dynids)
111{
112 spin_lock_init(&dynids->lock);
113 INIT_LIST_HEAD(&dynids->list);
114}
115
116static void
117pci_free_dynids(struct pci_driver *drv)
118{
119 struct list_head *pos, *n;
120 struct dynid *dynid;
121
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);
126 kfree(dynid);
127 }
128 spin_unlock(&drv->dynids.lock);
129}
130
131static int
132pci_create_newid_file(struct pci_driver *drv)
133{
134 int error = 0;
135 if (drv->probe != NULL)
136 error = sysfs_create_file(&drv->driver.kobj,
137 &driver_attr_new_id.attr);
138 return error;
139}
140
141static int
142pci_bus_match_dynids(const struct pci_dev *pci_dev, struct pci_driver *pci_drv)
143{
144 struct list_head *pos;
145 struct dynid *dynid;
146
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);
152 return 1;
153 }
154 }
155 spin_unlock(&pci_drv->dynids.lock);
156 return 0;
157}
158
159#else /* !CONFIG_HOTPLUG */
160static inline int pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
161{
162 return -ENODEV;
163}
164static inline void pci_init_dynids(struct pci_dynids *dynids) {}
165static inline void pci_free_dynids(struct pci_driver *drv) {}
166static inline int pci_create_newid_file(struct pci_driver *drv)
167{
168 return 0;
169}
170static inline int pci_bus_match_dynids(const struct pci_dev *pci_dev, struct pci_driver *pci_drv)
171{
172 return 0;
173}
174#endif
175
176/**
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
181 *
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.
185 */
186const struct pci_device_id *
187pci_match_device(const struct pci_device_id *ids, const struct pci_dev *dev)
188{
189 while (ids->vendor || ids->subvendor || ids->class_mask) {
190 if (pci_match_one_device(ids, dev))
191 return ids;
192 ids++;
193 }
194 return NULL;
195}
196
197/**
198 * pci_device_probe_static()
199 *
200 * returns 0 and sets pci_dev->driver when drv claims pci_dev, else error.
201 */
202static int
203pci_device_probe_static(struct pci_driver *drv, struct pci_dev *pci_dev)
204{
205 int error = -ENODEV;
206 const struct pci_device_id *id;
207
208 if (!drv->id_table)
209 return error;
210 id = pci_match_device(drv->id_table, pci_dev);
211 if (id)
212 error = drv->probe(pci_dev, id);
213 if (error >= 0) {
214 pci_dev->driver = drv;
215 error = 0;
216 }
217 return error;
218}
219
220/**
221 * __pci_device_probe()
222 *
223 * returns 0 on success, else error.
224 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
225 */
226static int
227__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
228{
229 int error = 0;
230
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);
235 }
236 return error;
237}
238
239static int pci_device_probe(struct device * dev)
240{
241 int error = 0;
242 struct pci_driver *drv;
243 struct pci_dev *pci_dev;
244
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);
249 if (error)
250 pci_dev_put(pci_dev);
251
252 return error;
253}
254
255static int pci_device_remove(struct device * dev)
256{
257 struct pci_dev * pci_dev = to_pci_dev(dev);
258 struct pci_driver * drv = pci_dev->driver;
259
260 if (drv) {
261 if (drv->remove)
262 drv->remove(pci_dev);
263 pci_dev->driver = NULL;
264 }
265
266 /*
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...
273 */
274
275 pci_dev_put(pci_dev);
276 return 0;
277}
278
279static int pci_device_suspend(struct device * dev, pm_message_t state)
280{
281 struct pci_dev * pci_dev = to_pci_dev(dev);
282 struct pci_driver * drv = pci_dev->driver;
283 int i = 0;
284
285 if (drv && drv->suspend)
286 i = drv->suspend(pci_dev, state);
287 else
288 pci_save_state(pci_dev);
289 return i;
290}
291
292
293/*
294 * Default resume method for devices that have no driver provided resume,
295 * or not even a driver at all.
296 */
297static void pci_default_resume(struct pci_dev *pci_dev)
298{
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);
307}
308
309static int pci_device_resume(struct device * dev)
310{
311 struct pci_dev * pci_dev = to_pci_dev(dev);
312 struct pci_driver * drv = pci_dev->driver;
313
314 if (drv && drv->resume)
315 drv->resume(pci_dev);
316 else
317 pci_default_resume(pci_dev);
318 return 0;
319}
320
Greg KHc8958172005-04-08 14:53:31 +0900321static void pci_device_shutdown(struct device *dev)
322{
323 struct pci_dev *pci_dev = to_pci_dev(dev);
324 struct pci_driver *drv = pci_dev->driver;
325
326 if (drv && drv->shutdown)
327 drv->shutdown(pci_dev);
328}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
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)
332
333static ssize_t
334pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
335{
336 struct device_driver *driver = kobj_to_pci_driver(kobj);
337 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500338 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500340 if (!get_driver(driver))
341 return -ENODEV;
342
343 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
344
345 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 return ret;
347}
348
349static ssize_t
350pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
351 const char *buf, size_t count)
352{
353 struct device_driver *driver = kobj_to_pci_driver(kobj);
354 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500355 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500357 if (!get_driver(driver))
358 return -ENODEV;
359
360 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
361
362 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return ret;
364}
365
366static struct sysfs_ops pci_driver_sysfs_ops = {
367 .show = pci_driver_attr_show,
368 .store = pci_driver_attr_store,
369};
370static struct kobj_type pci_driver_kobj_type = {
371 .sysfs_ops = &pci_driver_sysfs_ops,
372};
373
374static int
375pci_populate_driver_dir(struct pci_driver *drv)
376{
377 return pci_create_newid_file(drv);
378}
379
380/**
381 * pci_register_driver - register a new pci driver
382 * @drv: the driver structure to register
383 *
384 * Adds the driver structure to the list of registered drivers.
385 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600386 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 * no device was claimed during registration.
388 */
389int pci_register_driver(struct pci_driver *drv)
390{
391 int error;
392
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;
Christoph Hellwig794f5bf2005-06-17 12:25:25 -0700398 /* 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)
Mika Kukkonenc83d99452005-06-18 22:49:56 +0300401 drv->driver.shutdown = pci_device_shutdown;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 drv->driver.owner = drv->owner;
403 drv->driver.kobj.ktype = &pci_driver_kobj_type;
404 pci_init_dynids(&drv->dynids);
405
406 /* register with core */
407 error = driver_register(&drv->driver);
408
409 if (!error)
410 pci_populate_driver_dir(drv);
411
412 return error;
413}
414
415/**
416 * pci_unregister_driver - unregister a pci driver
417 * @drv: the driver structure to unregister
418 *
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
422 * driverless.
423 */
424
425void
426pci_unregister_driver(struct pci_driver *drv)
427{
428 driver_unregister(&drv->driver);
429 pci_free_dynids(drv);
430}
431
432static struct pci_driver pci_compat_driver = {
433 .name = "compat"
434};
435
436/**
437 * pci_dev_driver - get the pci_driver of a device
438 * @dev: the device to query
439 *
440 * Returns the appropriate pci_driver structure or %NULL if there is no
441 * registered driver for the device.
442 */
443struct pci_driver *
444pci_dev_driver(const struct pci_dev *dev)
445{
446 if (dev->driver)
447 return dev->driver;
448 else {
449 int i;
450 for(i=0; i<=PCI_ROM_RESOURCE; i++)
451 if (dev->resource[i].flags & IORESOURCE_BUSY)
452 return &pci_compat_driver;
453 }
454 return NULL;
455}
456
457/**
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
461 *
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.
465 */
466static int pci_bus_match(struct device * dev, struct device_driver * drv)
467{
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;
472
473 if (!ids)
474 return 0;
475
476 found_id = pci_match_device(ids, pci_dev);
477 if (found_id)
478 return 1;
479
480 return pci_bus_match_dynids(pci_dev, pci_drv);
481}
482
483/**
484 * pci_dev_get - increments the reference count of the pci device structure
485 * @dev: the device being referenced
486 *
487 * Each live reference to a device should be refcounted.
488 *
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.
492 *
493 * A pointer to the device with the incremented reference counter is returned.
494 */
495struct pci_dev *pci_dev_get(struct pci_dev *dev)
496{
497 if (dev)
498 get_device(&dev->dev);
499 return dev;
500}
501
502/**
503 * pci_dev_put - release a use of the pci device structure
504 * @dev: device that's been disconnected
505 *
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.
508 */
509void pci_dev_put(struct pci_dev *dev)
510{
511 if (dev)
512 put_device(&dev->dev);
513}
514
515#ifndef CONFIG_HOTPLUG
516int pci_hotplug (struct device *dev, char **envp, int num_envp,
517 char *buffer, int buffer_size)
518{
519 return -ENODEV;
520}
521#endif
522
523struct bus_type pci_bus_type = {
524 .name = "pci",
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,
530};
531
532static int __init pci_driver_init(void)
533{
534 return bus_register(&pci_bus_type);
535}
536
537postcore_initcall(pci_driver_init);
538
539EXPORT_SYMBOL(pci_match_device);
540EXPORT_SYMBOL(pci_register_driver);
541EXPORT_SYMBOL(pci_unregister_driver);
542EXPORT_SYMBOL(pci_dev_driver);
543EXPORT_SYMBOL(pci_bus_type);
544EXPORT_SYMBOL(pci_dev_get);
545EXPORT_SYMBOL(pci_dev_put);