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 (same as SUBSYSTEM, deprecated) */
 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 (PHYSDEV* values are deprecated)*/
 159         if (dev->driver) {
 160                 add_uevent_var(envp, num_envp, &i,
 161                                buffer, buffer_size, &length,
 162                                "DRIVER=%s", dev->driver->name);
 163                 add_uevent_var(envp, num_envp, &i,
 164                                buffer, buffer_size, &length,
 165                                "PHYSDEVDRIVER=%s", dev->driver->name);
 166         }
 167
 168         /* terminate, set to next free slot, shrink available space */
 169         envp[i] = NULL;
 170         envp = &envp[i];
 171         num_envp -= i;
 172         buffer = &buffer[length];
 173         buffer_size -= length;
 174
 175         if (dev->bus && dev->bus->uevent) {
 176                 /* have the bus specific function add its stuff */
 177                 retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size);
 178                         if (retval) {
 179                         pr_debug ("%s - uevent() returned %d\n",
 180                                   __FUNCTION__, retval);
 181                 }
 182         }
 183
 184         return retval;
 185 }
 186
 187 static struct kset_uevent_ops device_uevent_ops = {
 188         .filter =       dev_uevent_filter,
 189         .name =         dev_uevent_name,
 190         .uevent =       dev_uevent,
 191 };
 192
 193 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
 194                             const char *buf, size_t count)
 195 {
 196         kobject_uevent(&dev->kobj, KOBJ_ADD);
 197         return count;
 198 }
 199
 200 static int device_add_groups(struct device *dev)
 201 {
 202         int i;
 203         int error = 0;
 204
 205         if (dev->groups) {
 206                 for (i = 0; dev->groups[i]; i++) {
 207                         error = sysfs_create_group(&dev->kobj, dev->groups[i]);
 208                         if (error) {
 209                                 while (--i >= 0)
 210                                         sysfs_remove_group(&dev->kobj, dev->groups[i]);
 211                                 goto out;
 212                         }
 213                 }
 214         }
 215 out:
 216         return error;
 217 }
 218
 219 static void device_remove_groups(struct device *dev)
 220 {
 221         int i;
 222         if (dev->groups) {
 223                 for (i = 0; dev->groups[i]; i++) {
 224                         sysfs_remove_group(&dev->kobj, dev->groups[i]);
 225                 }
 226         }
 227 }
 228
 229 static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
 230                         char *buf)
 231 {
 232         return print_dev_t(buf, dev->devt);
 233 }
 234
 235 /*
 236  *      devices_subsys - structure to be registered with kobject core.
 237  */
 238
 239 decl_subsys(devices, &ktype_device, &device_uevent_ops);
 240
 241
 242 /**
 243  *      device_create_file - create sysfs attribute file for device.
 244  *      @dev:   device.
 245  *      @attr:  device attribute descriptor.
 246  */
 247
 248 int device_create_file(struct device * dev, struct device_attribute * attr)
 249 {
 250         int error = 0;
 251         if (get_device(dev)) {
 252                 error = sysfs_create_file(&dev->kobj, &attr->attr);
 253                 put_device(dev);
 254         }
 255         return error;
 256 }
 257
 258 /**
 259  *      device_remove_file - remove sysfs attribute file.
 260  *      @dev:   device.
 261  *      @attr:  device attribute descriptor.
 262  */
 263
 264 void device_remove_file(struct device * dev, struct device_attribute * attr)
 265 {
 266         if (get_device(dev)) {
 267                 sysfs_remove_file(&dev->kobj, &attr->attr);
 268                 put_device(dev);
 269         }
 270 }
 271
 272 static void klist_children_get(struct klist_node *n)
 273 {
 274         struct device *dev = container_of(n, struct device, knode_parent);
 275
 276         get_device(dev);
 277 }
 278
 279 static void klist_children_put(struct klist_node *n)
 280 {
 281         struct device *dev = container_of(n, struct device, knode_parent);
 282
 283         put_device(dev);
 284 }
 285
 286
 287 /**
 288  *      device_initialize - init device structure.
 289  *      @dev:   device.
 290  *
 291  *      This prepares the device for use by other layers,
 292  *      including adding it to the device hierarchy.
 293  *      It is the first half of device_register(), if called by
 294  *      that, though it can also be called separately, so one
 295  *      may use @dev's fields (e.g. the refcount).
 296  */
 297
 298 void device_initialize(struct device *dev)
 299 {
 300         kobj_set_kset_s(dev, devices_subsys);
 301         kobject_init(&dev->kobj);
 302         klist_init(&dev->klist_children, klist_children_get,
 303                    klist_children_put);
 304         INIT_LIST_HEAD(&dev->dma_pools);
 305         INIT_LIST_HEAD(&dev->node);
 306         init_MUTEX(&dev->sem);
 307         device_init_wakeup(dev, 0);
 308 }
 309
 310 /**
 311  *      device_add - add device to device hierarchy.
 312  *      @dev:   device.
 313  *
 314  *      This is part 2 of device_register(), though may be called
 315  *      separately _iff_ device_initialize() has been called separately.
 316  *
 317  *      This adds it to the kobject hierarchy via kobject_add(), adds it
 318  *      to the global and sibling lists for the device, then
 319  *      adds it to the other relevant subsystems of the driver model.
 320  */
 321 int device_add(struct device *dev)
 322 {
 323         struct device *parent = NULL;
 324         char *class_name = NULL;
 325         int error = -EINVAL;
 326
 327         dev = get_device(dev);
 328         if (!dev || !strlen(dev->bus_id))
 329                 goto Error;
 330
 331         parent = get_device(dev->parent);
 332
 333         pr_debug("DEV: registering device: ID = '%s'\n", dev->bus_id);
 334
 335         /* first, register with generic layer. */
 336         kobject_set_name(&dev->kobj, "%s", dev->bus_id);
 337         if (parent)
 338                 dev->kobj.parent = &parent->kobj;
 339
 340         if ((error = kobject_add(&dev->kobj)))
 341                 goto Error;
 342
 343         dev->uevent_attr.attr.name = "uevent";
 344         dev->uevent_attr.attr.mode = S_IWUSR;
 345         if (dev->driver)
 346                 dev->uevent_attr.attr.owner = dev->driver->owner;
 347         dev->uevent_attr.store = store_uevent;
 348         device_create_file(dev, &dev->uevent_attr);
 349
 350         if (MAJOR(dev->devt)) {
 351                 struct device_attribute *attr;
 352                 attr = kzalloc(sizeof(*attr), GFP_KERNEL);
 353                 if (!attr) {
 354                         error = -ENOMEM;
 355                         goto PMError;
 356                 }
 357                 attr->attr.name = "dev";
 358                 attr->attr.mode = S_IRUGO;
 359                 if (dev->driver)
 360                         attr->attr.owner = dev->driver->owner;
 361                 attr->show = show_dev;
 362                 error = device_create_file(dev, attr);
 363                 if (error) {
 364                         kfree(attr);
 365                         goto attrError;
 366                 }
 367
 368                 dev->devt_attr = attr;
 369         }
 370
 371         if (dev->class) {
 372                 sysfs_create_link(&dev->kobj, &dev->class->subsys.kset.kobj,
 373                                   "subsystem");
 374                 sysfs_create_link(&dev->class->subsys.kset.kobj, &dev->kobj,
 375                                   dev->bus_id);
 376
 377                 sysfs_create_link(&dev->kobj, &dev->parent->kobj, "device");
 378                 class_name = make_class_name(dev->class->name, &dev->kobj);
 379                 sysfs_create_link(&dev->parent->kobj, &dev->kobj, class_name);
 380         }
 381
 382         if ((error = device_add_groups(dev)))
 383                 goto GroupError;
 384         if ((error = device_pm_add(dev)))
 385                 goto PMError;
 386         if ((error = bus_add_device(dev)))
 387                 goto BusError;
 388         kobject_uevent(&dev->kobj, KOBJ_ADD);
 389         bus_attach_device(dev);
 390         if (parent)
 391                 klist_add_tail(&dev->knode_parent, &parent->klist_children);
 392
 393         if (dev->class) {
 394                 /* tie the class to the device */
 395                 down(&dev->class->sem);
 396                 list_add_tail(&dev->node, &dev->class->devices);
 397                 up(&dev->class->sem);
 398         }
 399
 400         /* notify platform of device entry */
 401         if (platform_notify)
 402                 platform_notify(dev);
 403  Done:
 404         kfree(class_name);
 405         put_device(dev);
 406         return error;
 407  BusError:
 408         device_pm_remove(dev);
 409  PMError:
 410         device_remove_groups(dev);
 411  GroupError:
 412         if (dev->devt_attr) {
 413                 device_remove_file(dev, dev->devt_attr);
 414                 kfree(dev->devt_attr);
 415         }
 416  attrError:
 417         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
 418         kobject_del(&dev->kobj);
 419  Error:
 420         if (parent)
 421                 put_device(parent);
 422         goto Done;
 423 }
 424
 425
 426 /**
 427  *      device_register - register a device with the system.
 428  *      @dev:   pointer to the device structure
 429  *
 430  *      This happens in two clean steps - initialize the device
 431  *      and add it to the system. The two steps can be called
 432  *      separately, but this is the easiest and most common.
 433  *      I.e. you should only call the two helpers separately if
 434  *      have a clearly defined need to use and refcount the device
 435  *      before it is added to the hierarchy.
 436  */
 437
 438 int device_register(struct device *dev)
 439 {
 440         device_initialize(dev);
 441         return device_add(dev);
 442 }
 443
 444
 445 /**
 446  *      get_device - increment reference count for device.
 447  *      @dev:   device.
 448  *
 449  *      This simply forwards the call to kobject_get(), though
 450  *      we do take care to provide for the case that we get a NULL
 451  *      pointer passed in.
 452  */
 453
 454 struct device * get_device(struct device * dev)
 455 {
 456         return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
 457 }
 458
 459
 460 /**
 461  *      put_device - decrement reference count.
 462  *      @dev:   device in question.
 463  */
 464 void put_device(struct device * dev)
 465 {
 466         if (dev)
 467                 kobject_put(&dev->kobj);
 468 }
 469
 470
 471 /**
 472  *      device_del - delete device from system.
 473  *      @dev:   device.
 474  *
 475  *      This is the first part of the device unregistration
 476  *      sequence. This removes the device from the lists we control
 477  *      from here, has it removed from the other driver model
 478  *      subsystems it was added to in device_add(), and removes it
 479  *      from the kobject hierarchy.
 480  *
 481  *      NOTE: this should be called manually _iff_ device_add() was
 482  *      also called manually.
 483  */
 484
 485 void device_del(struct device * dev)
 486 {
 487         struct device * parent = dev->parent;
 488         char *class_name = NULL;
 489
 490         if (parent)
 491                 klist_del(&dev->knode_parent);
 492         if (dev->devt_attr)
 493                 device_remove_file(dev, dev->devt_attr);
 494         if (dev->class) {
 495                 sysfs_remove_link(&dev->kobj, "subsystem");
 496                 sysfs_remove_link(&dev->class->subsys.kset.kobj, dev->bus_id);
 497                 class_name = make_class_name(dev->class->name, &dev->kobj);
 498                 sysfs_remove_link(&dev->kobj, "device");
 499                 sysfs_remove_link(&dev->parent->kobj, class_name);
 500                 kfree(class_name);
 501                 down(&dev->class->sem);
 502                 list_del_init(&dev->node);
 503                 up(&dev->class->sem);
 504         }
 505         device_remove_file(dev, &dev->uevent_attr);
 506         device_remove_groups(dev);
 507
 508         /* Notify the platform of the removal, in case they
 509          * need to do anything...
 510          */
 511         if (platform_notify_remove)
 512                 platform_notify_remove(dev);
 513         bus_remove_device(dev);
 514         device_pm_remove(dev);
 515         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
 516         kobject_del(&dev->kobj);
 517         if (parent)
 518                 put_device(parent);
 519 }
 520
 521 /**
 522  *      device_unregister - unregister device from system.
 523  *      @dev:   device going away.
 524  *
 525  *      We do this in two parts, like we do device_register(). First,
 526  *      we remove it from all the subsystems with device_del(), then
 527  *      we decrement the reference count via put_device(). If that
 528  *      is the final reference count, the device will be cleaned up
 529  *      via device_release() above. Otherwise, the structure will
 530  *      stick around until the final reference to the device is dropped.
 531  */
 532 void device_unregister(struct device * dev)
 533 {
 534         pr_debug("DEV: Unregistering device. ID = '%s'\n", dev->bus_id);
 535         device_del(dev);
 536         put_device(dev);
 537 }
 538
 539
 540 static struct device * next_device(struct klist_iter * i)
 541 {
 542         struct klist_node * n = klist_next(i);
 543         return n ? container_of(n, struct device, knode_parent) : NULL;
 544 }
 545
 546 /**
 547  *      device_for_each_child - device child iterator.
 548  *      @parent: parent struct device.
 549  *      @data:  data for the callback.
 550  *      @fn:    function to be called for each device.
 551  *
 552  *      Iterate over @parent's child devices, and call @fn for each,
 553  *      passing it @data.
 554  *
 555  *      We check the return of @fn each time. If it returns anything
 556  *      other than 0, we break out and return that value.
 557  */
 558 int device_for_each_child(struct device * parent, void * data,
 559                      int (*fn)(struct device *, void *))
 560 {
 561         struct klist_iter i;
 562         struct device * child;
 563         int error = 0;
 564
 565         klist_iter_init(&parent->klist_children, &i);
 566         while ((child = next_device(&i)) && !error)
 567                 error = fn(child, data);
 568         klist_iter_exit(&i);
 569         return error;
 570 }
 571
 572 int __init devices_init(void)
 573 {
 574         return subsystem_register(&devices_subsys);
 575 }
 576
 577 EXPORT_SYMBOL_GPL(device_for_each_child);
 578
 579 EXPORT_SYMBOL_GPL(device_initialize);
 580 EXPORT_SYMBOL_GPL(device_add);
 581 EXPORT_SYMBOL_GPL(device_register);
 582
 583 EXPORT_SYMBOL_GPL(device_del);
 584 EXPORT_SYMBOL_GPL(device_unregister);
 585 EXPORT_SYMBOL_GPL(get_device);
 586 EXPORT_SYMBOL_GPL(put_device);
 587
 588 EXPORT_SYMBOL_GPL(device_create_file);
 589 EXPORT_SYMBOL_GPL(device_remove_file);
 590
 591
 592 static void device_create_release(struct device *dev)
 593 {
 594         pr_debug("%s called for %s\n", __FUNCTION__, dev->bus_id);
 595         kfree(dev);
 596 }
 597
 598 /**
 599  * device_create - creates a device and registers it with sysfs
 600  * @class: pointer to the struct class that this device should be registered to
 601  * @parent: pointer to the parent struct device of this new device, if any
 602  * @devt: the dev_t for the char device to be added
 603  * @fmt: string for the device's name
 604  *
 605  * This function can be used by char device classes.  A struct device
 606  * will be created in sysfs, registered to the specified class.
 607  *
 608  * A "dev" file will be created, showing the dev_t for the device, if
 609  * the dev_t is not 0,0.
 610  * If a pointer to a parent struct device is passed in, the newly created
 611  * struct device will be a child of that device in sysfs.
 612  * The pointer to the struct device will be returned from the call.
 613  * Any further sysfs files that might be required can be created using this
 614  * pointer.
 615  *
 616  * Note: the struct class passed to this function must have previously
 617  * been created with a call to class_create().
 618  */
 619 struct device *device_create(struct class *class, struct device *parent,
 620                              dev_t devt, const char *fmt, ...)
 621 {
 622         va_list args;
 623         struct device *dev = NULL;
 624         int retval = -ENODEV;
 625
 626         if (class == NULL || IS_ERR(class))
 627                 goto error;
 628         if (parent == NULL) {
 629                 printk(KERN_WARNING "%s does not work yet for NULL parents\n", __FUNCTION__);
 630                 goto error;
 631         }
 632
 633         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 634         if (!dev) {
 635                 retval = -ENOMEM;
 636                 goto error;
 637         }
 638
 639         dev->devt = devt;
 640         dev->class = class;
 641         dev->parent = parent;
 642         dev->release = device_create_release;
 643
 644         va_start(args, fmt);
 645         vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args);
 646         va_end(args);
 647         retval = device_register(dev);
 648         if (retval)
 649                 goto error;
 650
 651         return dev;
 652
 653 error:
 654         kfree(dev);
 655         return ERR_PTR(retval);
 656 }
 657 EXPORT_SYMBOL_GPL(device_create);
 658
 659 /**
 660  * device_destroy - removes a device that was created with device_create()
 661  * @class: pointer to the struct class that this device was registered with
 662  * @devt: the dev_t of the device that was previously registered
 663  *
 664  * This call unregisters and cleans up a device that was created with a
 665  * call to device_create().
 666  */
 667 void device_destroy(struct class *class, dev_t devt)
 668 {
 669         struct device *dev = NULL;
 670         struct device *dev_tmp;
 671
 672         down(&class->sem);
 673         list_for_each_entry(dev_tmp, &class->devices, node) {
 674                 if (dev_tmp->devt == devt) {
 675                         dev = dev_tmp;
 676                         break;
 677                 }
 678         }
 679         up(&class->sem);
 680
 681         if (dev)
 682                 device_unregister(dev);
 683 }
 684 EXPORT_SYMBOL_GPL(device_destroy);