core.c 48.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 * drivers/base/core.c - core driver model code (device registration, etc)
 *
 * Copyright (c) 2002-3 Patrick Mochel
 * Copyright (c) 2002-3 Open Source Development Labs
6 7
 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
 * Copyright (c) 2006 Novell, Inc.
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18
 *
 * This file is released under the GPLv2
 *
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#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/mutex.h>
24
#include <linux/async.h>
25
#include <linux/pm_runtime.h>
L
Linus Torvalds 已提交
26 27 28 29

#include "base.h"
#include "power/power.h"

30 31 32 33 34 35 36 37 38 39 40 41 42
#ifdef CONFIG_SYSFS_DEPRECATED
#ifdef CONFIG_SYSFS_DEPRECATED_V2
long sysfs_deprecated = 1;
#else
long sysfs_deprecated = 0;
#endif
static __init int sysfs_deprecated_setup(char *arg)
{
	return strict_strtol(arg, 10, &sysfs_deprecated);
}
early_param("sysfs.deprecated", sysfs_deprecated_setup);
#endif

43 44
int (*platform_notify)(struct device *dev) = NULL;
int (*platform_notify_remove)(struct device *dev) = NULL;
45 46 47
static struct kobject *dev_kobj;
struct kobject *sysfs_dev_char_kobj;
struct kobject *sysfs_dev_block_kobj;
L
Linus Torvalds 已提交
48

49 50 51 52 53 54 55 56 57 58 59
#ifdef CONFIG_BLOCK
static inline int device_is_not_partition(struct device *dev)
{
	return !(dev->type == &part_type);
}
#else
static inline int device_is_not_partition(struct device *dev)
{
	return 1;
}
#endif
L
Linus Torvalds 已提交
60

61 62 63 64 65 66 67 68 69
/**
 * dev_driver_string - Return a device's driver name, if at all possible
 * @dev: struct device to get the name of
 *
 * Will return the device's driver's name if it is bound to a device.  If
 * the device is not bound to a device, it will return the name of the bus
 * it is attached to.  If it is not attached to a bus either, an empty
 * string will be returned.
 */
70
const char *dev_driver_string(const struct device *dev)
71
{
72 73 74 75 76 77 78 79
	struct device_driver *drv;

	/* dev->driver can change to NULL underneath us because of unbinding,
	 * so be careful about accessing it.  dev->bus and dev->class should
	 * never change once they are set, so they don't need special care.
	 */
	drv = ACCESS_ONCE(dev->driver);
	return drv ? drv->name :
80 81
			(dev->bus ? dev->bus->name :
			(dev->class ? dev->class->name : ""));
82
}
M
Matthew Wilcox 已提交
83
EXPORT_SYMBOL(dev_driver_string);
84

L
Linus Torvalds 已提交
85 86 87
#define to_dev(obj) container_of(obj, struct device, kobj)
#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)

88 89
static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
			     char *buf)
L
Linus Torvalds 已提交
90
{
91 92
	struct device_attribute *dev_attr = to_dev_attr(attr);
	struct device *dev = to_dev(kobj);
93
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
94 95

	if (dev_attr->show)
96
		ret = dev_attr->show(dev, dev_attr, buf);
97 98 99 100
	if (ret >= (ssize_t)PAGE_SIZE) {
		print_symbol("dev_attr_show: %s returned bad count\n",
				(unsigned long)dev_attr->show);
	}
L
Linus Torvalds 已提交
101 102 103
	return ret;
}

104 105
static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
			      const char *buf, size_t count)
L
Linus Torvalds 已提交
106
{
107 108
	struct device_attribute *dev_attr = to_dev_attr(attr);
	struct device *dev = to_dev(kobj);
109
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
110 111

	if (dev_attr->store)
112
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
113 114 115
	return ret;
}

116
static const struct sysfs_ops dev_sysfs_ops = {
L
Linus Torvalds 已提交
117 118 119 120
	.show	= dev_attr_show,
	.store	= dev_attr_store,
};

121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)

ssize_t device_store_ulong(struct device *dev,
			   struct device_attribute *attr,
			   const char *buf, size_t size)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);
	char *end;
	unsigned long new = simple_strtoul(buf, &end, 0);
	if (end == buf)
		return -EINVAL;
	*(unsigned long *)(ea->var) = new;
	/* Always return full write size even if we didn't consume all */
	return size;
}
EXPORT_SYMBOL_GPL(device_store_ulong);

ssize_t device_show_ulong(struct device *dev,
			  struct device_attribute *attr,
			  char *buf)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);
	return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
}
EXPORT_SYMBOL_GPL(device_show_ulong);

ssize_t device_store_int(struct device *dev,
			 struct device_attribute *attr,
			 const char *buf, size_t size)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);
	char *end;
	long new = simple_strtol(buf, &end, 0);
	if (end == buf || new > INT_MAX || new < INT_MIN)
		return -EINVAL;
	*(int *)(ea->var) = new;
	/* Always return full write size even if we didn't consume all */
	return size;
}
EXPORT_SYMBOL_GPL(device_store_int);

ssize_t device_show_int(struct device *dev,
			struct device_attribute *attr,
			char *buf)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);

	return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
}
EXPORT_SYMBOL_GPL(device_show_int);
L
Linus Torvalds 已提交
171 172 173 174 175 176 177 178 179

/**
 *	device_release - free device structure.
 *	@kobj:	device's kobject.
 *
 *	This is called once the reference count for the object
 *	reaches 0. We forward the call to the device's release
 *	method, which should handle actually freeing the structure.
 */
180
static void device_release(struct kobject *kobj)
L
Linus Torvalds 已提交
181
{
182
	struct device *dev = to_dev(kobj);
183
	struct device_private *p = dev->p;
L
Linus Torvalds 已提交
184 185 186

	if (dev->release)
		dev->release(dev);
187 188
	else if (dev->type && dev->type->release)
		dev->type->release(dev);
189 190
	else if (dev->class && dev->class->dev_release)
		dev->class->dev_release(dev);
A
Arjan van de Ven 已提交
191 192
	else
		WARN(1, KERN_ERR "Device '%s' does not have a release() "
193
			"function, it is broken and must be fixed.\n",
194
			dev_name(dev));
195
	kfree(p);
L
Linus Torvalds 已提交
196 197
}

198 199 200 201 202 203 204 205 206 207 208
static const void *device_namespace(struct kobject *kobj)
{
	struct device *dev = to_dev(kobj);
	const void *ns = NULL;

	if (dev->class && dev->class->ns_type)
		ns = dev->class->namespace(dev);

	return ns;
}

209
static struct kobj_type device_ktype = {
L
Linus Torvalds 已提交
210 211
	.release	= device_release,
	.sysfs_ops	= &dev_sysfs_ops,
212
	.namespace	= device_namespace,
L
Linus Torvalds 已提交
213 214 215
};


216
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
217 218 219
{
	struct kobj_type *ktype = get_ktype(kobj);

220
	if (ktype == &device_ktype) {
L
Linus Torvalds 已提交
221 222 223
		struct device *dev = to_dev(kobj);
		if (dev->bus)
			return 1;
224 225
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
226 227 228 229
	}
	return 0;
}

230
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
231 232 233
{
	struct device *dev = to_dev(kobj);

234 235 236 237 238
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
239 240
}

241 242
static int dev_uevent(struct kset *kset, struct kobject *kobj,
		      struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
243 244 245 246
{
	struct device *dev = to_dev(kobj);
	int retval = 0;

247
	/* add device node properties if present */
248
	if (MAJOR(dev->devt)) {
249 250
		const char *tmp;
		const char *name;
251
		umode_t mode = 0;
252

253 254
		add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
255
		name = device_get_devnode(dev, &mode, &tmp);
256 257 258
		if (name) {
			add_uevent_var(env, "DEVNAME=%s", name);
			kfree(tmp);
259 260
			if (mode)
				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
261
		}
262 263
	}

264
	if (dev->type && dev->type->name)
265
		add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
266

267
	if (dev->driver)
268
		add_uevent_var(env, "DRIVER=%s", dev->driver->name);
269

270
	/* have the bus specific function add its stuff */
271
	if (dev->bus && dev->bus->uevent) {
272
		retval = dev->bus->uevent(dev, env);
273
		if (retval)
274
			pr_debug("device: '%s': %s: bus uevent() returned %d\n",
275
				 dev_name(dev), __func__, retval);
L
Linus Torvalds 已提交
276 277
	}

278
	/* have the class specific function add its stuff */
279
	if (dev->class && dev->class->dev_uevent) {
280
		retval = dev->class->dev_uevent(dev, env);
281
		if (retval)
282
			pr_debug("device: '%s': %s: class uevent() "
283
				 "returned %d\n", dev_name(dev),
284
				 __func__, retval);
285 286
	}

287
	/* have the device type specific function add its stuff */
288
	if (dev->type && dev->type->uevent) {
289
		retval = dev->type->uevent(dev, env);
290
		if (retval)
291
			pr_debug("device: '%s': %s: dev_type uevent() "
292
				 "returned %d\n", dev_name(dev),
293
				 __func__, retval);
294 295
	}

L
Linus Torvalds 已提交
296 297 298
	return retval;
}

299
static const struct kset_uevent_ops device_uevent_ops = {
300 301 302
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
303 304
};

305 306 307 308 309
static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct kobject *top_kobj;
	struct kset *kset;
310
	struct kobj_uevent_env *env = NULL;
311 312 313 314 315 316
	int i;
	size_t count = 0;
	int retval;

	/* search the kset, the device belongs to */
	top_kobj = &dev->kobj;
317 318
	while (!top_kobj->kset && top_kobj->parent)
		top_kobj = top_kobj->parent;
319 320
	if (!top_kobj->kset)
		goto out;
321

322 323 324 325 326 327 328 329 330
	kset = top_kobj->kset;
	if (!kset->uevent_ops || !kset->uevent_ops->uevent)
		goto out;

	/* respect filter */
	if (kset->uevent_ops && kset->uevent_ops->filter)
		if (!kset->uevent_ops->filter(kset, &dev->kobj))
			goto out;

331 332
	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
	if (!env)
333 334
		return -ENOMEM;

335
	/* let the kset specific function add its keys */
336
	retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
337 338 339 340
	if (retval)
		goto out;

	/* copy keys to file */
341 342
	for (i = 0; i < env->envp_idx; i++)
		count += sprintf(&buf[count], "%s\n", env->envp[i]);
343
out:
344
	kfree(env);
345 346 347
	return count;
}

348 349 350
static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
351 352
	enum kobject_action action;

353
	if (kobject_action_type(buf, count, &action) == 0)
354
		kobject_uevent(&dev->kobj, action);
355 356
	else
		dev_err(dev, "uevent: unknown action-string\n");
357 358 359
	return count;
}

360 361 362
static struct device_attribute uevent_attr =
	__ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);

363 364
static int device_add_attributes(struct device *dev,
				 struct device_attribute *attrs)
365
{
366
	int error = 0;
367
	int i;
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391

	if (attrs) {
		for (i = 0; attr_name(attrs[i]); i++) {
			error = device_create_file(dev, &attrs[i]);
			if (error)
				break;
		}
		if (error)
			while (--i >= 0)
				device_remove_file(dev, &attrs[i]);
	}
	return error;
}

static void device_remove_attributes(struct device *dev,
				     struct device_attribute *attrs)
{
	int i;

	if (attrs)
		for (i = 0; attr_name(attrs[i]); i++)
			device_remove_file(dev, &attrs[i]);
}

392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
static int device_add_bin_attributes(struct device *dev,
				     struct bin_attribute *attrs)
{
	int error = 0;
	int i;

	if (attrs) {
		for (i = 0; attr_name(attrs[i]); i++) {
			error = device_create_bin_file(dev, &attrs[i]);
			if (error)
				break;
		}
		if (error)
			while (--i >= 0)
				device_remove_bin_file(dev, &attrs[i]);
	}
	return error;
}

static void device_remove_bin_attributes(struct device *dev,
					 struct bin_attribute *attrs)
{
	int i;

	if (attrs)
		for (i = 0; attr_name(attrs[i]); i++)
			device_remove_bin_file(dev, &attrs[i]);
}

421
static int device_add_groups(struct device *dev,
422
			     const struct attribute_group **groups)
423
{
424
	int error = 0;
425
	int i;
426

427 428 429
	if (groups) {
		for (i = 0; groups[i]; i++) {
			error = sysfs_create_group(&dev->kobj, groups[i]);
430 431
			if (error) {
				while (--i >= 0)
432 433
					sysfs_remove_group(&dev->kobj,
							   groups[i]);
434
				break;
435 436 437 438 439 440
			}
		}
	}
	return error;
}

441
static void device_remove_groups(struct device *dev,
442
				 const struct attribute_group **groups)
443 444
{
	int i;
445 446 447 448

	if (groups)
		for (i = 0; groups[i]; i++)
			sysfs_remove_group(&dev->kobj, groups[i]);
449 450
}

451 452 453
static int device_add_attrs(struct device *dev)
{
	struct class *class = dev->class;
454
	const struct device_type *type = dev->type;
455
	int error;
456

457 458
	if (class) {
		error = device_add_attributes(dev, class->dev_attrs);
459
		if (error)
460
			return error;
461 462 463
		error = device_add_bin_attributes(dev, class->dev_bin_attrs);
		if (error)
			goto err_remove_class_attrs;
464
	}
465

466 467
	if (type) {
		error = device_add_groups(dev, type->groups);
468
		if (error)
469
			goto err_remove_class_bin_attrs;
470 471
	}

472 473 474 475 476 477 478 479 480
	error = device_add_groups(dev, dev->groups);
	if (error)
		goto err_remove_type_groups;

	return 0;

 err_remove_type_groups:
	if (type)
		device_remove_groups(dev, type->groups);
481 482 483
 err_remove_class_bin_attrs:
	if (class)
		device_remove_bin_attributes(dev, class->dev_bin_attrs);
484 485 486 487
 err_remove_class_attrs:
	if (class)
		device_remove_attributes(dev, class->dev_attrs);

488 489 490 491 492 493
	return error;
}

static void device_remove_attrs(struct device *dev)
{
	struct class *class = dev->class;
494
	const struct device_type *type = dev->type;
495

496
	device_remove_groups(dev, dev->groups);
497

498 499 500
	if (type)
		device_remove_groups(dev, type->groups);

501
	if (class) {
502
		device_remove_attributes(dev, class->dev_attrs);
503 504
		device_remove_bin_attributes(dev, class->dev_bin_attrs);
	}
505 506 507
}


508 509 510 511 512 513
static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}

514 515 516
static struct device_attribute devt_attr =
	__ATTR(dev, S_IRUGO, show_dev, NULL);

517
/* /sys/devices/ */
518
struct kset *devices_kset;
L
Linus Torvalds 已提交
519 520

/**
521 522 523
 * device_create_file - create sysfs attribute file for device.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
524
 */
525 526
int device_create_file(struct device *dev,
		       const struct device_attribute *attr)
L
Linus Torvalds 已提交
527 528
{
	int error = 0;
529
	if (dev)
L
Linus Torvalds 已提交
530 531 532 533 534
		error = sysfs_create_file(&dev->kobj, &attr->attr);
	return error;
}

/**
535 536 537
 * device_remove_file - remove sysfs attribute file.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
538
 */
539 540
void device_remove_file(struct device *dev,
			const struct device_attribute *attr)
L
Linus Torvalds 已提交
541
{
542
	if (dev)
L
Linus Torvalds 已提交
543 544 545
		sysfs_remove_file(&dev->kobj, &attr->attr);
}

546 547 548 549 550
/**
 * device_create_bin_file - create sysfs binary attribute file for device.
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
551 552
int device_create_bin_file(struct device *dev,
			   const struct bin_attribute *attr)
553 554 555 556 557 558 559 560 561 562 563 564 565
{
	int error = -EINVAL;
	if (dev)
		error = sysfs_create_bin_file(&dev->kobj, attr);
	return error;
}
EXPORT_SYMBOL_GPL(device_create_bin_file);

/**
 * device_remove_bin_file - remove sysfs binary attribute file
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
566 567
void device_remove_bin_file(struct device *dev,
			    const struct bin_attribute *attr)
568 569 570 571 572 573
{
	if (dev)
		sysfs_remove_bin_file(&dev->kobj, attr);
}
EXPORT_SYMBOL_GPL(device_remove_bin_file);

574
/**
575
 * device_schedule_callback_owner - helper to schedule a callback for a device
576 577
 * @dev: device.
 * @func: callback function to invoke later.
578
 * @owner: module owning the callback routine
579 580 581 582 583 584 585 586 587 588
 *
 * Attribute methods must not unregister themselves or their parent device
 * (which would amount to the same thing).  Attempts to do so will deadlock,
 * since unregistration is mutually exclusive with driver callbacks.
 *
 * Instead methods can call this routine, which will attempt to allocate
 * and schedule a workqueue request to call back @func with @dev as its
 * argument in the workqueue's process context.  @dev will be pinned until
 * @func returns.
 *
589 590 591
 * This routine is usually called via the inline device_schedule_callback(),
 * which automatically sets @owner to THIS_MODULE.
 *
592
 * Returns 0 if the request was submitted, -ENOMEM if storage could not
593
 * be allocated, -ENODEV if a reference to @owner isn't available.
594 595 596 597 598
 *
 * NOTE: This routine won't work if CONFIG_SYSFS isn't set!  It uses an
 * underlying sysfs routine (since it is intended for use by attribute
 * methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
 */
599 600
int device_schedule_callback_owner(struct device *dev,
		void (*func)(struct device *), struct module *owner)
601 602
{
	return sysfs_schedule_callback(&dev->kobj,
603
			(void (*)(void *)) func, dev, owner);
604
}
605
EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
606

607 608
static void klist_children_get(struct klist_node *n)
{
609 610
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
611 612 613 614 615 616

	get_device(dev);
}

static void klist_children_put(struct klist_node *n)
{
617 618
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
619 620 621 622

	put_device(dev);
}

L
Linus Torvalds 已提交
623
/**
624 625
 * device_initialize - init device structure.
 * @dev: device.
L
Linus Torvalds 已提交
626
 *
627 628
 * This prepares the device for use by other layers by initializing
 * its fields.
629
 * It is the first half of device_register(), if called by
630 631 632 633 634
 * that function, though it can also be called separately, so one
 * may use @dev's fields. In particular, get_device()/put_device()
 * may be used for reference counting of @dev after calling this
 * function.
 *
635 636 637 638 639
 * All fields in @dev must be initialized by the caller to 0, except
 * for those explicitly set to some other value.  The simplest
 * approach is to use kzalloc() to allocate the structure containing
 * @dev.
 *
640 641
 * NOTE: Use put_device() to give up your reference instead of freeing
 * @dev directly once you have called this function.
L
Linus Torvalds 已提交
642 643 644
 */
void device_initialize(struct device *dev)
{
645
	dev->kobj.kset = devices_kset;
646
	kobject_init(&dev->kobj, &device_ktype);
L
Linus Torvalds 已提交
647
	INIT_LIST_HEAD(&dev->dma_pools);
648
	mutex_init(&dev->mutex);
649
	lockdep_set_novalidate_class(&dev->mutex);
T
Tejun Heo 已提交
650 651
	spin_lock_init(&dev->devres_lock);
	INIT_LIST_HEAD(&dev->devres_head);
652
	device_pm_init(dev);
653
	set_dev_node(dev, -1);
L
Linus Torvalds 已提交
654 655
}

656
static struct kobject *virtual_device_parent(struct device *dev)
657
{
658
	static struct kobject *virtual_dir = NULL;
659

660
	if (!virtual_dir)
661
		virtual_dir = kobject_create_and_add("virtual",
662
						     &devices_kset->kobj);
663

664
	return virtual_dir;
665 666
}

667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
struct class_dir {
	struct kobject kobj;
	struct class *class;
};

#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)

static void class_dir_release(struct kobject *kobj)
{
	struct class_dir *dir = to_class_dir(kobj);
	kfree(dir);
}

static const
struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
682
{
683 684 685 686 687 688 689 690 691 692 693 694 695 696
	struct class_dir *dir = to_class_dir(kobj);
	return dir->class->ns_type;
}

static struct kobj_type class_dir_ktype = {
	.release	= class_dir_release,
	.sysfs_ops	= &kobj_sysfs_ops,
	.child_ns_type	= class_dir_child_ns_type
};

static struct kobject *
class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
{
	struct class_dir *dir;
697 698
	int retval;

699 700 701 702 703 704 705
	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
	if (!dir)
		return NULL;

	dir->class = class;
	kobject_init(&dir->kobj, &class_dir_ktype);

706
	dir->kobj.kset = &class->p->glue_dirs;
707 708 709 710 711 712 713 714 715 716 717 718 719

	retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
	if (retval < 0) {
		kobject_put(&dir->kobj);
		return NULL;
	}
	return &dir->kobj;
}


static struct kobject *get_device_parent(struct device *dev,
					 struct device *parent)
{
720
	if (dev->class) {
721
		static DEFINE_MUTEX(gdp_mutex);
722 723 724 725
		struct kobject *kobj = NULL;
		struct kobject *parent_kobj;
		struct kobject *k;

726
#ifdef CONFIG_BLOCK
727
		/* block disks show up in /sys/block */
728
		if (sysfs_deprecated && dev->class == &block_class) {
729 730
			if (parent && parent->class == &block_class)
				return &parent->kobj;
731
			return &block_class.p->subsys.kobj;
732
		}
733
#endif
734

735 736
		/*
		 * If we have no parent, we live in "virtual".
737 738
		 * Class-devices with a non class-device as parent, live
		 * in a "glue" directory to prevent namespace collisions.
739 740 741
		 */
		if (parent == NULL)
			parent_kobj = virtual_device_parent(dev);
742
		else if (parent->class && !dev->class->ns_type)
743 744 745 746
			return &parent->kobj;
		else
			parent_kobj = &parent->kobj;

747 748
		mutex_lock(&gdp_mutex);

749
		/* find our class-directory at the parent and reference it */
750 751
		spin_lock(&dev->class->p->glue_dirs.list_lock);
		list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
752 753 754 755
			if (k->parent == parent_kobj) {
				kobj = kobject_get(k);
				break;
			}
756
		spin_unlock(&dev->class->p->glue_dirs.list_lock);
757 758
		if (kobj) {
			mutex_unlock(&gdp_mutex);
759
			return kobj;
760
		}
761 762

		/* or create a new class-directory at the parent device */
763
		k = class_dir_create_and_add(dev->class, parent_kobj);
764
		/* do not emit an uevent for this simple "glue" directory */
765
		mutex_unlock(&gdp_mutex);
766
		return k;
767 768
	}

769 770 771 772
	/* subsystems can specify a default root directory for their devices */
	if (!parent && dev->bus && dev->bus->dev_root)
		return &dev->bus->dev_root->kobj;

773
	if (parent)
774 775 776
		return &parent->kobj;
	return NULL;
}
777

778
static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
779
{
780
	/* see if we live in a "glue" directory */
781
	if (!glue_dir || !dev->class ||
782
	    glue_dir->kset != &dev->class->p->glue_dirs)
783 784
		return;

785
	kobject_put(glue_dir);
786
}
787 788 789 790 791

static void cleanup_device_parent(struct device *dev)
{
	cleanup_glue_dir(dev, dev->kobj.parent);
}
792

793 794 795 796 797 798
static int device_add_class_symlinks(struct device *dev)
{
	int error;

	if (!dev->class)
		return 0;
799

800
	error = sysfs_create_link(&dev->kobj,
801
				  &dev->class->p->subsys.kobj,
802 803 804
				  "subsystem");
	if (error)
		goto out;
805

806
	if (dev->parent && device_is_not_partition(dev)) {
807
		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
808 809
					  "device");
		if (error)
810
			goto out_subsys;
811 812
	}

813
#ifdef CONFIG_BLOCK
814
	/* /sys/block has directories and does not need symlinks */
815
	if (sysfs_deprecated && dev->class == &block_class)
816
		return 0;
817
#endif
818

819
	/* link in the class directory pointing to the device */
820
	error = sysfs_create_link(&dev->class->p->subsys.kobj,
821
				  &dev->kobj, dev_name(dev));
822
	if (error)
823
		goto out_device;
824 825 826

	return 0;

827 828
out_device:
	sysfs_remove_link(&dev->kobj, "device");
829

830 831 832 833 834 835 836 837 838 839
out_subsys:
	sysfs_remove_link(&dev->kobj, "subsystem");
out:
	return error;
}

static void device_remove_class_symlinks(struct device *dev)
{
	if (!dev->class)
		return;
840

841
	if (dev->parent && device_is_not_partition(dev))
842
		sysfs_remove_link(&dev->kobj, "device");
843
	sysfs_remove_link(&dev->kobj, "subsystem");
844
#ifdef CONFIG_BLOCK
845
	if (sysfs_deprecated && dev->class == &block_class)
846
		return;
847
#endif
848
	sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
849 850
}

851 852 853
/**
 * dev_set_name - set a device name
 * @dev: device
854
 * @fmt: format string for the device's name
855 856 857 858
 */
int dev_set_name(struct device *dev, const char *fmt, ...)
{
	va_list vargs;
859
	int err;
860 861

	va_start(vargs, fmt);
862
	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
863
	va_end(vargs);
864
	return err;
865 866 867
}
EXPORT_SYMBOL_GPL(dev_set_name);

868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
/**
 * device_to_dev_kobj - select a /sys/dev/ directory for the device
 * @dev: device
 *
 * By default we select char/ for new entries.  Setting class->dev_obj
 * to NULL prevents an entry from being created.  class->dev_kobj must
 * be set (or cleared) before any devices are registered to the class
 * otherwise device_create_sys_dev_entry() and
 * device_remove_sys_dev_entry() will disagree about the the presence
 * of the link.
 */
static struct kobject *device_to_dev_kobj(struct device *dev)
{
	struct kobject *kobj;

	if (dev->class)
		kobj = dev->class->dev_kobj;
	else
		kobj = sysfs_dev_char_kobj;

	return kobj;
}

static int device_create_sys_dev_entry(struct device *dev)
{
	struct kobject *kobj = device_to_dev_kobj(dev);
	int error = 0;
	char devt_str[15];

	if (kobj) {
		format_dev_t(devt_str, dev->devt);
		error = sysfs_create_link(kobj, &dev->kobj, devt_str);
	}

	return error;
}

static void device_remove_sys_dev_entry(struct device *dev)
{
	struct kobject *kobj = device_to_dev_kobj(dev);
	char devt_str[15];

	if (kobj) {
		format_dev_t(devt_str, dev->devt);
		sysfs_remove_link(kobj, devt_str);
	}
}

916 917 918 919 920 921 922 923 924 925 926
int device_private_init(struct device *dev)
{
	dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
	if (!dev->p)
		return -ENOMEM;
	dev->p->device = dev;
	klist_init(&dev->p->klist_children, klist_children_get,
		   klist_children_put);
	return 0;
}

L
Linus Torvalds 已提交
927
/**
928 929
 * device_add - add device to device hierarchy.
 * @dev: device.
L
Linus Torvalds 已提交
930
 *
931 932
 * This is part 2 of device_register(), though may be called
 * separately _iff_ device_initialize() has been called separately.
L
Linus Torvalds 已提交
933
 *
934
 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
935 936
 * to the global and sibling lists for the device, then
 * adds it to the other relevant subsystems of the driver model.
937
 *
938 939 940 941 942 943 944
 * Do not call this routine or device_register() more than once for
 * any device structure.  The driver model core is not designed to work
 * with devices that get unregistered and then spring back to life.
 * (Among other things, it's very hard to guarantee that all references
 * to the previous incarnation of @dev have been dropped.)  Allocate
 * and register a fresh new struct device instead.
 *
945 946 947
 * NOTE: _Never_ directly free @dev after calling this function, even
 * if it returned an error! Always use put_device() to give up your
 * reference instead.
L
Linus Torvalds 已提交
948 949 950 951
 */
int device_add(struct device *dev)
{
	struct device *parent = NULL;
952
	struct kobject *kobj;
953
	struct class_interface *class_intf;
954
	int error = -EINVAL;
955

L
Linus Torvalds 已提交
956
	dev = get_device(dev);
957 958 959
	if (!dev)
		goto done;

960
	if (!dev->p) {
961 962 963
		error = device_private_init(dev);
		if (error)
			goto done;
964 965
	}

966 967 968 969 970 971
	/*
	 * for statically allocated devices, which should all be converted
	 * some day, we need to initialize the name. We prevent reading back
	 * the name, and force the use of dev_name()
	 */
	if (dev->init_name) {
972
		dev_set_name(dev, "%s", dev->init_name);
973 974
		dev->init_name = NULL;
	}
975

976 977 978 979
	/* subsystems can specify simple device enumeration */
	if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
		dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);

980 981
	if (!dev_name(dev)) {
		error = -EINVAL;
982
		goto name_error;
983
	}
L
Linus Torvalds 已提交
984

985
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
986

L
Linus Torvalds 已提交
987
	parent = get_device(dev->parent);
988 989 990
	kobj = get_device_parent(dev, parent);
	if (kobj)
		dev->kobj.parent = kobj;
L
Linus Torvalds 已提交
991

992 993 994 995
	/* use parent numa_node */
	if (parent)
		set_dev_node(dev, dev_to_node(parent));

L
Linus Torvalds 已提交
996
	/* first, register with generic layer. */
997 998
	/* we require the name to be set before, and pass NULL */
	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
999
	if (error)
L
Linus Torvalds 已提交
1000
		goto Error;
1001

1002 1003 1004 1005
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);

1006
	error = device_create_file(dev, &uevent_attr);
1007 1008
	if (error)
		goto attrError;
1009

1010
	if (MAJOR(dev->devt)) {
1011 1012
		error = device_create_file(dev, &devt_attr);
		if (error)
1013
			goto ueventattrError;
1014 1015 1016 1017

		error = device_create_sys_dev_entry(dev);
		if (error)
			goto devtattrError;
1018 1019

		devtmpfs_create_node(dev);
1020 1021
	}

1022 1023 1024
	error = device_add_class_symlinks(dev);
	if (error)
		goto SymlinkError;
1025 1026
	error = device_add_attrs(dev);
	if (error)
1027
		goto AttrsError;
1028 1029
	error = bus_add_device(dev);
	if (error)
L
Linus Torvalds 已提交
1030
		goto BusError;
1031
	error = dpm_sysfs_add(dev);
1032
	if (error)
1033 1034
		goto DPMError;
	device_pm_add(dev);
1035 1036

	/* Notify clients of device addition.  This call must come
1037
	 * after dpm_sysfs_add() and before kobject_uevent().
1038 1039 1040 1041 1042
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_ADD_DEVICE, dev);

1043
	kobject_uevent(&dev->kobj, KOBJ_ADD);
1044
	bus_probe_device(dev);
L
Linus Torvalds 已提交
1045
	if (parent)
1046 1047
		klist_add_tail(&dev->p->knode_parent,
			       &parent->p->klist_children);
L
Linus Torvalds 已提交
1048

1049
	if (dev->class) {
1050
		mutex_lock(&dev->class->p->mutex);
1051
		/* tie the class to the device */
1052
		klist_add_tail(&dev->knode_class,
1053
			       &dev->class->p->klist_devices);
1054 1055

		/* notify any interfaces that the device is here */
1056
		list_for_each_entry(class_intf,
1057
				    &dev->class->p->interfaces, node)
1058 1059
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
1060
		mutex_unlock(&dev->class->p->mutex);
1061
	}
1062
done:
L
Linus Torvalds 已提交
1063 1064
	put_device(dev);
	return error;
1065
 DPMError:
1066 1067
	bus_remove_device(dev);
 BusError:
1068
	device_remove_attrs(dev);
1069
 AttrsError:
1070 1071
	device_remove_class_symlinks(dev);
 SymlinkError:
1072 1073
	if (MAJOR(dev->devt))
		devtmpfs_delete_node(dev);
1074 1075 1076
	if (MAJOR(dev->devt))
		device_remove_sys_dev_entry(dev);
 devtattrError:
1077 1078
	if (MAJOR(dev->devt))
		device_remove_file(dev, &devt_attr);
1079
 ueventattrError:
1080
	device_remove_file(dev, &uevent_attr);
1081
 attrError:
1082
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
L
Linus Torvalds 已提交
1083 1084
	kobject_del(&dev->kobj);
 Error:
1085
	cleanup_device_parent(dev);
L
Linus Torvalds 已提交
1086 1087
	if (parent)
		put_device(parent);
1088 1089 1090
name_error:
	kfree(dev->p);
	dev->p = NULL;
1091
	goto done;
L
Linus Torvalds 已提交
1092 1093 1094
}

/**
1095 1096
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
L
Linus Torvalds 已提交
1097
 *
1098 1099 1100 1101 1102 1103
 * This happens in two clean steps - initialize the device
 * and add it to the system. The two steps can be called
 * separately, but this is the easiest and most common.
 * I.e. you should only call the two helpers separately if
 * have a clearly defined need to use and refcount the device
 * before it is added to the hierarchy.
1104
 *
1105 1106 1107
 * For more information, see the kerneldoc for device_initialize()
 * and device_add().
 *
1108 1109 1110
 * NOTE: _Never_ directly free @dev after calling this function, even
 * if it returned an error! Always use put_device() to give up the
 * reference initialized in this function instead.
L
Linus Torvalds 已提交
1111 1112 1113 1114 1115 1116 1117 1118
 */
int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}

/**
1119 1120
 * get_device - increment reference count for device.
 * @dev: device.
L
Linus Torvalds 已提交
1121
 *
1122 1123 1124
 * This simply forwards the call to kobject_get(), though
 * we do take care to provide for the case that we get a NULL
 * pointer passed in.
L
Linus Torvalds 已提交
1125
 */
1126
struct device *get_device(struct device *dev)
L
Linus Torvalds 已提交
1127 1128 1129 1130 1131
{
	return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
}

/**
1132 1133
 * put_device - decrement reference count.
 * @dev: device in question.
L
Linus Torvalds 已提交
1134
 */
1135
void put_device(struct device *dev)
L
Linus Torvalds 已提交
1136
{
1137
	/* might_sleep(); */
L
Linus Torvalds 已提交
1138 1139 1140 1141 1142
	if (dev)
		kobject_put(&dev->kobj);
}

/**
1143 1144
 * device_del - delete device from system.
 * @dev: device.
L
Linus Torvalds 已提交
1145
 *
1146 1147 1148 1149 1150
 * This is the first part of the device unregistration
 * sequence. This removes the device from the lists we control
 * from here, has it removed from the other driver model
 * subsystems it was added to in device_add(), and removes it
 * from the kobject hierarchy.
L
Linus Torvalds 已提交
1151
 *
1152 1153
 * NOTE: this should be called manually _iff_ device_add() was
 * also called manually.
L
Linus Torvalds 已提交
1154
 */
1155
void device_del(struct device *dev)
L
Linus Torvalds 已提交
1156
{
1157
	struct device *parent = dev->parent;
1158
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
1159

1160 1161 1162 1163 1164 1165
	/* Notify clients of device removal.  This call must come
	 * before dpm_sysfs_remove().
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_DEL_DEVICE, dev);
1166
	device_pm_remove(dev);
1167
	dpm_sysfs_remove(dev);
L
Linus Torvalds 已提交
1168
	if (parent)
1169
		klist_del(&dev->p->knode_parent);
1170
	if (MAJOR(dev->devt)) {
1171
		devtmpfs_delete_node(dev);
1172
		device_remove_sys_dev_entry(dev);
1173
		device_remove_file(dev, &devt_attr);
1174
	}
1175
	if (dev->class) {
1176
		device_remove_class_symlinks(dev);
1177

1178
		mutex_lock(&dev->class->p->mutex);
1179
		/* notify any interfaces that the device is now gone */
1180
		list_for_each_entry(class_intf,
1181
				    &dev->class->p->interfaces, node)
1182 1183 1184
			if (class_intf->remove_dev)
				class_intf->remove_dev(dev, class_intf);
		/* remove the device from the class list */
1185
		klist_del(&dev->knode_class);
1186
		mutex_unlock(&dev->class->p->mutex);
1187
	}
1188
	device_remove_file(dev, &uevent_attr);
1189
	device_remove_attrs(dev);
1190
	bus_remove_device(dev);
L
Linus Torvalds 已提交
1191

1192 1193 1194 1195 1196 1197 1198
	/*
	 * Some platform devices are driven without driver attached
	 * and managed resources may have been acquired.  Make sure
	 * all resources are released.
	 */
	devres_release_all(dev);

L
Linus Torvalds 已提交
1199 1200 1201 1202 1203
	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
1204
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1205
	cleanup_device_parent(dev);
L
Linus Torvalds 已提交
1206
	kobject_del(&dev->kobj);
1207
	put_device(parent);
L
Linus Torvalds 已提交
1208 1209 1210
}

/**
1211 1212
 * device_unregister - unregister device from system.
 * @dev: device going away.
L
Linus Torvalds 已提交
1213
 *
1214 1215 1216 1217 1218 1219
 * We do this in two parts, like we do device_register(). First,
 * we remove it from all the subsystems with device_del(), then
 * we decrement the reference count via put_device(). If that
 * is the final reference count, the device will be cleaned up
 * via device_release() above. Otherwise, the structure will
 * stick around until the final reference to the device is dropped.
L
Linus Torvalds 已提交
1220
 */
1221
void device_unregister(struct device *dev)
L
Linus Torvalds 已提交
1222
{
1223
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
L
Linus Torvalds 已提交
1224 1225 1226 1227
	device_del(dev);
	put_device(dev);
}

1228
static struct device *next_device(struct klist_iter *i)
1229
{
1230
	struct klist_node *n = klist_next(i);
1231 1232 1233 1234 1235 1236 1237 1238
	struct device *dev = NULL;
	struct device_private *p;

	if (n) {
		p = to_device_private_parent(n);
		dev = p->device;
	}
	return dev;
1239 1240
}

1241
/**
1242
 * device_get_devnode - path of device node file
1243
 * @dev: device
1244
 * @mode: returned file access mode
1245 1246 1247 1248 1249 1250 1251
 * @tmp: possibly allocated string
 *
 * Return the relative path of a possible device node.
 * Non-default names may need to allocate a memory to compose
 * a name. This memory is returned in tmp and needs to be
 * freed by the caller.
 */
1252
const char *device_get_devnode(struct device *dev,
1253
			       umode_t *mode, const char **tmp)
1254 1255 1256 1257 1258 1259
{
	char *s;

	*tmp = NULL;

	/* the device type may provide a specific name */
1260 1261
	if (dev->type && dev->type->devnode)
		*tmp = dev->type->devnode(dev, mode);
1262 1263 1264 1265
	if (*tmp)
		return *tmp;

	/* the class may provide a specific name */
1266 1267
	if (dev->class && dev->class->devnode)
		*tmp = dev->class->devnode(dev, mode);
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
	if (*tmp)
		return *tmp;

	/* return name without allocation, tmp == NULL */
	if (strchr(dev_name(dev), '!') == NULL)
		return dev_name(dev);

	/* replace '!' in the name with '/' */
	*tmp = kstrdup(dev_name(dev), GFP_KERNEL);
	if (!*tmp)
		return NULL;
	while ((s = strchr(*tmp, '!')))
		s[0] = '/';
	return *tmp;
}

L
Linus Torvalds 已提交
1284
/**
1285 1286 1287 1288
 * device_for_each_child - device child iterator.
 * @parent: parent struct device.
 * @data: data for the callback.
 * @fn: function to be called for each device.
L
Linus Torvalds 已提交
1289
 *
1290 1291
 * Iterate over @parent's child devices, and call @fn for each,
 * passing it @data.
L
Linus Torvalds 已提交
1292
 *
1293 1294
 * We check the return of @fn each time. If it returns anything
 * other than 0, we break out and return that value.
L
Linus Torvalds 已提交
1295
 */
1296 1297
int device_for_each_child(struct device *parent, void *data,
			  int (*fn)(struct device *dev, void *data))
L
Linus Torvalds 已提交
1298
{
1299
	struct klist_iter i;
1300
	struct device *child;
L
Linus Torvalds 已提交
1301 1302
	int error = 0;

1303 1304 1305
	if (!parent->p)
		return 0;

1306
	klist_iter_init(&parent->p->klist_children, &i);
1307 1308 1309
	while ((child = next_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
1310 1311 1312
	return error;
}

1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327
/**
 * device_find_child - device iterator for locating a particular device.
 * @parent: parent struct device
 * @data: Data to pass to match function
 * @match: Callback function to check device
 *
 * This is similar to the device_for_each_child() function above, but it
 * returns a reference to a device that is 'found' for later use, as
 * determined by the @match callback.
 *
 * The callback should return 0 if the device doesn't match and non-zero
 * if it does.  If the callback returns non-zero and a reference to the
 * current device can be obtained, this function will return to the caller
 * and not iterate over any more devices.
 */
1328 1329
struct device *device_find_child(struct device *parent, void *data,
				 int (*match)(struct device *dev, void *data))
1330 1331 1332 1333 1334 1335 1336
{
	struct klist_iter i;
	struct device *child;

	if (!parent)
		return NULL;

1337
	klist_iter_init(&parent->p->klist_children, &i);
1338 1339 1340 1341 1342 1343 1344
	while ((child = next_device(&i)))
		if (match(child, data) && get_device(child))
			break;
	klist_iter_exit(&i);
	return child;
}

L
Linus Torvalds 已提交
1345 1346
int __init devices_init(void)
{
1347 1348 1349
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	if (!devices_kset)
		return -ENOMEM;
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
	dev_kobj = kobject_create_and_add("dev", NULL);
	if (!dev_kobj)
		goto dev_kobj_err;
	sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
	if (!sysfs_dev_block_kobj)
		goto block_kobj_err;
	sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
	if (!sysfs_dev_char_kobj)
		goto char_kobj_err;

1360
	return 0;
1361 1362 1363 1364 1365 1366 1367 1368

 char_kobj_err:
	kobject_put(sysfs_dev_block_kobj);
 block_kobj_err:
	kobject_put(dev_kobj);
 dev_kobj_err:
	kset_unregister(devices_kset);
	return -ENOMEM;
L
Linus Torvalds 已提交
1369 1370 1371
}

EXPORT_SYMBOL_GPL(device_for_each_child);
1372
EXPORT_SYMBOL_GPL(device_find_child);
L
Linus Torvalds 已提交
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384

EXPORT_SYMBOL_GPL(device_initialize);
EXPORT_SYMBOL_GPL(device_add);
EXPORT_SYMBOL_GPL(device_register);

EXPORT_SYMBOL_GPL(device_del);
EXPORT_SYMBOL_GPL(device_unregister);
EXPORT_SYMBOL_GPL(get_device);
EXPORT_SYMBOL_GPL(put_device);

EXPORT_SYMBOL_GPL(device_create_file);
EXPORT_SYMBOL_GPL(device_remove_file);
1385

1386
struct root_device {
1387 1388 1389 1390
	struct device dev;
	struct module *owner;
};

1391 1392 1393 1394
inline struct root_device *to_root_device(struct device *d)
{
	return container_of(d, struct root_device, dev);
}
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418

static void root_device_release(struct device *dev)
{
	kfree(to_root_device(dev));
}

/**
 * __root_device_register - allocate and register a root device
 * @name: root device name
 * @owner: owner module of the root device, usually THIS_MODULE
 *
 * This function allocates a root device and registers it
 * using device_register(). In order to free the returned
 * device, use root_device_unregister().
 *
 * Root devices are dummy devices which allow other devices
 * to be grouped under /sys/devices. Use this function to
 * allocate a root device and then use it as the parent of
 * any device which should appear under /sys/devices/{name}
 *
 * The /sys/devices/{name} directory will also contain a
 * 'module' symlink which points to the @owner directory
 * in sysfs.
 *
1419 1420
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
 * Note: You probably want to use root_device_register().
 */
struct device *__root_device_register(const char *name, struct module *owner)
{
	struct root_device *root;
	int err = -ENOMEM;

	root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
	if (!root)
		return ERR_PTR(err);

1432
	err = dev_set_name(&root->dev, "%s", name);
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
	if (err) {
		kfree(root);
		return ERR_PTR(err);
	}

	root->dev.release = root_device_release;

	err = device_register(&root->dev);
	if (err) {
		put_device(&root->dev);
		return ERR_PTR(err);
	}

1446
#ifdef CONFIG_MODULES	/* gotta find a "cleaner" way to do this */
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
	if (owner) {
		struct module_kobject *mk = &owner->mkobj;

		err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
		if (err) {
			device_unregister(&root->dev);
			return ERR_PTR(err);
		}
		root->owner = owner;
	}
#endif

	return &root->dev;
}
EXPORT_SYMBOL_GPL(__root_device_register);

/**
 * root_device_unregister - unregister and free a root device
1465
 * @dev: device going away
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
 *
 * This function unregisters and cleans up a device that was created by
 * root_device_register().
 */
void root_device_unregister(struct device *dev)
{
	struct root_device *root = to_root_device(dev);

	if (root->owner)
		sysfs_remove_link(&root->dev.kobj, "module");

	device_unregister(dev);
}
EXPORT_SYMBOL_GPL(root_device_unregister);

1481 1482 1483

static void device_create_release(struct device *dev)
{
1484
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1485 1486 1487 1488
	kfree(dev);
}

/**
1489
 * device_create_vargs - creates a device and registers it with sysfs
1490 1491 1492
 * @class: pointer to the struct class that this device should be registered to
 * @parent: pointer to the parent struct device of this new device, if any
 * @devt: the dev_t for the char device to be added
1493
 * @drvdata: the data to be added to the device for callbacks
1494
 * @fmt: string for the device's name
1495
 * @args: va_list for the device's name
1496 1497 1498
 *
 * This function can be used by char device classes.  A struct device
 * will be created in sysfs, registered to the specified class.
1499 1500 1501
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
1502 1503 1504 1505
 * If a pointer to a parent struct device is passed in, the newly created
 * struct device will be a child of that device in sysfs.
 * The pointer to the struct device will be returned from the call.
 * Any further sysfs files that might be required can be created using this
1506 1507
 * pointer.
 *
1508 1509
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
1510 1511 1512
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
1513 1514 1515
struct device *device_create_vargs(struct class *class, struct device *parent,
				   dev_t devt, void *drvdata, const char *fmt,
				   va_list args)
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
{
	struct device *dev = NULL;
	int retval = -ENODEV;

	if (class == NULL || IS_ERR(class))
		goto error;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev) {
		retval = -ENOMEM;
		goto error;
	}

	dev->devt = devt;
	dev->class = class;
	dev->parent = parent;
	dev->release = device_create_release;
1533
	dev_set_drvdata(dev, drvdata);
1534

1535 1536 1537 1538
	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
	if (retval)
		goto error;

1539 1540 1541 1542 1543 1544 1545
	retval = device_register(dev);
	if (retval)
		goto error;

	return dev;

error:
1546
	put_device(dev);
1547 1548
	return ERR_PTR(retval);
}
1549 1550 1551
EXPORT_SYMBOL_GPL(device_create_vargs);

/**
1552
 * device_create - creates a device and registers it with sysfs
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
 * @class: pointer to the struct class that this device should be registered to
 * @parent: pointer to the parent struct device of this new device, if any
 * @devt: the dev_t for the char device to be added
 * @drvdata: the data to be added to the device for callbacks
 * @fmt: string for the device's name
 *
 * This function can be used by char device classes.  A struct device
 * will be created in sysfs, registered to the specified class.
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
 * If a pointer to a parent struct device is passed in, the newly created
 * struct device will be a child of that device in sysfs.
 * The pointer to the struct device will be returned from the call.
 * Any further sysfs files that might be required can be created using this
 * pointer.
 *
1570 1571
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
1572 1573 1574
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
1575 1576
struct device *device_create(struct class *class, struct device *parent,
			     dev_t devt, void *drvdata, const char *fmt, ...)
1577 1578 1579 1580 1581 1582 1583 1584 1585
{
	va_list vargs;
	struct device *dev;

	va_start(vargs, fmt);
	dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
	va_end(vargs);
	return dev;
}
1586
EXPORT_SYMBOL_GPL(device_create);
1587

1588
static int __match_devt(struct device *dev, void *data)
1589
{
1590
	dev_t *devt = data;
1591

1592
	return dev->devt == *devt;
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605
}

/**
 * device_destroy - removes a device that was created with device_create()
 * @class: pointer to the struct class that this device was registered with
 * @devt: the dev_t of the device that was previously registered
 *
 * This call unregisters and cleans up a device that was created with a
 * call to device_create().
 */
void device_destroy(struct class *class, dev_t devt)
{
	struct device *dev;
1606

1607
	dev = class_find_device(class, NULL, &devt, __match_devt);
1608 1609
	if (dev) {
		put_device(dev);
1610
		device_unregister(dev);
1611
	}
1612 1613
}
EXPORT_SYMBOL_GPL(device_destroy);
1614 1615 1616 1617 1618

/**
 * device_rename - renames a device
 * @dev: the pointer to the struct device to be renamed
 * @new_name: the new name of the device
1619 1620 1621 1622 1623
 *
 * It is the responsibility of the caller to provide mutual
 * exclusion between two different calls of device_rename
 * on the same device to ensure that new_name is valid and
 * won't conflict with other devices.
1624
 *
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
 * Note: Don't call this function.  Currently, the networking layer calls this
 * function, but that will change.  The following text from Kay Sievers offers
 * some insight:
 *
 * Renaming devices is racy at many levels, symlinks and other stuff are not
 * replaced atomically, and you get a "move" uevent, but it's not easy to
 * connect the event to the old and new device. Device nodes are not renamed at
 * all, there isn't even support for that in the kernel now.
 *
 * In the meantime, during renaming, your target name might be taken by another
 * driver, creating conflicts. Or the old name is taken directly after you
 * renamed it -- then you get events for the same DEVPATH, before you even see
 * the "move" event. It's just a mess, and nothing new should ever rely on
 * kernel device renaming. Besides that, it's not even implemented now for
 * other things than (driver-core wise very simple) network devices.
 *
 * We are currently about to change network renaming in udev to completely
 * disallow renaming of devices in the same namespace as the kernel uses,
 * because we can't solve the problems properly, that arise with swapping names
 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
 * be allowed to some other name than eth[0-9]*, for the aforementioned
 * reasons.
 *
 * Make up a "real" name in the driver before you register anything, or add
 * some other attributes for userspace to find the device, or use udev to add
 * symlinks -- but never rename kernel devices later, it's a complete mess. We
 * don't even want to get into that and try to implement the missing pieces in
 * the core. We really have other pieces to fix in the driver core mess. :)
1653
 */
1654
int device_rename(struct device *dev, const char *new_name)
1655 1656 1657
{
	char *old_class_name = NULL;
	char *new_class_name = NULL;
1658
	char *old_device_name = NULL;
1659 1660 1661 1662 1663 1664
	int error;

	dev = get_device(dev);
	if (!dev)
		return -EINVAL;

1665
	pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
1666
		 __func__, new_name);
1667

1668
	old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1669 1670 1671
	if (!old_device_name) {
		error = -ENOMEM;
		goto out;
1672 1673
	}

1674
	if (dev->class) {
1675
		error = sysfs_rename_link(&dev->class->p->subsys.kobj,
1676 1677 1678 1679
			&dev->kobj, old_device_name, new_name);
		if (error)
			goto out;
	}
1680

1681
	error = kobject_rename(&dev->kobj, new_name);
1682
	if (error)
1683
		goto out;
1684

1685
out:
1686 1687 1688
	put_device(dev);

	kfree(new_class_name);
1689
	kfree(old_class_name);
1690
	kfree(old_device_name);
1691 1692 1693

	return error;
}
1694
EXPORT_SYMBOL_GPL(device_rename);
1695 1696 1697 1698 1699

static int device_move_class_links(struct device *dev,
				   struct device *old_parent,
				   struct device *new_parent)
{
1700
	int error = 0;
1701

1702 1703 1704 1705 1706 1707
	if (old_parent)
		sysfs_remove_link(&dev->kobj, "device");
	if (new_parent)
		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
					  "device");
	return error;
1708 1709 1710 1711 1712
}

/**
 * device_move - moves a device to a new parent
 * @dev: the pointer to the struct device to be moved
1713
 * @new_parent: the new parent of the device (can by NULL)
1714
 * @dpm_order: how to reorder the dpm_list
1715
 */
1716 1717
int device_move(struct device *dev, struct device *new_parent,
		enum dpm_order dpm_order)
1718 1719 1720
{
	int error;
	struct device *old_parent;
1721
	struct kobject *new_parent_kobj;
1722 1723 1724 1725 1726

	dev = get_device(dev);
	if (!dev)
		return -EINVAL;

1727
	device_pm_lock();
1728
	new_parent = get_device(new_parent);
1729
	new_parent_kobj = get_device_parent(dev, new_parent);
1730

1731 1732
	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
		 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1733
	error = kobject_move(&dev->kobj, new_parent_kobj);
1734
	if (error) {
1735
		cleanup_glue_dir(dev, new_parent_kobj);
1736 1737 1738 1739 1740 1741
		put_device(new_parent);
		goto out;
	}
	old_parent = dev->parent;
	dev->parent = new_parent;
	if (old_parent)
1742
		klist_remove(&dev->p->knode_parent);
1743
	if (new_parent) {
1744 1745
		klist_add_tail(&dev->p->knode_parent,
			       &new_parent->p->klist_children);
1746 1747 1748
		set_dev_node(dev, dev_to_node(new_parent));
	}

1749 1750 1751 1752 1753 1754 1755
	if (!dev->class)
		goto out_put;
	error = device_move_class_links(dev, old_parent, new_parent);
	if (error) {
		/* We ignore errors on cleanup since we're hosed anyway... */
		device_move_class_links(dev, new_parent, old_parent);
		if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1756
			if (new_parent)
1757
				klist_remove(&dev->p->knode_parent);
1758 1759
			dev->parent = old_parent;
			if (old_parent) {
1760 1761
				klist_add_tail(&dev->p->knode_parent,
					       &old_parent->p->klist_children);
1762 1763
				set_dev_node(dev, dev_to_node(old_parent));
			}
1764
		}
1765
		cleanup_glue_dir(dev, new_parent_kobj);
1766 1767 1768
		put_device(new_parent);
		goto out;
	}
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
	switch (dpm_order) {
	case DPM_ORDER_NONE:
		break;
	case DPM_ORDER_DEV_AFTER_PARENT:
		device_pm_move_after(dev, new_parent);
		break;
	case DPM_ORDER_PARENT_BEFORE_DEV:
		device_pm_move_before(new_parent, dev);
		break;
	case DPM_ORDER_DEV_LAST:
		device_pm_move_last(dev);
		break;
	}
1782 1783 1784
out_put:
	put_device(old_parent);
out:
1785
	device_pm_unlock();
1786 1787 1788 1789
	put_device(dev);
	return error;
}
EXPORT_SYMBOL_GPL(device_move);
1790 1791 1792 1793 1794 1795

/**
 * device_shutdown - call ->shutdown() on each device to shutdown.
 */
void device_shutdown(void)
{
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
	struct device *dev;

	spin_lock(&devices_kset->list_lock);
	/*
	 * Walk the devices list backward, shutting down each in turn.
	 * Beware that device unplug events may also start pulling
	 * devices offline, even as the system is shutting down.
	 */
	while (!list_empty(&devices_kset->list)) {
		dev = list_entry(devices_kset->list.prev, struct device,
				kobj.entry);
		get_device(dev);
		/*
		 * Make sure the device is off the kset list, in the
		 * event that dev->*->shutdown() doesn't remove it.
		 */
		list_del_init(&dev->kobj.entry);
		spin_unlock(&devices_kset->list_lock);
1814 1815 1816 1817

		/* Don't allow any more runtime suspends */
		pm_runtime_get_noresume(dev);
		pm_runtime_barrier(dev);
1818 1819 1820 1821 1822 1823 1824 1825

		if (dev->bus && dev->bus->shutdown) {
			dev_dbg(dev, "shutdown\n");
			dev->bus->shutdown(dev);
		} else if (dev->driver && dev->driver->shutdown) {
			dev_dbg(dev, "shutdown\n");
			dev->driver->shutdown(dev);
		}
1826 1827 1828
		put_device(dev);

		spin_lock(&devices_kset->list_lock);
1829
	}
1830
	spin_unlock(&devices_kset->list_lock);
1831
	async_synchronize_full();
1832
}
1833 1834 1835 1836 1837 1838 1839

/*
 * Device logging functions
 */

#ifdef CONFIG_PRINTK

1840 1841
int __dev_printk(const char *level, const struct device *dev,
		 struct va_format *vaf)
1842 1843 1844 1845 1846 1847 1848
{
	if (!dev)
		return printk("%s(NULL device *): %pV", level, vaf);

	return printk("%s%s %s: %pV",
		      level, dev_driver_string(dev), dev_name(dev), vaf);
}
1849
EXPORT_SYMBOL(__dev_printk);
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897

int dev_printk(const char *level, const struct device *dev,
	       const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;
	int r;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

	r = __dev_printk(level, dev, &vaf);
	va_end(args);

	return r;
}
EXPORT_SYMBOL(dev_printk);

#define define_dev_printk_level(func, kern_level)		\
int func(const struct device *dev, const char *fmt, ...)	\
{								\
	struct va_format vaf;					\
	va_list args;						\
	int r;							\
								\
	va_start(args, fmt);					\
								\
	vaf.fmt = fmt;						\
	vaf.va = &args;						\
								\
	r = __dev_printk(kern_level, dev, &vaf);		\
	va_end(args);						\
								\
	return r;						\
}								\
EXPORT_SYMBOL(func);

define_dev_printk_level(dev_emerg, KERN_EMERG);
define_dev_printk_level(dev_alert, KERN_ALERT);
define_dev_printk_level(dev_crit, KERN_CRIT);
define_dev_printk_level(dev_err, KERN_ERR);
define_dev_printk_level(dev_warn, KERN_WARNING);
define_dev_printk_level(dev_notice, KERN_NOTICE);
define_dev_printk_level(_dev_info, KERN_INFO);

#endif