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  * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
   7  * Copyright (c) 2006 Novell, Inc.
   8  *
   9  * This file is released under the GPLv2
  10  *
  11  */
  12
  13 #include <linux/device.h>
  14 #include <linux/err.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/string.h>
  19 #include <linux/kdev_t.h>
  20 #include <linux/notifier.h>
  21 #include <linux/genhd.h>
  22 #include <linux/kallsyms.h>
  23 #include <linux/semaphore.h>
  24 #include <linux/mutex.h>
  25 #include <linux/async.h>
  26
  27 #include "base.h"
  28 #include "power/power.h"
  29
  30 int (*platform_notify)(struct device *dev) = NULL;
  31 int (*platform_notify_remove)(struct device *dev) = NULL;
  32 static struct kobject *dev_kobj;
  33 struct kobject *sysfs_dev_char_kobj;
  34 struct kobject *sysfs_dev_block_kobj;
  35
  36 #ifdef CONFIG_BLOCK
  37 static inline int device_is_not_partition(struct device *dev)
  38 {
  39         return !(dev->type == &part_type);
  40 }
  41 #else
  42 static inline int device_is_not_partition(struct device *dev)
  43 {
  44         return 1;
  45 }
  46 #endif
  47
  48 /**
  49  * dev_driver_string - Return a device's driver name, if at all possible
  50  * @dev: struct device to get the name of
  51  *
  52  * Will return the device's driver's name if it is bound to a device.  If
  53  * the device is not bound to a device, it will return the name of the bus
  54  * it is attached to.  If it is not attached to a bus either, an empty
  55  * string will be returned.
  56  */
  57 const char *dev_driver_string(const struct device *dev)
  58 {
  59         struct device_driver *drv;
  60
  61         /* dev->driver can change to NULL underneath us because of unbinding,
  62          * so be careful about accessing it.  dev->bus and dev->class should
  63          * never change once they are set, so they don't need special care.
  64          */
  65         drv = ACCESS_ONCE(dev->driver);
  66         return drv ? drv->name :
  67                         (dev->bus ? dev->bus->name :
  68                         (dev->class ? dev->class->name : ""));
  69 }
  70 EXPORT_SYMBOL(dev_driver_string);
  71
  72 #define to_dev(obj) container_of(obj, struct device, kobj)
  73 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
  74
  75 static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
  76                              char *buf)
  77 {
  78         struct device_attribute *dev_attr = to_dev_attr(attr);
  79         struct device *dev = to_dev(kobj);
  80         ssize_t ret = -EIO;
  81
  82         if (dev_attr->show)
  83                 ret = dev_attr->show(dev, dev_attr, buf);
  84         if (ret >= (ssize_t)PAGE_SIZE) {
  85                 print_symbol("dev_attr_show: %s returned bad count\n",
  86                                 (unsigned long)dev_attr->show);
  87         }
  88         return ret;
  89 }
  90
  91 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
  92                               const char *buf, size_t count)
  93 {
  94         struct device_attribute *dev_attr = to_dev_attr(attr);
  95         struct device *dev = to_dev(kobj);
  96         ssize_t ret = -EIO;
  97
  98         if (dev_attr->store)
  99                 ret = dev_attr->store(dev, dev_attr, buf, count);
 100         return ret;
 101 }
 102
 103 static struct sysfs_ops dev_sysfs_ops = {
 104         .show   = dev_attr_show,
 105         .store  = dev_attr_store,
 106 };
 107
 108
 109 /**
 110  *      device_release - free device structure.
 111  *      @kobj:  device's kobject.
 112  *
 113  *      This is called once the reference count for the object
 114  *      reaches 0. We forward the call to the device's release
 115  *      method, which should handle actually freeing the structure.
 116  */
 117 static void device_release(struct kobject *kobj)
 118 {
 119         struct device *dev = to_dev(kobj);
 120         struct device_private *p = dev->p;
 121
 122         if (dev->release)
 123                 dev->release(dev);
 124         else if (dev->type && dev->type->release)
 125                 dev->type->release(dev);
 126         else if (dev->class && dev->class->dev_release)
 127                 dev->class->dev_release(dev);
 128         else
 129                 WARN(1, KERN_ERR "Device '%s' does not have a release() "
 130                         "function, it is broken and must be fixed.\n",
 131                         dev_name(dev));
 132         kfree(p);
 133 }
 134
 135 static struct kobj_type device_ktype = {
 136         .release        = device_release,
 137         .sysfs_ops      = &dev_sysfs_ops,
 138 };
 139
 140
 141 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
 142 {
 143         struct kobj_type *ktype = get_ktype(kobj);
 144
 145         if (ktype == &device_ktype) {
 146                 struct device *dev = to_dev(kobj);
 147                 if (dev->bus)
 148                         return 1;
 149                 if (dev->class)
 150                         return 1;
 151         }
 152         return 0;
 153 }
 154
 155 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
 156 {
 157         struct device *dev = to_dev(kobj);
 158
 159         if (dev->bus)
 160                 return dev->bus->name;
 161         if (dev->class)
 162                 return dev->class->name;
 163         return NULL;
 164 }
 165
 166 static int dev_uevent(struct kset *kset, struct kobject *kobj,
 167                       struct kobj_uevent_env *env)
 168 {
 169         struct device *dev = to_dev(kobj);
 170         int retval = 0;
 171
 172         /* add device node properties if present */
 173         if (MAJOR(dev->devt)) {
 174                 const char *tmp;
 175                 const char *name;
 176                 mode_t mode = 0;
 177
 178                 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
 179                 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
 180                 name = device_get_devnode(dev, &mode, &tmp);
 181                 if (name) {
 182                         add_uevent_var(env, "DEVNAME=%s", name);
 183                         kfree(tmp);
 184                         if (mode)
 185                                 add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
 186                 }
 187         }
 188
 189         if (dev->type && dev->type->name)
 190                 add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
 191
 192         if (dev->driver)
 193                 add_uevent_var(env, "DRIVER=%s", dev->driver->name);
 194
 195 #ifdef CONFIG_SYSFS_DEPRECATED
 196         if (dev->class) {
 197                 struct device *parent = dev->parent;
 198
 199                 /* find first bus device in parent chain */
 200                 while (parent && !parent->bus)
 201                         parent = parent->parent;
 202                 if (parent && parent->bus) {
 203                         const char *path;
 204
 205                         path = kobject_get_path(&parent->kobj, GFP_KERNEL);
 206                         if (path) {
 207                                 add_uevent_var(env, "PHYSDEVPATH=%s", path);
 208                                 kfree(path);
 209                         }
 210
 211                         add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name);
 212
 213                         if (parent->driver)
 214                                 add_uevent_var(env, "PHYSDEVDRIVER=%s",
 215                                                parent->driver->name);
 216                 }
 217         } else if (dev->bus) {
 218                 add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
 219
 220                 if (dev->driver)
 221                         add_uevent_var(env, "PHYSDEVDRIVER=%s",
 222                                        dev->driver->name);
 223         }
 224 #endif
 225
 226         /* have the bus specific function add its stuff */
 227         if (dev->bus && dev->bus->uevent) {
 228                 retval = dev->bus->uevent(dev, env);
 229                 if (retval)
 230                         pr_debug("device: '%s': %s: bus uevent() returned %d\n",
 231                                  dev_name(dev), __func__, retval);
 232         }
 233
 234         /* have the class specific function add its stuff */
 235         if (dev->class && dev->class->dev_uevent) {
 236                 retval = dev->class->dev_uevent(dev, env);
 237                 if (retval)
 238                         pr_debug("device: '%s': %s: class uevent() "
 239                                  "returned %d\n", dev_name(dev),
 240                                  __func__, retval);
 241         }
 242
 243         /* have the device type specific fuction add its stuff */
 244         if (dev->type && dev->type->uevent) {
 245                 retval = dev->type->uevent(dev, env);
 246                 if (retval)
 247                         pr_debug("device: '%s': %s: dev_type uevent() "
 248                                  "returned %d\n", dev_name(dev),
 249                                  __func__, retval);
 250         }
 251
 252         return retval;
 253 }
 254
 255 static struct kset_uevent_ops device_uevent_ops = {
 256         .filter =       dev_uevent_filter,
 257         .name =         dev_uevent_name,
 258         .uevent =       dev_uevent,
 259 };
 260
 261 static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
 262                            char *buf)
 263 {
 264         struct kobject *top_kobj;
 265         struct kset *kset;
 266         struct kobj_uevent_env *env = NULL;
 267         int i;
 268         size_t count = 0;
 269         int retval;
 270
 271         /* search the kset, the device belongs to */
 272         top_kobj = &dev->kobj;
 273         while (!top_kobj->kset && top_kobj->parent)
 274                 top_kobj = top_kobj->parent;
 275         if (!top_kobj->kset)
 276                 goto out;
 277
 278         kset = top_kobj->kset;
 279         if (!kset->uevent_ops || !kset->uevent_ops->uevent)
 280                 goto out;
 281
 282         /* respect filter */
 283         if (kset->uevent_ops && kset->uevent_ops->filter)
 284                 if (!kset->uevent_ops->filter(kset, &dev->kobj))
 285                         goto out;
 286
 287         env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
 288         if (!env)
 289                 return -ENOMEM;
 290
 291         /* let the kset specific function add its keys */
 292         retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
 293         if (retval)
 294                 goto out;
 295
 296         /* copy keys to file */
 297         for (i = 0; i < env->envp_idx; i++)
 298                 count += sprintf(&buf[count], "%s\n", env->envp[i]);
 299 out:
 300         kfree(env);
 301         return count;
 302 }
 303
 304 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
 305                             const char *buf, size_t count)
 306 {
 307         enum kobject_action action;
 308
 309         if (kobject_action_type(buf, count, &action) == 0) {
 310                 kobject_uevent(&dev->kobj, action);
 311                 goto out;
 312         }
 313
 314         dev_err(dev, "uevent: unsupported action-string; this will "
 315                      "be ignored in a future kernel version\n");
 316         kobject_uevent(&dev->kobj, KOBJ_ADD);
 317 out:
 318         return count;
 319 }
 320
 321 static struct device_attribute uevent_attr =
 322         __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
 323
 324 static int device_add_attributes(struct device *dev,
 325                                  struct device_attribute *attrs)
 326 {
 327         int error = 0;
 328         int i;
 329
 330         if (attrs) {
 331                 for (i = 0; attr_name(attrs[i]); i++) {
 332                         error = device_create_file(dev, &attrs[i]);
 333                         if (error)
 334                                 break;
 335                 }
 336                 if (error)
 337                         while (--i >= 0)
 338                                 device_remove_file(dev, &attrs[i]);
 339         }
 340         return error;
 341 }
 342
 343 static void device_remove_attributes(struct device *dev,
 344                                      struct device_attribute *attrs)
 345 {
 346         int i;
 347
 348         if (attrs)
 349                 for (i = 0; attr_name(attrs[i]); i++)
 350                         device_remove_file(dev, &attrs[i]);
 351 }
 352
 353 static int device_add_groups(struct device *dev,
 354                              const struct attribute_group **groups)
 355 {
 356         int error = 0;
 357         int i;
 358
 359         if (groups) {
 360                 for (i = 0; groups[i]; i++) {
 361                         error = sysfs_create_group(&dev->kobj, groups[i]);
 362                         if (error) {
 363                                 while (--i >= 0)
 364                                         sysfs_remove_group(&dev->kobj,
 365                                                            groups[i]);
 366                                 break;
 367                         }
 368                 }
 369         }
 370         return error;
 371 }
 372
 373 static void device_remove_groups(struct device *dev,
 374                                  const struct attribute_group **groups)
 375 {
 376         int i;
 377
 378         if (groups)
 379                 for (i = 0; groups[i]; i++)
 380                         sysfs_remove_group(&dev->kobj, groups[i]);
 381 }
 382
 383 static int device_add_attrs(struct device *dev)
 384 {
 385         struct class *class = dev->class;
 386         struct device_type *type = dev->type;
 387         int error;
 388
 389         if (class) {
 390                 error = device_add_attributes(dev, class->dev_attrs);
 391                 if (error)
 392                         return error;
 393         }
 394
 395         if (type) {
 396                 error = device_add_groups(dev, type->groups);
 397                 if (error)
 398                         goto err_remove_class_attrs;
 399         }
 400
 401         error = device_add_groups(dev, dev->groups);
 402         if (error)
 403                 goto err_remove_type_groups;
 404
 405         return 0;
 406
 407  err_remove_type_groups:
 408         if (type)
 409                 device_remove_groups(dev, type->groups);
 410  err_remove_class_attrs:
 411         if (class)
 412                 device_remove_attributes(dev, class->dev_attrs);
 413
 414         return error;
 415 }
 416
 417 static void device_remove_attrs(struct device *dev)
 418 {
 419         struct class *class = dev->class;
 420         struct device_type *type = dev->type;
 421
 422         device_remove_groups(dev, dev->groups);
 423
 424         if (type)
 425                 device_remove_groups(dev, type->groups);
 426
 427         if (class)
 428                 device_remove_attributes(dev, class->dev_attrs);
 429 }
 430
 431
 432 static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
 433                         char *buf)
 434 {
 435         return print_dev_t(buf, dev->devt);
 436 }
 437
 438 static struct device_attribute devt_attr =
 439         __ATTR(dev, S_IRUGO, show_dev, NULL);
 440
 441 /* kset to create /sys/devices/  */
 442 struct kset *devices_kset;
 443
 444 /**
 445  * device_create_file - create sysfs attribute file for device.
 446  * @dev: device.
 447  * @attr: device attribute descriptor.
 448  */
 449 int device_create_file(struct device *dev,
 450                        const struct device_attribute *attr)
 451 {
 452         int error = 0;
 453         if (dev)
 454                 error = sysfs_create_file(&dev->kobj, &attr->attr);
 455         return error;
 456 }
 457
 458 /**
 459  * device_remove_file - remove sysfs attribute file.
 460  * @dev: device.
 461  * @attr: device attribute descriptor.
 462  */
 463 void device_remove_file(struct device *dev,
 464                         const struct device_attribute *attr)
 465 {
 466         if (dev)
 467                 sysfs_remove_file(&dev->kobj, &attr->attr);
 468 }
 469
 470 /**
 471  * device_create_bin_file - create sysfs binary attribute file for device.
 472  * @dev: device.
 473  * @attr: device binary attribute descriptor.
 474  */
 475 int device_create_bin_file(struct device *dev,
 476                            const struct bin_attribute *attr)
 477 {
 478         int error = -EINVAL;
 479         if (dev)
 480                 error = sysfs_create_bin_file(&dev->kobj, attr);
 481         return error;
 482 }
 483 EXPORT_SYMBOL_GPL(device_create_bin_file);
 484
 485 /**
 486  * device_remove_bin_file - remove sysfs binary attribute file
 487  * @dev: device.
 488  * @attr: device binary attribute descriptor.
 489  */
 490 void device_remove_bin_file(struct device *dev,
 491                             const struct bin_attribute *attr)
 492 {
 493         if (dev)
 494                 sysfs_remove_bin_file(&dev->kobj, attr);
 495 }
 496 EXPORT_SYMBOL_GPL(device_remove_bin_file);
 497
 498 /**
 499  * device_schedule_callback_owner - helper to schedule a callback for a device
 500  * @dev: device.
 501  * @func: callback function to invoke later.
 502  * @owner: module owning the callback routine
 503  *
 504  * Attribute methods must not unregister themselves or their parent device
 505  * (which would amount to the same thing).  Attempts to do so will deadlock,
 506  * since unregistration is mutually exclusive with driver callbacks.
 507  *
 508  * Instead methods can call this routine, which will attempt to allocate
 509  * and schedule a workqueue request to call back @func with @dev as its
 510  * argument in the workqueue's process context.  @dev will be pinned until
 511  * @func returns.
 512  *
 513  * This routine is usually called via the inline device_schedule_callback(),
 514  * which automatically sets @owner to THIS_MODULE.
 515  *
 516  * Returns 0 if the request was submitted, -ENOMEM if storage could not
 517  * be allocated, -ENODEV if a reference to @owner isn't available.
 518  *
 519  * NOTE: This routine won't work if CONFIG_SYSFS isn't set!  It uses an
 520  * underlying sysfs routine (since it is intended for use by attribute
 521  * methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
 522  */
 523 int device_schedule_callback_owner(struct device *dev,
 524                 void (*func)(struct device *), struct module *owner)
 525 {
 526         return sysfs_schedule_callback(&dev->kobj,
 527                         (void (*)(void *)) func, dev, owner);
 528 }
 529 EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
 530
 531 static void klist_children_get(struct klist_node *n)
 532 {
 533         struct device_private *p = to_device_private_parent(n);
 534         struct device *dev = p->device;
 535
 536         get_device(dev);
 537 }
 538
 539 static void klist_children_put(struct klist_node *n)
 540 {
 541         struct device_private *p = to_device_private_parent(n);
 542         struct device *dev = p->device;
 543
 544         put_device(dev);
 545 }
 546
 547 /**
 548  * device_initialize - init device structure.
 549  * @dev: device.
 550  *
 551  * This prepares the device for use by other layers by initializing
 552  * its fields.
 553  * It is the first half of device_register(), if called by
 554  * that function, though it can also be called separately, so one
 555  * may use @dev's fields. In particular, get_device()/put_device()
 556  * may be used for reference counting of @dev after calling this
 557  * function.
 558  *
 559  * NOTE: Use put_device() to give up your reference instead of freeing
 560  * @dev directly once you have called this function.
 561  */
 562 void device_initialize(struct device *dev)
 563 {
 564         dev->kobj.kset = devices_kset;
 565         kobject_init(&dev->kobj, &device_ktype);
 566         INIT_LIST_HEAD(&dev->dma_pools);
 567         init_MUTEX(&dev->sem);
 568         spin_lock_init(&dev->devres_lock);
 569         INIT_LIST_HEAD(&dev->devres_head);
 570         device_init_wakeup(dev, 0);
 571         device_pm_init(dev);
 572         set_dev_node(dev, -1);
 573 }
 574
 575 #ifdef CONFIG_SYSFS_DEPRECATED
 576 static struct kobject *get_device_parent(struct device *dev,
 577                                          struct device *parent)
 578 {
 579         /* class devices without a parent live in /sys/class/<classname>/ */
 580         if (dev->class && (!parent || parent->class != dev->class))
 581                 return &dev->class->p->class_subsys.kobj;
 582         /* all other devices keep their parent */
 583         else if (parent)
 584                 return &parent->kobj;
 585
 586         return NULL;
 587 }
 588
 589 static inline void cleanup_device_parent(struct device *dev) {}
 590 static inline void cleanup_glue_dir(struct device *dev,
 591                                     struct kobject *glue_dir) {}
 592 #else
 593 static struct kobject *virtual_device_parent(struct device *dev)
 594 {
 595         static struct kobject *virtual_dir = NULL;
 596
 597         if (!virtual_dir)
 598                 virtual_dir = kobject_create_and_add("virtual",
 599                                                      &devices_kset->kobj);
 600
 601         return virtual_dir;
 602 }
 603
 604 static struct kobject *get_device_parent(struct device *dev,
 605                                          struct device *parent)
 606 {
 607         int retval;
 608
 609         if (dev->class) {
 610                 struct kobject *kobj = NULL;
 611                 struct kobject *parent_kobj;
 612                 struct kobject *k;
 613
 614                 /*
 615                  * If we have no parent, we live in "virtual".
 616                  * Class-devices with a non class-device as parent, live
 617                  * in a "glue" directory to prevent namespace collisions.
 618                  */
 619                 if (parent == NULL)
 620                         parent_kobj = virtual_device_parent(dev);
 621                 else if (parent->class)
 622                         return &parent->kobj;
 623                 else
 624                         parent_kobj = &parent->kobj;
 625
 626                 /* find our class-directory at the parent and reference it */
 627                 spin_lock(&dev->class->p->class_dirs.list_lock);
 628                 list_for_each_entry(k, &dev->class->p->class_dirs.list, entry)
 629                         if (k->parent == parent_kobj) {
 630                                 kobj = kobject_get(k);
 631                                 break;
 632                         }
 633                 spin_unlock(&dev->class->p->class_dirs.list_lock);
 634                 if (kobj)
 635                         return kobj;
 636
 637                 /* or create a new class-directory at the parent device */
 638                 k = kobject_create();
 639                 if (!k)
 640                         return NULL;
 641                 k->kset = &dev->class->p->class_dirs;
 642                 retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
 643                 if (retval < 0) {
 644                         kobject_put(k);
 645                         return NULL;
 646                 }
 647                 /* do not emit an uevent for this simple "glue" directory */
 648                 return k;
 649         }
 650
 651         if (parent)
 652                 return &parent->kobj;
 653         return NULL;
 654 }
 655
 656 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
 657 {
 658         /* see if we live in a "glue" directory */
 659         if (!glue_dir || !dev->class ||
 660             glue_dir->kset != &dev->class->p->class_dirs)
 661                 return;
 662
 663         kobject_put(glue_dir);
 664 }
 665
 666 static void cleanup_device_parent(struct device *dev)
 667 {
 668         cleanup_glue_dir(dev, dev->kobj.parent);
 669 }
 670 #endif
 671
 672 static void setup_parent(struct device *dev, struct device *parent)
 673 {
 674         struct kobject *kobj;
 675         kobj = get_device_parent(dev, parent);
 676         if (kobj)
 677                 dev->kobj.parent = kobj;
 678 }
 679
 680 static int device_add_class_symlinks(struct device *dev)
 681 {
 682         int error;
 683
 684         if (!dev->class)
 685                 return 0;
 686
 687         error = sysfs_create_link(&dev->kobj,
 688                                   &dev->class->p->class_subsys.kobj,
 689                                   "subsystem");
 690         if (error)
 691                 goto out;
 692
 693 #ifdef CONFIG_SYSFS_DEPRECATED
 694         /* stacked class devices need a symlink in the class directory */
 695         if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
 696             device_is_not_partition(dev)) {
 697                 error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
 698                                           &dev->kobj, dev_name(dev));
 699                 if (error)
 700                         goto out_subsys;
 701         }
 702
 703         if (dev->parent && device_is_not_partition(dev)) {
 704                 struct device *parent = dev->parent;
 705                 char *class_name;
 706
 707                 /*
 708                  * stacked class devices have the 'device' link
 709                  * pointing to the bus device instead of the parent
 710                  */
 711                 while (parent->class && !parent->bus && parent->parent)
 712                         parent = parent->parent;
 713
 714                 error = sysfs_create_link(&dev->kobj,
 715                                           &parent->kobj,
 716                                           "device");
 717                 if (error)
 718                         goto out_busid;
 719
 720                 class_name = make_class_name(dev->class->name,
 721                                                 &dev->kobj);
 722                 if (class_name)
 723                         error = sysfs_create_link(&dev->parent->kobj,
 724                                                 &dev->kobj, class_name);
 725                 kfree(class_name);
 726                 if (error)
 727                         goto out_device;
 728         }
 729         return 0;
 730
 731 out_device:
 732         if (dev->parent && device_is_not_partition(dev))
 733                 sysfs_remove_link(&dev->kobj, "device");
 734 out_busid:
 735         if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
 736             device_is_not_partition(dev))
 737                 sysfs_remove_link(&dev->class->p->class_subsys.kobj,
 738                                   dev_name(dev));
 739 #else
 740         /* link in the class directory pointing to the device */
 741         error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
 742                                   &dev->kobj, dev_name(dev));
 743         if (error)
 744                 goto out_subsys;
 745
 746         if (dev->parent && device_is_not_partition(dev)) {
 747                 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
 748                                           "device");
 749                 if (error)
 750                         goto out_busid;
 751         }
 752         return 0;
 753
 754 out_busid:
 755         sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
 756 #endif
 757
 758 out_subsys:
 759         sysfs_remove_link(&dev->kobj, "subsystem");
 760 out:
 761         return error;
 762 }
 763
 764 static void device_remove_class_symlinks(struct device *dev)
 765 {
 766         if (!dev->class)
 767                 return;
 768
 769 #ifdef CONFIG_SYSFS_DEPRECATED
 770         if (dev->parent && device_is_not_partition(dev)) {
 771                 char *class_name;
 772
 773                 class_name = make_class_name(dev->class->name, &dev->kobj);
 774                 if (class_name) {
 775                         sysfs_remove_link(&dev->parent->kobj, class_name);
 776                         kfree(class_name);
 777                 }
 778                 sysfs_remove_link(&dev->kobj, "device");
 779         }
 780
 781         if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
 782             device_is_not_partition(dev))
 783                 sysfs_remove_link(&dev->class->p->class_subsys.kobj,
 784                                   dev_name(dev));
 785 #else
 786         if (dev->parent && device_is_not_partition(dev))
 787                 sysfs_remove_link(&dev->kobj, "device");
 788
 789         sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
 790 #endif
 791
 792         sysfs_remove_link(&dev->kobj, "subsystem");
 793 }
 794
 795 /**
 796  * dev_set_name - set a device name
 797  * @dev: device
 798  * @fmt: format string for the device's name
 799  */
 800 int dev_set_name(struct device *dev, const char *fmt, ...)
 801 {
 802         va_list vargs;
 803         int err;
 804
 805         va_start(vargs, fmt);
 806         err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
 807         va_end(vargs);
 808         return err;
 809 }
 810 EXPORT_SYMBOL_GPL(dev_set_name);
 811
 812 /**
 813  * device_to_dev_kobj - select a /sys/dev/ directory for the device
 814  * @dev: device
 815  *
 816  * By default we select char/ for new entries.  Setting class->dev_obj
 817  * to NULL prevents an entry from being created.  class->dev_kobj must
 818  * be set (or cleared) before any devices are registered to the class
 819  * otherwise device_create_sys_dev_entry() and
 820  * device_remove_sys_dev_entry() will disagree about the the presence
 821  * of the link.
 822  */
 823 static struct kobject *device_to_dev_kobj(struct device *dev)
 824 {
 825         struct kobject *kobj;
 826
 827         if (dev->class)
 828                 kobj = dev->class->dev_kobj;
 829         else
 830                 kobj = sysfs_dev_char_kobj;
 831
 832         return kobj;
 833 }
 834
 835 static int device_create_sys_dev_entry(struct device *dev)
 836 {
 837         struct kobject *kobj = device_to_dev_kobj(dev);
 838         int error = 0;
 839         char devt_str[15];
 840
 841         if (kobj) {
 842                 format_dev_t(devt_str, dev->devt);
 843                 error = sysfs_create_link(kobj, &dev->kobj, devt_str);
 844         }
 845
 846         return error;
 847 }
 848
 849 static void device_remove_sys_dev_entry(struct device *dev)
 850 {
 851         struct kobject *kobj = device_to_dev_kobj(dev);
 852         char devt_str[15];
 853
 854         if (kobj) {
 855                 format_dev_t(devt_str, dev->devt);
 856                 sysfs_remove_link(kobj, devt_str);
 857         }
 858 }
 859
 860 int device_private_init(struct device *dev)
 861 {
 862         dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
 863         if (!dev->p)
 864                 return -ENOMEM;
 865         dev->p->device = dev;
 866         klist_init(&dev->p->klist_children, klist_children_get,
 867                    klist_children_put);
 868         return 0;
 869 }
 870
 871 /**
 872  * device_add - add device to device hierarchy.
 873  * @dev: device.
 874  *
 875  * This is part 2 of device_register(), though may be called
 876  * separately _iff_ device_initialize() has been called separately.
 877  *
 878  * This adds @dev to the kobject hierarchy via kobject_add(), adds it
 879  * to the global and sibling lists for the device, then
 880  * adds it to the other relevant subsystems of the driver model.
 881  *
 882  * NOTE: _Never_ directly free @dev after calling this function, even
 883  * if it returned an error! Always use put_device() to give up your
 884  * reference instead.
 885  */
 886 int device_add(struct device *dev)
 887 {
 888         struct device *parent = NULL;
 889         struct class_interface *class_intf;
 890         int error = -EINVAL;
 891
 892         dev = get_device(dev);
 893         if (!dev)
 894                 goto done;
 895
 896         if (!dev->p) {
 897                 error = device_private_init(dev);
 898                 if (error)
 899                         goto done;
 900         }
 901
 902         /*
 903          * for statically allocated devices, which should all be converted
 904          * some day, we need to initialize the name. We prevent reading back
 905          * the name, and force the use of dev_name()
 906          */
 907         if (dev->init_name) {
 908                 dev_set_name(dev, "%s", dev->init_name);
 909                 dev->init_name = NULL;
 910         }
 911
 912         if (!dev_name(dev)) {
 913                 error = -EINVAL;
 914                 goto name_error;
 915         }
 916
 917         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
 918
 919         parent = get_device(dev->parent);
 920         setup_parent(dev, parent);
 921
 922         /* use parent numa_node */
 923         if (parent)
 924                 set_dev_node(dev, dev_to_node(parent));
 925
 926         /* first, register with generic layer. */
 927         /* we require the name to be set before, and pass NULL */
 928         error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
 929         if (error)
 930                 goto Error;
 931
 932         /* notify platform of device entry */
 933         if (platform_notify)
 934                 platform_notify(dev);
 935
 936         error = device_create_file(dev, &uevent_attr);
 937         if (error)
 938                 goto attrError;
 939
 940         if (MAJOR(dev->devt)) {
 941                 error = device_create_file(dev, &devt_attr);
 942                 if (error)
 943                         goto ueventattrError;
 944
 945                 error = device_create_sys_dev_entry(dev);
 946                 if (error)
 947                         goto devtattrError;
 948
 949                 devtmpfs_create_node(dev);
 950         }
 951
 952         error = device_add_class_symlinks(dev);
 953         if (error)
 954                 goto SymlinkError;
 955         error = device_add_attrs(dev);
 956         if (error)
 957                 goto AttrsError;
 958         error = bus_add_device(dev);
 959         if (error)
 960                 goto BusError;
 961         error = dpm_sysfs_add(dev);
 962         if (error)
 963                 goto DPMError;
 964         device_pm_add(dev);
 965
 966         /* Notify clients of device addition.  This call must come
 967          * after dpm_sysf_add() and before kobject_uevent().
 968          */
 969         if (dev->bus)
 970                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
 971                                              BUS_NOTIFY_ADD_DEVICE, dev);
 972
 973         kobject_uevent(&dev->kobj, KOBJ_ADD);
 974         bus_probe_device(dev);
 975         if (parent)
 976                 klist_add_tail(&dev->p->knode_parent,
 977                                &parent->p->klist_children);
 978
 979         if (dev->class) {
 980                 mutex_lock(&dev->class->p->class_mutex);
 981                 /* tie the class to the device */
 982                 klist_add_tail(&dev->knode_class,
 983                                &dev->class->p->class_devices);
 984
 985                 /* notify any interfaces that the device is here */
 986                 list_for_each_entry(class_intf,
 987                                     &dev->class->p->class_interfaces, node)
 988                         if (class_intf->add_dev)
 989                                 class_intf->add_dev(dev, class_intf);
 990                 mutex_unlock(&dev->class->p->class_mutex);
 991         }
 992 done:
 993         put_device(dev);
 994         return error;
 995  DPMError:
 996         bus_remove_device(dev);
 997  BusError:
 998         device_remove_attrs(dev);
 999  AttrsError:
1000         device_remove_class_symlinks(dev);
1001  SymlinkError:
1002         if (MAJOR(dev->devt))
1003                 devtmpfs_delete_node(dev);
1004         if (MAJOR(dev->devt))
1005                 device_remove_sys_dev_entry(dev);
1006  devtattrError:
1007         if (MAJOR(dev->devt))
1008                 device_remove_file(dev, &devt_attr);
1009  ueventattrError:
1010         device_remove_file(dev, &uevent_attr);
1011  attrError:
1012         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1013         kobject_del(&dev->kobj);
1014  Error:
1015         cleanup_device_parent(dev);
1016         if (parent)
1017                 put_device(parent);
1018 name_error:
1019         kfree(dev->p);
1020         dev->p = NULL;
1021         goto done;
1022 }
1023
1024 /**
1025  * device_register - register a device with the system.
1026  * @dev: pointer to the device structure
1027  *
1028  * This happens in two clean steps - initialize the device
1029  * and add it to the system. The two steps can be called
1030  * separately, but this is the easiest and most common.
1031  * I.e. you should only call the two helpers separately if
1032  * have a clearly defined need to use and refcount the device
1033  * before it is added to the hierarchy.
1034  *
1035  * NOTE: _Never_ directly free @dev after calling this function, even
1036  * if it returned an error! Always use put_device() to give up the
1037  * reference initialized in this function instead.
1038  */
1039 int device_register(struct device *dev)
1040 {
1041         device_initialize(dev);
1042         return device_add(dev);
1043 }
1044
1045 /**
1046  * get_device - increment reference count for device.
1047  * @dev: device.
1048  *
1049  * This simply forwards the call to kobject_get(), though
1050  * we do take care to provide for the case that we get a NULL
1051  * pointer passed in.
1052  */
1053 struct device *get_device(struct device *dev)
1054 {
1055         return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
1056 }
1057
1058 /**
1059  * put_device - decrement reference count.
1060  * @dev: device in question.
1061  */
1062 void put_device(struct device *dev)
1063 {
1064         /* might_sleep(); */
1065         if (dev)
1066                 kobject_put(&dev->kobj);
1067 }
1068
1069 /**
1070  * device_del - delete device from system.
1071  * @dev: device.
1072  *
1073  * This is the first part of the device unregistration
1074  * sequence. This removes the device from the lists we control
1075  * from here, has it removed from the other driver model
1076  * subsystems it was added to in device_add(), and removes it
1077  * from the kobject hierarchy.
1078  *
1079  * NOTE: this should be called manually _iff_ device_add() was
1080  * also called manually.
1081  */
1082 void device_del(struct device *dev)
1083 {
1084         struct device *parent = dev->parent;
1085         struct class_interface *class_intf;
1086
1087         /* Notify clients of device removal.  This call must come
1088          * before dpm_sysfs_remove().
1089          */
1090         if (dev->bus)
1091                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1092                                              BUS_NOTIFY_DEL_DEVICE, dev);
1093         device_pm_remove(dev);
1094         dpm_sysfs_remove(dev);
1095         if (parent)
1096                 klist_del(&dev->p->knode_parent);
1097         if (MAJOR(dev->devt)) {
1098                 devtmpfs_delete_node(dev);
1099                 device_remove_sys_dev_entry(dev);
1100                 device_remove_file(dev, &devt_attr);
1101         }
1102         if (dev->class) {
1103                 device_remove_class_symlinks(dev);
1104
1105                 mutex_lock(&dev->class->p->class_mutex);
1106                 /* notify any interfaces that the device is now gone */
1107                 list_for_each_entry(class_intf,
1108                                     &dev->class->p->class_interfaces, node)
1109                         if (class_intf->remove_dev)
1110                                 class_intf->remove_dev(dev, class_intf);
1111                 /* remove the device from the class list */
1112                 klist_del(&dev->knode_class);
1113                 mutex_unlock(&dev->class->p->class_mutex);
1114         }
1115         device_remove_file(dev, &uevent_attr);
1116         device_remove_attrs(dev);
1117         bus_remove_device(dev);
1118
1119         /*
1120          * Some platform devices are driven without driver attached
1121          * and managed resources may have been acquired.  Make sure
1122          * all resources are released.
1123          */
1124         devres_release_all(dev);
1125
1126         /* Notify the platform of the removal, in case they
1127          * need to do anything...
1128          */
1129         if (platform_notify_remove)
1130                 platform_notify_remove(dev);
1131         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1132         cleanup_device_parent(dev);
1133         kobject_del(&dev->kobj);
1134         put_device(parent);
1135 }
1136
1137 /**
1138  * device_unregister - unregister device from system.
1139  * @dev: device going away.
1140  *
1141  * We do this in two parts, like we do device_register(). First,
1142  * we remove it from all the subsystems with device_del(), then
1143  * we decrement the reference count via put_device(). If that
1144  * is the final reference count, the device will be cleaned up
1145  * via device_release() above. Otherwise, the structure will
1146  * stick around until the final reference to the device is dropped.
1147  */
1148 void device_unregister(struct device *dev)
1149 {
1150         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1151         device_del(dev);
1152         put_device(dev);
1153 }
1154
1155 static struct device *next_device(struct klist_iter *i)
1156 {
1157         struct klist_node *n = klist_next(i);
1158         struct device *dev = NULL;
1159         struct device_private *p;
1160
1161         if (n) {
1162                 p = to_device_private_parent(n);
1163                 dev = p->device;
1164         }
1165         return dev;
1166 }
1167
1168 /**
1169  * device_get_devnode - path of device node file
1170  * @dev: device
1171  * @mode: returned file access mode
1172  * @tmp: possibly allocated string
1173  *
1174  * Return the relative path of a possible device node.
1175  * Non-default names may need to allocate a memory to compose
1176  * a name. This memory is returned in tmp and needs to be
1177  * freed by the caller.
1178  */
1179 const char *device_get_devnode(struct device *dev,
1180                                mode_t *mode, const char **tmp)
1181 {
1182         char *s;
1183
1184         *tmp = NULL;
1185
1186         /* the device type may provide a specific name */
1187         if (dev->type && dev->type->devnode)
1188                 *tmp = dev->type->devnode(dev, mode);
1189         if (*tmp)
1190                 return *tmp;
1191
1192         /* the class may provide a specific name */
1193         if (dev->class && dev->class->devnode)
1194                 *tmp = dev->class->devnode(dev, mode);
1195         if (*tmp)
1196                 return *tmp;
1197
1198         /* return name without allocation, tmp == NULL */
1199         if (strchr(dev_name(dev), '!') == NULL)
1200                 return dev_name(dev);
1201
1202         /* replace '!' in the name with '/' */
1203         *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1204         if (!*tmp)
1205                 return NULL;
1206         while ((s = strchr(*tmp, '!')))
1207                 s[0] = '/';
1208         return *tmp;
1209 }
1210
1211 /**
1212  * device_for_each_child - device child iterator.
1213  * @parent: parent struct device.
1214  * @data: data for the callback.
1215  * @fn: function to be called for each device.
1216  *
1217  * Iterate over @parent's child devices, and call @fn for each,
1218  * passing it @data.
1219  *
1220  * We check the return of @fn each time. If it returns anything
1221  * other than 0, we break out and return that value.
1222  */
1223 int device_for_each_child(struct device *parent, void *data,
1224                           int (*fn)(struct device *dev, void *data))
1225 {
1226         struct klist_iter i;
1227         struct device *child;
1228         int error = 0;
1229
1230         if (!parent->p)
1231                 return 0;
1232
1233         klist_iter_init(&parent->p->klist_children, &i);
1234         while ((child = next_device(&i)) && !error)
1235                 error = fn(child, data);
1236         klist_iter_exit(&i);
1237         return error;
1238 }
1239
1240 /**
1241  * device_find_child - device iterator for locating a particular device.
1242  * @parent: parent struct device
1243  * @data: Data to pass to match function
1244  * @match: Callback function to check device
1245  *
1246  * This is similar to the device_for_each_child() function above, but it
1247  * returns a reference to a device that is 'found' for later use, as
1248  * determined by the @match callback.
1249  *
1250  * The callback should return 0 if the device doesn't match and non-zero
1251  * if it does.  If the callback returns non-zero and a reference to the
1252  * current device can be obtained, this function will return to the caller
1253  * and not iterate over any more devices.
1254  */
1255 struct device *device_find_child(struct device *parent, void *data,
1256                                  int (*match)(struct device *dev, void *data))
1257 {
1258         struct klist_iter i;
1259         struct device *child;
1260
1261         if (!parent)
1262                 return NULL;
1263
1264         klist_iter_init(&parent->p->klist_children, &i);
1265         while ((child = next_device(&i)))
1266                 if (match(child, data) && get_device(child))
1267                         break;
1268         klist_iter_exit(&i);
1269         return child;
1270 }
1271
1272 int __init devices_init(void)
1273 {
1274         devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1275         if (!devices_kset)
1276                 return -ENOMEM;
1277         dev_kobj = kobject_create_and_add("dev", NULL);
1278         if (!dev_kobj)
1279                 goto dev_kobj_err;
1280         sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1281         if (!sysfs_dev_block_kobj)
1282                 goto block_kobj_err;
1283         sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1284         if (!sysfs_dev_char_kobj)
1285                 goto char_kobj_err;
1286
1287         return 0;
1288
1289  char_kobj_err:
1290         kobject_put(sysfs_dev_block_kobj);
1291  block_kobj_err:
1292         kobject_put(dev_kobj);
1293  dev_kobj_err:
1294         kset_unregister(devices_kset);
1295         return -ENOMEM;
1296 }
1297
1298 EXPORT_SYMBOL_GPL(device_for_each_child);
1299 EXPORT_SYMBOL_GPL(device_find_child);
1300
1301 EXPORT_SYMBOL_GPL(device_initialize);
1302 EXPORT_SYMBOL_GPL(device_add);
1303 EXPORT_SYMBOL_GPL(device_register);
1304
1305 EXPORT_SYMBOL_GPL(device_del);
1306 EXPORT_SYMBOL_GPL(device_unregister);
1307 EXPORT_SYMBOL_GPL(get_device);
1308 EXPORT_SYMBOL_GPL(put_device);
1309
1310 EXPORT_SYMBOL_GPL(device_create_file);
1311 EXPORT_SYMBOL_GPL(device_remove_file);
1312
1313 struct root_device
1314 {
1315         struct device dev;
1316         struct module *owner;
1317 };
1318
1319 #define to_root_device(dev) container_of(dev, struct root_device, dev)
1320
1321 static void root_device_release(struct device *dev)
1322 {
1323         kfree(to_root_device(dev));
1324 }
1325
1326 /**
1327  * __root_device_register - allocate and register a root device
1328  * @name: root device name
1329  * @owner: owner module of the root device, usually THIS_MODULE
1330  *
1331  * This function allocates a root device and registers it
1332  * using device_register(). In order to free the returned
1333  * device, use root_device_unregister().
1334  *
1335  * Root devices are dummy devices which allow other devices
1336  * to be grouped under /sys/devices. Use this function to
1337  * allocate a root device and then use it as the parent of
1338  * any device which should appear under /sys/devices/{name}
1339  *
1340  * The /sys/devices/{name} directory will also contain a
1341  * 'module' symlink which points to the @owner directory
1342  * in sysfs.
1343  *
1344  * Note: You probably want to use root_device_register().
1345  */
1346 struct device *__root_device_register(const char *name, struct module *owner)
1347 {
1348         struct root_device *root;
1349         int err = -ENOMEM;
1350
1351         root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1352         if (!root)
1353                 return ERR_PTR(err);
1354
1355         err = dev_set_name(&root->dev, "%s", name);
1356         if (err) {
1357                 kfree(root);
1358                 return ERR_PTR(err);
1359         }
1360
1361         root->dev.release = root_device_release;
1362
1363         err = device_register(&root->dev);
1364         if (err) {
1365                 put_device(&root->dev);
1366                 return ERR_PTR(err);
1367         }
1368
1369 #ifdef CONFIG_MODULE    /* gotta find a "cleaner" way to do this */
1370         if (owner) {
1371                 struct module_kobject *mk = &owner->mkobj;
1372
1373                 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1374                 if (err) {
1375                         device_unregister(&root->dev);
1376                         return ERR_PTR(err);
1377                 }
1378                 root->owner = owner;
1379         }
1380 #endif
1381
1382         return &root->dev;
1383 }
1384 EXPORT_SYMBOL_GPL(__root_device_register);
1385
1386 /**
1387  * root_device_unregister - unregister and free a root device
1388  * @dev: device going away
1389  *
1390  * This function unregisters and cleans up a device that was created by
1391  * root_device_register().
1392  */
1393 void root_device_unregister(struct device *dev)
1394 {
1395         struct root_device *root = to_root_device(dev);
1396
1397         if (root->owner)
1398                 sysfs_remove_link(&root->dev.kobj, "module");
1399
1400         device_unregister(dev);
1401 }
1402 EXPORT_SYMBOL_GPL(root_device_unregister);
1403
1404
1405 static void device_create_release(struct device *dev)
1406 {
1407         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1408         kfree(dev);
1409 }
1410
1411 /**
1412  * device_create_vargs - creates a device and registers it with sysfs
1413  * @class: pointer to the struct class that this device should be registered to
1414  * @parent: pointer to the parent struct device of this new device, if any
1415  * @devt: the dev_t for the char device to be added
1416  * @drvdata: the data to be added to the device for callbacks
1417  * @fmt: string for the device's name
1418  * @args: va_list for the device's name
1419  *
1420  * This function can be used by char device classes.  A struct device
1421  * will be created in sysfs, registered to the specified class.
1422  *
1423  * A "dev" file will be created, showing the dev_t for the device, if
1424  * the dev_t is not 0,0.
1425  * If a pointer to a parent struct device is passed in, the newly created
1426  * struct device will be a child of that device in sysfs.
1427  * The pointer to the struct device will be returned from the call.
1428  * Any further sysfs files that might be required can be created using this
1429  * pointer.
1430  *
1431  * Note: the struct class passed to this function must have previously
1432  * been created with a call to class_create().
1433  */
1434 struct device *device_create_vargs(struct class *class, struct device *parent,
1435                                    dev_t devt, void *drvdata, const char *fmt,
1436                                    va_list args)
1437 {
1438         struct device *dev = NULL;
1439         int retval = -ENODEV;
1440
1441         if (class == NULL || IS_ERR(class))
1442                 goto error;
1443
1444         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1445         if (!dev) {
1446                 retval = -ENOMEM;
1447                 goto error;
1448         }
1449
1450         dev->devt = devt;
1451         dev->class = class;
1452         dev->parent = parent;
1453         dev->release = device_create_release;
1454         dev_set_drvdata(dev, drvdata);
1455
1456         retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1457         if (retval)
1458                 goto error;
1459
1460         retval = device_register(dev);
1461         if (retval)
1462                 goto error;
1463
1464         return dev;
1465
1466 error:
1467         put_device(dev);
1468         return ERR_PTR(retval);
1469 }
1470 EXPORT_SYMBOL_GPL(device_create_vargs);
1471
1472 /**
1473  * device_create - creates a device and registers it with sysfs
1474  * @class: pointer to the struct class that this device should be registered to
1475  * @parent: pointer to the parent struct device of this new device, if any
1476  * @devt: the dev_t for the char device to be added
1477  * @drvdata: the data to be added to the device for callbacks
1478  * @fmt: string for the device's name
1479  *
1480  * This function can be used by char device classes.  A struct device
1481  * will be created in sysfs, registered to the specified class.
1482  *
1483  * A "dev" file will be created, showing the dev_t for the device, if
1484  * the dev_t is not 0,0.
1485  * If a pointer to a parent struct device is passed in, the newly created
1486  * struct device will be a child of that device in sysfs.
1487  * The pointer to the struct device will be returned from the call.
1488  * Any further sysfs files that might be required can be created using this
1489  * pointer.
1490  *
1491  * Note: the struct class passed to this function must have previously
1492  * been created with a call to class_create().
1493  */
1494 struct device *device_create(struct class *class, struct device *parent,
1495                              dev_t devt, void *drvdata, const char *fmt, ...)
1496 {
1497         va_list vargs;
1498         struct device *dev;
1499
1500         va_start(vargs, fmt);
1501         dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1502         va_end(vargs);
1503         return dev;
1504 }
1505 EXPORT_SYMBOL_GPL(device_create);
1506
1507 static int __match_devt(struct device *dev, void *data)
1508 {
1509         dev_t *devt = data;
1510
1511         return dev->devt == *devt;
1512 }
1513
1514 /**
1515  * device_destroy - removes a device that was created with device_create()
1516  * @class: pointer to the struct class that this device was registered with
1517  * @devt: the dev_t of the device that was previously registered
1518  *
1519  * This call unregisters and cleans up a device that was created with a
1520  * call to device_create().
1521  */
1522 void device_destroy(struct class *class, dev_t devt)
1523 {
1524         struct device *dev;
1525
1526         dev = class_find_device(class, NULL, &devt, __match_devt);
1527         if (dev) {
1528                 put_device(dev);
1529                 device_unregister(dev);
1530         }
1531 }
1532 EXPORT_SYMBOL_GPL(device_destroy);
1533
1534 /**
1535  * device_rename - renames a device
1536  * @dev: the pointer to the struct device to be renamed
1537  * @new_name: the new name of the device
1538  *
1539  * It is the responsibility of the caller to provide mutual
1540  * exclusion between two different calls of device_rename
1541  * on the same device to ensure that new_name is valid and
1542  * won't conflict with other devices.
1543  */
1544 int device_rename(struct device *dev, char *new_name)
1545 {
1546         char *old_class_name = NULL;
1547         char *new_class_name = NULL;
1548         char *old_device_name = NULL;
1549         int error;
1550
1551         dev = get_device(dev);
1552         if (!dev)
1553                 return -EINVAL;
1554
1555         pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
1556                  __func__, new_name);
1557
1558 #ifdef CONFIG_SYSFS_DEPRECATED
1559         if ((dev->class) && (dev->parent))
1560                 old_class_name = make_class_name(dev->class->name, &dev->kobj);
1561 #endif
1562
1563         old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1564         if (!old_device_name) {
1565                 error = -ENOMEM;
1566                 goto out;
1567         }
1568
1569         error = kobject_rename(&dev->kobj, new_name);
1570         if (error)
1571                 goto out;
1572
1573 #ifdef CONFIG_SYSFS_DEPRECATED
1574         if (old_class_name) {
1575                 new_class_name = make_class_name(dev->class->name, &dev->kobj);
1576                 if (new_class_name) {
1577                         error = sysfs_create_link_nowarn(&dev->parent->kobj,
1578                                                          &dev->kobj,
1579                                                          new_class_name);
1580                         if (error)
1581                                 goto out;
1582                         sysfs_remove_link(&dev->parent->kobj, old_class_name);
1583                 }
1584         }
1585 #else
1586         if (dev->class) {
1587                 error = sysfs_create_link_nowarn(&dev->class->p->class_subsys.kobj,
1588                                                  &dev->kobj, dev_name(dev));
1589                 if (error)
1590                         goto out;
1591                 sysfs_remove_link(&dev->class->p->class_subsys.kobj,
1592                                   old_device_name);
1593         }
1594 #endif
1595
1596 out:
1597         put_device(dev);
1598
1599         kfree(new_class_name);
1600         kfree(old_class_name);
1601         kfree(old_device_name);
1602
1603         return error;
1604 }
1605 EXPORT_SYMBOL_GPL(device_rename);
1606
1607 static int device_move_class_links(struct device *dev,
1608                                    struct device *old_parent,
1609                                    struct device *new_parent)
1610 {
1611         int error = 0;
1612 #ifdef CONFIG_SYSFS_DEPRECATED
1613         char *class_name;
1614
1615         class_name = make_class_name(dev->class->name, &dev->kobj);
1616         if (!class_name) {
1617                 error = -ENOMEM;
1618                 goto out;
1619         }
1620         if (old_parent) {
1621                 sysfs_remove_link(&dev->kobj, "device");
1622                 sysfs_remove_link(&old_parent->kobj, class_name);
1623         }
1624         if (new_parent) {
1625                 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1626                                           "device");
1627                 if (error)
1628                         goto out;
1629                 error = sysfs_create_link(&new_parent->kobj, &dev->kobj,
1630                                           class_name);
1631                 if (error)
1632                         sysfs_remove_link(&dev->kobj, "device");
1633         } else
1634                 error = 0;
1635 out:
1636         kfree(class_name);
1637         return error;
1638 #else
1639         if (old_parent)
1640                 sysfs_remove_link(&dev->kobj, "device");
1641         if (new_parent)
1642                 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1643                                           "device");
1644         return error;
1645 #endif
1646 }
1647
1648 /**
1649  * device_move - moves a device to a new parent
1650  * @dev: the pointer to the struct device to be moved
1651  * @new_parent: the new parent of the device (can by NULL)
1652  * @dpm_order: how to reorder the dpm_list
1653  */
1654 int device_move(struct device *dev, struct device *new_parent,
1655                 enum dpm_order dpm_order)
1656 {
1657         int error;
1658         struct device *old_parent;
1659         struct kobject *new_parent_kobj;
1660
1661         dev = get_device(dev);
1662         if (!dev)
1663                 return -EINVAL;
1664
1665         device_pm_lock();
1666         new_parent = get_device(new_parent);
1667         new_parent_kobj = get_device_parent(dev, new_parent);
1668
1669         pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1670                  __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1671         error = kobject_move(&dev->kobj, new_parent_kobj);
1672         if (error) {
1673                 cleanup_glue_dir(dev, new_parent_kobj);
1674                 put_device(new_parent);
1675                 goto out;
1676         }
1677         old_parent = dev->parent;
1678         dev->parent = new_parent;
1679         if (old_parent)
1680                 klist_remove(&dev->p->knode_parent);
1681         if (new_parent) {
1682                 klist_add_tail(&dev->p->knode_parent,
1683                                &new_parent->p->klist_children);
1684                 set_dev_node(dev, dev_to_node(new_parent));
1685         }
1686
1687         if (!dev->class)
1688                 goto out_put;
1689         error = device_move_class_links(dev, old_parent, new_parent);
1690         if (error) {
1691                 /* We ignore errors on cleanup since we're hosed anyway... */
1692                 device_move_class_links(dev, new_parent, old_parent);
1693                 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1694                         if (new_parent)
1695                                 klist_remove(&dev->p->knode_parent);
1696                         dev->parent = old_parent;
1697                         if (old_parent) {
1698                                 klist_add_tail(&dev->p->knode_parent,
1699                                                &old_parent->p->klist_children);
1700                                 set_dev_node(dev, dev_to_node(old_parent));
1701                         }
1702                 }
1703                 cleanup_glue_dir(dev, new_parent_kobj);
1704                 put_device(new_parent);
1705                 goto out;
1706         }
1707         switch (dpm_order) {
1708         case DPM_ORDER_NONE:
1709                 break;
1710         case DPM_ORDER_DEV_AFTER_PARENT:
1711                 device_pm_move_after(dev, new_parent);
1712                 break;
1713         case DPM_ORDER_PARENT_BEFORE_DEV:
1714                 device_pm_move_before(new_parent, dev);
1715                 break;
1716         case DPM_ORDER_DEV_LAST:
1717                 device_pm_move_last(dev);
1718                 break;
1719         }
1720 out_put:
1721         put_device(old_parent);
1722 out:
1723         device_pm_unlock();
1724         put_device(dev);
1725         return error;
1726 }
1727 EXPORT_SYMBOL_GPL(device_move);
1728
1729 /**
1730  * device_shutdown - call ->shutdown() on each device to shutdown.
1731  */
1732 void device_shutdown(void)
1733 {
1734         struct device *dev, *devn;
1735
1736         list_for_each_entry_safe_reverse(dev, devn, &devices_kset->list,
1737                                 kobj.entry) {
1738                 if (dev->bus && dev->bus->shutdown) {
1739                         dev_dbg(dev, "shutdown\n");
1740                         dev->bus->shutdown(dev);
1741                 } else if (dev->driver && dev->driver->shutdown) {
1742                         dev_dbg(dev, "shutdown\n");
1743                         dev->driver->shutdown(dev);
1744                 }
1745         }
1746         async_synchronize_full();
1747 }