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/of.h>
  22 #include <linux/of_device.h>
  23 #include <linux/genhd.h>
  24 #include <linux/kallsyms.h>
  25 #include <linux/mutex.h>
  26 #include <linux/async.h>
  27 #include <linux/pm_runtime.h>
  28 #include <linux/netdevice.h>
  29
  30 #include "base.h"
  31 #include "power/power.h"
  32
  33 #ifdef CONFIG_SYSFS_DEPRECATED
  34 #ifdef CONFIG_SYSFS_DEPRECATED_V2
  35 long sysfs_deprecated = 1;
  36 #else
  37 long sysfs_deprecated = 0;
  38 #endif
  39 static __init int sysfs_deprecated_setup(char *arg)
  40 {
  41         return kstrtol(arg, 10, &sysfs_deprecated);
  42 }
  43 early_param("sysfs.deprecated", sysfs_deprecated_setup);
  44 #endif
  45
  46 int (*platform_notify)(struct device *dev) = NULL;
  47 int (*platform_notify_remove)(struct device *dev) = NULL;
  48 static struct kobject *dev_kobj;
  49 struct kobject *sysfs_dev_char_kobj;
  50 struct kobject *sysfs_dev_block_kobj;
  51
  52 #ifdef CONFIG_BLOCK
  53 static inline int device_is_not_partition(struct device *dev)
  54 {
  55         return !(dev->type == &part_type);
  56 }
  57 #else
  58 static inline int device_is_not_partition(struct device *dev)
  59 {
  60         return 1;
  61 }
  62 #endif
  63
  64 /**
  65  * dev_driver_string - Return a device's driver name, if at all possible
  66  * @dev: struct device to get the name of
  67  *
  68  * Will return the device's driver's name if it is bound to a device.  If
  69  * the device is not bound to a driver, it will return the name of the bus
  70  * it is attached to.  If it is not attached to a bus either, an empty
  71  * string will be returned.
  72  */
  73 const char *dev_driver_string(const struct device *dev)
  74 {
  75         struct device_driver *drv;
  76
  77         /* dev->driver can change to NULL underneath us because of unbinding,
  78          * so be careful about accessing it.  dev->bus and dev->class should
  79          * never change once they are set, so they don't need special care.
  80          */
  81         drv = ACCESS_ONCE(dev->driver);
  82         return drv ? drv->name :
  83                         (dev->bus ? dev->bus->name :
  84                         (dev->class ? dev->class->name : ""));
  85 }
  86 EXPORT_SYMBOL(dev_driver_string);
  87
  88 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
  89
  90 static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
  91                              char *buf)
  92 {
  93         struct device_attribute *dev_attr = to_dev_attr(attr);
  94         struct device *dev = kobj_to_dev(kobj);
  95         ssize_t ret = -EIO;
  96
  97         if (dev_attr->show)
  98                 ret = dev_attr->show(dev, dev_attr, buf);
  99         if (ret >= (ssize_t)PAGE_SIZE) {
 100                 print_symbol("dev_attr_show: %s returned bad count\n",
 101                                 (unsigned long)dev_attr->show);
 102         }
 103         return ret;
 104 }
 105
 106 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
 107                               const char *buf, size_t count)
 108 {
 109         struct device_attribute *dev_attr = to_dev_attr(attr);
 110         struct device *dev = kobj_to_dev(kobj);
 111         ssize_t ret = -EIO;
 112
 113         if (dev_attr->store)
 114                 ret = dev_attr->store(dev, dev_attr, buf, count);
 115         return ret;
 116 }
 117
 118 static const struct sysfs_ops dev_sysfs_ops = {
 119         .show   = dev_attr_show,
 120         .store  = dev_attr_store,
 121 };
 122
 123 #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
 124
 125 ssize_t device_store_ulong(struct device *dev,
 126                            struct device_attribute *attr,
 127                            const char *buf, size_t size)
 128 {
 129         struct dev_ext_attribute *ea = to_ext_attr(attr);
 130         char *end;
 131         unsigned long new = simple_strtoul(buf, &end, 0);
 132         if (end == buf)
 133                 return -EINVAL;
 134         *(unsigned long *)(ea->var) = new;
 135         /* Always return full write size even if we didn't consume all */
 136         return size;
 137 }
 138 EXPORT_SYMBOL_GPL(device_store_ulong);
 139
 140 ssize_t device_show_ulong(struct device *dev,
 141                           struct device_attribute *attr,
 142                           char *buf)
 143 {
 144         struct dev_ext_attribute *ea = to_ext_attr(attr);
 145         return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
 146 }
 147 EXPORT_SYMBOL_GPL(device_show_ulong);
 148
 149 ssize_t device_store_int(struct device *dev,
 150                          struct device_attribute *attr,
 151                          const char *buf, size_t size)
 152 {
 153         struct dev_ext_attribute *ea = to_ext_attr(attr);
 154         char *end;
 155         long new = simple_strtol(buf, &end, 0);
 156         if (end == buf || new > INT_MAX || new < INT_MIN)
 157                 return -EINVAL;
 158         *(int *)(ea->var) = new;
 159         /* Always return full write size even if we didn't consume all */
 160         return size;
 161 }
 162 EXPORT_SYMBOL_GPL(device_store_int);
 163
 164 ssize_t device_show_int(struct device *dev,
 165                         struct device_attribute *attr,
 166                         char *buf)
 167 {
 168         struct dev_ext_attribute *ea = to_ext_attr(attr);
 169
 170         return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
 171 }
 172 EXPORT_SYMBOL_GPL(device_show_int);
 173
 174 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
 175                           const char *buf, size_t size)
 176 {
 177         struct dev_ext_attribute *ea = to_ext_attr(attr);
 178
 179         if (strtobool(buf, ea->var) < 0)
 180                 return -EINVAL;
 181
 182         return size;
 183 }
 184 EXPORT_SYMBOL_GPL(device_store_bool);
 185
 186 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
 187                          char *buf)
 188 {
 189         struct dev_ext_attribute *ea = to_ext_attr(attr);
 190
 191         return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var));
 192 }
 193 EXPORT_SYMBOL_GPL(device_show_bool);
 194
 195 /**
 196  * device_release - free device structure.
 197  * @kobj: device's kobject.
 198  *
 199  * This is called once the reference count for the object
 200  * reaches 0. We forward the call to the device's release
 201  * method, which should handle actually freeing the structure.
 202  */
 203 static void device_release(struct kobject *kobj)
 204 {
 205         struct device *dev = kobj_to_dev(kobj);
 206         struct device_private *p = dev->p;
 207
 208         /*
 209          * Some platform devices are driven without driver attached
 210          * and managed resources may have been acquired.  Make sure
 211          * all resources are released.
 212          *
 213          * Drivers still can add resources into device after device
 214          * is deleted but alive, so release devres here to avoid
 215          * possible memory leak.
 216          */
 217         devres_release_all(dev);
 218
 219         if (dev->release)
 220                 dev->release(dev);
 221         else if (dev->type && dev->type->release)
 222                 dev->type->release(dev);
 223         else if (dev->class && dev->class->dev_release)
 224                 dev->class->dev_release(dev);
 225         else
 226                 WARN(1, KERN_ERR "Device '%s' does not have a release() "
 227                         "function, it is broken and must be fixed.\n",
 228                         dev_name(dev));
 229         kfree(p);
 230 }
 231
 232 static const void *device_namespace(struct kobject *kobj)
 233 {
 234         struct device *dev = kobj_to_dev(kobj);
 235         const void *ns = NULL;
 236
 237         if (dev->class && dev->class->ns_type)
 238                 ns = dev->class->namespace(dev);
 239
 240         return ns;
 241 }
 242
 243 static struct kobj_type device_ktype = {
 244         .release        = device_release,
 245         .sysfs_ops      = &dev_sysfs_ops,
 246         .namespace      = device_namespace,
 247 };
 248
 249
 250 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
 251 {
 252         struct kobj_type *ktype = get_ktype(kobj);
 253
 254         if (ktype == &device_ktype) {
 255                 struct device *dev = kobj_to_dev(kobj);
 256                 if (dev->bus)
 257                         return 1;
 258                 if (dev->class)
 259                         return 1;
 260         }
 261         return 0;
 262 }
 263
 264 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
 265 {
 266         struct device *dev = kobj_to_dev(kobj);
 267
 268         if (dev->bus)
 269                 return dev->bus->name;
 270         if (dev->class)
 271                 return dev->class->name;
 272         return NULL;
 273 }
 274
 275 static int dev_uevent(struct kset *kset, struct kobject *kobj,
 276                       struct kobj_uevent_env *env)
 277 {
 278         struct device *dev = kobj_to_dev(kobj);
 279         int retval = 0;
 280
 281         /* add device node properties if present */
 282         if (MAJOR(dev->devt)) {
 283                 const char *tmp;
 284                 const char *name;
 285                 umode_t mode = 0;
 286                 kuid_t uid = GLOBAL_ROOT_UID;
 287                 kgid_t gid = GLOBAL_ROOT_GID;
 288
 289                 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
 290                 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
 291                 name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
 292                 if (name) {
 293                         add_uevent_var(env, "DEVNAME=%s", name);
 294                         if (mode)
 295                                 add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
 296                         if (!uid_eq(uid, GLOBAL_ROOT_UID))
 297                                 add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
 298                         if (!gid_eq(gid, GLOBAL_ROOT_GID))
 299                                 add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
 300                         kfree(tmp);
 301                 }
 302         }
 303
 304         if (dev->type && dev->type->name)
 305                 add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
 306
 307         if (dev->driver)
 308                 add_uevent_var(env, "DRIVER=%s", dev->driver->name);
 309
 310         /* Add common DT information about the device */
 311         of_device_uevent(dev, env);
 312
 313         /* have the bus specific function add its stuff */
 314         if (dev->bus && dev->bus->uevent) {
 315                 retval = dev->bus->uevent(dev, env);
 316                 if (retval)
 317                         pr_debug("device: '%s': %s: bus uevent() returned %d\n",
 318                                  dev_name(dev), __func__, retval);
 319         }
 320
 321         /* have the class specific function add its stuff */
 322         if (dev->class && dev->class->dev_uevent) {
 323                 retval = dev->class->dev_uevent(dev, env);
 324                 if (retval)
 325                         pr_debug("device: '%s': %s: class uevent() "
 326                                  "returned %d\n", dev_name(dev),
 327                                  __func__, retval);
 328         }
 329
 330         /* have the device type specific function add its stuff */
 331         if (dev->type && dev->type->uevent) {
 332                 retval = dev->type->uevent(dev, env);
 333                 if (retval)
 334                         pr_debug("device: '%s': %s: dev_type uevent() "
 335                                  "returned %d\n", dev_name(dev),
 336                                  __func__, retval);
 337         }
 338
 339         return retval;
 340 }
 341
 342 static const struct kset_uevent_ops device_uevent_ops = {
 343         .filter =       dev_uevent_filter,
 344         .name =         dev_uevent_name,
 345         .uevent =       dev_uevent,
 346 };
 347
 348 static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
 349                            char *buf)
 350 {
 351         struct kobject *top_kobj;
 352         struct kset *kset;
 353         struct kobj_uevent_env *env = NULL;
 354         int i;
 355         size_t count = 0;
 356         int retval;
 357
 358         /* search the kset, the device belongs to */
 359         top_kobj = &dev->kobj;
 360         while (!top_kobj->kset && top_kobj->parent)
 361                 top_kobj = top_kobj->parent;
 362         if (!top_kobj->kset)
 363                 goto out;
 364
 365         kset = top_kobj->kset;
 366         if (!kset->uevent_ops || !kset->uevent_ops->uevent)
 367                 goto out;
 368
 369         /* respect filter */
 370         if (kset->uevent_ops && kset->uevent_ops->filter)
 371                 if (!kset->uevent_ops->filter(kset, &dev->kobj))
 372                         goto out;
 373
 374         env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
 375         if (!env)
 376                 return -ENOMEM;
 377
 378         /* let the kset specific function add its keys */
 379         retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
 380         if (retval)
 381                 goto out;
 382
 383         /* copy keys to file */
 384         for (i = 0; i < env->envp_idx; i++)
 385                 count += sprintf(&buf[count], "%s\n", env->envp[i]);
 386 out:
 387         kfree(env);
 388         return count;
 389 }
 390
 391 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
 392                             const char *buf, size_t count)
 393 {
 394         enum kobject_action action;
 395
 396         if (kobject_action_type(buf, count, &action) == 0)
 397                 kobject_uevent(&dev->kobj, action);
 398         else
 399                 dev_err(dev, "uevent: unknown action-string\n");
 400         return count;
 401 }
 402
 403 static struct device_attribute uevent_attr =
 404         __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
 405
 406 static ssize_t show_online(struct device *dev, struct device_attribute *attr,
 407                            char *buf)
 408 {
 409         bool val;
 410
 411         lock_device_hotplug();
 412         val = !dev->offline;
 413         unlock_device_hotplug();
 414         return sprintf(buf, "%u\n", val);
 415 }
 416
 417 static ssize_t store_online(struct device *dev, struct device_attribute *attr,
 418                             const char *buf, size_t count)
 419 {
 420         bool val;
 421         int ret;
 422
 423         ret = strtobool(buf, &val);
 424         if (ret < 0)
 425                 return ret;
 426
 427         lock_device_hotplug();
 428         ret = val ? device_online(dev) : device_offline(dev);
 429         unlock_device_hotplug();
 430         return ret < 0 ? ret : count;
 431 }
 432
 433 static struct device_attribute online_attr =
 434         __ATTR(online, S_IRUGO | S_IWUSR, show_online, store_online);
 435
 436 static int device_add_attributes(struct device *dev,
 437                                  struct device_attribute *attrs)
 438 {
 439         int error = 0;
 440         int i;
 441
 442         if (attrs) {
 443                 for (i = 0; attr_name(attrs[i]); i++) {
 444                         error = device_create_file(dev, &attrs[i]);
 445                         if (error)
 446                                 break;
 447                 }
 448                 if (error)
 449                         while (--i >= 0)
 450                                 device_remove_file(dev, &attrs[i]);
 451         }
 452         return error;
 453 }
 454
 455 static void device_remove_attributes(struct device *dev,
 456                                      struct device_attribute *attrs)
 457 {
 458         int i;
 459
 460         if (attrs)
 461                 for (i = 0; attr_name(attrs[i]); i++)
 462                         device_remove_file(dev, &attrs[i]);
 463 }
 464
 465 static int device_add_bin_attributes(struct device *dev,
 466                                      struct bin_attribute *attrs)
 467 {
 468         int error = 0;
 469         int i;
 470
 471         if (attrs) {
 472                 for (i = 0; attr_name(attrs[i]); i++) {
 473                         error = device_create_bin_file(dev, &attrs[i]);
 474                         if (error)
 475                                 break;
 476                 }
 477                 if (error)
 478                         while (--i >= 0)
 479                                 device_remove_bin_file(dev, &attrs[i]);
 480         }
 481         return error;
 482 }
 483
 484 static void device_remove_bin_attributes(struct device *dev,
 485                                          struct bin_attribute *attrs)
 486 {
 487         int i;
 488
 489         if (attrs)
 490                 for (i = 0; attr_name(attrs[i]); i++)
 491                         device_remove_bin_file(dev, &attrs[i]);
 492 }
 493
 494 int device_add_groups(struct device *dev, const struct attribute_group **groups)
 495 {
 496         int error = 0;
 497         int i;
 498
 499         if (groups) {
 500                 for (i = 0; groups[i]; i++) {
 501                         error = sysfs_create_group(&dev->kobj, groups[i]);
 502                         if (error) {
 503                                 while (--i >= 0)
 504                                         sysfs_remove_group(&dev->kobj,
 505                                                            groups[i]);
 506                                 break;
 507                         }
 508                 }
 509         }
 510         return error;
 511 }
 512
 513 void device_remove_groups(struct device *dev,
 514                           const struct attribute_group **groups)
 515 {
 516         int i;
 517
 518         if (groups)
 519                 for (i = 0; groups[i]; i++)
 520                         sysfs_remove_group(&dev->kobj, groups[i]);
 521 }
 522
 523 static int device_add_attrs(struct device *dev)
 524 {
 525         struct class *class = dev->class;
 526         const struct device_type *type = dev->type;
 527         int error;
 528
 529         if (class) {
 530                 error = device_add_groups(dev, class->dev_groups);
 531                 if (error)
 532                         return error;
 533                 error = device_add_attributes(dev, class->dev_attrs);
 534                 if (error)
 535                         goto err_remove_class_groups;
 536                 error = device_add_bin_attributes(dev, class->dev_bin_attrs);
 537                 if (error)
 538                         goto err_remove_class_attrs;
 539         }
 540
 541         if (type) {
 542                 error = device_add_groups(dev, type->groups);
 543                 if (error)
 544                         goto err_remove_class_bin_attrs;
 545         }
 546
 547         error = device_add_groups(dev, dev->groups);
 548         if (error)
 549                 goto err_remove_type_groups;
 550
 551         if (device_supports_offline(dev) && !dev->offline_disabled) {
 552                 error = device_create_file(dev, &online_attr);
 553                 if (error)
 554                         goto err_remove_type_groups;
 555         }
 556
 557         return 0;
 558
 559  err_remove_type_groups:
 560         if (type)
 561                 device_remove_groups(dev, type->groups);
 562  err_remove_class_bin_attrs:
 563         if (class)
 564                 device_remove_bin_attributes(dev, class->dev_bin_attrs);
 565  err_remove_class_attrs:
 566         if (class)
 567                 device_remove_attributes(dev, class->dev_attrs);
 568  err_remove_class_groups:
 569         if (class)
 570                 device_remove_groups(dev, class->dev_groups);
 571
 572         return error;
 573 }
 574
 575 static void device_remove_attrs(struct device *dev)
 576 {
 577         struct class *class = dev->class;
 578         const struct device_type *type = dev->type;
 579
 580         device_remove_file(dev, &online_attr);
 581         device_remove_groups(dev, dev->groups);
 582
 583         if (type)
 584                 device_remove_groups(dev, type->groups);
 585
 586         if (class) {
 587                 device_remove_attributes(dev, class->dev_attrs);
 588                 device_remove_bin_attributes(dev, class->dev_bin_attrs);
 589                 device_remove_groups(dev, class->dev_groups);
 590         }
 591 }
 592
 593
 594 static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
 595                         char *buf)
 596 {
 597         return print_dev_t(buf, dev->devt);
 598 }
 599
 600 static struct device_attribute devt_attr =
 601         __ATTR(dev, S_IRUGO, show_dev, NULL);
 602
 603 /* /sys/devices/ */
 604 struct kset *devices_kset;
 605
 606 /**
 607  * device_create_file - create sysfs attribute file for device.
 608  * @dev: device.
 609  * @attr: device attribute descriptor.
 610  */
 611 int device_create_file(struct device *dev,
 612                        const struct device_attribute *attr)
 613 {
 614         int error = 0;
 615
 616         if (dev) {
 617                 WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
 618                         "Attribute %s: write permission without 'store'\n",
 619                         attr->attr.name);
 620                 WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
 621                         "Attribute %s: read permission without 'show'\n",
 622                         attr->attr.name);
 623                 error = sysfs_create_file(&dev->kobj, &attr->attr);
 624         }
 625
 626         return error;
 627 }
 628 EXPORT_SYMBOL_GPL(device_create_file);
 629
 630 /**
 631  * device_remove_file - remove sysfs attribute file.
 632  * @dev: device.
 633  * @attr: device attribute descriptor.
 634  */
 635 void device_remove_file(struct device *dev,
 636                         const struct device_attribute *attr)
 637 {
 638         if (dev)
 639                 sysfs_remove_file(&dev->kobj, &attr->attr);
 640 }
 641 EXPORT_SYMBOL_GPL(device_remove_file);
 642
 643 /**
 644  * device_create_bin_file - create sysfs binary attribute file for device.
 645  * @dev: device.
 646  * @attr: device binary attribute descriptor.
 647  */
 648 int device_create_bin_file(struct device *dev,
 649                            const struct bin_attribute *attr)
 650 {
 651         int error = -EINVAL;
 652         if (dev)
 653                 error = sysfs_create_bin_file(&dev->kobj, attr);
 654         return error;
 655 }
 656 EXPORT_SYMBOL_GPL(device_create_bin_file);
 657
 658 /**
 659  * device_remove_bin_file - remove sysfs binary attribute file
 660  * @dev: device.
 661  * @attr: device binary attribute descriptor.
 662  */
 663 void device_remove_bin_file(struct device *dev,
 664                             const struct bin_attribute *attr)
 665 {
 666         if (dev)
 667                 sysfs_remove_bin_file(&dev->kobj, attr);
 668 }
 669 EXPORT_SYMBOL_GPL(device_remove_bin_file);
 670
 671 /**
 672  * device_schedule_callback_owner - helper to schedule a callback for a device
 673  * @dev: device.
 674  * @func: callback function to invoke later.
 675  * @owner: module owning the callback routine
 676  *
 677  * Attribute methods must not unregister themselves or their parent device
 678  * (which would amount to the same thing).  Attempts to do so will deadlock,
 679  * since unregistration is mutually exclusive with driver callbacks.
 680  *
 681  * Instead methods can call this routine, which will attempt to allocate
 682  * and schedule a workqueue request to call back @func with @dev as its
 683  * argument in the workqueue's process context.  @dev will be pinned until
 684  * @func returns.
 685  *
 686  * This routine is usually called via the inline device_schedule_callback(),
 687  * which automatically sets @owner to THIS_MODULE.
 688  *
 689  * Returns 0 if the request was submitted, -ENOMEM if storage could not
 690  * be allocated, -ENODEV if a reference to @owner isn't available.
 691  *
 692  * NOTE: This routine won't work if CONFIG_SYSFS isn't set!  It uses an
 693  * underlying sysfs routine (since it is intended for use by attribute
 694  * methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
 695  */
 696 int device_schedule_callback_owner(struct device *dev,
 697                 void (*func)(struct device *), struct module *owner)
 698 {
 699         return sysfs_schedule_callback(&dev->kobj,
 700                         (void (*)(void *)) func, dev, owner);
 701 }
 702 EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
 703
 704 static void klist_children_get(struct klist_node *n)
 705 {
 706         struct device_private *p = to_device_private_parent(n);
 707         struct device *dev = p->device;
 708
 709         get_device(dev);
 710 }
 711
 712 static void klist_children_put(struct klist_node *n)
 713 {
 714         struct device_private *p = to_device_private_parent(n);
 715         struct device *dev = p->device;
 716
 717         put_device(dev);
 718 }
 719
 720 /**
 721  * device_initialize - init device structure.
 722  * @dev: device.
 723  *
 724  * This prepares the device for use by other layers by initializing
 725  * its fields.
 726  * It is the first half of device_register(), if called by
 727  * that function, though it can also be called separately, so one
 728  * may use @dev's fields. In particular, get_device()/put_device()
 729  * may be used for reference counting of @dev after calling this
 730  * function.
 731  *
 732  * All fields in @dev must be initialized by the caller to 0, except
 733  * for those explicitly set to some other value.  The simplest
 734  * approach is to use kzalloc() to allocate the structure containing
 735  * @dev.
 736  *
 737  * NOTE: Use put_device() to give up your reference instead of freeing
 738  * @dev directly once you have called this function.
 739  */
 740 void device_initialize(struct device *dev)
 741 {
 742         dev->kobj.kset = devices_kset;
 743         kobject_init(&dev->kobj, &device_ktype);
 744         INIT_LIST_HEAD(&dev->dma_pools);
 745         mutex_init(&dev->mutex);
 746         lockdep_set_novalidate_class(&dev->mutex);
 747         spin_lock_init(&dev->devres_lock);
 748         INIT_LIST_HEAD(&dev->devres_head);
 749         device_pm_init(dev);
 750         set_dev_node(dev, -1);
 751 }
 752 EXPORT_SYMBOL_GPL(device_initialize);
 753
 754 struct kobject *virtual_device_parent(struct device *dev)
 755 {
 756         static struct kobject *virtual_dir = NULL;
 757
 758         if (!virtual_dir)
 759                 virtual_dir = kobject_create_and_add("virtual",
 760                                                      &devices_kset->kobj);
 761
 762         return virtual_dir;
 763 }
 764
 765 struct class_dir {
 766         struct kobject kobj;
 767         struct class *class;
 768 };
 769
 770 #define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
 771
 772 static void class_dir_release(struct kobject *kobj)
 773 {
 774         struct class_dir *dir = to_class_dir(kobj);
 775         kfree(dir);
 776 }
 777
 778 static const
 779 struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
 780 {
 781         struct class_dir *dir = to_class_dir(kobj);
 782         return dir->class->ns_type;
 783 }
 784
 785 static struct kobj_type class_dir_ktype = {
 786         .release        = class_dir_release,
 787         .sysfs_ops      = &kobj_sysfs_ops,
 788         .child_ns_type  = class_dir_child_ns_type
 789 };
 790
 791 static struct kobject *
 792 class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
 793 {
 794         struct class_dir *dir;
 795         int retval;
 796
 797         dir = kzalloc(sizeof(*dir), GFP_KERNEL);
 798         if (!dir)
 799                 return NULL;
 800
 801         dir->class = class;
 802         kobject_init(&dir->kobj, &class_dir_ktype);
 803
 804         dir->kobj.kset = &class->p->glue_dirs;
 805
 806         retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
 807         if (retval < 0) {
 808                 kobject_put(&dir->kobj);
 809                 return NULL;
 810         }
 811         return &dir->kobj;
 812 }
 813
 814
 815 static struct kobject *get_device_parent(struct device *dev,
 816                                          struct device *parent)
 817 {
 818         if (dev->class) {
 819                 static DEFINE_MUTEX(gdp_mutex);
 820                 struct kobject *kobj = NULL;
 821                 struct kobject *parent_kobj;
 822                 struct kobject *k;
 823
 824 #ifdef CONFIG_BLOCK
 825                 /* block disks show up in /sys/block */
 826                 if (sysfs_deprecated && dev->class == &block_class) {
 827                         if (parent && parent->class == &block_class)
 828                                 return &parent->kobj;
 829                         return &block_class.p->subsys.kobj;
 830                 }
 831 #endif
 832
 833                 /*
 834                  * If we have no parent, we live in "virtual".
 835                  * Class-devices with a non class-device as parent, live
 836                  * in a "glue" directory to prevent namespace collisions.
 837                  */
 838                 if (parent == NULL)
 839                         parent_kobj = virtual_device_parent(dev);
 840                 else if (parent->class && !dev->class->ns_type)
 841                         return &parent->kobj;
 842                 else
 843                         parent_kobj = &parent->kobj;
 844
 845                 mutex_lock(&gdp_mutex);
 846
 847                 /* find our class-directory at the parent and reference it */
 848                 spin_lock(&dev->class->p->glue_dirs.list_lock);
 849                 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
 850                         if (k->parent == parent_kobj) {
 851                                 kobj = kobject_get(k);
 852                                 break;
 853                         }
 854                 spin_unlock(&dev->class->p->glue_dirs.list_lock);
 855                 if (kobj) {
 856                         mutex_unlock(&gdp_mutex);
 857                         return kobj;
 858                 }
 859
 860                 /* or create a new class-directory at the parent device */
 861                 k = class_dir_create_and_add(dev->class, parent_kobj);
 862                 /* do not emit an uevent for this simple "glue" directory */
 863                 mutex_unlock(&gdp_mutex);
 864                 return k;
 865         }
 866
 867         /* subsystems can specify a default root directory for their devices */
 868         if (!parent && dev->bus && dev->bus->dev_root)
 869                 return &dev->bus->dev_root->kobj;
 870
 871         if (parent)
 872                 return &parent->kobj;
 873         return NULL;
 874 }
 875
 876 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
 877 {
 878         /* see if we live in a "glue" directory */
 879         if (!glue_dir || !dev->class ||
 880             glue_dir->kset != &dev->class->p->glue_dirs)
 881                 return;
 882
 883         kobject_put(glue_dir);
 884 }
 885
 886 static void cleanup_device_parent(struct device *dev)
 887 {
 888         cleanup_glue_dir(dev, dev->kobj.parent);
 889 }
 890
 891 static int device_add_class_symlinks(struct device *dev)
 892 {
 893         int error;
 894
 895         if (!dev->class)
 896                 return 0;
 897
 898         error = sysfs_create_link(&dev->kobj,
 899                                   &dev->class->p->subsys.kobj,
 900                                   "subsystem");
 901         if (error)
 902                 goto out;
 903
 904         if (dev->parent && device_is_not_partition(dev)) {
 905                 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
 906                                           "device");
 907                 if (error)
 908                         goto out_subsys;
 909         }
 910
 911 #ifdef CONFIG_BLOCK
 912         /* /sys/block has directories and does not need symlinks */
 913         if (sysfs_deprecated && dev->class == &block_class)
 914                 return 0;
 915 #endif
 916
 917         /* link in the class directory pointing to the device */
 918         error = sysfs_create_link(&dev->class->p->subsys.kobj,
 919                                   &dev->kobj, dev_name(dev));
 920         if (error)
 921                 goto out_device;
 922
 923         return 0;
 924
 925 out_device:
 926         sysfs_remove_link(&dev->kobj, "device");
 927
 928 out_subsys:
 929         sysfs_remove_link(&dev->kobj, "subsystem");
 930 out:
 931         return error;
 932 }
 933
 934 static void device_remove_class_symlinks(struct device *dev)
 935 {
 936         if (!dev->class)
 937                 return;
 938
 939         if (dev->parent && device_is_not_partition(dev))
 940                 sysfs_remove_link(&dev->kobj, "device");
 941         sysfs_remove_link(&dev->kobj, "subsystem");
 942 #ifdef CONFIG_BLOCK
 943         if (sysfs_deprecated && dev->class == &block_class)
 944                 return;
 945 #endif
 946         sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
 947 }
 948
 949 /**
 950  * dev_set_name - set a device name
 951  * @dev: device
 952  * @fmt: format string for the device's name
 953  */
 954 int dev_set_name(struct device *dev, const char *fmt, ...)
 955 {
 956         va_list vargs;
 957         int err;
 958
 959         va_start(vargs, fmt);
 960         err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
 961         va_end(vargs);
 962         return err;
 963 }
 964 EXPORT_SYMBOL_GPL(dev_set_name);
 965
 966 /**
 967  * device_to_dev_kobj - select a /sys/dev/ directory for the device
 968  * @dev: device
 969  *
 970  * By default we select char/ for new entries.  Setting class->dev_obj
 971  * to NULL prevents an entry from being created.  class->dev_kobj must
 972  * be set (or cleared) before any devices are registered to the class
 973  * otherwise device_create_sys_dev_entry() and
 974  * device_remove_sys_dev_entry() will disagree about the presence of
 975  * the link.
 976  */
 977 static struct kobject *device_to_dev_kobj(struct device *dev)
 978 {
 979         struct kobject *kobj;
 980
 981         if (dev->class)
 982                 kobj = dev->class->dev_kobj;
 983         else
 984                 kobj = sysfs_dev_char_kobj;
 985
 986         return kobj;
 987 }
 988
 989 static int device_create_sys_dev_entry(struct device *dev)
 990 {
 991         struct kobject *kobj = device_to_dev_kobj(dev);
 992         int error = 0;
 993         char devt_str[15];
 994
 995         if (kobj) {
 996                 format_dev_t(devt_str, dev->devt);
 997                 error = sysfs_create_link(kobj, &dev->kobj, devt_str);
 998         }
 999
1000         return error;
1001 }
1002
1003 static void device_remove_sys_dev_entry(struct device *dev)
1004 {
1005         struct kobject *kobj = device_to_dev_kobj(dev);
1006         char devt_str[15];
1007
1008         if (kobj) {
1009                 format_dev_t(devt_str, dev->devt);
1010                 sysfs_remove_link(kobj, devt_str);
1011         }
1012 }
1013
1014 int device_private_init(struct device *dev)
1015 {
1016         dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
1017         if (!dev->p)
1018                 return -ENOMEM;
1019         dev->p->device = dev;
1020         klist_init(&dev->p->klist_children, klist_children_get,
1021                    klist_children_put);
1022         INIT_LIST_HEAD(&dev->p->deferred_probe);
1023         return 0;
1024 }
1025
1026 /**
1027  * device_add - add device to device hierarchy.
1028  * @dev: device.
1029  *
1030  * This is part 2 of device_register(), though may be called
1031  * separately _iff_ device_initialize() has been called separately.
1032  *
1033  * This adds @dev to the kobject hierarchy via kobject_add(), adds it
1034  * to the global and sibling lists for the device, then
1035  * adds it to the other relevant subsystems of the driver model.
1036  *
1037  * Do not call this routine or device_register() more than once for
1038  * any device structure.  The driver model core is not designed to work
1039  * with devices that get unregistered and then spring back to life.
1040  * (Among other things, it's very hard to guarantee that all references
1041  * to the previous incarnation of @dev have been dropped.)  Allocate
1042  * and register a fresh new struct device instead.
1043  *
1044  * NOTE: _Never_ directly free @dev after calling this function, even
1045  * if it returned an error! Always use put_device() to give up your
1046  * reference instead.
1047  */
1048 int device_add(struct device *dev)
1049 {
1050         struct device *parent = NULL;
1051         struct kobject *kobj;
1052         struct class_interface *class_intf;
1053         int error = -EINVAL;
1054
1055         dev = get_device(dev);
1056         if (!dev)
1057                 goto done;
1058
1059         if (!dev->p) {
1060                 error = device_private_init(dev);
1061                 if (error)
1062                         goto done;
1063         }
1064
1065         /*
1066          * for statically allocated devices, which should all be converted
1067          * some day, we need to initialize the name. We prevent reading back
1068          * the name, and force the use of dev_name()
1069          */
1070         if (dev->init_name) {
1071                 dev_set_name(dev, "%s", dev->init_name);
1072                 dev->init_name = NULL;
1073         }
1074
1075         /* subsystems can specify simple device enumeration */
1076         if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
1077                 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
1078
1079         if (!dev_name(dev)) {
1080                 error = -EINVAL;
1081                 goto name_error;
1082         }
1083
1084         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1085
1086         parent = get_device(dev->parent);
1087         kobj = get_device_parent(dev, parent);
1088         if (kobj)
1089                 dev->kobj.parent = kobj;
1090
1091         /* use parent numa_node */
1092         if (parent)
1093                 set_dev_node(dev, dev_to_node(parent));
1094
1095         /* first, register with generic layer. */
1096         /* we require the name to be set before, and pass NULL */
1097         error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1098         if (error)
1099                 goto Error;
1100
1101         /* notify platform of device entry */
1102         if (platform_notify)
1103                 platform_notify(dev);
1104
1105         error = device_create_file(dev, &uevent_attr);
1106         if (error)
1107                 goto attrError;
1108
1109         if (MAJOR(dev->devt)) {
1110                 error = device_create_file(dev, &devt_attr);
1111                 if (error)
1112                         goto ueventattrError;
1113
1114                 error = device_create_sys_dev_entry(dev);
1115                 if (error)
1116                         goto devtattrError;
1117
1118                 devtmpfs_create_node(dev);
1119         }
1120
1121         error = device_add_class_symlinks(dev);
1122         if (error)
1123                 goto SymlinkError;
1124         error = device_add_attrs(dev);
1125         if (error)
1126                 goto AttrsError;
1127         error = bus_add_device(dev);
1128         if (error)
1129                 goto BusError;
1130         error = dpm_sysfs_add(dev);
1131         if (error)
1132                 goto DPMError;
1133         device_pm_add(dev);
1134
1135         /* Notify clients of device addition.  This call must come
1136          * after dpm_sysfs_add() and before kobject_uevent().
1137          */
1138         if (dev->bus)
1139                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1140                                              BUS_NOTIFY_ADD_DEVICE, dev);
1141
1142         kobject_uevent(&dev->kobj, KOBJ_ADD);
1143         bus_probe_device(dev);
1144         if (parent)
1145                 klist_add_tail(&dev->p->knode_parent,
1146                                &parent->p->klist_children);
1147
1148         if (dev->class) {
1149                 mutex_lock(&dev->class->p->mutex);
1150                 /* tie the class to the device */
1151                 klist_add_tail(&dev->knode_class,
1152                                &dev->class->p->klist_devices);
1153
1154                 /* notify any interfaces that the device is here */
1155                 list_for_each_entry(class_intf,
1156                                     &dev->class->p->interfaces, node)
1157                         if (class_intf->add_dev)
1158                                 class_intf->add_dev(dev, class_intf);
1159                 mutex_unlock(&dev->class->p->mutex);
1160         }
1161 done:
1162         put_device(dev);
1163         return error;
1164  DPMError:
1165         bus_remove_device(dev);
1166  BusError:
1167         device_remove_attrs(dev);
1168  AttrsError:
1169         device_remove_class_symlinks(dev);
1170  SymlinkError:
1171         if (MAJOR(dev->devt))
1172                 devtmpfs_delete_node(dev);
1173         if (MAJOR(dev->devt))
1174                 device_remove_sys_dev_entry(dev);
1175  devtattrError:
1176         if (MAJOR(dev->devt))
1177                 device_remove_file(dev, &devt_attr);
1178  ueventattrError:
1179         device_remove_file(dev, &uevent_attr);
1180  attrError:
1181         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1182         kobject_del(&dev->kobj);
1183  Error:
1184         cleanup_device_parent(dev);
1185         if (parent)
1186                 put_device(parent);
1187 name_error:
1188         kfree(dev->p);
1189         dev->p = NULL;
1190         goto done;
1191 }
1192 EXPORT_SYMBOL_GPL(device_add);
1193
1194 /**
1195  * device_register - register a device with the system.
1196  * @dev: pointer to the device structure
1197  *
1198  * This happens in two clean steps - initialize the device
1199  * and add it to the system. The two steps can be called
1200  * separately, but this is the easiest and most common.
1201  * I.e. you should only call the two helpers separately if
1202  * have a clearly defined need to use and refcount the device
1203  * before it is added to the hierarchy.
1204  *
1205  * For more information, see the kerneldoc for device_initialize()
1206  * and device_add().
1207  *
1208  * NOTE: _Never_ directly free @dev after calling this function, even
1209  * if it returned an error! Always use put_device() to give up the
1210  * reference initialized in this function instead.
1211  */
1212 int device_register(struct device *dev)
1213 {
1214         device_initialize(dev);
1215         return device_add(dev);
1216 }
1217 EXPORT_SYMBOL_GPL(device_register);
1218
1219 /**
1220  * get_device - increment reference count for device.
1221  * @dev: device.
1222  *
1223  * This simply forwards the call to kobject_get(), though
1224  * we do take care to provide for the case that we get a NULL
1225  * pointer passed in.
1226  */
1227 struct device *get_device(struct device *dev)
1228 {
1229         return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
1230 }
1231 EXPORT_SYMBOL_GPL(get_device);
1232
1233 /**
1234  * put_device - decrement reference count.
1235  * @dev: device in question.
1236  */
1237 void put_device(struct device *dev)
1238 {
1239         /* might_sleep(); */
1240         if (dev)
1241                 kobject_put(&dev->kobj);
1242 }
1243 EXPORT_SYMBOL_GPL(put_device);
1244
1245 /**
1246  * device_del - delete device from system.
1247  * @dev: device.
1248  *
1249  * This is the first part of the device unregistration
1250  * sequence. This removes the device from the lists we control
1251  * from here, has it removed from the other driver model
1252  * subsystems it was added to in device_add(), and removes it
1253  * from the kobject hierarchy.
1254  *
1255  * NOTE: this should be called manually _iff_ device_add() was
1256  * also called manually.
1257  */
1258 void device_del(struct device *dev)
1259 {
1260         struct device *parent = dev->parent;
1261         struct class_interface *class_intf;
1262
1263         /* Notify clients of device removal.  This call must come
1264          * before dpm_sysfs_remove().
1265          */
1266         if (dev->bus)
1267                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1268                                              BUS_NOTIFY_DEL_DEVICE, dev);
1269         dpm_sysfs_remove(dev);
1270         if (parent)
1271                 klist_del(&dev->p->knode_parent);
1272         if (MAJOR(dev->devt)) {
1273                 devtmpfs_delete_node(dev);
1274                 device_remove_sys_dev_entry(dev);
1275                 device_remove_file(dev, &devt_attr);
1276         }
1277         if (dev->class) {
1278                 device_remove_class_symlinks(dev);
1279
1280                 mutex_lock(&dev->class->p->mutex);
1281                 /* notify any interfaces that the device is now gone */
1282                 list_for_each_entry(class_intf,
1283                                     &dev->class->p->interfaces, node)
1284                         if (class_intf->remove_dev)
1285                                 class_intf->remove_dev(dev, class_intf);
1286                 /* remove the device from the class list */
1287                 klist_del(&dev->knode_class);
1288                 mutex_unlock(&dev->class->p->mutex);
1289         }
1290         device_remove_file(dev, &uevent_attr);
1291         device_remove_attrs(dev);
1292         bus_remove_device(dev);
1293         device_pm_remove(dev);
1294         driver_deferred_probe_del(dev);
1295
1296         /* Notify the platform of the removal, in case they
1297          * need to do anything...
1298          */
1299         if (platform_notify_remove)
1300                 platform_notify_remove(dev);
1301         kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1302         cleanup_device_parent(dev);
1303         kobject_del(&dev->kobj);
1304         put_device(parent);
1305 }
1306 EXPORT_SYMBOL_GPL(device_del);
1307
1308 /**
1309  * device_unregister - unregister device from system.
1310  * @dev: device going away.
1311  *
1312  * We do this in two parts, like we do device_register(). First,
1313  * we remove it from all the subsystems with device_del(), then
1314  * we decrement the reference count via put_device(). If that
1315  * is the final reference count, the device will be cleaned up
1316  * via device_release() above. Otherwise, the structure will
1317  * stick around until the final reference to the device is dropped.
1318  */
1319 void device_unregister(struct device *dev)
1320 {
1321         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1322         device_del(dev);
1323         put_device(dev);
1324 }
1325 EXPORT_SYMBOL_GPL(device_unregister);
1326
1327 static struct device *next_device(struct klist_iter *i)
1328 {
1329         struct klist_node *n = klist_next(i);
1330         struct device *dev = NULL;
1331         struct device_private *p;
1332
1333         if (n) {
1334                 p = to_device_private_parent(n);
1335                 dev = p->device;
1336         }
1337         return dev;
1338 }
1339
1340 /**
1341  * device_get_devnode - path of device node file
1342  * @dev: device
1343  * @mode: returned file access mode
1344  * @uid: returned file owner
1345  * @gid: returned file group
1346  * @tmp: possibly allocated string
1347  *
1348  * Return the relative path of a possible device node.
1349  * Non-default names may need to allocate a memory to compose
1350  * a name. This memory is returned in tmp and needs to be
1351  * freed by the caller.
1352  */
1353 const char *device_get_devnode(struct device *dev,
1354                                umode_t *mode, kuid_t *uid, kgid_t *gid,
1355                                const char **tmp)
1356 {
1357         char *s;
1358
1359         *tmp = NULL;
1360
1361         /* the device type may provide a specific name */
1362         if (dev->type && dev->type->devnode)
1363                 *tmp = dev->type->devnode(dev, mode, uid, gid);
1364         if (*tmp)
1365                 return *tmp;
1366
1367         /* the class may provide a specific name */
1368         if (dev->class && dev->class->devnode)
1369                 *tmp = dev->class->devnode(dev, mode);
1370         if (*tmp)
1371                 return *tmp;
1372
1373         /* return name without allocation, tmp == NULL */
1374         if (strchr(dev_name(dev), '!') == NULL)
1375                 return dev_name(dev);
1376
1377         /* replace '!' in the name with '/' */
1378         *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1379         if (!*tmp)
1380                 return NULL;
1381         while ((s = strchr(*tmp, '!')))
1382                 s[0] = '/';
1383         return *tmp;
1384 }
1385
1386 /**
1387  * device_for_each_child - device child iterator.
1388  * @parent: parent struct device.
1389  * @fn: function to be called for each device.
1390  * @data: data for the callback.
1391  *
1392  * Iterate over @parent's child devices, and call @fn for each,
1393  * passing it @data.
1394  *
1395  * We check the return of @fn each time. If it returns anything
1396  * other than 0, we break out and return that value.
1397  */
1398 int device_for_each_child(struct device *parent, void *data,
1399                           int (*fn)(struct device *dev, void *data))
1400 {
1401         struct klist_iter i;
1402         struct device *child;
1403         int error = 0;
1404
1405         if (!parent->p)
1406                 return 0;
1407
1408         klist_iter_init(&parent->p->klist_children, &i);
1409         while ((child = next_device(&i)) && !error)
1410                 error = fn(child, data);
1411         klist_iter_exit(&i);
1412         return error;
1413 }
1414 EXPORT_SYMBOL_GPL(device_for_each_child);
1415
1416 /**
1417  * device_find_child - device iterator for locating a particular device.
1418  * @parent: parent struct device
1419  * @match: Callback function to check device
1420  * @data: Data to pass to match function
1421  *
1422  * This is similar to the device_for_each_child() function above, but it
1423  * returns a reference to a device that is 'found' for later use, as
1424  * determined by the @match callback.
1425  *
1426  * The callback should return 0 if the device doesn't match and non-zero
1427  * if it does.  If the callback returns non-zero and a reference to the
1428  * current device can be obtained, this function will return to the caller
1429  * and not iterate over any more devices.
1430  *
1431  * NOTE: you will need to drop the reference with put_device() after use.
1432  */
1433 struct device *device_find_child(struct device *parent, void *data,
1434                                  int (*match)(struct device *dev, void *data))
1435 {
1436         struct klist_iter i;
1437         struct device *child;
1438
1439         if (!parent)
1440                 return NULL;
1441
1442         klist_iter_init(&parent->p->klist_children, &i);
1443         while ((child = next_device(&i)))
1444                 if (match(child, data) && get_device(child))
1445                         break;
1446         klist_iter_exit(&i);
1447         return child;
1448 }
1449 EXPORT_SYMBOL_GPL(device_find_child);
1450
1451 int __init devices_init(void)
1452 {
1453         devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1454         if (!devices_kset)
1455                 return -ENOMEM;
1456         dev_kobj = kobject_create_and_add("dev", NULL);
1457         if (!dev_kobj)
1458                 goto dev_kobj_err;
1459         sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1460         if (!sysfs_dev_block_kobj)
1461                 goto block_kobj_err;
1462         sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1463         if (!sysfs_dev_char_kobj)
1464                 goto char_kobj_err;
1465
1466         return 0;
1467
1468  char_kobj_err:
1469         kobject_put(sysfs_dev_block_kobj);
1470  block_kobj_err:
1471         kobject_put(dev_kobj);
1472  dev_kobj_err:
1473         kset_unregister(devices_kset);
1474         return -ENOMEM;
1475 }
1476
1477 static DEFINE_MUTEX(device_hotplug_lock);
1478
1479 void lock_device_hotplug(void)
1480 {
1481         mutex_lock(&device_hotplug_lock);
1482 }
1483
1484 void unlock_device_hotplug(void)
1485 {
1486         mutex_unlock(&device_hotplug_lock);
1487 }
1488
1489 static int device_check_offline(struct device *dev, void *not_used)
1490 {
1491         int ret;
1492
1493         ret = device_for_each_child(dev, NULL, device_check_offline);
1494         if (ret)
1495                 return ret;
1496
1497         return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
1498 }
1499
1500 /**
1501  * device_offline - Prepare the device for hot-removal.
1502  * @dev: Device to be put offline.
1503  *
1504  * Execute the device bus type's .offline() callback, if present, to prepare
1505  * the device for a subsequent hot-removal.  If that succeeds, the device must
1506  * not be used until either it is removed or its bus type's .online() callback
1507  * is executed.
1508  *
1509  * Call under device_hotplug_lock.
1510  */
1511 int device_offline(struct device *dev)
1512 {
1513         int ret;
1514
1515         if (dev->offline_disabled)
1516                 return -EPERM;
1517
1518         ret = device_for_each_child(dev, NULL, device_check_offline);
1519         if (ret)
1520                 return ret;
1521
1522         device_lock(dev);
1523         if (device_supports_offline(dev)) {
1524                 if (dev->offline) {
1525                         ret = 1;
1526                 } else {
1527                         ret = dev->bus->offline(dev);
1528                         if (!ret) {
1529                                 kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
1530                                 dev->offline = true;
1531                         }
1532                 }
1533         }
1534         device_unlock(dev);
1535
1536         return ret;
1537 }
1538
1539 /**
1540  * device_online - Put the device back online after successful device_offline().
1541  * @dev: Device to be put back online.
1542  *
1543  * If device_offline() has been successfully executed for @dev, but the device
1544  * has not been removed subsequently, execute its bus type's .online() callback
1545  * to indicate that the device can be used again.
1546  *
1547  * Call under device_hotplug_lock.
1548  */
1549 int device_online(struct device *dev)
1550 {
1551         int ret = 0;
1552
1553         device_lock(dev);
1554         if (device_supports_offline(dev)) {
1555                 if (dev->offline) {
1556                         ret = dev->bus->online(dev);
1557                         if (!ret) {
1558                                 kobject_uevent(&dev->kobj, KOBJ_ONLINE);
1559                                 dev->offline = false;
1560                         }
1561                 } else {
1562                         ret = 1;
1563                 }
1564         }
1565         device_unlock(dev);
1566
1567         return ret;
1568 }
1569
1570 struct root_device {
1571         struct device dev;
1572         struct module *owner;
1573 };
1574
1575 static inline struct root_device *to_root_device(struct device *d)
1576 {
1577         return container_of(d, struct root_device, dev);
1578 }
1579
1580 static void root_device_release(struct device *dev)
1581 {
1582         kfree(to_root_device(dev));
1583 }
1584
1585 /**
1586  * __root_device_register - allocate and register a root device
1587  * @name: root device name
1588  * @owner: owner module of the root device, usually THIS_MODULE
1589  *
1590  * This function allocates a root device and registers it
1591  * using device_register(). In order to free the returned
1592  * device, use root_device_unregister().
1593  *
1594  * Root devices are dummy devices which allow other devices
1595  * to be grouped under /sys/devices. Use this function to
1596  * allocate a root device and then use it as the parent of
1597  * any device which should appear under /sys/devices/{name}
1598  *
1599  * The /sys/devices/{name} directory will also contain a
1600  * 'module' symlink which points to the @owner directory
1601  * in sysfs.
1602  *
1603  * Returns &struct device pointer on success, or ERR_PTR() on error.
1604  *
1605  * Note: You probably want to use root_device_register().
1606  */
1607 struct device *__root_device_register(const char *name, struct module *owner)
1608 {
1609         struct root_device *root;
1610         int err = -ENOMEM;
1611
1612         root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1613         if (!root)
1614                 return ERR_PTR(err);
1615
1616         err = dev_set_name(&root->dev, "%s", name);
1617         if (err) {
1618                 kfree(root);
1619                 return ERR_PTR(err);
1620         }
1621
1622         root->dev.release = root_device_release;
1623
1624         err = device_register(&root->dev);
1625         if (err) {
1626                 put_device(&root->dev);
1627                 return ERR_PTR(err);
1628         }
1629
1630 #ifdef CONFIG_MODULES   /* gotta find a "cleaner" way to do this */
1631         if (owner) {
1632                 struct module_kobject *mk = &owner->mkobj;
1633
1634                 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1635                 if (err) {
1636                         device_unregister(&root->dev);
1637                         return ERR_PTR(err);
1638                 }
1639                 root->owner = owner;
1640         }
1641 #endif
1642
1643         return &root->dev;
1644 }
1645 EXPORT_SYMBOL_GPL(__root_device_register);
1646
1647 /**
1648  * root_device_unregister - unregister and free a root device
1649  * @dev: device going away
1650  *
1651  * This function unregisters and cleans up a device that was created by
1652  * root_device_register().
1653  */
1654 void root_device_unregister(struct device *dev)
1655 {
1656         struct root_device *root = to_root_device(dev);
1657
1658         if (root->owner)
1659                 sysfs_remove_link(&root->dev.kobj, "module");
1660
1661         device_unregister(dev);
1662 }
1663 EXPORT_SYMBOL_GPL(root_device_unregister);
1664
1665
1666 static void device_create_release(struct device *dev)
1667 {
1668         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1669         kfree(dev);
1670 }
1671
1672 static struct device *
1673 device_create_groups_vargs(struct class *class, struct device *parent,
1674                            dev_t devt, void *drvdata,
1675                            const struct attribute_group **groups,
1676                            const char *fmt, va_list args)
1677 {
1678         struct device *dev = NULL;
1679         int retval = -ENODEV;
1680
1681         if (class == NULL || IS_ERR(class))
1682                 goto error;
1683
1684         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1685         if (!dev) {
1686                 retval = -ENOMEM;
1687                 goto error;
1688         }
1689
1690         dev->devt = devt;
1691         dev->class = class;
1692         dev->parent = parent;
1693         dev->groups = groups;
1694         dev->release = device_create_release;
1695         dev_set_drvdata(dev, drvdata);
1696
1697         retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1698         if (retval)
1699                 goto error;
1700
1701         retval = device_register(dev);
1702         if (retval)
1703                 goto error;
1704
1705         return dev;
1706
1707 error:
1708         put_device(dev);
1709         return ERR_PTR(retval);
1710 }
1711
1712 /**
1713  * device_create_vargs - creates a device and registers it with sysfs
1714  * @class: pointer to the struct class that this device should be registered to
1715  * @parent: pointer to the parent struct device of this new device, if any
1716  * @devt: the dev_t for the char device to be added
1717  * @drvdata: the data to be added to the device for callbacks
1718  * @fmt: string for the device's name
1719  * @args: va_list for the device's name
1720  *
1721  * This function can be used by char device classes.  A struct device
1722  * will be created in sysfs, registered to the specified class.
1723  *
1724  * A "dev" file will be created, showing the dev_t for the device, if
1725  * the dev_t is not 0,0.
1726  * If a pointer to a parent struct device is passed in, the newly created
1727  * struct device will be a child of that device in sysfs.
1728  * The pointer to the struct device will be returned from the call.
1729  * Any further sysfs files that might be required can be created using this
1730  * pointer.
1731  *
1732  * Returns &struct device pointer on success, or ERR_PTR() on error.
1733  *
1734  * Note: the struct class passed to this function must have previously
1735  * been created with a call to class_create().
1736  */
1737 struct device *device_create_vargs(struct class *class, struct device *parent,
1738                                    dev_t devt, void *drvdata, const char *fmt,
1739                                    va_list args)
1740 {
1741         return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
1742                                           fmt, args);
1743 }
1744 EXPORT_SYMBOL_GPL(device_create_vargs);
1745
1746 /**
1747  * device_create - creates a device and registers it with sysfs
1748  * @class: pointer to the struct class that this device should be registered to
1749  * @parent: pointer to the parent struct device of this new device, if any
1750  * @devt: the dev_t for the char device to be added
1751  * @drvdata: the data to be added to the device for callbacks
1752  * @fmt: string for the device's name
1753  *
1754  * This function can be used by char device classes.  A struct device
1755  * will be created in sysfs, registered to the specified class.
1756  *
1757  * A "dev" file will be created, showing the dev_t for the device, if
1758  * the dev_t is not 0,0.
1759  * If a pointer to a parent struct device is passed in, the newly created
1760  * struct device will be a child of that device in sysfs.
1761  * The pointer to the struct device will be returned from the call.
1762  * Any further sysfs files that might be required can be created using this
1763  * pointer.
1764  *
1765  * Returns &struct device pointer on success, or ERR_PTR() on error.
1766  *
1767  * Note: the struct class passed to this function must have previously
1768  * been created with a call to class_create().
1769  */
1770 struct device *device_create(struct class *class, struct device *parent,
1771                              dev_t devt, void *drvdata, const char *fmt, ...)
1772 {
1773         va_list vargs;
1774         struct device *dev;
1775
1776         va_start(vargs, fmt);
1777         dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1778         va_end(vargs);
1779         return dev;
1780 }
1781 EXPORT_SYMBOL_GPL(device_create);
1782
1783 /**
1784  * device_create_with_groups - creates a device and registers it with sysfs
1785  * @class: pointer to the struct class that this device should be registered to
1786  * @parent: pointer to the parent struct device of this new device, if any
1787  * @devt: the dev_t for the char device to be added
1788  * @drvdata: the data to be added to the device for callbacks
1789  * @groups: NULL-terminated list of attribute groups to be created
1790  * @fmt: string for the device's name
1791  *
1792  * This function can be used by char device classes.  A struct device
1793  * will be created in sysfs, registered to the specified class.
1794  * Additional attributes specified in the groups parameter will also
1795  * be created automatically.
1796  *
1797  * A "dev" file will be created, showing the dev_t for the device, if
1798  * the dev_t is not 0,0.
1799  * If a pointer to a parent struct device is passed in, the newly created
1800  * struct device will be a child of that device in sysfs.
1801  * The pointer to the struct device will be returned from the call.
1802  * Any further sysfs files that might be required can be created using this
1803  * pointer.
1804  *
1805  * Returns &struct device pointer on success, or ERR_PTR() on error.
1806  *
1807  * Note: the struct class passed to this function must have previously
1808  * been created with a call to class_create().
1809  */
1810 struct device *device_create_with_groups(struct class *class,
1811                                          struct device *parent, dev_t devt,
1812                                          void *drvdata,
1813                                          const struct attribute_group **groups,
1814                                          const char *fmt, ...)
1815 {
1816         va_list vargs;
1817         struct device *dev;
1818
1819         va_start(vargs, fmt);
1820         dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
1821                                          fmt, vargs);
1822         va_end(vargs);
1823         return dev;
1824 }
1825 EXPORT_SYMBOL_GPL(device_create_with_groups);
1826
1827 static int __match_devt(struct device *dev, const void *data)
1828 {
1829         const dev_t *devt = data;
1830
1831         return dev->devt == *devt;
1832 }
1833
1834 /**
1835  * device_destroy - removes a device that was created with device_create()
1836  * @class: pointer to the struct class that this device was registered with
1837  * @devt: the dev_t of the device that was previously registered
1838  *
1839  * This call unregisters and cleans up a device that was created with a
1840  * call to device_create().
1841  */
1842 void device_destroy(struct class *class, dev_t devt)
1843 {
1844         struct device *dev;
1845
1846         dev = class_find_device(class, NULL, &devt, __match_devt);
1847         if (dev) {
1848                 put_device(dev);
1849                 device_unregister(dev);
1850         }
1851 }
1852 EXPORT_SYMBOL_GPL(device_destroy);
1853
1854 /**
1855  * device_rename - renames a device
1856  * @dev: the pointer to the struct device to be renamed
1857  * @new_name: the new name of the device
1858  *
1859  * It is the responsibility of the caller to provide mutual
1860  * exclusion between two different calls of device_rename
1861  * on the same device to ensure that new_name is valid and
1862  * won't conflict with other devices.
1863  *
1864  * Note: Don't call this function.  Currently, the networking layer calls this
1865  * function, but that will change.  The following text from Kay Sievers offers
1866  * some insight:
1867  *
1868  * Renaming devices is racy at many levels, symlinks and other stuff are not
1869  * replaced atomically, and you get a "move" uevent, but it's not easy to
1870  * connect the event to the old and new device. Device nodes are not renamed at
1871  * all, there isn't even support for that in the kernel now.
1872  *
1873  * In the meantime, during renaming, your target name might be taken by another
1874  * driver, creating conflicts. Or the old name is taken directly after you
1875  * renamed it -- then you get events for the same DEVPATH, before you even see
1876  * the "move" event. It's just a mess, and nothing new should ever rely on
1877  * kernel device renaming. Besides that, it's not even implemented now for
1878  * other things than (driver-core wise very simple) network devices.
1879  *
1880  * We are currently about to change network renaming in udev to completely
1881  * disallow renaming of devices in the same namespace as the kernel uses,
1882  * because we can't solve the problems properly, that arise with swapping names
1883  * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
1884  * be allowed to some other name than eth[0-9]*, for the aforementioned
1885  * reasons.
1886  *
1887  * Make up a "real" name in the driver before you register anything, or add
1888  * some other attributes for userspace to find the device, or use udev to add
1889  * symlinks -- but never rename kernel devices later, it's a complete mess. We
1890  * don't even want to get into that and try to implement the missing pieces in
1891  * the core. We really have other pieces to fix in the driver core mess. :)
1892  */
1893 int device_rename(struct device *dev, const char *new_name)
1894 {
1895         char *old_device_name = NULL;
1896         int error;
1897
1898         dev = get_device(dev);
1899         if (!dev)
1900                 return -EINVAL;
1901
1902         pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
1903                  __func__, new_name);
1904
1905         old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1906         if (!old_device_name) {
1907                 error = -ENOMEM;
1908                 goto out;
1909         }
1910
1911         if (dev->class) {
1912                 error = sysfs_rename_link(&dev->class->p->subsys.kobj,
1913                         &dev->kobj, old_device_name, new_name);
1914                 if (error)
1915                         goto out;
1916         }
1917
1918         error = kobject_rename(&dev->kobj, new_name);
1919         if (error)
1920                 goto out;
1921
1922 out:
1923         put_device(dev);
1924
1925         kfree(old_device_name);
1926
1927         return error;
1928 }
1929 EXPORT_SYMBOL_GPL(device_rename);
1930
1931 static int device_move_class_links(struct device *dev,
1932                                    struct device *old_parent,
1933                                    struct device *new_parent)
1934 {
1935         int error = 0;
1936
1937         if (old_parent)
1938                 sysfs_remove_link(&dev->kobj, "device");
1939         if (new_parent)
1940                 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1941                                           "device");
1942         return error;
1943 }
1944
1945 /**
1946  * device_move - moves a device to a new parent
1947  * @dev: the pointer to the struct device to be moved
1948  * @new_parent: the new parent of the device (can by NULL)
1949  * @dpm_order: how to reorder the dpm_list
1950  */
1951 int device_move(struct device *dev, struct device *new_parent,
1952                 enum dpm_order dpm_order)
1953 {
1954         int error;
1955         struct device *old_parent;
1956         struct kobject *new_parent_kobj;
1957
1958         dev = get_device(dev);
1959         if (!dev)
1960                 return -EINVAL;
1961
1962         device_pm_lock();
1963         new_parent = get_device(new_parent);
1964         new_parent_kobj = get_device_parent(dev, new_parent);
1965
1966         pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1967                  __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1968         error = kobject_move(&dev->kobj, new_parent_kobj);
1969         if (error) {
1970                 cleanup_glue_dir(dev, new_parent_kobj);
1971                 put_device(new_parent);
1972                 goto out;
1973         }
1974         old_parent = dev->parent;
1975         dev->parent = new_parent;
1976         if (old_parent)
1977                 klist_remove(&dev->p->knode_parent);
1978         if (new_parent) {
1979                 klist_add_tail(&dev->p->knode_parent,
1980                                &new_parent->p->klist_children);
1981                 set_dev_node(dev, dev_to_node(new_parent));
1982         }
1983
1984         if (dev->class) {
1985                 error = device_move_class_links(dev, old_parent, new_parent);
1986                 if (error) {
1987                         /* We ignore errors on cleanup since we're hosed anyway... */
1988                         device_move_class_links(dev, new_parent, old_parent);
1989                         if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1990                                 if (new_parent)
1991                                         klist_remove(&dev->p->knode_parent);
1992                                 dev->parent = old_parent;
1993                                 if (old_parent) {
1994                                         klist_add_tail(&dev->p->knode_parent,
1995                                                        &old_parent->p->klist_children);
1996                                         set_dev_node(dev, dev_to_node(old_parent));
1997                                 }
1998                         }
1999                         cleanup_glue_dir(dev, new_parent_kobj);
2000                         put_device(new_parent);
2001                         goto out;
2002                 }
2003         }
2004         switch (dpm_order) {
2005         case DPM_ORDER_NONE:
2006                 break;
2007         case DPM_ORDER_DEV_AFTER_PARENT:
2008                 device_pm_move_after(dev, new_parent);
2009                 break;
2010         case DPM_ORDER_PARENT_BEFORE_DEV:
2011                 device_pm_move_before(new_parent, dev);
2012                 break;
2013         case DPM_ORDER_DEV_LAST:
2014                 device_pm_move_last(dev);
2015                 break;
2016         }
2017
2018         put_device(old_parent);
2019 out:
2020         device_pm_unlock();
2021         put_device(dev);
2022         return error;
2023 }
2024 EXPORT_SYMBOL_GPL(device_move);
2025
2026 /**
2027  * device_shutdown - call ->shutdown() on each device to shutdown.
2028  */
2029 void device_shutdown(void)
2030 {
2031         struct device *dev;
2032
2033         spin_lock(&devices_kset->list_lock);
2034         /*
2035          * Walk the devices list backward, shutting down each in turn.
2036          * Beware that device unplug events may also start pulling
2037          * devices offline, even as the system is shutting down.
2038          */
2039         while (!list_empty(&devices_kset->list)) {
2040                 dev = list_entry(devices_kset->list.prev, struct device,
2041                                 kobj.entry);
2042
2043                 /*
2044                  * hold reference count of device's parent to
2045                  * prevent it from being freed because parent's
2046                  * lock is to be held
2047                  */
2048                 get_device(dev->parent);
2049                 get_device(dev);
2050                 /*
2051                  * Make sure the device is off the kset list, in the
2052                  * event that dev->*->shutdown() doesn't remove it.
2053                  */
2054                 list_del_init(&dev->kobj.entry);
2055                 spin_unlock(&devices_kset->list_lock);
2056
2057                 /* hold lock to avoid race with probe/release */
2058                 if (dev->parent)
2059                         device_lock(dev->parent);
2060                 device_lock(dev);
2061
2062                 /* Don't allow any more runtime suspends */
2063                 pm_runtime_get_noresume(dev);
2064                 pm_runtime_barrier(dev);
2065
2066                 if (dev->bus && dev->bus->shutdown) {
2067                         if (initcall_debug)
2068                                 dev_info(dev, "shutdown\n");
2069                         dev->bus->shutdown(dev);
2070                 } else if (dev->driver && dev->driver->shutdown) {
2071                         if (initcall_debug)
2072                                 dev_info(dev, "shutdown\n");
2073                         dev->driver->shutdown(dev);
2074                 }
2075
2076                 device_unlock(dev);
2077                 if (dev->parent)
2078                         device_unlock(dev->parent);
2079
2080                 put_device(dev);
2081                 put_device(dev->parent);
2082
2083                 spin_lock(&devices_kset->list_lock);
2084         }
2085         spin_unlock(&devices_kset->list_lock);
2086         async_synchronize_full();
2087 }
2088
2089 /*
2090  * Device logging functions
2091  */
2092
2093 #ifdef CONFIG_PRINTK
2094 static int
2095 create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2096 {
2097         const char *subsys;
2098         size_t pos = 0;
2099
2100         if (dev->class)
2101                 subsys = dev->class->name;
2102         else if (dev->bus)
2103                 subsys = dev->bus->name;
2104         else
2105                 return 0;
2106
2107         pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2108
2109         /*
2110          * Add device identifier DEVICE=:
2111          *   b12:8         block dev_t
2112          *   c127:3        char dev_t
2113          *   n8            netdev ifindex
2114          *   +sound:card0  subsystem:devname
2115          */
2116         if (MAJOR(dev->devt)) {
2117                 char c;
2118
2119                 if (strcmp(subsys, "block") == 0)
2120                         c = 'b';
2121                 else
2122                         c = 'c';
2123                 pos++;
2124                 pos += snprintf(hdr + pos, hdrlen - pos,
2125                                 "DEVICE=%c%u:%u",
2126                                 c, MAJOR(dev->devt), MINOR(dev->devt));
2127         } else if (strcmp(subsys, "net") == 0) {
2128                 struct net_device *net = to_net_dev(dev);
2129
2130                 pos++;
2131                 pos += snprintf(hdr + pos, hdrlen - pos,
2132                                 "DEVICE=n%u", net->ifindex);
2133         } else {
2134                 pos++;
2135                 pos += snprintf(hdr + pos, hdrlen - pos,
2136                                 "DEVICE=+%s:%s", subsys, dev_name(dev));
2137         }
2138
2139         return pos;
2140 }
2141 EXPORT_SYMBOL(create_syslog_header);
2142
2143 int dev_vprintk_emit(int level, const struct device *dev,
2144                      const char *fmt, va_list args)
2145 {
2146         char hdr[128];
2147         size_t hdrlen;
2148
2149         hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));
2150
2151         return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
2152 }
2153 EXPORT_SYMBOL(dev_vprintk_emit);
2154
2155 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
2156 {
2157         va_list args;
2158         int r;
2159
2160         va_start(args, fmt);
2161
2162         r = dev_vprintk_emit(level, dev, fmt, args);
2163
2164         va_end(args);
2165
2166         return r;
2167 }
2168 EXPORT_SYMBOL(dev_printk_emit);
2169
2170 static int __dev_printk(const char *level, const struct device *dev,
2171                         struct va_format *vaf)
2172 {
2173         if (!dev)
2174                 return printk("%s(NULL device *): %pV", level, vaf);
2175
2176         return dev_printk_emit(level[1] - '0', dev,
2177                                "%s %s: %pV",
2178                                dev_driver_string(dev), dev_name(dev), vaf);
2179 }
2180
2181 int dev_printk(const char *level, const struct device *dev,
2182                const char *fmt, ...)
2183 {
2184         struct va_format vaf;
2185         va_list args;
2186         int r;
2187
2188         va_start(args, fmt);
2189
2190         vaf.fmt = fmt;
2191         vaf.va = &args;
2192
2193         r = __dev_printk(level, dev, &vaf);
2194
2195         va_end(args);
2196
2197         return r;
2198 }
2199 EXPORT_SYMBOL(dev_printk);
2200
2201 #define define_dev_printk_level(func, kern_level)               \
2202 int func(const struct device *dev, const char *fmt, ...)        \
2203 {                                                               \
2204         struct va_format vaf;                                   \
2205         va_list args;                                           \
2206         int r;                                                  \
2207                                                                 \
2208         va_start(args, fmt);                                    \
2209                                                                 \
2210         vaf.fmt = fmt;                                          \
2211         vaf.va = &args;                                         \
2212                                                                 \
2213         r = __dev_printk(kern_level, dev, &vaf);                \
2214                                                                 \
2215         va_end(args);                                           \
2216                                                                 \
2217         return r;                                               \
2218 }                                                               \
2219 EXPORT_SYMBOL(func);
2220
2221 define_dev_printk_level(dev_emerg, KERN_EMERG);
2222 define_dev_printk_level(dev_alert, KERN_ALERT);
2223 define_dev_printk_level(dev_crit, KERN_CRIT);
2224 define_dev_printk_level(dev_err, KERN_ERR);
2225 define_dev_printk_level(dev_warn, KERN_WARNING);
2226 define_dev_printk_level(dev_notice, KERN_NOTICE);
2227 define_dev_printk_level(_dev_info, KERN_INFO);
2228
2229 #endif