Remove obsolete #include <linux/config.h>
[linux-3.10.git] / drivers / base / core.c
1 /*
2  * drivers/base/core.c - core driver model code (device registration, etc)
3  *
4  * Copyright (c) 2002-3 Patrick Mochel
5  * Copyright (c) 2002-3 Open Source Development Labs
6  *
7  * This file is released under the GPLv2
8  *
9  */
10
11 #include <linux/device.h>
12 #include <linux/err.h>
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/string.h>
17 #include <linux/kdev_t.h>
18
19 #include <asm/semaphore.h>
20
21 #include "base.h"
22 #include "power/power.h"
23
24 int (*platform_notify)(struct device * dev) = NULL;
25 int (*platform_notify_remove)(struct device * dev) = NULL;
26
27 /*
28  * sysfs bindings for devices.
29  */
30
31 /**
32  * dev_driver_string - Return a device's driver name, if at all possible
33  * @dev: struct device to get the name of
34  *
35  * Will return the device's driver's name if it is bound to a device.  If
36  * the device is not bound to a device, it will return the name of the bus
37  * it is attached to.  If it is not attached to a bus either, an empty
38  * string will be returned.
39  */
40 const char *dev_driver_string(struct device *dev)
41 {
42         return dev->driver ? dev->driver->name :
43                         (dev->bus ? dev->bus->name : "");
44 }
45 EXPORT_SYMBOL_GPL(dev_driver_string);
46
47 #define to_dev(obj) container_of(obj, struct device, kobj)
48 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
49
50 static ssize_t
51 dev_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
52 {
53         struct device_attribute * dev_attr = to_dev_attr(attr);
54         struct device * dev = to_dev(kobj);
55         ssize_t ret = -EIO;
56
57         if (dev_attr->show)
58                 ret = dev_attr->show(dev, dev_attr, buf);
59         return ret;
60 }
61
62 static ssize_t
63 dev_attr_store(struct kobject * kobj, struct attribute * attr,
64                const char * buf, size_t count)
65 {
66         struct device_attribute * dev_attr = to_dev_attr(attr);
67         struct device * dev = to_dev(kobj);
68         ssize_t ret = -EIO;
69
70         if (dev_attr->store)
71                 ret = dev_attr->store(dev, dev_attr, buf, count);
72         return ret;
73 }
74
75 static struct sysfs_ops dev_sysfs_ops = {
76         .show   = dev_attr_show,
77         .store  = dev_attr_store,
78 };
79
80
81 /**
82  *      device_release - free device structure.
83  *      @kobj:  device's kobject.
84  *
85  *      This is called once the reference count for the object
86  *      reaches 0. We forward the call to the device's release
87  *      method, which should handle actually freeing the structure.
88  */
89 static void device_release(struct kobject * kobj)
90 {
91         struct device * dev = to_dev(kobj);
92
93         if (dev->release)
94                 dev->release(dev);
95         else {
96                 printk(KERN_ERR "Device '%s' does not have a release() function, "
97                         "it is broken and must be fixed.\n",
98                         dev->bus_id);
99                 WARN_ON(1);
100         }
101 }
102
103 static struct kobj_type ktype_device = {
104         .release        = device_release,
105         .sysfs_ops      = &dev_sysfs_ops,
106 };
107
108
109 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
110 {
111         struct kobj_type *ktype = get_ktype(kobj);
112
113         if (ktype == &ktype_device) {
114                 struct device *dev = to_dev(kobj);
115                 if (dev->bus)
116                         return 1;
117                 if (dev->class)
118                         return 1;
119         }
120         return 0;
121 }
122
123 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
124 {
125         struct device *dev = to_dev(kobj);
126
127         if (dev->bus)
128                 return dev->bus->name;
129         if (dev->class)
130                 return dev->class->name;
131         return NULL;
132 }
133
134 static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
135                         int num_envp, char *buffer, int buffer_size)
136 {
137         struct device *dev = to_dev(kobj);
138         int i = 0;
139         int length = 0;
140         int retval = 0;
141
142         /* add the major/minor if present */
143         if (MAJOR(dev->devt)) {
144                 add_uevent_var(envp, num_envp, &i,
145                                buffer, buffer_size, &length,
146                                "MAJOR=%u", MAJOR(dev->devt));
147                 add_uevent_var(envp, num_envp, &i,
148                                buffer, buffer_size, &length,
149                                "MINOR=%u", MINOR(dev->devt));
150         }
151
152         /* add bus name of physical device */
153         if (dev->bus)
154                 add_uevent_var(envp, num_envp, &i,
155                                buffer, buffer_size, &length,
156                                "PHYSDEVBUS=%s", dev->bus->name);
157
158         /* add driver name of physical device */
159         if (dev->driver)
160                 add_uevent_var(envp, num_envp, &i,
161                                buffer, buffer_size, &length,
162                                "PHYSDEVDRIVER=%s", dev->driver->name);
163
164         /* terminate, set to next free slot, shrink available space */
165         envp[i] = NULL;
166         envp = &envp[i];
167         num_envp -= i;
168         buffer = &buffer[length];
169         buffer_size -= length;
170
171         if (dev->bus && dev->bus->uevent) {
172                 /* have the bus specific function add its stuff */
173                 retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size);
174                         if (retval) {
175                         pr_debug ("%s - uevent() returned %d\n",
176                                   __FUNCTION__, retval);
177                 }
178         }
179
180         return retval;
181 }
182
183 static struct kset_uevent_ops device_uevent_ops = {
184         .filter =       dev_uevent_filter,
185         .name =         dev_uevent_name,
186         .uevent =       dev_uevent,
187 };
188
189 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
190                             const char *buf, size_t count)
191 {
192         kobject_uevent(&dev->kobj, KOBJ_ADD);
193         return count;
194 }
195
196 static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
197                         char *buf)
198 {
199         return print_dev_t(buf, dev->devt);
200 }
201
202 /*
203  *      devices_subsys - structure to be registered with kobject core.
204  */
205
206 decl_subsys(devices, &ktype_device, &device_uevent_ops);
207
208
209 /**
210  *      device_create_file - create sysfs attribute file for device.
211  *      @dev:   device.
212  *      @attr:  device attribute descriptor.
213  */
214
215 int device_create_file(struct device * dev, struct device_attribute * attr)
216 {
217         int error = 0;
218         if (get_device(dev)) {
219                 error = sysfs_create_file(&dev->kobj, &attr->attr);
220                 put_device(dev);
221         }
222         return error;
223 }
224
225 /**
226  *      device_remove_file - remove sysfs attribute file.
227  *      @dev:   device.
228  *      @attr:  device attribute descriptor.
229  */
230
231 void device_remove_file(struct device * dev, struct device_attribute * attr)
232 {
233         if (get_device(dev)) {
234                 sysfs_remove_file(&dev->kobj, &attr->attr);
235                 put_device(dev);
236         }
237 }
238
239 static void klist_children_get(struct klist_node *n)
240 {
241         struct device *dev = container_of(n, struct device, knode_parent);
242
243         get_device(dev);
244 }
245
246 static void klist_children_put(struct klist_node *n)
247 {
248         struct device *dev = container_of(n, struct device, knode_parent);
249
250         put_device(dev);
251 }
252
253
254 /**
255  *      device_initialize - init device structure.
256  *      @dev:   device.
257  *
258  *      This prepares the device for use by other layers,
259  *      including adding it to the device hierarchy.
260  *      It is the first half of device_register(), if called by
261  *      that, though it can also be called separately, so one
262  *      may use @dev's fields (e.g. the refcount).
263  */
264
265 void device_initialize(struct device *dev)
266 {
267         kobj_set_kset_s(dev, devices_subsys);
268         kobject_init(&dev->kobj);
269         klist_init(&dev->klist_children, klist_children_get,
270                    klist_children_put);
271         INIT_LIST_HEAD(&dev->dma_pools);
272         INIT_LIST_HEAD(&dev->node);
273         init_MUTEX(&dev->sem);
274         device_init_wakeup(dev, 0);
275 }
276
277 /**
278  *      device_add - add device to device hierarchy.
279  *      @dev:   device.
280  *
281  *      This is part 2 of device_register(), though may be called
282  *      separately _iff_ device_initialize() has been called separately.
283  *
284  *      This adds it to the kobject hierarchy via kobject_add(), adds it
285  *      to the global and sibling lists for the device, then
286  *      adds it to the other relevant subsystems of the driver model.
287  */
288 int device_add(struct device *dev)
289 {
290         struct device *parent = NULL;
291         char *class_name = NULL;
292         int error = -EINVAL;
293
294         dev = get_device(dev);
295         if (!dev || !strlen(dev->bus_id))
296                 goto Error;
297
298         parent = get_device(dev->parent);
299
300         pr_debug("DEV: registering device: ID = '%s'\n", dev->bus_id);
301
302         /* first, register with generic layer. */
303         kobject_set_name(&dev->kobj, "%s", dev->bus_id);
304         if (parent)
305                 dev->kobj.parent = &parent->kobj;
306
307         if ((error = kobject_add(&dev->kobj)))
308                 goto Error;
309
310         dev->uevent_attr.attr.name = "uevent";
311         dev->uevent_attr.attr.mode = S_IWUSR;
312         if (dev->driver)
313                 dev->uevent_attr.attr.owner = dev->driver->owner;
314         dev->uevent_attr.store = store_uevent;
315         device_create_file(dev, &dev->uevent_attr);
316
317         if (MAJOR(dev->devt)) {
318                 struct device_attribute *attr;
319                 attr = kzalloc(sizeof(*attr), GFP_KERNEL);
320                 if (!attr) {
321                         error = -ENOMEM;
322                         goto PMError;
323                 }
324                 attr->attr.name = "dev";
325                 attr->attr.mode = S_IRUGO;
326                 if (dev->driver)
327                         attr->attr.owner = dev->driver->owner;
328                 attr->show = show_dev;
329                 error = device_create_file(dev, attr);
330                 if (error) {
331                         kfree(attr);
332                         goto attrError;
333                 }
334
335                 dev->devt_attr = attr;
336         }
337
338         if (dev->class) {
339                 sysfs_create_link(&dev->kobj, &dev->class->subsys.kset.kobj,
340                                   "subsystem");
341                 sysfs_create_link(&dev->class->subsys.kset.kobj, &dev->kobj,
342                                   dev->bus_id);
343
344                 sysfs_create_link(&dev->kobj, &dev->parent->kobj, "device");
345                 class_name = make_class_name(dev->class->name, &dev->kobj);
346                 sysfs_create_link(&dev->parent->kobj, &dev->kobj, class_name);
347         }
348
349         if ((error = device_pm_add(dev)))
350                 goto PMError;
351         if ((error = bus_add_device(dev)))
352                 goto BusError;
353         kobject_uevent(&dev->kobj, KOBJ_ADD);
354         bus_attach_device(dev);
355         if (parent)
356                 klist_add_tail(&dev->knode_parent, &parent->klist_children);
357
358         if (dev->class) {
359                 /* tie the class to the device */
360                 down(&dev->class->sem);
361                 list_add_tail(&dev->node, &dev->class->devices);
362                 up(&dev->class->sem);
363         }
364
365         /* notify platform of device entry */
366         if (platform_notify)
367                 platform_notify(dev);
368  Done:
369         kfree(class_name);
370         put_device(dev);
371         return error;
372  BusError:
373         device_pm_remove(dev);
374  PMError:
375         if (dev->devt_attr) {
376                 device_remove_file(dev, dev->devt_attr);
377                 kfree(dev->devt_attr);
378         }
379  attrError:
380         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
381         kobject_del(&dev->kobj);
382  Error:
383         if (parent)
384                 put_device(parent);
385         goto Done;
386 }
387
388
389 /**
390  *      device_register - register a device with the system.
391  *      @dev:   pointer to the device structure
392  *
393  *      This happens in two clean steps - initialize the device
394  *      and add it to the system. The two steps can be called
395  *      separately, but this is the easiest and most common.
396  *      I.e. you should only call the two helpers separately if
397  *      have a clearly defined need to use and refcount the device
398  *      before it is added to the hierarchy.
399  */
400
401 int device_register(struct device *dev)
402 {
403         device_initialize(dev);
404         return device_add(dev);
405 }
406
407
408 /**
409  *      get_device - increment reference count for device.
410  *      @dev:   device.
411  *
412  *      This simply forwards the call to kobject_get(), though
413  *      we do take care to provide for the case that we get a NULL
414  *      pointer passed in.
415  */
416
417 struct device * get_device(struct device * dev)
418 {
419         return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
420 }
421
422
423 /**
424  *      put_device - decrement reference count.
425  *      @dev:   device in question.
426  */
427 void put_device(struct device * dev)
428 {
429         if (dev)
430                 kobject_put(&dev->kobj);
431 }
432
433
434 /**
435  *      device_del - delete device from system.
436  *      @dev:   device.
437  *
438  *      This is the first part of the device unregistration
439  *      sequence. This removes the device from the lists we control
440  *      from here, has it removed from the other driver model
441  *      subsystems it was added to in device_add(), and removes it
442  *      from the kobject hierarchy.
443  *
444  *      NOTE: this should be called manually _iff_ device_add() was
445  *      also called manually.
446  */
447
448 void device_del(struct device * dev)
449 {
450         struct device * parent = dev->parent;
451         char *class_name = NULL;
452
453         if (parent)
454                 klist_del(&dev->knode_parent);
455         if (dev->devt_attr)
456                 device_remove_file(dev, dev->devt_attr);
457         if (dev->class) {
458                 sysfs_remove_link(&dev->kobj, "subsystem");
459                 sysfs_remove_link(&dev->class->subsys.kset.kobj, dev->bus_id);
460                 class_name = make_class_name(dev->class->name, &dev->kobj);
461                 sysfs_remove_link(&dev->kobj, "device");
462                 sysfs_remove_link(&dev->parent->kobj, class_name);
463                 kfree(class_name);
464                 down(&dev->class->sem);
465                 list_del_init(&dev->node);
466                 up(&dev->class->sem);
467         }
468         device_remove_file(dev, &dev->uevent_attr);
469
470         /* Notify the platform of the removal, in case they
471          * need to do anything...
472          */
473         if (platform_notify_remove)
474                 platform_notify_remove(dev);
475         bus_remove_device(dev);
476         device_pm_remove(dev);
477         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
478         kobject_del(&dev->kobj);
479         if (parent)
480                 put_device(parent);
481 }
482
483 /**
484  *      device_unregister - unregister device from system.
485  *      @dev:   device going away.
486  *
487  *      We do this in two parts, like we do device_register(). First,
488  *      we remove it from all the subsystems with device_del(), then
489  *      we decrement the reference count via put_device(). If that
490  *      is the final reference count, the device will be cleaned up
491  *      via device_release() above. Otherwise, the structure will
492  *      stick around until the final reference to the device is dropped.
493  */
494 void device_unregister(struct device * dev)
495 {
496         pr_debug("DEV: Unregistering device. ID = '%s'\n", dev->bus_id);
497         device_del(dev);
498         put_device(dev);
499 }
500
501
502 static struct device * next_device(struct klist_iter * i)
503 {
504         struct klist_node * n = klist_next(i);
505         return n ? container_of(n, struct device, knode_parent) : NULL;
506 }
507
508 /**
509  *      device_for_each_child - device child iterator.
510  *      @parent: parent struct device.
511  *      @data:  data for the callback.
512  *      @fn:    function to be called for each device.
513  *
514  *      Iterate over @parent's child devices, and call @fn for each,
515  *      passing it @data.
516  *
517  *      We check the return of @fn each time. If it returns anything
518  *      other than 0, we break out and return that value.
519  */
520 int device_for_each_child(struct device * parent, void * data,
521                      int (*fn)(struct device *, void *))
522 {
523         struct klist_iter i;
524         struct device * child;
525         int error = 0;
526
527         klist_iter_init(&parent->klist_children, &i);
528         while ((child = next_device(&i)) && !error)
529                 error = fn(child, data);
530         klist_iter_exit(&i);
531         return error;
532 }
533
534 int __init devices_init(void)
535 {
536         return subsystem_register(&devices_subsys);
537 }
538
539 EXPORT_SYMBOL_GPL(device_for_each_child);
540
541 EXPORT_SYMBOL_GPL(device_initialize);
542 EXPORT_SYMBOL_GPL(device_add);
543 EXPORT_SYMBOL_GPL(device_register);
544
545 EXPORT_SYMBOL_GPL(device_del);
546 EXPORT_SYMBOL_GPL(device_unregister);
547 EXPORT_SYMBOL_GPL(get_device);
548 EXPORT_SYMBOL_GPL(put_device);
549
550 EXPORT_SYMBOL_GPL(device_create_file);
551 EXPORT_SYMBOL_GPL(device_remove_file);
552
553
554 static void device_create_release(struct device *dev)
555 {
556         pr_debug("%s called for %s\n", __FUNCTION__, dev->bus_id);
557         kfree(dev);
558 }
559
560 /**
561  * device_create - creates a device and registers it with sysfs
562  * @cs: pointer to the struct class that this device should be registered to.
563  * @parent: pointer to the parent struct device of this new device, if any.
564  * @dev: the dev_t for the char device to be added.
565  * @fmt: string for the class device's name
566  *
567  * This function can be used by char device classes.  A struct
568  * device will be created in sysfs, registered to the specified
569  * class.
570  * A "dev" file will be created, showing the dev_t for the device, if
571  * the dev_t is not 0,0.
572  * If a pointer to a parent struct device is passed in, the newly
573  * created struct device will be a child of that device in sysfs.  The
574  * pointer to the struct device will be returned from the call.  Any
575  * further sysfs files that might be required can be created using this
576  * pointer.
577  *
578  * Note: the struct class passed to this function must have previously
579  * been created with a call to class_create().
580  */
581 struct device *device_create(struct class *class, struct device *parent,
582                              dev_t devt, char *fmt, ...)
583 {
584         va_list args;
585         struct device *dev = NULL;
586         int retval = -ENODEV;
587
588         if (class == NULL || IS_ERR(class))
589                 goto error;
590         if (parent == NULL) {
591                 printk(KERN_WARNING "%s does not work yet for NULL parents\n", __FUNCTION__);
592                 goto error;
593         }
594
595         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
596         if (!dev) {
597                 retval = -ENOMEM;
598                 goto error;
599         }
600
601         dev->devt = devt;
602         dev->class = class;
603         dev->parent = parent;
604         dev->release = device_create_release;
605
606         va_start(args, fmt);
607         vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args);
608         va_end(args);
609         retval = device_register(dev);
610         if (retval)
611                 goto error;
612
613         return dev;
614
615 error:
616         kfree(dev);
617         return ERR_PTR(retval);
618 }
619 EXPORT_SYMBOL_GPL(device_create);
620
621 /**
622  * device_destroy - removes a device that was created with device_create()
623  * @class: the pointer to the struct class that this device was registered * with.
624  * @dev: the dev_t of the device that was previously registered.
625  *
626  * This call unregisters and cleans up a class device that was created with a
627  * call to class_device_create()
628  */
629 void device_destroy(struct class *class, dev_t devt)
630 {
631         struct device *dev = NULL;
632         struct device *dev_tmp;
633
634         down(&class->sem);
635         list_for_each_entry(dev_tmp, &class->devices, node) {
636                 if (dev_tmp->devt == devt) {
637                         dev = dev_tmp;
638                         break;
639                 }
640         }
641         up(&class->sem);
642
643         if (dev)
644                 device_unregister(dev);
645 }
646 EXPORT_SYMBOL_GPL(device_destroy);