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  * @class: 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  * @devt: the dev_t for the char device to be added
 565  * @fmt: string for the device's name
 566  *
 567  * This function can be used by char device classes.  A struct device
 568  * will be created in sysfs, registered to the specified class.
 569  *
 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 created
 573  * struct device will be a child of that device in sysfs.
 574  * The pointer to the struct device will be returned from the call.
 575  * Any 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: pointer to the struct class that this device was registered with
 624  * @devt: the dev_t of the device that was previously registered
 625  *
 626  * This call unregisters and cleans up a device that was created with a
 627  * call to 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);