e65bf2b395aab8f12ec033e9e33c53978942961b
[linux-2.6.git] / drivers / pci / pci-driver.c
1 /*
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  */
28 static int
29 pci_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  */
58 static inline ssize_t
59 store_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
108 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
109 static inline void
110 pci_init_dynids(struct pci_dynids *dynids)
111 {
112         spin_lock_init(&dynids->lock);
113         INIT_LIST_HEAD(&dynids->list);
114 }
115
116 static void
117 pci_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
131 static int
132 pci_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
141 static int
142 pci_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 */
160 static inline int pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
161 {
162         return -ENODEV;
163 }
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)
167 {
168         return 0;
169 }
170 static 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  */
186 const struct pci_device_id *
187 pci_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  */
202 static int
203 pci_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  */
226 static 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
239 static 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
255 static 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
279 static 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  */
297 static 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
309 static 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
321 static 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 }
329
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
333 static ssize_t
334 pci_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);
338         ssize_t ret;
339
340         if (!get_driver(driver))
341                 return -ENODEV;
342
343         ret = dattr->show ? dattr->show(driver, buf) : -EIO;
344
345         put_driver(driver);
346         return ret;
347 }
348
349 static ssize_t
350 pci_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);
355         ssize_t ret;
356
357         if (!get_driver(driver))
358                 return -ENODEV;
359
360         ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
361
362         put_driver(driver);
363         return ret;
364 }
365
366 static struct sysfs_ops pci_driver_sysfs_ops = {
367         .show = pci_driver_attr_show,
368         .store = pci_driver_attr_store,
369 };
370 static struct kobj_type pci_driver_kobj_type = {
371         .sysfs_ops = &pci_driver_sysfs_ops,
372 };
373
374 static int
375 pci_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. 
386  * If no error occurred, the driver remains registered even if 
387  * no device was claimed during registration.
388  */
389 int 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;
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);
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
425 void
426 pci_unregister_driver(struct pci_driver *drv)
427 {
428         driver_unregister(&drv->driver);
429         pci_free_dynids(drv);
430 }
431
432 static 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  */
443 struct pci_driver *
444 pci_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  */
466 static 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  */
495 struct 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  */
509 void pci_dev_put(struct pci_dev *dev)
510 {
511         if (dev)
512                 put_device(&dev->dev);
513 }
514
515 #ifndef CONFIG_HOTPLUG
516 int pci_hotplug (struct device *dev, char **envp, int num_envp,
517                  char *buffer, int buffer_size)
518 {
519         return -ENODEV;
520 }
521 #endif
522
523 struct 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
532 static int __init pci_driver_init(void)
533 {
534         return bus_register(&pci_bus_type);
535 }
536
537 postcore_initcall(pci_driver_init);
538
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);