Driver core: change add_uevent_var to use a struct
[linux-3.10.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/mempolicy.h>
11 #include <linux/string.h>
12 #include <linux/slab.h>
13 #include <linux/sched.h>
14 #include "pci.h"
15
16 /*
17  * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
18  */
19
20 struct pci_dynid {
21         struct list_head node;
22         struct pci_device_id id;
23 };
24
25 #ifdef CONFIG_HOTPLUG
26
27 /**
28  * store_new_id - add a new PCI device ID to this driver and re-probe devices
29  * @driver: target device driver
30  * @buf: buffer for scanning device ID data
31  * @count: input size
32  *
33  * Adds a new dynamic pci device ID to this driver,
34  * and causes the driver to probe for all devices again.
35  */
36 static ssize_t
37 store_new_id(struct device_driver *driver, const char *buf, size_t count)
38 {
39         struct pci_dynid *dynid;
40         struct pci_driver *pdrv = to_pci_driver(driver);
41         __u32 vendor, device, subvendor=PCI_ANY_ID,
42                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
43         unsigned long driver_data=0;
44         int fields=0;
45         int retval = 0;
46
47         fields = sscanf(buf, "%x %x %x %x %x %x %lux",
48                         &vendor, &device, &subvendor, &subdevice,
49                         &class, &class_mask, &driver_data);
50         if (fields < 2)
51                 return -EINVAL;
52
53         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
54         if (!dynid)
55                 return -ENOMEM;
56
57         INIT_LIST_HEAD(&dynid->node);
58         dynid->id.vendor = vendor;
59         dynid->id.device = device;
60         dynid->id.subvendor = subvendor;
61         dynid->id.subdevice = subdevice;
62         dynid->id.class = class;
63         dynid->id.class_mask = class_mask;
64         dynid->id.driver_data = pdrv->dynids.use_driver_data ?
65                 driver_data : 0UL;
66
67         spin_lock(&pdrv->dynids.lock);
68         list_add_tail(&pdrv->dynids.list, &dynid->node);
69         spin_unlock(&pdrv->dynids.lock);
70
71         if (get_driver(&pdrv->driver)) {
72                 retval = driver_attach(&pdrv->driver);
73                 put_driver(&pdrv->driver);
74         }
75
76         if (retval)
77                 return retval;
78         return count;
79 }
80 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
81
82 static void
83 pci_free_dynids(struct pci_driver *drv)
84 {
85         struct pci_dynid *dynid, *n;
86
87         spin_lock(&drv->dynids.lock);
88         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
89                 list_del(&dynid->node);
90                 kfree(dynid);
91         }
92         spin_unlock(&drv->dynids.lock);
93 }
94
95 static int
96 pci_create_newid_file(struct pci_driver *drv)
97 {
98         int error = 0;
99         if (drv->probe != NULL)
100                 error = sysfs_create_file(&drv->driver.kobj,
101                                           &driver_attr_new_id.attr);
102         return error;
103 }
104
105 #else /* !CONFIG_HOTPLUG */
106 static inline void pci_free_dynids(struct pci_driver *drv) {}
107 static inline int pci_create_newid_file(struct pci_driver *drv)
108 {
109         return 0;
110 }
111 #endif
112
113 /**
114  * pci_match_id - See if a pci device matches a given pci_id table
115  * @ids: array of PCI device id structures to search in
116  * @dev: the PCI device structure to match against.
117  *
118  * Used by a driver to check whether a PCI device present in the
119  * system is in its list of supported devices.  Returns the matching
120  * pci_device_id structure or %NULL if there is no match.
121  *
122  * Deprecated, don't use this as it will not catch any dynamic ids
123  * that a driver might want to check for.
124  */
125 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
126                                          struct pci_dev *dev)
127 {
128         if (ids) {
129                 while (ids->vendor || ids->subvendor || ids->class_mask) {
130                         if (pci_match_one_device(ids, dev))
131                                 return ids;
132                         ids++;
133                 }
134         }
135         return NULL;
136 }
137
138 /**
139  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
140  * @drv: the PCI driver to match against
141  * @dev: the PCI device structure to match against
142  *
143  * Used by a driver to check whether a PCI device present in the
144  * system is in its list of supported devices.  Returns the matching
145  * pci_device_id structure or %NULL if there is no match.
146  */
147 const struct pci_device_id *pci_match_device(struct pci_driver *drv,
148                                              struct pci_dev *dev)
149 {
150         struct pci_dynid *dynid;
151
152         /* Look at the dynamic ids first, before the static ones */
153         spin_lock(&drv->dynids.lock);
154         list_for_each_entry(dynid, &drv->dynids.list, node) {
155                 if (pci_match_one_device(&dynid->id, dev)) {
156                         spin_unlock(&drv->dynids.lock);
157                         return &dynid->id;
158                 }
159         }
160         spin_unlock(&drv->dynids.lock);
161
162         return pci_match_id(drv->id_table, dev);
163 }
164
165 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
166                           const struct pci_device_id *id)
167 {
168         int error;
169 #ifdef CONFIG_NUMA
170         /* Execute driver initialization on node where the
171            device's bus is attached to.  This way the driver likely
172            allocates its local memory on the right node without
173            any need to change it. */
174         struct mempolicy *oldpol;
175         cpumask_t oldmask = current->cpus_allowed;
176         int node = pcibus_to_node(dev->bus);
177         if (node >= 0 && node_online(node))
178             set_cpus_allowed(current, node_to_cpumask(node));
179         /* And set default memory allocation policy */
180         oldpol = current->mempolicy;
181         current->mempolicy = &default_policy;
182         mpol_get(current->mempolicy);
183 #endif
184         error = drv->probe(dev, id);
185 #ifdef CONFIG_NUMA
186         set_cpus_allowed(current, oldmask);
187         mpol_free(current->mempolicy);
188         current->mempolicy = oldpol;
189 #endif
190         return error;
191 }
192
193 /**
194  * __pci_device_probe()
195  * @drv: driver to call to check if it wants the PCI device
196  * @pci_dev: PCI device being probed
197  * 
198  * returns 0 on success, else error.
199  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
200  */
201 static int
202 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
203 {
204         const struct pci_device_id *id;
205         int error = 0;
206
207         if (!pci_dev->driver && drv->probe) {
208                 error = -ENODEV;
209
210                 id = pci_match_device(drv, pci_dev);
211                 if (id)
212                         error = pci_call_probe(drv, pci_dev, id);
213                 if (error >= 0) {
214                         pci_dev->driver = drv;
215                         error = 0;
216                 }
217         }
218         return error;
219 }
220
221 static int pci_device_probe(struct device * dev)
222 {
223         int error = 0;
224         struct pci_driver *drv;
225         struct pci_dev *pci_dev;
226
227         drv = to_pci_driver(dev->driver);
228         pci_dev = to_pci_dev(dev);
229         pci_dev_get(pci_dev);
230         error = __pci_device_probe(drv, pci_dev);
231         if (error)
232                 pci_dev_put(pci_dev);
233
234         return error;
235 }
236
237 static int pci_device_remove(struct device * dev)
238 {
239         struct pci_dev * pci_dev = to_pci_dev(dev);
240         struct pci_driver * drv = pci_dev->driver;
241
242         if (drv) {
243                 if (drv->remove)
244                         drv->remove(pci_dev);
245                 pci_dev->driver = NULL;
246         }
247
248         /*
249          * If the device is still on, set the power state as "unknown",
250          * since it might change by the next time we load the driver.
251          */
252         if (pci_dev->current_state == PCI_D0)
253                 pci_dev->current_state = PCI_UNKNOWN;
254
255         /*
256          * We would love to complain here if pci_dev->is_enabled is set, that
257          * the driver should have called pci_disable_device(), but the
258          * unfortunate fact is there are too many odd BIOS and bridge setups
259          * that don't like drivers doing that all of the time.  
260          * Oh well, we can dream of sane hardware when we sleep, no matter how
261          * horrible the crap we have to deal with is when we are awake...
262          */
263
264         pci_dev_put(pci_dev);
265         return 0;
266 }
267
268 static int pci_device_suspend(struct device * dev, pm_message_t state)
269 {
270         struct pci_dev * pci_dev = to_pci_dev(dev);
271         struct pci_driver * drv = pci_dev->driver;
272         int i = 0;
273
274         if (drv && drv->suspend) {
275                 i = drv->suspend(pci_dev, state);
276                 suspend_report_result(drv->suspend, i);
277         } else {
278                 pci_save_state(pci_dev);
279                 /*
280                  * mark its power state as "unknown", since we don't know if
281                  * e.g. the BIOS will change its device state when we suspend.
282                  */
283                 if (pci_dev->current_state == PCI_D0)
284                         pci_dev->current_state = PCI_UNKNOWN;
285         }
286         return i;
287 }
288
289 static int pci_device_suspend_late(struct device * dev, pm_message_t state)
290 {
291         struct pci_dev * pci_dev = to_pci_dev(dev);
292         struct pci_driver * drv = pci_dev->driver;
293         int i = 0;
294
295         if (drv && drv->suspend_late) {
296                 i = drv->suspend_late(pci_dev, state);
297                 suspend_report_result(drv->suspend_late, i);
298         }
299         return i;
300 }
301
302 /*
303  * Default resume method for devices that have no driver provided resume,
304  * or not even a driver at all.
305  */
306 static int pci_default_resume(struct pci_dev *pci_dev)
307 {
308         int retval = 0;
309
310         /* restore the PCI config space */
311         pci_restore_state(pci_dev);
312         /* if the device was enabled before suspend, reenable */
313         retval = pci_reenable_device(pci_dev);
314         /* if the device was busmaster before the suspend, make it busmaster again */
315         if (pci_dev->is_busmaster)
316                 pci_set_master(pci_dev);
317
318         return retval;
319 }
320
321 static int pci_device_resume(struct device * dev)
322 {
323         int error;
324         struct pci_dev * pci_dev = to_pci_dev(dev);
325         struct pci_driver * drv = pci_dev->driver;
326
327         if (drv && drv->resume)
328                 error = drv->resume(pci_dev);
329         else
330                 error = pci_default_resume(pci_dev);
331         return error;
332 }
333
334 static int pci_device_resume_early(struct device * dev)
335 {
336         int error = 0;
337         struct pci_dev * pci_dev = to_pci_dev(dev);
338         struct pci_driver * drv = pci_dev->driver;
339
340         pci_fixup_device(pci_fixup_resume, pci_dev);
341
342         if (drv && drv->resume_early)
343                 error = drv->resume_early(pci_dev);
344         return error;
345 }
346
347 static void pci_device_shutdown(struct device *dev)
348 {
349         struct pci_dev *pci_dev = to_pci_dev(dev);
350         struct pci_driver *drv = pci_dev->driver;
351
352         if (drv && drv->shutdown)
353                 drv->shutdown(pci_dev);
354 }
355
356 #define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
357 #define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
358
359 static ssize_t
360 pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
361 {
362         struct device_driver *driver = kobj_to_pci_driver(kobj);
363         struct driver_attribute *dattr = attr_to_driver_attribute(attr);
364         ssize_t ret;
365
366         if (!get_driver(driver))
367                 return -ENODEV;
368
369         ret = dattr->show ? dattr->show(driver, buf) : -EIO;
370
371         put_driver(driver);
372         return ret;
373 }
374
375 static ssize_t
376 pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
377                       const char *buf, size_t count)
378 {
379         struct device_driver *driver = kobj_to_pci_driver(kobj);
380         struct driver_attribute *dattr = attr_to_driver_attribute(attr);
381         ssize_t ret;
382
383         if (!get_driver(driver))
384                 return -ENODEV;
385
386         ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
387
388         put_driver(driver);
389         return ret;
390 }
391
392 static struct sysfs_ops pci_driver_sysfs_ops = {
393         .show = pci_driver_attr_show,
394         .store = pci_driver_attr_store,
395 };
396 static struct kobj_type pci_driver_kobj_type = {
397         .sysfs_ops = &pci_driver_sysfs_ops,
398 };
399
400 /**
401  * __pci_register_driver - register a new pci driver
402  * @drv: the driver structure to register
403  * @owner: owner module of drv
404  * @mod_name: module name string
405  * 
406  * Adds the driver structure to the list of registered drivers.
407  * Returns a negative value on error, otherwise 0. 
408  * If no error occurred, the driver remains registered even if 
409  * no device was claimed during registration.
410  */
411 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
412                           const char *mod_name)
413 {
414         int error;
415
416         /* initialize common driver fields */
417         drv->driver.name = drv->name;
418         drv->driver.bus = &pci_bus_type;
419         drv->driver.owner = owner;
420         drv->driver.mod_name = mod_name;
421         drv->driver.kobj.ktype = &pci_driver_kobj_type;
422
423         spin_lock_init(&drv->dynids.lock);
424         INIT_LIST_HEAD(&drv->dynids.list);
425
426         /* register with core */
427         error = driver_register(&drv->driver);
428         if (error)
429                 return error;
430
431         error = pci_create_newid_file(drv);
432         if (error)
433                 driver_unregister(&drv->driver);
434
435         return error;
436 }
437
438 /**
439  * pci_unregister_driver - unregister a pci driver
440  * @drv: the driver structure to unregister
441  * 
442  * Deletes the driver structure from the list of registered PCI drivers,
443  * gives it a chance to clean up by calling its remove() function for
444  * each device it was responsible for, and marks those devices as
445  * driverless.
446  */
447
448 void
449 pci_unregister_driver(struct pci_driver *drv)
450 {
451         driver_unregister(&drv->driver);
452         pci_free_dynids(drv);
453 }
454
455 static struct pci_driver pci_compat_driver = {
456         .name = "compat"
457 };
458
459 /**
460  * pci_dev_driver - get the pci_driver of a device
461  * @dev: the device to query
462  *
463  * Returns the appropriate pci_driver structure or %NULL if there is no 
464  * registered driver for the device.
465  */
466 struct pci_driver *
467 pci_dev_driver(const struct pci_dev *dev)
468 {
469         if (dev->driver)
470                 return dev->driver;
471         else {
472                 int i;
473                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
474                         if (dev->resource[i].flags & IORESOURCE_BUSY)
475                                 return &pci_compat_driver;
476         }
477         return NULL;
478 }
479
480 /**
481  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
482  * @dev: the PCI device structure to match against
483  * @drv: the device driver to search for matching PCI device id structures
484  * 
485  * Used by a driver to check whether a PCI device present in the
486  * system is in its list of supported devices. Returns the matching
487  * pci_device_id structure or %NULL if there is no match.
488  */
489 static int pci_bus_match(struct device *dev, struct device_driver *drv)
490 {
491         struct pci_dev *pci_dev = to_pci_dev(dev);
492         struct pci_driver *pci_drv = to_pci_driver(drv);
493         const struct pci_device_id *found_id;
494
495         found_id = pci_match_device(pci_drv, pci_dev);
496         if (found_id)
497                 return 1;
498
499         return 0;
500 }
501
502 /**
503  * pci_dev_get - increments the reference count of the pci device structure
504  * @dev: the device being referenced
505  *
506  * Each live reference to a device should be refcounted.
507  *
508  * Drivers for PCI devices should normally record such references in
509  * their probe() methods, when they bind to a device, and release
510  * them by calling pci_dev_put(), in their disconnect() methods.
511  *
512  * A pointer to the device with the incremented reference counter is returned.
513  */
514 struct pci_dev *pci_dev_get(struct pci_dev *dev)
515 {
516         if (dev)
517                 get_device(&dev->dev);
518         return dev;
519 }
520
521 /**
522  * pci_dev_put - release a use of the pci device structure
523  * @dev: device that's been disconnected
524  *
525  * Must be called when a user of a device is finished with it.  When the last
526  * user of the device calls this function, the memory of the device is freed.
527  */
528 void pci_dev_put(struct pci_dev *dev)
529 {
530         if (dev)
531                 put_device(&dev->dev);
532 }
533
534 #ifndef CONFIG_HOTPLUG
535 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
536 {
537         return -ENODEV;
538 }
539 #endif
540
541 struct bus_type pci_bus_type = {
542         .name           = "pci",
543         .match          = pci_bus_match,
544         .uevent         = pci_uevent,
545         .probe          = pci_device_probe,
546         .remove         = pci_device_remove,
547         .suspend        = pci_device_suspend,
548         .suspend_late   = pci_device_suspend_late,
549         .resume_early   = pci_device_resume_early,
550         .resume         = pci_device_resume,
551         .shutdown       = pci_device_shutdown,
552         .dev_attrs      = pci_dev_attrs,
553 };
554
555 static int __init pci_driver_init(void)
556 {
557         return bus_register(&pci_bus_type);
558 }
559
560 postcore_initcall(pci_driver_init);
561
562 EXPORT_SYMBOL(pci_match_id);
563 EXPORT_SYMBOL(pci_match_device);
564 EXPORT_SYMBOL(__pci_register_driver);
565 EXPORT_SYMBOL(pci_unregister_driver);
566 EXPORT_SYMBOL(pci_dev_driver);
567 EXPORT_SYMBOL(pci_bus_type);
568 EXPORT_SYMBOL(pci_dev_get);
569 EXPORT_SYMBOL(pci_dev_put);