core.c 15.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * 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
 *
 * 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>
17
#include <linux/kdev_t.h>
L
Linus Torvalds 已提交
18 19 20 21 22 23 24 25 26 27 28 29 30

#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.
 */

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
/**
 * 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 : "");
}
EXPORT_SYMBOL_GPL(dev_driver_string);

L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54
#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);
55
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
56 57

	if (dev_attr->show)
58
		ret = dev_attr->show(dev, dev_attr, buf);
L
Linus Torvalds 已提交
59 60 61 62 63 64 65 66 67
	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);
68
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
69 70

	if (dev_attr->store)
71
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
	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);
	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,
};


109
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
110 111 112 113 114 115 116
{
	struct kobj_type *ktype = get_ktype(kobj);

	if (ktype == &ktype_device) {
		struct device *dev = to_dev(kobj);
		if (dev->bus)
			return 1;
117 118
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
119 120 121 122
	}
	return 0;
}

123
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
124 125 126
{
	struct device *dev = to_dev(kobj);

127 128 129 130 131
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
132 133
}

134
static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
L
Linus Torvalds 已提交
135 136 137 138 139 140 141
			int num_envp, char *buffer, int buffer_size)
{
	struct device *dev = to_dev(kobj);
	int i = 0;
	int length = 0;
	int retval = 0;

142 143 144 145 146 147 148 149 150 151
	/* 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));
	}

L
Linus Torvalds 已提交
152 153
	/* add bus name of physical device */
	if (dev->bus)
154 155 156
		add_uevent_var(envp, num_envp, &i,
			       buffer, buffer_size, &length,
			       "PHYSDEVBUS=%s", dev->bus->name);
L
Linus Torvalds 已提交
157 158 159

	/* add driver name of physical device */
	if (dev->driver)
160 161 162
		add_uevent_var(envp, num_envp, &i,
			       buffer, buffer_size, &length,
			       "PHYSDEVDRIVER=%s", dev->driver->name);
L
Linus Torvalds 已提交
163 164 165 166 167 168 169 170

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

171
	if (dev->bus && dev->bus->uevent) {
L
Linus Torvalds 已提交
172
		/* have the bus specific function add its stuff */
173
		retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size);
L
Linus Torvalds 已提交
174
			if (retval) {
175
			pr_debug ("%s - uevent() returned %d\n",
L
Linus Torvalds 已提交
176 177 178 179 180 181 182
				  __FUNCTION__, retval);
		}
	}

	return retval;
}

183 184 185 186
static struct kset_uevent_ops device_uevent_ops = {
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
187 188
};

189 190 191
static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
192
	kobject_uevent(&dev->kobj, KOBJ_ADD);
193 194 195
	return count;
}

196 197 198 199 200 201
static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}

202 203
/*
 *	devices_subsys - structure to be registered with kobject core.
L
Linus Torvalds 已提交
204 205
 */

206
decl_subsys(devices, &ktype_device, &device_uevent_ops);
L
Linus Torvalds 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238


/**
 *	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);
	}
}

239 240 241 242 243 244 245 246 247 248 249 250 251 252
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 已提交
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268

/**
 *	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);
269 270
	klist_init(&dev->klist_children, klist_children_get,
		   klist_children_put);
L
Linus Torvalds 已提交
271
	INIT_LIST_HEAD(&dev->dma_pools);
272
	INIT_LIST_HEAD(&dev->node);
273
	init_MUTEX(&dev->sem);
D
David Brownell 已提交
274
	device_init_wakeup(dev, 0);
L
Linus Torvalds 已提交
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
}

/**
 *	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;
291
	char *class_name = NULL;
L
Linus Torvalds 已提交
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
	int error = -EINVAL;

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

	parent = get_device(dev->parent);

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

	/* first, register with generic layer. */
	kobject_set_name(&dev->kobj, "%s", dev->bus_id);
	if (parent)
		dev->kobj.parent = &parent->kobj;

	if ((error = kobject_add(&dev->kobj)))
		goto Error;
309 310 311 312 313 314 315 316

	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;
	device_create_file(dev, &dev->uevent_attr);

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
	if (MAJOR(dev->devt)) {
		struct device_attribute *attr;
		attr = kzalloc(sizeof(*attr), GFP_KERNEL);
		if (!attr) {
			error = -ENOMEM;
			goto PMError;
		}
		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);
			goto attrError;
		}

		dev->devt_attr = attr;
	}

338 339 340
	if (dev->class) {
		sysfs_create_link(&dev->kobj, &dev->class->subsys.kset.kobj,
				  "subsystem");
341 342
		sysfs_create_link(&dev->class->subsys.kset.kobj, &dev->kobj,
				  dev->bus_id);
343 344 345 346

		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);
347
	}
348

L
Linus Torvalds 已提交
349 350 351 352
	if ((error = device_pm_add(dev)))
		goto PMError;
	if ((error = bus_add_device(dev)))
		goto BusError;
353 354
	kobject_uevent(&dev->kobj, KOBJ_ADD);
	bus_attach_device(dev);
L
Linus Torvalds 已提交
355
	if (parent)
356
		klist_add_tail(&dev->knode_parent, &parent->klist_children);
L
Linus Torvalds 已提交
357

358 359 360 361 362 363 364
	if (dev->class) {
		/* tie the class to the device */
		down(&dev->class->sem);
		list_add_tail(&dev->node, &dev->class->devices);
		up(&dev->class->sem);
	}

L
Linus Torvalds 已提交
365 366 367 368
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);
 Done:
369
 	kfree(class_name);
L
Linus Torvalds 已提交
370 371 372 373 374
	put_device(dev);
	return error;
 BusError:
	device_pm_remove(dev);
 PMError:
375 376 377 378 379
	if (dev->devt_attr) {
		device_remove_file(dev, dev->devt_attr);
		kfree(dev->devt_attr);
	}
 attrError:
380
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
L
Linus Torvalds 已提交
381 382 383 384 385 386 387 388 389 390 391 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 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
	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;
451
	char *class_name = NULL;
L
Linus Torvalds 已提交
452 453

	if (parent)
454
		klist_del(&dev->knode_parent);
455 456
	if (dev->devt_attr)
		device_remove_file(dev, dev->devt_attr);
457 458
	if (dev->class) {
		sysfs_remove_link(&dev->kobj, "subsystem");
459
		sysfs_remove_link(&dev->class->subsys.kset.kobj, dev->bus_id);
460 461 462 463
		class_name = make_class_name(dev->class->name, &dev->kobj);
		sysfs_remove_link(&dev->kobj, "device");
		sysfs_remove_link(&dev->parent->kobj, class_name);
		kfree(class_name);
464 465 466
		down(&dev->class->sem);
		list_del_init(&dev->node);
		up(&dev->class->sem);
467
	}
468
	device_remove_file(dev, &dev->uevent_attr);
L
Linus Torvalds 已提交
469 470 471 472 473 474 475 476

	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
	bus_remove_device(dev);
	device_pm_remove(dev);
477
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
L
Linus Torvalds 已提交
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
	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);
}


502 503 504 505 506 507
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 已提交
508 509
/**
 *	device_for_each_child - device child iterator.
510
 *	@parent: parent struct device.
L
Linus Torvalds 已提交
511 512 513
 *	@data:	data for the callback.
 *	@fn:	function to be called for each device.
 *
514
 *	Iterate over @parent's child devices, and call @fn for each,
L
Linus Torvalds 已提交
515 516 517 518 519
 *	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.
 */
520
int device_for_each_child(struct device * parent, void * data,
L
Linus Torvalds 已提交
521 522
		     int (*fn)(struct device *, void *))
{
523
	struct klist_iter i;
L
Linus Torvalds 已提交
524 525 526
	struct device * child;
	int error = 0;

527 528 529 530
	klist_iter_init(&parent->klist_children, &i);
	while ((child = next_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
	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);
552 553 554 555 556 557 558 559 560 561


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
562 563 564 565 566 567 568
 * @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.
569 570 571
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
572 573 574 575
 * 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
576 577 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
 * 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,
			     dev_t devt, char *fmt, ...)
{
	va_list args;
	struct device *dev = NULL;
	int retval = -ENODEV;

	if (class == NULL || IS_ERR(class))
		goto error;
	if (parent == NULL) {
		printk(KERN_WARNING "%s does not work yet for NULL parents\n", __FUNCTION__);
		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()
623 624
 * @class: pointer to the struct class that this device was registered with
 * @devt: the dev_t of the device that was previously registered
625
 *
626 627
 * This call unregisters and cleans up a device that was created with a
 * call to device_create().
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
 */
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);

643
	if (dev)
644 645 646
		device_unregister(dev);
}
EXPORT_SYMBOL_GPL(device_destroy);