core.c 22.6 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>
L
Linus Torvalds 已提交
21 22 23 24 25 26 27 28 29 30 31 32 33

#include <asm/semaphore.h>

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

int (*platform_notify)(struct device * dev) = NULL;
int (*platform_notify_remove)(struct device * dev) = NULL;

/*
 * sysfs bindings for devices.
 */

34 35 36 37 38 39 40 41 42 43 44 45 46 47
/**
 * 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.
 */
const char *dev_driver_string(struct device *dev)
{
	return dev->driver ? dev->driver->name :
			(dev->bus ? dev->bus->name : "");
}
M
Matthew Wilcox 已提交
48
EXPORT_SYMBOL(dev_driver_string);
49

L
Linus Torvalds 已提交
50 51 52 53 54 55 56 57
#define to_dev(obj) container_of(obj, struct device, kobj)
#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)

static ssize_t
dev_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
{
	struct device_attribute * dev_attr = to_dev_attr(attr);
	struct device * dev = to_dev(kobj);
58
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
59 60

	if (dev_attr->show)
61
		ret = dev_attr->show(dev, dev_attr, buf);
L
Linus Torvalds 已提交
62 63 64 65 66 67 68 69 70
	return ret;
}

static ssize_t
dev_attr_store(struct kobject * kobj, struct attribute * attr,
	       const char * buf, size_t count)
{
	struct device_attribute * dev_attr = to_dev_attr(attr);
	struct device * dev = to_dev(kobj);
71
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
72 73

	if (dev_attr->store)
74
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
	return ret;
}

static struct sysfs_ops dev_sysfs_ops = {
	.show	= dev_attr_show,
	.store	= dev_attr_store,
};


/**
 *	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.
 */
static void device_release(struct kobject * kobj)
{
	struct device * dev = to_dev(kobj);

	if (dev->release)
		dev->release(dev);
98 99
	else if (dev->class && dev->class->dev_release)
		dev->class->dev_release(dev);
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112 113
	else {
		printk(KERN_ERR "Device '%s' does not have a release() function, "
			"it is broken and must be fixed.\n",
			dev->bus_id);
		WARN_ON(1);
	}
}

static struct kobj_type ktype_device = {
	.release	= device_release,
	.sysfs_ops	= &dev_sysfs_ops,
};


114
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
115 116 117 118 119 120 121
{
	struct kobj_type *ktype = get_ktype(kobj);

	if (ktype == &ktype_device) {
		struct device *dev = to_dev(kobj);
		if (dev->bus)
			return 1;
122 123
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
124 125 126 127
	}
	return 0;
}

128
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
129 130 131
{
	struct device *dev = to_dev(kobj);

132 133 134 135 136
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
137 138
}

139
static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
L
Linus Torvalds 已提交
140 141 142 143 144 145 146
			int num_envp, char *buffer, int buffer_size)
{
	struct device *dev = to_dev(kobj);
	int i = 0;
	int length = 0;
	int retval = 0;

147 148 149 150 151 152 153 154 155 156
	/* add the major/minor if present */
	if (MAJOR(dev->devt)) {
		add_uevent_var(envp, num_envp, &i,
			       buffer, buffer_size, &length,
			       "MAJOR=%u", MAJOR(dev->devt));
		add_uevent_var(envp, num_envp, &i,
			       buffer, buffer_size, &length,
			       "MINOR=%u", MINOR(dev->devt));
	}

157
#ifdef CONFIG_SYSFS_DEPRECATED
K
Kay Sievers 已提交
158
	/* add bus name (same as SUBSYSTEM, deprecated) */
L
Linus Torvalds 已提交
159
	if (dev->bus)
160 161 162
		add_uevent_var(envp, num_envp, &i,
			       buffer, buffer_size, &length,
			       "PHYSDEVBUS=%s", dev->bus->name);
163
#endif
L
Linus Torvalds 已提交
164

K
Kay Sievers 已提交
165 166 167 168 169
	/* add driver name (PHYSDEV* values are deprecated)*/
	if (dev->driver) {
		add_uevent_var(envp, num_envp, &i,
			       buffer, buffer_size, &length,
			       "DRIVER=%s", dev->driver->name);
170
#ifdef CONFIG_SYSFS_DEPRECATED
171 172 173
		add_uevent_var(envp, num_envp, &i,
			       buffer, buffer_size, &length,
			       "PHYSDEVDRIVER=%s", dev->driver->name);
174
#endif
K
Kay Sievers 已提交
175
	}
L
Linus Torvalds 已提交
176 177 178 179 180 181 182 183

	/* terminate, set to next free slot, shrink available space */
	envp[i] = NULL;
	envp = &envp[i];
	num_envp -= i;
	buffer = &buffer[length];
	buffer_size -= length;

184
	if (dev->bus && dev->bus->uevent) {
L
Linus Torvalds 已提交
185
		/* have the bus specific function add its stuff */
186
		retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size);
L
Linus Torvalds 已提交
187
			if (retval) {
188
			pr_debug ("%s - uevent() returned %d\n",
L
Linus Torvalds 已提交
189 190 191 192
				  __FUNCTION__, retval);
		}
	}

193 194 195 196 197 198 199 200 201
	if (dev->class && dev->class->dev_uevent) {
		/* have the class specific function add its stuff */
		retval = dev->class->dev_uevent(dev, envp, num_envp, buffer, buffer_size);
			if (retval) {
				pr_debug("%s - dev_uevent() returned %d\n",
					 __FUNCTION__, retval);
		}
	}

L
Linus Torvalds 已提交
202 203 204
	return retval;
}

205 206 207 208
static struct kset_uevent_ops device_uevent_ops = {
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
209 210
};

211 212 213
static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
214
	kobject_uevent(&dev->kobj, KOBJ_ADD);
215 216 217
	return count;
}

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
static int device_add_groups(struct device *dev)
{
	int i;
	int error = 0;

	if (dev->groups) {
		for (i = 0; dev->groups[i]; i++) {
			error = sysfs_create_group(&dev->kobj, dev->groups[i]);
			if (error) {
				while (--i >= 0)
					sysfs_remove_group(&dev->kobj, dev->groups[i]);
				goto out;
			}
		}
	}
out:
	return error;
}

static void device_remove_groups(struct device *dev)
{
	int i;
	if (dev->groups) {
		for (i = 0; dev->groups[i]; i++) {
			sysfs_remove_group(&dev->kobj, dev->groups[i]);
		}
	}
}

247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
static int device_add_attrs(struct device *dev)
{
	struct class *class = dev->class;
	int error = 0;
	int i;

	if (!class)
		return 0;

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

static void device_remove_attrs(struct device *dev)
{
	struct class *class = dev->class;
	int i;

	if (!class)
		return;

	if (class->dev_attrs) {
		for (i = 0; attr_name(class->dev_attrs[i]); i++)
			device_remove_file(dev, &class->dev_attrs[i]);
	}
}


284 285 286 287 288 289
static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}

290 291
/*
 *	devices_subsys - structure to be registered with kobject core.
L
Linus Torvalds 已提交
292 293
 */

294
decl_subsys(devices, &ktype_device, &device_uevent_ops);
L
Linus Torvalds 已提交
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326


/**
 *	device_create_file - create sysfs attribute file for device.
 *	@dev:	device.
 *	@attr:	device attribute descriptor.
 */

int device_create_file(struct device * dev, struct device_attribute * attr)
{
	int error = 0;
	if (get_device(dev)) {
		error = sysfs_create_file(&dev->kobj, &attr->attr);
		put_device(dev);
	}
	return error;
}

/**
 *	device_remove_file - remove sysfs attribute file.
 *	@dev:	device.
 *	@attr:	device attribute descriptor.
 */

void device_remove_file(struct device * dev, struct device_attribute * attr)
{
	if (get_device(dev)) {
		sysfs_remove_file(&dev->kobj, &attr->attr);
		put_device(dev);
	}
}

327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
/**
 * device_create_bin_file - create sysfs binary attribute file for device.
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
int device_create_bin_file(struct device *dev, struct bin_attribute *attr)
{
	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.
 */
void device_remove_bin_file(struct device *dev, struct bin_attribute *attr)
{
	if (dev)
		sysfs_remove_bin_file(&dev->kobj, attr);
}
EXPORT_SYMBOL_GPL(device_remove_bin_file);

353 354 355 356 357 358 359 360 361 362 363 364 365 366
static void klist_children_get(struct klist_node *n)
{
	struct device *dev = container_of(n, struct device, knode_parent);

	get_device(dev);
}

static void klist_children_put(struct klist_node *n)
{
	struct device *dev = container_of(n, struct device, knode_parent);

	put_device(dev);
}

L
Linus Torvalds 已提交
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382

/**
 *	device_initialize - init device structure.
 *	@dev:	device.
 *
 *	This prepares the device for use by other layers,
 *	including adding it to the device hierarchy.
 *	It is the first half of device_register(), if called by
 *	that, though it can also be called separately, so one
 *	may use @dev's fields (e.g. the refcount).
 */

void device_initialize(struct device *dev)
{
	kobj_set_kset_s(dev, devices_subsys);
	kobject_init(&dev->kobj);
383 384
	klist_init(&dev->klist_children, klist_children_get,
		   klist_children_put);
L
Linus Torvalds 已提交
385
	INIT_LIST_HEAD(&dev->dma_pools);
386
	INIT_LIST_HEAD(&dev->node);
387
	init_MUTEX(&dev->sem);
D
David Brownell 已提交
388
	device_init_wakeup(dev, 0);
L
Linus Torvalds 已提交
389 390
}

391 392 393 394 395 396 397 398 399 400 401 402 403
#ifdef CONFIG_SYSFS_DEPRECATED
int setup_parent(struct device *dev, struct device *parent)
{
	/* Set the parent to the class, not the parent device */
	/* this keeps sysfs from having a symlink to make old udevs happy */
	if (dev->class)
		dev->kobj.parent = &dev->class->subsys.kset.kobj;
	else if (parent)
		dev->kobj.parent = &parent->kobj;

	return 0;
}
#else
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
static int virtual_device_parent(struct device *dev)
{
	if (!dev->class)
		return -ENODEV;

	if (!dev->class->virtual_dir) {
		static struct kobject *virtual_dir = NULL;

		if (!virtual_dir)
			virtual_dir = kobject_add_dir(&devices_subsys.kset.kobj, "virtual");
		dev->class->virtual_dir = kobject_add_dir(virtual_dir, dev->class->name);
	}

	dev->kobj.parent = dev->class->virtual_dir;
	return 0;
}

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
int setup_parent(struct device *dev, struct device *parent)
{
	int error;

	/* if this is a class device, and has no parent, create one */
	if ((dev->class) && (parent == NULL)) {
		error = virtual_device_parent(dev);
		if (error)
			return error;
	} else if (parent)
		dev->kobj.parent = &parent->kobj;

	return 0;
}
#endif

L
Linus Torvalds 已提交
437 438 439 440 441 442 443 444 445 446 447 448 449 450
/**
 *	device_add - add device to device hierarchy.
 *	@dev:	device.
 *
 *	This is part 2 of device_register(), though may be called
 *	separately _iff_ device_initialize() has been called separately.
 *
 *	This adds it to the kobject hierarchy via kobject_add(), adds it
 *	to the global and sibling lists for the device, then
 *	adds it to the other relevant subsystems of the driver model.
 */
int device_add(struct device *dev)
{
	struct device *parent = NULL;
451
	char *class_name = NULL;
452
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
453 454 455 456 457 458
	int error = -EINVAL;

	dev = get_device(dev);
	if (!dev || !strlen(dev->bus_id))
		goto Error;

459
	pr_debug("DEV: registering device: ID = '%s'\n", dev->bus_id);
460

L
Linus Torvalds 已提交
461 462
	parent = get_device(dev->parent);

463 464 465
	error = setup_parent(dev, parent);
	if (error)
		goto Error;
L
Linus Torvalds 已提交
466 467 468

	/* first, register with generic layer. */
	kobject_set_name(&dev->kobj, "%s", dev->bus_id);
469 470
	error = kobject_add(&dev->kobj);
	if (error)
L
Linus Torvalds 已提交
471
		goto Error;
472

473 474 475 476
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);

477 478 479 480 481
	/* notify clients of device entry (new way) */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->bus_notifier,
					     BUS_NOTIFY_ADD_DEVICE, dev);

482 483 484 485 486
	dev->uevent_attr.attr.name = "uevent";
	dev->uevent_attr.attr.mode = S_IWUSR;
	if (dev->driver)
		dev->uevent_attr.attr.owner = dev->driver->owner;
	dev->uevent_attr.store = store_uevent;
487 488 489
	error = device_create_file(dev, &dev->uevent_attr);
	if (error)
		goto attrError;
490

491 492 493 494 495
	if (MAJOR(dev->devt)) {
		struct device_attribute *attr;
		attr = kzalloc(sizeof(*attr), GFP_KERNEL);
		if (!attr) {
			error = -ENOMEM;
496
			goto ueventattrError;
497 498 499 500 501 502 503 504 505
		}
		attr->attr.name = "dev";
		attr->attr.mode = S_IRUGO;
		if (dev->driver)
			attr->attr.owner = dev->driver->owner;
		attr->show = show_dev;
		error = device_create_file(dev, attr);
		if (error) {
			kfree(attr);
506
			goto ueventattrError;
507 508 509 510 511
		}

		dev->devt_attr = attr;
	}

512 513 514
	if (dev->class) {
		sysfs_create_link(&dev->kobj, &dev->class->subsys.kset.kobj,
				  "subsystem");
515 516 517 518 519
		/* If this is not a "fake" compatible device, then create the
		 * symlink from the class to the device. */
		if (dev->kobj.parent != &dev->class->subsys.kset.kobj)
			sysfs_create_link(&dev->class->subsys.kset.kobj,
					  &dev->kobj, dev->bus_id);
520
#ifdef CONFIG_SYSFS_DEPRECATED
521 522 523 524 525
		if (parent) {
			sysfs_create_link(&dev->kobj, &dev->parent->kobj, "device");
			class_name = make_class_name(dev->class->name, &dev->kobj);
			sysfs_create_link(&dev->parent->kobj, &dev->kobj, class_name);
		}
526
#endif
527
	}
528

529 530
	if ((error = device_add_attrs(dev)))
		goto AttrsError;
531 532
	if ((error = device_add_groups(dev)))
		goto GroupError;
L
Linus Torvalds 已提交
533 534 535 536
	if ((error = device_pm_add(dev)))
		goto PMError;
	if ((error = bus_add_device(dev)))
		goto BusError;
537
	kobject_uevent(&dev->kobj, KOBJ_ADD);
538 539
	if ((error = bus_attach_device(dev)))
		goto AttachError;
L
Linus Torvalds 已提交
540
	if (parent)
541
		klist_add_tail(&dev->knode_parent, &parent->klist_children);
L
Linus Torvalds 已提交
542

543 544
	if (dev->class) {
		down(&dev->class->sem);
545
		/* tie the class to the device */
546
		list_add_tail(&dev->node, &dev->class->devices);
547 548 549 550 551

		/* notify any interfaces that the device is here */
		list_for_each_entry(class_intf, &dev->class->interfaces, node)
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
552 553
		up(&dev->class->sem);
	}
L
Linus Torvalds 已提交
554
 Done:
555
 	kfree(class_name);
L
Linus Torvalds 已提交
556 557
	put_device(dev);
	return error;
558 559
 AttachError:
	bus_remove_device(dev);
L
Linus Torvalds 已提交
560 561 562
 BusError:
	device_pm_remove(dev);
 PMError:
563 564 565
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->bus_notifier,
					     BUS_NOTIFY_DEL_DEVICE, dev);
566 567
	device_remove_groups(dev);
 GroupError:
568 569
 	device_remove_attrs(dev);
 AttrsError:
570 571 572 573
	if (dev->devt_attr) {
		device_remove_file(dev, dev->devt_attr);
		kfree(dev->devt_attr);
	}
574 575
 ueventattrError:
	device_remove_file(dev, &dev->uevent_attr);
576
 attrError:
577
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
L
Linus Torvalds 已提交
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
	kobject_del(&dev->kobj);
 Error:
	if (parent)
		put_device(parent);
	goto Done;
}


/**
 *	device_register - register a device with the system.
 *	@dev:	pointer to the device structure
 *
 *	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.
 */

int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}


/**
 *	get_device - increment reference count for device.
 *	@dev:	device.
 *
 *	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.
 */

struct device * get_device(struct device * dev)
{
	return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
}


/**
 *	put_device - decrement reference count.
 *	@dev:	device in question.
 */
void put_device(struct device * dev)
{
	if (dev)
		kobject_put(&dev->kobj);
}


/**
 *	device_del - delete device from system.
 *	@dev:	device.
 *
 *	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.
 *
 *	NOTE: this should be called manually _iff_ device_add() was
 *	also called manually.
 */

void device_del(struct device * dev)
{
	struct device * parent = dev->parent;
648
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
649 650

	if (parent)
651
		klist_del(&dev->knode_parent);
652
	if (dev->devt_attr) {
653
		device_remove_file(dev, dev->devt_attr);
654 655
		kfree(dev->devt_attr);
	}
656 657
	if (dev->class) {
		sysfs_remove_link(&dev->kobj, "subsystem");
658 659 660 661 662
		/* If this is not a "fake" compatible device, remove the
		 * symlink from the class to the device. */
		if (dev->kobj.parent != &dev->class->subsys.kset.kobj)
			sysfs_remove_link(&dev->class->subsys.kset.kobj,
					  dev->bus_id);
663
#ifdef CONFIG_SYSFS_DEPRECATED
664
		if (parent) {
665 666
			char *class_name = make_class_name(dev->class->name,
							   &dev->kobj);
667
			sysfs_remove_link(&dev->parent->kobj, class_name);
668 669
			kfree(class_name);
			sysfs_remove_link(&dev->kobj, "device");
670
		}
671 672
#endif

673
		down(&dev->class->sem);
674 675 676 677 678
		/* notify any interfaces that the device is now gone */
		list_for_each_entry(class_intf, &dev->class->interfaces, node)
			if (class_intf->remove_dev)
				class_intf->remove_dev(dev, class_intf);
		/* remove the device from the class list */
679 680
		list_del_init(&dev->node);
		up(&dev->class->sem);
681
	}
682
	device_remove_file(dev, &dev->uevent_attr);
683
	device_remove_groups(dev);
684
	device_remove_attrs(dev);
L
Linus Torvalds 已提交
685 686 687 688 689 690

	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
691 692 693
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->bus_notifier,
					     BUS_NOTIFY_DEL_DEVICE, dev);
L
Linus Torvalds 已提交
694 695
	bus_remove_device(dev);
	device_pm_remove(dev);
696
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
L
Linus Torvalds 已提交
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
	kobject_del(&dev->kobj);
	if (parent)
		put_device(parent);
}

/**
 *	device_unregister - unregister device from system.
 *	@dev:	device going away.
 *
 *	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.
 */
void device_unregister(struct device * dev)
{
	pr_debug("DEV: Unregistering device. ID = '%s'\n", dev->bus_id);
	device_del(dev);
	put_device(dev);
}


721 722 723 724 725 726
static struct device * next_device(struct klist_iter * i)
{
	struct klist_node * n = klist_next(i);
	return n ? container_of(n, struct device, knode_parent) : NULL;
}

L
Linus Torvalds 已提交
727 728
/**
 *	device_for_each_child - device child iterator.
729
 *	@parent: parent struct device.
L
Linus Torvalds 已提交
730 731 732
 *	@data:	data for the callback.
 *	@fn:	function to be called for each device.
 *
733
 *	Iterate over @parent's child devices, and call @fn for each,
L
Linus Torvalds 已提交
734 735 736 737 738
 *	passing it @data.
 *
 *	We check the return of @fn each time. If it returns anything
 *	other than 0, we break out and return that value.
 */
739
int device_for_each_child(struct device * parent, void * data,
L
Linus Torvalds 已提交
740 741
		     int (*fn)(struct device *, void *))
{
742
	struct klist_iter i;
L
Linus Torvalds 已提交
743 744 745
	struct device * child;
	int error = 0;

746 747 748 749
	klist_iter_init(&parent->klist_children, &i);
	while ((child = next_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
	return error;
}

int __init devices_init(void)
{
	return subsystem_register(&devices_subsys);
}

EXPORT_SYMBOL_GPL(device_for_each_child);

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);
771 772 773 774 775 776 777 778 779 780


static void device_create_release(struct device *dev)
{
	pr_debug("%s called for %s\n", __FUNCTION__, dev->bus_id);
	kfree(dev);
}

/**
 * device_create - creates a device and registers it with sysfs
781 782 783 784 785 786 787
 * @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
 * @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.
788 789 790
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
791 792 793 794
 * 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
795 796 797 798 799 800
 * pointer.
 *
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
struct device *device_create(struct class *class, struct device *parent,
801
			     dev_t devt, const char *fmt, ...)
802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
{
	va_list args;
	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;

	va_start(args, fmt);
	vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args);
	va_end(args);
	retval = device_register(dev);
	if (retval)
		goto error;

	return dev;

error:
	kfree(dev);
	return ERR_PTR(retval);
}
EXPORT_SYMBOL_GPL(device_create);

/**
 * device_destroy - removes a device that was created with device_create()
838 839
 * @class: pointer to the struct class that this device was registered with
 * @devt: the dev_t of the device that was previously registered
840
 *
841 842
 * This call unregisters and cleans up a device that was created with a
 * call to device_create().
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
 */
void device_destroy(struct class *class, dev_t devt)
{
	struct device *dev = NULL;
	struct device *dev_tmp;

	down(&class->sem);
	list_for_each_entry(dev_tmp, &class->devices, node) {
		if (dev_tmp->devt == devt) {
			dev = dev_tmp;
			break;
		}
	}
	up(&class->sem);

858
	if (dev)
859 860 861
		device_unregister(dev);
}
EXPORT_SYMBOL_GPL(device_destroy);
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880

/**
 * device_rename - renames a device
 * @dev: the pointer to the struct device to be renamed
 * @new_name: the new name of the device
 */
int device_rename(struct device *dev, char *new_name)
{
	char *old_class_name = NULL;
	char *new_class_name = NULL;
	char *old_symlink_name = NULL;
	int error;

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

	pr_debug("DEVICE: renaming '%s' to '%s'\n", dev->bus_id, new_name);

881
#ifdef CONFIG_SYSFS_DEPRECATED
882 883
	if ((dev->class) && (dev->parent))
		old_class_name = make_class_name(dev->class->name, &dev->kobj);
884
#endif
885 886 887

	if (dev->class) {
		old_symlink_name = kmalloc(BUS_ID_SIZE, GFP_KERNEL);
888 889 890 891
		if (!old_symlink_name) {
			error = -ENOMEM;
			goto out_free_old_class;
		}
892 893 894 895 896 897 898
		strlcpy(old_symlink_name, dev->bus_id, BUS_ID_SIZE);
	}

	strlcpy(dev->bus_id, new_name, BUS_ID_SIZE);

	error = kobject_rename(&dev->kobj, new_name);

899
#ifdef CONFIG_SYSFS_DEPRECATED
900 901 902 903 904 905 906 907
	if (old_class_name) {
		new_class_name = make_class_name(dev->class->name, &dev->kobj);
		if (new_class_name) {
			sysfs_create_link(&dev->parent->kobj, &dev->kobj,
					  new_class_name);
			sysfs_remove_link(&dev->parent->kobj, old_class_name);
		}
	}
908 909
#endif

910 911 912 913 914 915 916 917 918 919
	if (dev->class) {
		sysfs_remove_link(&dev->class->subsys.kset.kobj,
				  old_symlink_name);
		sysfs_create_link(&dev->class->subsys.kset.kobj, &dev->kobj,
				  dev->bus_id);
	}
	put_device(dev);

	kfree(new_class_name);
	kfree(old_symlink_name);
920 921
 out_free_old_class:
	kfree(old_class_name);
922 923 924

	return error;
}