core.c 72.9 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
 *
 * This file is released under the GPLv2
 *
 */

#include <linux/device.h>
#include <linux/err.h>
15
#include <linux/fwnode.h>
L
Linus Torvalds 已提交
16 17 18 19
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
20
#include <linux/kdev_t.h>
21
#include <linux/notifier.h>
22 23
#include <linux/of.h>
#include <linux/of_device.h>
24
#include <linux/genhd.h>
25
#include <linux/kallsyms.h>
26
#include <linux/mutex.h>
27
#include <linux/pm_runtime.h>
28
#include <linux/netdevice.h>
29
#include <linux/sysfs.h>
L
Linus Torvalds 已提交
30 31 32 33

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

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

47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 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 109 110 111 112 113 114 115 116 117 118 119 120 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 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 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 239 240 241 242 243 244 245 246 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 284 285 286 287 288 289 290 291 292 293 294 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 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 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 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 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
/* Device links support. */

#ifdef CONFIG_SRCU
static DEFINE_MUTEX(device_links_lock);
DEFINE_STATIC_SRCU(device_links_srcu);

static inline void device_links_write_lock(void)
{
	mutex_lock(&device_links_lock);
}

static inline void device_links_write_unlock(void)
{
	mutex_unlock(&device_links_lock);
}

int device_links_read_lock(void)
{
	return srcu_read_lock(&device_links_srcu);
}

void device_links_read_unlock(int idx)
{
	srcu_read_unlock(&device_links_srcu, idx);
}
#else /* !CONFIG_SRCU */
static DECLARE_RWSEM(device_links_lock);

static inline void device_links_write_lock(void)
{
	down_write(&device_links_lock);
}

static inline void device_links_write_unlock(void)
{
	up_write(&device_links_lock);
}

int device_links_read_lock(void)
{
	down_read(&device_links_lock);
	return 0;
}

void device_links_read_unlock(int not_used)
{
	up_read(&device_links_lock);
}
#endif /* !CONFIG_SRCU */

/**
 * device_is_dependent - Check if one device depends on another one
 * @dev: Device to check dependencies for.
 * @target: Device to check against.
 *
 * Check if @target depends on @dev or any device dependent on it (its child or
 * its consumer etc).  Return 1 if that is the case or 0 otherwise.
 */
static int device_is_dependent(struct device *dev, void *target)
{
	struct device_link *link;
	int ret;

	if (WARN_ON(dev == target))
		return 1;

	ret = device_for_each_child(dev, target, device_is_dependent);
	if (ret)
		return ret;

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (WARN_ON(link->consumer == target))
			return 1;

		ret = device_is_dependent(link->consumer, target);
		if (ret)
			break;
	}
	return ret;
}

static int device_reorder_to_tail(struct device *dev, void *not_used)
{
	struct device_link *link;

	/*
	 * Devices that have not been registered yet will be put to the ends
	 * of the lists during the registration, so skip them here.
	 */
	if (device_is_registered(dev))
		devices_kset_move_last(dev);

	if (device_pm_initialized(dev))
		device_pm_move_last(dev);

	device_for_each_child(dev, NULL, device_reorder_to_tail);
	list_for_each_entry(link, &dev->links.consumers, s_node)
		device_reorder_to_tail(link->consumer, NULL);

	return 0;
}

/**
 * device_link_add - Create a link between two devices.
 * @consumer: Consumer end of the link.
 * @supplier: Supplier end of the link.
 * @flags: Link flags.
 *
 * If the DL_FLAG_AUTOREMOVE is set, the link will be removed automatically
 * when the consumer device driver unbinds from it.  The combination of both
 * DL_FLAG_AUTOREMOVE and DL_FLAG_STATELESS set is invalid and will cause NULL
 * to be returned.
 *
 * A side effect of the link creation is re-ordering of dpm_list and the
 * devices_kset list by moving the consumer device and all devices depending
 * on it to the ends of these lists (that does not happen to devices that have
 * not been registered when this function is called).
 *
 * The supplier device is required to be registered when this function is called
 * and NULL will be returned if that is not the case.  The consumer device need
 * not be registerd, however.
 */
struct device_link *device_link_add(struct device *consumer,
				    struct device *supplier, u32 flags)
{
	struct device_link *link;

	if (!consumer || !supplier ||
	    ((flags & DL_FLAG_STATELESS) && (flags & DL_FLAG_AUTOREMOVE)))
		return NULL;

	device_links_write_lock();
	device_pm_lock();

	/*
	 * If the supplier has not been fully registered yet or there is a
	 * reverse dependency between the consumer and the supplier already in
	 * the graph, return NULL.
	 */
	if (!device_pm_initialized(supplier)
	    || device_is_dependent(consumer, supplier)) {
		link = NULL;
		goto out;
	}

	list_for_each_entry(link, &supplier->links.consumers, s_node)
		if (link->consumer == consumer)
			goto out;

	link = kmalloc(sizeof(*link), GFP_KERNEL);
	if (!link)
		goto out;

	get_device(supplier);
	link->supplier = supplier;
	INIT_LIST_HEAD(&link->s_node);
	get_device(consumer);
	link->consumer = consumer;
	INIT_LIST_HEAD(&link->c_node);
	link->flags = flags;

	/* Deterine the initial link state. */
	if (flags & DL_FLAG_STATELESS) {
		link->status = DL_STATE_NONE;
	} else {
		switch (supplier->links.status) {
		case DL_DEV_DRIVER_BOUND:
			switch (consumer->links.status) {
			case DL_DEV_PROBING:
				link->status = DL_STATE_CONSUMER_PROBE;
				break;
			case DL_DEV_DRIVER_BOUND:
				link->status = DL_STATE_ACTIVE;
				break;
			default:
				link->status = DL_STATE_AVAILABLE;
				break;
			}
			break;
		case DL_DEV_UNBINDING:
			link->status = DL_STATE_SUPPLIER_UNBIND;
			break;
		default:
			link->status = DL_STATE_DORMANT;
			break;
		}
	}

	/*
	 * Move the consumer and all of the devices depending on it to the end
	 * of dpm_list and the devices_kset list.
	 *
	 * It is necessary to hold dpm_list locked throughout all that or else
	 * we may end up suspending with a wrong ordering of it.
	 */
	device_reorder_to_tail(consumer, NULL);

	list_add_tail_rcu(&link->s_node, &supplier->links.consumers);
	list_add_tail_rcu(&link->c_node, &consumer->links.suppliers);

	dev_info(consumer, "Linked as a consumer to %s\n", dev_name(supplier));

 out:
	device_pm_unlock();
	device_links_write_unlock();
	return link;
}
EXPORT_SYMBOL_GPL(device_link_add);

static void device_link_free(struct device_link *link)
{
	put_device(link->consumer);
	put_device(link->supplier);
	kfree(link);
}

#ifdef CONFIG_SRCU
static void __device_link_free_srcu(struct rcu_head *rhead)
{
	device_link_free(container_of(rhead, struct device_link, rcu_head));
}

static void __device_link_del(struct device_link *link)
{
	dev_info(link->consumer, "Dropping the link to %s\n",
		 dev_name(link->supplier));

	list_del_rcu(&link->s_node);
	list_del_rcu(&link->c_node);
	call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu);
}
#else /* !CONFIG_SRCU */
static void __device_link_del(struct device_link *link)
{
	dev_info(link->consumer, "Dropping the link to %s\n",
		 dev_name(link->supplier));

	list_del(&link->s_node);
	list_del(&link->c_node);
	device_link_free(link);
}
#endif /* !CONFIG_SRCU */

/**
 * device_link_del - Delete a link between two devices.
 * @link: Device link to delete.
 *
 * The caller must ensure proper synchronization of this function with runtime
 * PM.
 */
void device_link_del(struct device_link *link)
{
	device_links_write_lock();
	device_pm_lock();
	__device_link_del(link);
	device_pm_unlock();
	device_links_write_unlock();
}
EXPORT_SYMBOL_GPL(device_link_del);

static void device_links_missing_supplier(struct device *dev)
{
	struct device_link *link;

	list_for_each_entry(link, &dev->links.suppliers, c_node)
		if (link->status == DL_STATE_CONSUMER_PROBE)
			WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
}

/**
 * device_links_check_suppliers - Check presence of supplier drivers.
 * @dev: Consumer device.
 *
 * Check links from this device to any suppliers.  Walk the list of the device's
 * links to suppliers and see if all of them are available.  If not, simply
 * return -EPROBE_DEFER.
 *
 * We need to guarantee that the supplier will not go away after the check has
 * been positive here.  It only can go away in __device_release_driver() and
 * that function  checks the device's links to consumers.  This means we need to
 * mark the link as "consumer probe in progress" to make the supplier removal
 * wait for us to complete (or bad things may happen).
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
int device_links_check_suppliers(struct device *dev)
{
	struct device_link *link;
	int ret = 0;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.suppliers, c_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		if (link->status != DL_STATE_AVAILABLE) {
			device_links_missing_supplier(dev);
			ret = -EPROBE_DEFER;
			break;
		}
		WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
	}
	dev->links.status = DL_DEV_PROBING;

	device_links_write_unlock();
	return ret;
}

/**
 * device_links_driver_bound - Update device links after probing its driver.
 * @dev: Device to update the links for.
 *
 * The probe has been successful, so update links from this device to any
 * consumers by changing their status to "available".
 *
 * Also change the status of @dev's links to suppliers to "active".
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
void device_links_driver_bound(struct device *dev)
{
	struct device_link *link;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		WARN_ON(link->status != DL_STATE_DORMANT);
		WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
	}

	list_for_each_entry(link, &dev->links.suppliers, c_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		WARN_ON(link->status != DL_STATE_CONSUMER_PROBE);
		WRITE_ONCE(link->status, DL_STATE_ACTIVE);
	}

	dev->links.status = DL_DEV_DRIVER_BOUND;

	device_links_write_unlock();
}

/**
 * __device_links_no_driver - Update links of a device without a driver.
 * @dev: Device without a drvier.
 *
 * Delete all non-persistent links from this device to any suppliers.
 *
 * Persistent links stay around, but their status is changed to "available",
 * unless they already are in the "supplier unbind in progress" state in which
 * case they need not be updated.
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
static void __device_links_no_driver(struct device *dev)
{
	struct device_link *link, *ln;

	list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		if (link->flags & DL_FLAG_AUTOREMOVE)
			__device_link_del(link);
		else if (link->status != DL_STATE_SUPPLIER_UNBIND)
			WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
	}

	dev->links.status = DL_DEV_NO_DRIVER;
}

void device_links_no_driver(struct device *dev)
{
	device_links_write_lock();
	__device_links_no_driver(dev);
	device_links_write_unlock();
}

/**
 * device_links_driver_cleanup - Update links after driver removal.
 * @dev: Device whose driver has just gone away.
 *
 * Update links to consumers for @dev by changing their status to "dormant" and
 * invoke %__device_links_no_driver() to update links to suppliers for it as
 * appropriate.
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
void device_links_driver_cleanup(struct device *dev)
{
	struct device_link *link;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		WARN_ON(link->flags & DL_FLAG_AUTOREMOVE);
		WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND);
		WRITE_ONCE(link->status, DL_STATE_DORMANT);
	}

	__device_links_no_driver(dev);

	device_links_write_unlock();
}

/**
 * device_links_busy - Check if there are any busy links to consumers.
 * @dev: Device to check.
 *
 * Check each consumer of the device and return 'true' if its link's status
 * is one of "consumer probe" or "active" (meaning that the given consumer is
 * probing right now or its driver is present).  Otherwise, change the link
 * state to "supplier unbind" to prevent the consumer from being probed
 * successfully going forward.
 *
 * Return 'false' if there are no probing or active consumers.
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
bool device_links_busy(struct device *dev)
{
	struct device_link *link;
	bool ret = false;

	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		if (link->flags & DL_FLAG_STATELESS)
			continue;

		if (link->status == DL_STATE_CONSUMER_PROBE
		    || link->status == DL_STATE_ACTIVE) {
			ret = true;
			break;
		}
		WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
	}

	dev->links.status = DL_DEV_UNBINDING;

	device_links_write_unlock();
	return ret;
}

/**
 * device_links_unbind_consumers - Force unbind consumers of the given device.
 * @dev: Device to unbind the consumers of.
 *
 * Walk the list of links to consumers for @dev and if any of them is in the
 * "consumer probe" state, wait for all device probes in progress to complete
 * and start over.
 *
 * If that's not the case, change the status of the link to "supplier unbind"
 * and check if the link was in the "active" state.  If so, force the consumer
 * driver to unbind and start over (the consumer will not re-probe as we have
 * changed the state of the link already).
 *
 * Links with the DL_FLAG_STATELESS flag set are ignored.
 */
void device_links_unbind_consumers(struct device *dev)
{
	struct device_link *link;

 start:
	device_links_write_lock();

	list_for_each_entry(link, &dev->links.consumers, s_node) {
		enum device_link_state status;

		if (link->flags & DL_FLAG_STATELESS)
			continue;

		status = link->status;
		if (status == DL_STATE_CONSUMER_PROBE) {
			device_links_write_unlock();

			wait_for_device_probe();
			goto start;
		}
		WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
		if (status == DL_STATE_ACTIVE) {
			struct device *consumer = link->consumer;

			get_device(consumer);

			device_links_write_unlock();

			device_release_driver_internal(consumer, NULL,
						       consumer->parent);
			put_device(consumer);
			goto start;
		}
	}

	device_links_write_unlock();
}

/**
 * device_links_purge - Delete existing links to other devices.
 * @dev: Target device.
 */
static void device_links_purge(struct device *dev)
{
	struct device_link *link, *ln;

	/*
	 * Delete all of the remaining links from this device to any other
	 * devices (either consumers or suppliers).
	 */
	device_links_write_lock();

	list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
		WARN_ON(link->status == DL_STATE_ACTIVE);
		__device_link_del(link);
	}

	list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) {
		WARN_ON(link->status != DL_STATE_DORMANT &&
			link->status != DL_STATE_NONE);
		__device_link_del(link);
	}

	device_links_write_unlock();
}

/* Device links support end. */

582 583
int (*platform_notify)(struct device *dev) = NULL;
int (*platform_notify_remove)(struct device *dev) = NULL;
584 585 586
static struct kobject *dev_kobj;
struct kobject *sysfs_dev_char_kobj;
struct kobject *sysfs_dev_block_kobj;
L
Linus Torvalds 已提交
587

588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
static DEFINE_MUTEX(device_hotplug_lock);

void lock_device_hotplug(void)
{
	mutex_lock(&device_hotplug_lock);
}

void unlock_device_hotplug(void)
{
	mutex_unlock(&device_hotplug_lock);
}

int lock_device_hotplug_sysfs(void)
{
	if (mutex_trylock(&device_hotplug_lock))
		return 0;

	/* Avoid busy looping (5 ms of sleep should do). */
	msleep(5);
	return restart_syscall();
}

610 611 612 613 614 615 616 617 618 619 620
#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 已提交
621

622 623 624 625 626
/**
 * 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
627
 * the device is not bound to a driver, it will return the name of the bus
628 629 630
 * it is attached to.  If it is not attached to a bus either, an empty
 * string will be returned.
 */
631
const char *dev_driver_string(const struct device *dev)
632
{
633 634 635 636 637 638 639 640
	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 :
641 642
			(dev->bus ? dev->bus->name :
			(dev->class ? dev->class->name : ""));
643
}
644
EXPORT_SYMBOL(dev_driver_string);
645

L
Linus Torvalds 已提交
646 647
#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)

648 649
static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
			     char *buf)
L
Linus Torvalds 已提交
650
{
651
	struct device_attribute *dev_attr = to_dev_attr(attr);
652
	struct device *dev = kobj_to_dev(kobj);
653
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
654 655

	if (dev_attr->show)
656
		ret = dev_attr->show(dev, dev_attr, buf);
657
	if (ret >= (ssize_t)PAGE_SIZE) {
658 659
		print_symbol("dev_attr_show: %s returned bad count\n",
				(unsigned long)dev_attr->show);
660
	}
L
Linus Torvalds 已提交
661 662 663
	return ret;
}

664 665
static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
			      const char *buf, size_t count)
L
Linus Torvalds 已提交
666
{
667
	struct device_attribute *dev_attr = to_dev_attr(attr);
668
	struct device *dev = kobj_to_dev(kobj);
669
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
670 671

	if (dev_attr->store)
672
		ret = dev_attr->store(dev, dev_attr, buf, count);
L
Linus Torvalds 已提交
673 674 675
	return ret;
}

676
static const struct sysfs_ops dev_sysfs_ops = {
L
Linus Torvalds 已提交
677 678 679 680
	.show	= dev_attr_show,
	.store	= dev_attr_store,
};

681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
#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 已提交
731

732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t size)
{
	struct dev_ext_attribute *ea = to_ext_attr(attr);

	if (strtobool(buf, ea->var) < 0)
		return -EINVAL;

	return size;
}
EXPORT_SYMBOL_GPL(device_store_bool);

ssize_t device_show_bool(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", *(bool *)(ea->var));
}
EXPORT_SYMBOL_GPL(device_show_bool);

L
Linus Torvalds 已提交
753
/**
754 755
 * device_release - free device structure.
 * @kobj: device's kobject.
L
Linus Torvalds 已提交
756
 *
757 758 759
 * 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.
L
Linus Torvalds 已提交
760
 */
761
static void device_release(struct kobject *kobj)
L
Linus Torvalds 已提交
762
{
763
	struct device *dev = kobj_to_dev(kobj);
764
	struct device_private *p = dev->p;
L
Linus Torvalds 已提交
765

766 767 768 769 770 771 772 773 774 775 776
	/*
	 * Some platform devices are driven without driver attached
	 * and managed resources may have been acquired.  Make sure
	 * all resources are released.
	 *
	 * Drivers still can add resources into device after device
	 * is deleted but alive, so release devres here to avoid
	 * possible memory leak.
	 */
	devres_release_all(dev);

L
Linus Torvalds 已提交
777 778
	if (dev->release)
		dev->release(dev);
779 780
	else if (dev->type && dev->type->release)
		dev->type->release(dev);
781 782
	else if (dev->class && dev->class->dev_release)
		dev->class->dev_release(dev);
783 784
	else
		WARN(1, KERN_ERR "Device '%s' does not have a release() "
785
			"function, it is broken and must be fixed.\n",
786
			dev_name(dev));
787
	kfree(p);
L
Linus Torvalds 已提交
788 789
}

790 791
static const void *device_namespace(struct kobject *kobj)
{
792
	struct device *dev = kobj_to_dev(kobj);
793 794 795 796 797 798 799 800
	const void *ns = NULL;

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

	return ns;
}

801
static struct kobj_type device_ktype = {
L
Linus Torvalds 已提交
802 803
	.release	= device_release,
	.sysfs_ops	= &dev_sysfs_ops,
804
	.namespace	= device_namespace,
L
Linus Torvalds 已提交
805 806 807
};


808
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
809 810 811
{
	struct kobj_type *ktype = get_ktype(kobj);

812
	if (ktype == &device_ktype) {
813
		struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
814 815
		if (dev->bus)
			return 1;
816 817
		if (dev->class)
			return 1;
L
Linus Torvalds 已提交
818 819 820 821
	}
	return 0;
}

822
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
L
Linus Torvalds 已提交
823
{
824
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
825

826 827 828 829 830
	if (dev->bus)
		return dev->bus->name;
	if (dev->class)
		return dev->class->name;
	return NULL;
L
Linus Torvalds 已提交
831 832
}

833 834
static int dev_uevent(struct kset *kset, struct kobject *kobj,
		      struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
835
{
836
	struct device *dev = kobj_to_dev(kobj);
L
Linus Torvalds 已提交
837 838
	int retval = 0;

839
	/* add device node properties if present */
840
	if (MAJOR(dev->devt)) {
841 842
		const char *tmp;
		const char *name;
843
		umode_t mode = 0;
844 845
		kuid_t uid = GLOBAL_ROOT_UID;
		kgid_t gid = GLOBAL_ROOT_GID;
846

847 848
		add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
849
		name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
850 851
		if (name) {
			add_uevent_var(env, "DEVNAME=%s", name);
852 853
			if (mode)
				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
854 855 856 857
			if (!uid_eq(uid, GLOBAL_ROOT_UID))
				add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
			if (!gid_eq(gid, GLOBAL_ROOT_GID))
				add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
858
			kfree(tmp);
859
		}
860 861
	}

862
	if (dev->type && dev->type->name)
863
		add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
864

865
	if (dev->driver)
866
		add_uevent_var(env, "DRIVER=%s", dev->driver->name);
867

868 869 870
	/* Add common DT information about the device */
	of_device_uevent(dev, env);

871
	/* have the bus specific function add its stuff */
872
	if (dev->bus && dev->bus->uevent) {
873
		retval = dev->bus->uevent(dev, env);
874
		if (retval)
875
			pr_debug("device: '%s': %s: bus uevent() returned %d\n",
876
				 dev_name(dev), __func__, retval);
L
Linus Torvalds 已提交
877 878
	}

879
	/* have the class specific function add its stuff */
880
	if (dev->class && dev->class->dev_uevent) {
881
		retval = dev->class->dev_uevent(dev, env);
882
		if (retval)
883
			pr_debug("device: '%s': %s: class uevent() "
884
				 "returned %d\n", dev_name(dev),
885
				 __func__, retval);
886 887
	}

888
	/* have the device type specific function add its stuff */
889
	if (dev->type && dev->type->uevent) {
890
		retval = dev->type->uevent(dev, env);
891
		if (retval)
892
			pr_debug("device: '%s': %s: dev_type uevent() "
893
				 "returned %d\n", dev_name(dev),
894
				 __func__, retval);
895 896
	}

L
Linus Torvalds 已提交
897 898 899
	return retval;
}

900
static const struct kset_uevent_ops device_uevent_ops = {
901 902 903
	.filter =	dev_uevent_filter,
	.name =		dev_uevent_name,
	.uevent =	dev_uevent,
L
Linus Torvalds 已提交
904 905
};

906
static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
907 908 909 910
			   char *buf)
{
	struct kobject *top_kobj;
	struct kset *kset;
911
	struct kobj_uevent_env *env = NULL;
912 913 914 915 916 917
	int i;
	size_t count = 0;
	int retval;

	/* search the kset, the device belongs to */
	top_kobj = &dev->kobj;
918 919
	while (!top_kobj->kset && top_kobj->parent)
		top_kobj = top_kobj->parent;
920 921
	if (!top_kobj->kset)
		goto out;
922

923 924 925 926 927 928 929 930 931
	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;

932 933
	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
	if (!env)
934 935
		return -ENOMEM;

936
	/* let the kset specific function add its keys */
937
	retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
938 939 940 941
	if (retval)
		goto out;

	/* copy keys to file */
942 943
	for (i = 0; i < env->envp_idx; i++)
		count += sprintf(&buf[count], "%s\n", env->envp[i]);
944
out:
945
	kfree(env);
946 947 948
	return count;
}

949
static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
950 951
			    const char *buf, size_t count)
{
952 953
	enum kobject_action action;

954
	if (kobject_action_type(buf, count, &action) == 0)
955
		kobject_uevent(&dev->kobj, action);
956 957
	else
		dev_err(dev, "uevent: unknown action-string\n");
958 959
	return count;
}
960
static DEVICE_ATTR_RW(uevent);
961

962
static ssize_t online_show(struct device *dev, struct device_attribute *attr,
963 964 965 966
			   char *buf)
{
	bool val;

967
	device_lock(dev);
968
	val = !dev->offline;
969
	device_unlock(dev);
970 971 972
	return sprintf(buf, "%u\n", val);
}

973
static ssize_t online_store(struct device *dev, struct device_attribute *attr,
974 975 976 977 978 979 980 981 982
			    const char *buf, size_t count)
{
	bool val;
	int ret;

	ret = strtobool(buf, &val);
	if (ret < 0)
		return ret;

983 984 985 986
	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;

987 988 989 990
	ret = val ? device_online(dev) : device_offline(dev);
	unlock_device_hotplug();
	return ret < 0 ? ret : count;
}
991
static DEVICE_ATTR_RW(online);
992

993
int device_add_groups(struct device *dev, const struct attribute_group **groups)
994
{
995
	return sysfs_create_groups(&dev->kobj, groups);
996 997
}

998 999
void device_remove_groups(struct device *dev,
			  const struct attribute_group **groups)
1000
{
1001
	sysfs_remove_groups(&dev->kobj, groups);
1002 1003
}

1004 1005 1006
static int device_add_attrs(struct device *dev)
{
	struct class *class = dev->class;
1007
	const struct device_type *type = dev->type;
1008
	int error;
1009

1010
	if (class) {
1011
		error = device_add_groups(dev, class->dev_groups);
1012
		if (error)
1013
			return error;
1014
	}
1015

1016 1017
	if (type) {
		error = device_add_groups(dev, type->groups);
1018
		if (error)
1019
			goto err_remove_class_groups;
1020 1021
	}

1022 1023 1024 1025
	error = device_add_groups(dev, dev->groups);
	if (error)
		goto err_remove_type_groups;

1026
	if (device_supports_offline(dev) && !dev->offline_disabled) {
1027
		error = device_create_file(dev, &dev_attr_online);
1028
		if (error)
1029
			goto err_remove_dev_groups;
1030 1031
	}

1032 1033
	return 0;

1034 1035
 err_remove_dev_groups:
	device_remove_groups(dev, dev->groups);
1036 1037 1038
 err_remove_type_groups:
	if (type)
		device_remove_groups(dev, type->groups);
1039 1040 1041
 err_remove_class_groups:
	if (class)
		device_remove_groups(dev, class->dev_groups);
1042

1043 1044 1045 1046 1047 1048
	return error;
}

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

1051
	device_remove_file(dev, &dev_attr_online);
1052
	device_remove_groups(dev, dev->groups);
1053

1054 1055 1056
	if (type)
		device_remove_groups(dev, type->groups);

1057
	if (class)
1058
		device_remove_groups(dev, class->dev_groups);
1059 1060
}

1061
static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
1062 1063 1064 1065
			char *buf)
{
	return print_dev_t(buf, dev->devt);
}
1066
static DEVICE_ATTR_RO(dev);
1067

1068
/* /sys/devices/ */
1069
struct kset *devices_kset;
L
Linus Torvalds 已提交
1070

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
/**
 * devices_kset_move_before - Move device in the devices_kset's list.
 * @deva: Device to move.
 * @devb: Device @deva should come before.
 */
static void devices_kset_move_before(struct device *deva, struct device *devb)
{
	if (!devices_kset)
		return;
	pr_debug("devices_kset: Moving %s before %s\n",
		 dev_name(deva), dev_name(devb));
	spin_lock(&devices_kset->list_lock);
	list_move_tail(&deva->kobj.entry, &devb->kobj.entry);
	spin_unlock(&devices_kset->list_lock);
}

/**
 * devices_kset_move_after - Move device in the devices_kset's list.
 * @deva: Device to move
 * @devb: Device @deva should come after.
 */
static void devices_kset_move_after(struct device *deva, struct device *devb)
{
	if (!devices_kset)
		return;
	pr_debug("devices_kset: Moving %s after %s\n",
		 dev_name(deva), dev_name(devb));
	spin_lock(&devices_kset->list_lock);
	list_move(&deva->kobj.entry, &devb->kobj.entry);
	spin_unlock(&devices_kset->list_lock);
}

/**
 * devices_kset_move_last - move the device to the end of devices_kset's list.
 * @dev: device to move
 */
void devices_kset_move_last(struct device *dev)
{
	if (!devices_kset)
		return;
	pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev));
	spin_lock(&devices_kset->list_lock);
	list_move_tail(&dev->kobj.entry, &devices_kset->list);
	spin_unlock(&devices_kset->list_lock);
}

L
Linus Torvalds 已提交
1117
/**
1118 1119 1120
 * device_create_file - create sysfs attribute file for device.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
1121
 */
1122 1123
int device_create_file(struct device *dev,
		       const struct device_attribute *attr)
L
Linus Torvalds 已提交
1124 1125
{
	int error = 0;
1126 1127 1128

	if (dev) {
		WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
1129 1130
			"Attribute %s: write permission without 'store'\n",
			attr->attr.name);
1131
		WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
1132 1133
			"Attribute %s: read permission without 'show'\n",
			attr->attr.name);
L
Linus Torvalds 已提交
1134
		error = sysfs_create_file(&dev->kobj, &attr->attr);
1135 1136
	}

L
Linus Torvalds 已提交
1137 1138
	return error;
}
1139
EXPORT_SYMBOL_GPL(device_create_file);
L
Linus Torvalds 已提交
1140 1141

/**
1142 1143 1144
 * device_remove_file - remove sysfs attribute file.
 * @dev: device.
 * @attr: device attribute descriptor.
L
Linus Torvalds 已提交
1145
 */
1146 1147
void device_remove_file(struct device *dev,
			const struct device_attribute *attr)
L
Linus Torvalds 已提交
1148
{
1149
	if (dev)
L
Linus Torvalds 已提交
1150 1151
		sysfs_remove_file(&dev->kobj, &attr->attr);
}
1152
EXPORT_SYMBOL_GPL(device_remove_file);
L
Linus Torvalds 已提交
1153

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
/**
 * device_remove_file_self - remove sysfs attribute file from its own method.
 * @dev: device.
 * @attr: device attribute descriptor.
 *
 * See kernfs_remove_self() for details.
 */
bool device_remove_file_self(struct device *dev,
			     const struct device_attribute *attr)
{
	if (dev)
		return sysfs_remove_file_self(&dev->kobj, &attr->attr);
	else
		return false;
}
EXPORT_SYMBOL_GPL(device_remove_file_self);

1171 1172 1173 1174 1175
/**
 * device_create_bin_file - create sysfs binary attribute file for device.
 * @dev: device.
 * @attr: device binary attribute descriptor.
 */
1176 1177
int device_create_bin_file(struct device *dev,
			   const struct bin_attribute *attr)
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
{
	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.
 */
1191 1192
void device_remove_bin_file(struct device *dev,
			    const struct bin_attribute *attr)
1193 1194 1195 1196 1197 1198
{
	if (dev)
		sysfs_remove_bin_file(&dev->kobj, attr);
}
EXPORT_SYMBOL_GPL(device_remove_bin_file);

1199 1200
static void klist_children_get(struct klist_node *n)
{
1201 1202
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
1203 1204 1205 1206 1207 1208

	get_device(dev);
}

static void klist_children_put(struct klist_node *n)
{
1209 1210
	struct device_private *p = to_device_private_parent(n);
	struct device *dev = p->device;
1211 1212 1213 1214

	put_device(dev);
}

L
Linus Torvalds 已提交
1215
/**
1216 1217
 * device_initialize - init device structure.
 * @dev: device.
L
Linus Torvalds 已提交
1218
 *
1219 1220
 * This prepares the device for use by other layers by initializing
 * its fields.
1221
 * It is the first half of device_register(), if called by
1222 1223 1224 1225 1226
 * 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.
 *
1227 1228 1229 1230 1231
 * 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.
 *
1232 1233
 * NOTE: Use put_device() to give up your reference instead of freeing
 * @dev directly once you have called this function.
L
Linus Torvalds 已提交
1234 1235 1236
 */
void device_initialize(struct device *dev)
{
1237
	dev->kobj.kset = devices_kset;
1238
	kobject_init(&dev->kobj, &device_ktype);
L
Linus Torvalds 已提交
1239
	INIT_LIST_HEAD(&dev->dma_pools);
1240
	mutex_init(&dev->mutex);
1241
	lockdep_set_novalidate_class(&dev->mutex);
1242 1243
	spin_lock_init(&dev->devres_lock);
	INIT_LIST_HEAD(&dev->devres_head);
1244
	device_pm_init(dev);
1245
	set_dev_node(dev, -1);
1246 1247 1248
#ifdef CONFIG_GENERIC_MSI_IRQ
	INIT_LIST_HEAD(&dev->msi_list);
#endif
1249 1250 1251
	INIT_LIST_HEAD(&dev->links.consumers);
	INIT_LIST_HEAD(&dev->links.suppliers);
	dev->links.status = DL_DEV_NO_DRIVER;
L
Linus Torvalds 已提交
1252
}
1253
EXPORT_SYMBOL_GPL(device_initialize);
L
Linus Torvalds 已提交
1254

1255
struct kobject *virtual_device_parent(struct device *dev)
1256
{
1257
	static struct kobject *virtual_dir = NULL;
1258

1259
	if (!virtual_dir)
1260
		virtual_dir = kobject_create_and_add("virtual",
1261
						     &devices_kset->kobj);
1262

1263
	return virtual_dir;
1264 1265
}

1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
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)
1281
{
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
	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;
1296 1297
	int retval;

1298 1299 1300 1301 1302 1303 1304
	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
	if (!dir)
		return NULL;

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

1305
	dir->kobj.kset = &class->p->glue_dirs;
1306 1307 1308 1309 1310 1311 1312 1313 1314

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

1315
static DEFINE_MUTEX(gdp_mutex);
1316 1317 1318 1319

static struct kobject *get_device_parent(struct device *dev,
					 struct device *parent)
{
1320 1321 1322 1323 1324
	if (dev->class) {
		struct kobject *kobj = NULL;
		struct kobject *parent_kobj;
		struct kobject *k;

1325
#ifdef CONFIG_BLOCK
1326
		/* block disks show up in /sys/block */
1327
		if (sysfs_deprecated && dev->class == &block_class) {
1328 1329
			if (parent && parent->class == &block_class)
				return &parent->kobj;
1330
			return &block_class.p->subsys.kobj;
1331
		}
1332
#endif
1333

1334 1335
		/*
		 * If we have no parent, we live in "virtual".
1336 1337
		 * Class-devices with a non class-device as parent, live
		 * in a "glue" directory to prevent namespace collisions.
1338 1339 1340
		 */
		if (parent == NULL)
			parent_kobj = virtual_device_parent(dev);
1341
		else if (parent->class && !dev->class->ns_type)
1342 1343 1344 1345
			return &parent->kobj;
		else
			parent_kobj = &parent->kobj;

1346 1347
		mutex_lock(&gdp_mutex);

1348
		/* find our class-directory at the parent and reference it */
1349 1350
		spin_lock(&dev->class->p->glue_dirs.list_lock);
		list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
1351 1352 1353 1354
			if (k->parent == parent_kobj) {
				kobj = kobject_get(k);
				break;
			}
1355
		spin_unlock(&dev->class->p->glue_dirs.list_lock);
1356 1357
		if (kobj) {
			mutex_unlock(&gdp_mutex);
1358
			return kobj;
1359
		}
1360 1361

		/* or create a new class-directory at the parent device */
1362
		k = class_dir_create_and_add(dev->class, parent_kobj);
1363
		/* do not emit an uevent for this simple "glue" directory */
1364
		mutex_unlock(&gdp_mutex);
1365
		return k;
1366 1367
	}

1368 1369 1370 1371
	/* subsystems can specify a default root directory for their devices */
	if (!parent && dev->bus && dev->bus->dev_root)
		return &dev->bus->dev_root->kobj;

1372
	if (parent)
1373 1374 1375
		return &parent->kobj;
	return NULL;
}
1376

1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
static inline bool live_in_glue_dir(struct kobject *kobj,
				    struct device *dev)
{
	if (!kobj || !dev->class ||
	    kobj->kset != &dev->class->p->glue_dirs)
		return false;
	return true;
}

static inline struct kobject *get_glue_dir(struct device *dev)
{
	return dev->kobj.parent;
}

/*
 * make sure cleaning up dir as the last step, we need to make
 * sure .release handler of kobject is run with holding the
 * global lock
 */
1396
static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
1397
{
1398
	/* see if we live in a "glue" directory */
1399
	if (!live_in_glue_dir(glue_dir, dev))
1400 1401
		return;

1402
	mutex_lock(&gdp_mutex);
1403
	kobject_put(glue_dir);
1404
	mutex_unlock(&gdp_mutex);
1405
}
1406

1407 1408
static int device_add_class_symlinks(struct device *dev)
{
1409
	struct device_node *of_node = dev_of_node(dev);
1410 1411
	int error;

1412 1413 1414 1415 1416 1417 1418
	if (of_node) {
		error = sysfs_create_link(&dev->kobj, &of_node->kobj,"of_node");
		if (error)
			dev_warn(dev, "Error %d creating of_node link\n",error);
		/* An error here doesn't warrant bringing down the device */
	}

1419 1420
	if (!dev->class)
		return 0;
1421

1422
	error = sysfs_create_link(&dev->kobj,
1423
				  &dev->class->p->subsys.kobj,
1424 1425
				  "subsystem");
	if (error)
1426
		goto out_devnode;
1427

1428
	if (dev->parent && device_is_not_partition(dev)) {
1429
		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
1430 1431
					  "device");
		if (error)
1432
			goto out_subsys;
1433 1434
	}

1435
#ifdef CONFIG_BLOCK
1436
	/* /sys/block has directories and does not need symlinks */
1437
	if (sysfs_deprecated && dev->class == &block_class)
1438
		return 0;
1439
#endif
1440

1441
	/* link in the class directory pointing to the device */
1442
	error = sysfs_create_link(&dev->class->p->subsys.kobj,
1443
				  &dev->kobj, dev_name(dev));
1444
	if (error)
1445
		goto out_device;
1446 1447 1448

	return 0;

1449 1450
out_device:
	sysfs_remove_link(&dev->kobj, "device");
1451

1452 1453
out_subsys:
	sysfs_remove_link(&dev->kobj, "subsystem");
1454 1455
out_devnode:
	sysfs_remove_link(&dev->kobj, "of_node");
1456 1457 1458 1459 1460
	return error;
}

static void device_remove_class_symlinks(struct device *dev)
{
1461 1462 1463
	if (dev_of_node(dev))
		sysfs_remove_link(&dev->kobj, "of_node");

1464 1465
	if (!dev->class)
		return;
1466

1467
	if (dev->parent && device_is_not_partition(dev))
1468
		sysfs_remove_link(&dev->kobj, "device");
1469
	sysfs_remove_link(&dev->kobj, "subsystem");
1470
#ifdef CONFIG_BLOCK
1471
	if (sysfs_deprecated && dev->class == &block_class)
1472
		return;
1473
#endif
1474
	sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
1475 1476
}

1477 1478 1479
/**
 * dev_set_name - set a device name
 * @dev: device
1480
 * @fmt: format string for the device's name
1481 1482 1483 1484
 */
int dev_set_name(struct device *dev, const char *fmt, ...)
{
	va_list vargs;
1485
	int err;
1486 1487

	va_start(vargs, fmt);
1488
	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
1489
	va_end(vargs);
1490
	return err;
1491 1492 1493
}
EXPORT_SYMBOL_GPL(dev_set_name);

1494 1495 1496 1497 1498 1499 1500 1501
/**
 * 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
1502 1503
 * device_remove_sys_dev_entry() will disagree about the presence of
 * the link.
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
 */
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);
	}
}

1542 1543 1544 1545 1546 1547 1548 1549
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);
1550
	INIT_LIST_HEAD(&dev->p->deferred_probe);
1551 1552 1553
	return 0;
}

L
Linus Torvalds 已提交
1554
/**
1555 1556
 * device_add - add device to device hierarchy.
 * @dev: device.
L
Linus Torvalds 已提交
1557
 *
1558 1559
 * This is part 2 of device_register(), though may be called
 * separately _iff_ device_initialize() has been called separately.
L
Linus Torvalds 已提交
1560
 *
1561
 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
1562 1563
 * to the global and sibling lists for the device, then
 * adds it to the other relevant subsystems of the driver model.
1564
 *
1565 1566 1567 1568 1569 1570 1571
 * 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.
 *
1572 1573 1574
 * 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 已提交
1575 1576 1577 1578
 */
int device_add(struct device *dev)
{
	struct device *parent = NULL;
1579
	struct kobject *kobj;
1580
	struct class_interface *class_intf;
1581
	int error = -EINVAL;
1582
	struct kobject *glue_dir = NULL;
1583

L
Linus Torvalds 已提交
1584
	dev = get_device(dev);
1585 1586 1587
	if (!dev)
		goto done;

1588
	if (!dev->p) {
1589 1590 1591
		error = device_private_init(dev);
		if (error)
			goto done;
1592 1593
	}

1594 1595 1596 1597 1598 1599
	/*
	 * 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) {
1600
		dev_set_name(dev, "%s", dev->init_name);
1601 1602
		dev->init_name = NULL;
	}
1603

1604 1605 1606 1607
	/* 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);

1608 1609
	if (!dev_name(dev)) {
		error = -EINVAL;
1610
		goto name_error;
1611
	}
L
Linus Torvalds 已提交
1612

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

L
Linus Torvalds 已提交
1615
	parent = get_device(dev->parent);
1616 1617 1618
	kobj = get_device_parent(dev, parent);
	if (kobj)
		dev->kobj.parent = kobj;
L
Linus Torvalds 已提交
1619

1620
	/* use parent numa_node */
1621
	if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
1622 1623
		set_dev_node(dev, dev_to_node(parent));

L
Linus Torvalds 已提交
1624
	/* first, register with generic layer. */
1625 1626
	/* we require the name to be set before, and pass NULL */
	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1627 1628
	if (error) {
		glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
1629
		goto Error;
1630
	}
1631

1632 1633 1634 1635
	/* notify platform of device entry */
	if (platform_notify)
		platform_notify(dev);

1636
	error = device_create_file(dev, &dev_attr_uevent);
1637 1638
	if (error)
		goto attrError;
1639

1640 1641 1642
	error = device_add_class_symlinks(dev);
	if (error)
		goto SymlinkError;
1643 1644
	error = device_add_attrs(dev);
	if (error)
1645
		goto AttrsError;
1646 1647
	error = bus_add_device(dev);
	if (error)
L
Linus Torvalds 已提交
1648
		goto BusError;
1649
	error = dpm_sysfs_add(dev);
1650
	if (error)
1651 1652
		goto DPMError;
	device_pm_add(dev);
1653

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
	if (MAJOR(dev->devt)) {
		error = device_create_file(dev, &dev_attr_dev);
		if (error)
			goto DevAttrError;

		error = device_create_sys_dev_entry(dev);
		if (error)
			goto SysEntryError;

		devtmpfs_create_node(dev);
	}

1666
	/* Notify clients of device addition.  This call must come
1667
	 * after dpm_sysfs_add() and before kobject_uevent().
1668 1669 1670 1671 1672
	 */
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_ADD_DEVICE, dev);

1673
	kobject_uevent(&dev->kobj, KOBJ_ADD);
1674
	bus_probe_device(dev);
L
Linus Torvalds 已提交
1675
	if (parent)
1676 1677
		klist_add_tail(&dev->p->knode_parent,
			       &parent->p->klist_children);
L
Linus Torvalds 已提交
1678

1679
	if (dev->class) {
1680
		mutex_lock(&dev->class->p->mutex);
1681
		/* tie the class to the device */
1682
		klist_add_tail(&dev->knode_class,
1683
			       &dev->class->p->klist_devices);
1684 1685

		/* notify any interfaces that the device is here */
1686
		list_for_each_entry(class_intf,
1687
				    &dev->class->p->interfaces, node)
1688 1689
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
1690
		mutex_unlock(&dev->class->p->mutex);
1691
	}
1692
done:
L
Linus Torvalds 已提交
1693 1694
	put_device(dev);
	return error;
1695 1696 1697 1698 1699 1700
 SysEntryError:
	if (MAJOR(dev->devt))
		device_remove_file(dev, &dev_attr_dev);
 DevAttrError:
	device_pm_remove(dev);
	dpm_sysfs_remove(dev);
1701
 DPMError:
1702 1703
	bus_remove_device(dev);
 BusError:
1704
	device_remove_attrs(dev);
1705
 AttrsError:
1706 1707
	device_remove_class_symlinks(dev);
 SymlinkError:
1708
	device_remove_file(dev, &dev_attr_uevent);
1709
 attrError:
1710
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1711
	glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
1712 1713
	kobject_del(&dev->kobj);
 Error:
1714
	cleanup_glue_dir(dev, glue_dir);
1715
	put_device(parent);
1716 1717 1718
name_error:
	kfree(dev->p);
	dev->p = NULL;
1719
	goto done;
L
Linus Torvalds 已提交
1720
}
1721
EXPORT_SYMBOL_GPL(device_add);
L
Linus Torvalds 已提交
1722 1723

/**
1724 1725
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
L
Linus Torvalds 已提交
1726
 *
1727 1728 1729 1730 1731 1732
 * 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.
1733
 *
1734 1735 1736
 * For more information, see the kerneldoc for device_initialize()
 * and device_add().
 *
1737 1738 1739
 * 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 已提交
1740 1741 1742 1743 1744 1745
 */
int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}
1746
EXPORT_SYMBOL_GPL(device_register);
L
Linus Torvalds 已提交
1747 1748

/**
1749 1750
 * get_device - increment reference count for device.
 * @dev: device.
L
Linus Torvalds 已提交
1751
 *
1752 1753 1754
 * 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 已提交
1755
 */
1756
struct device *get_device(struct device *dev)
L
Linus Torvalds 已提交
1757
{
1758
	return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
L
Linus Torvalds 已提交
1759
}
1760
EXPORT_SYMBOL_GPL(get_device);
L
Linus Torvalds 已提交
1761 1762

/**
1763 1764
 * put_device - decrement reference count.
 * @dev: device in question.
L
Linus Torvalds 已提交
1765
 */
1766
void put_device(struct device *dev)
L
Linus Torvalds 已提交
1767
{
1768
	/* might_sleep(); */
L
Linus Torvalds 已提交
1769 1770 1771
	if (dev)
		kobject_put(&dev->kobj);
}
1772
EXPORT_SYMBOL_GPL(put_device);
L
Linus Torvalds 已提交
1773 1774

/**
1775 1776
 * device_del - delete device from system.
 * @dev: device.
L
Linus Torvalds 已提交
1777
 *
1778 1779 1780 1781 1782
 * 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 已提交
1783
 *
1784 1785
 * NOTE: this should be called manually _iff_ device_add() was
 * also called manually.
L
Linus Torvalds 已提交
1786
 */
1787
void device_del(struct device *dev)
L
Linus Torvalds 已提交
1788
{
1789
	struct device *parent = dev->parent;
1790
	struct kobject *glue_dir = NULL;
1791
	struct class_interface *class_intf;
L
Linus Torvalds 已提交
1792

1793 1794 1795 1796 1797 1798
	/* 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);
1799 1800

	device_links_purge(dev);
1801
	dpm_sysfs_remove(dev);
L
Linus Torvalds 已提交
1802
	if (parent)
1803
		klist_del(&dev->p->knode_parent);
1804
	if (MAJOR(dev->devt)) {
1805
		devtmpfs_delete_node(dev);
1806
		device_remove_sys_dev_entry(dev);
1807
		device_remove_file(dev, &dev_attr_dev);
1808
	}
1809
	if (dev->class) {
1810
		device_remove_class_symlinks(dev);
1811

1812
		mutex_lock(&dev->class->p->mutex);
1813
		/* notify any interfaces that the device is now gone */
1814
		list_for_each_entry(class_intf,
1815
				    &dev->class->p->interfaces, node)
1816 1817 1818
			if (class_intf->remove_dev)
				class_intf->remove_dev(dev, class_intf);
		/* remove the device from the class list */
1819
		klist_del(&dev->knode_class);
1820
		mutex_unlock(&dev->class->p->mutex);
1821
	}
1822
	device_remove_file(dev, &dev_attr_uevent);
1823
	device_remove_attrs(dev);
1824
	bus_remove_device(dev);
1825
	device_pm_remove(dev);
1826
	driver_deferred_probe_del(dev);
1827
	device_remove_properties(dev);
L
Linus Torvalds 已提交
1828 1829 1830 1831 1832 1833

	/* Notify the platform of the removal, in case they
	 * need to do anything...
	 */
	if (platform_notify_remove)
		platform_notify_remove(dev);
1834 1835 1836
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
					     BUS_NOTIFY_REMOVED_DEVICE, dev);
1837
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1838
	glue_dir = get_glue_dir(dev);
L
Linus Torvalds 已提交
1839
	kobject_del(&dev->kobj);
1840
	cleanup_glue_dir(dev, glue_dir);
1841
	put_device(parent);
L
Linus Torvalds 已提交
1842
}
1843
EXPORT_SYMBOL_GPL(device_del);
L
Linus Torvalds 已提交
1844 1845

/**
1846 1847
 * device_unregister - unregister device from system.
 * @dev: device going away.
L
Linus Torvalds 已提交
1848
 *
1849 1850 1851 1852 1853 1854
 * 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 已提交
1855
 */
1856
void device_unregister(struct device *dev)
L
Linus Torvalds 已提交
1857
{
1858
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
L
Linus Torvalds 已提交
1859 1860 1861
	device_del(dev);
	put_device(dev);
}
1862
EXPORT_SYMBOL_GPL(device_unregister);
L
Linus Torvalds 已提交
1863

1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876
static struct device *prev_device(struct klist_iter *i)
{
	struct klist_node *n = klist_prev(i);
	struct device *dev = NULL;
	struct device_private *p;

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

1877
static struct device *next_device(struct klist_iter *i)
1878
{
1879
	struct klist_node *n = klist_next(i);
1880 1881 1882 1883 1884 1885 1886 1887
	struct device *dev = NULL;
	struct device_private *p;

	if (n) {
		p = to_device_private_parent(n);
		dev = p->device;
	}
	return dev;
1888 1889
}

1890
/**
1891
 * device_get_devnode - path of device node file
1892
 * @dev: device
1893
 * @mode: returned file access mode
1894 1895
 * @uid: returned file owner
 * @gid: returned file group
1896 1897 1898 1899 1900 1901 1902
 * @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.
 */
1903
const char *device_get_devnode(struct device *dev,
1904
			       umode_t *mode, kuid_t *uid, kgid_t *gid,
1905
			       const char **tmp)
1906 1907 1908 1909 1910 1911
{
	char *s;

	*tmp = NULL;

	/* the device type may provide a specific name */
1912
	if (dev->type && dev->type->devnode)
1913
		*tmp = dev->type->devnode(dev, mode, uid, gid);
1914 1915 1916 1917
	if (*tmp)
		return *tmp;

	/* the class may provide a specific name */
1918 1919
	if (dev->class && dev->class->devnode)
		*tmp = dev->class->devnode(dev, mode);
1920 1921 1922 1923 1924 1925 1926 1927
	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 '/' */
1928 1929
	s = kstrdup(dev_name(dev), GFP_KERNEL);
	if (!s)
1930
		return NULL;
1931 1932
	strreplace(s, '!', '/');
	return *tmp = s;
1933 1934
}

L
Linus Torvalds 已提交
1935
/**
1936 1937 1938
 * device_for_each_child - device child iterator.
 * @parent: parent struct device.
 * @fn: function to be called for each device.
1939
 * @data: data for the callback.
L
Linus Torvalds 已提交
1940
 *
1941 1942
 * Iterate over @parent's child devices, and call @fn for each,
 * passing it @data.
L
Linus Torvalds 已提交
1943
 *
1944 1945
 * 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 已提交
1946
 */
1947 1948
int device_for_each_child(struct device *parent, void *data,
			  int (*fn)(struct device *dev, void *data))
L
Linus Torvalds 已提交
1949
{
1950
	struct klist_iter i;
1951
	struct device *child;
L
Linus Torvalds 已提交
1952 1953
	int error = 0;

1954 1955 1956
	if (!parent->p)
		return 0;

1957
	klist_iter_init(&parent->p->klist_children, &i);
1958 1959 1960
	while ((child = next_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
L
Linus Torvalds 已提交
1961 1962
	return error;
}
1963
EXPORT_SYMBOL_GPL(device_for_each_child);
L
Linus Torvalds 已提交
1964

1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994
/**
 * device_for_each_child_reverse - device child iterator in reversed order.
 * @parent: parent struct device.
 * @fn: function to be called for each device.
 * @data: data for the callback.
 *
 * Iterate over @parent's child devices, and call @fn for each,
 * 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.
 */
int device_for_each_child_reverse(struct device *parent, void *data,
				  int (*fn)(struct device *dev, void *data))
{
	struct klist_iter i;
	struct device *child;
	int error = 0;

	if (!parent->p)
		return 0;

	klist_iter_init(&parent->p->klist_children, &i);
	while ((child = prev_device(&i)) && !error)
		error = fn(child, data);
	klist_iter_exit(&i);
	return error;
}
EXPORT_SYMBOL_GPL(device_for_each_child_reverse);

1995 1996 1997 1998
/**
 * device_find_child - device iterator for locating a particular device.
 * @parent: parent struct device
 * @match: Callback function to check device
1999
 * @data: Data to pass to match function
2000 2001 2002 2003 2004 2005 2006 2007 2008
 *
 * 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.
2009 2010
 *
 * NOTE: you will need to drop the reference with put_device() after use.
2011
 */
2012 2013
struct device *device_find_child(struct device *parent, void *data,
				 int (*match)(struct device *dev, void *data))
2014 2015 2016 2017 2018 2019 2020
{
	struct klist_iter i;
	struct device *child;

	if (!parent)
		return NULL;

2021
	klist_iter_init(&parent->p->klist_children, &i);
2022 2023 2024 2025 2026 2027
	while ((child = next_device(&i)))
		if (match(child, data) && get_device(child))
			break;
	klist_iter_exit(&i);
	return child;
}
2028
EXPORT_SYMBOL_GPL(device_find_child);
2029

L
Linus Torvalds 已提交
2030 2031
int __init devices_init(void)
{
2032 2033 2034
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	if (!devices_kset)
		return -ENOMEM;
2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
	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;

2045
	return 0;
2046 2047 2048 2049 2050 2051 2052 2053

 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 已提交
2054 2055
}

2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136
static int device_check_offline(struct device *dev, void *not_used)
{
	int ret;

	ret = device_for_each_child(dev, NULL, device_check_offline);
	if (ret)
		return ret;

	return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
}

/**
 * device_offline - Prepare the device for hot-removal.
 * @dev: Device to be put offline.
 *
 * Execute the device bus type's .offline() callback, if present, to prepare
 * the device for a subsequent hot-removal.  If that succeeds, the device must
 * not be used until either it is removed or its bus type's .online() callback
 * is executed.
 *
 * Call under device_hotplug_lock.
 */
int device_offline(struct device *dev)
{
	int ret;

	if (dev->offline_disabled)
		return -EPERM;

	ret = device_for_each_child(dev, NULL, device_check_offline);
	if (ret)
		return ret;

	device_lock(dev);
	if (device_supports_offline(dev)) {
		if (dev->offline) {
			ret = 1;
		} else {
			ret = dev->bus->offline(dev);
			if (!ret) {
				kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
				dev->offline = true;
			}
		}
	}
	device_unlock(dev);

	return ret;
}

/**
 * device_online - Put the device back online after successful device_offline().
 * @dev: Device to be put back online.
 *
 * If device_offline() has been successfully executed for @dev, but the device
 * has not been removed subsequently, execute its bus type's .online() callback
 * to indicate that the device can be used again.
 *
 * Call under device_hotplug_lock.
 */
int device_online(struct device *dev)
{
	int ret = 0;

	device_lock(dev);
	if (device_supports_offline(dev)) {
		if (dev->offline) {
			ret = dev->bus->online(dev);
			if (!ret) {
				kobject_uevent(&dev->kobj, KOBJ_ONLINE);
				dev->offline = false;
			}
		} else {
			ret = 1;
		}
	}
	device_unlock(dev);

	return ret;
}

2137
struct root_device {
2138 2139 2140 2141
	struct device dev;
	struct module *owner;
};

2142
static inline struct root_device *to_root_device(struct device *d)
2143 2144 2145
{
	return container_of(d, struct root_device, dev);
}
2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169

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.
 *
2170 2171
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
 * 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);

2183
	err = dev_set_name(&root->dev, "%s", name);
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196
	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);
	}

2197
#ifdef CONFIG_MODULES	/* gotta find a "cleaner" way to do this */
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
	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
2216
 * @dev: device going away
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
 *
 * 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);

2232 2233 2234

static void device_create_release(struct device *dev)
{
2235
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
2236 2237 2238
	kfree(dev);
}

2239 2240 2241 2242 2243
static struct device *
device_create_groups_vargs(struct class *class, struct device *parent,
			   dev_t devt, void *drvdata,
			   const struct attribute_group **groups,
			   const char *fmt, va_list args)
2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
{
	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;
	}

2257
	device_initialize(dev);
2258 2259 2260
	dev->devt = devt;
	dev->class = class;
	dev->parent = parent;
2261
	dev->groups = groups;
2262
	dev->release = device_create_release;
2263
	dev_set_drvdata(dev, drvdata);
2264

2265 2266 2267 2268
	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
	if (retval)
		goto error;

2269
	retval = device_add(dev);
2270 2271 2272 2273 2274 2275
	if (retval)
		goto error;

	return dev;

error:
2276
	put_device(dev);
2277 2278
	return ERR_PTR(retval);
}
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311

/**
 * device_create_vargs - creates a device and registers it with sysfs
 * @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
 * @args: va_list 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.
 *
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
struct device *device_create_vargs(struct class *class, struct device *parent,
				   dev_t devt, void *drvdata, const char *fmt,
				   va_list args)
{
	return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
					  fmt, args);
}
2312 2313 2314
EXPORT_SYMBOL_GPL(device_create_vargs);

/**
2315
 * device_create - creates a device and registers it with sysfs
2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
 * @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.
 *
2333 2334
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
2335 2336 2337
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
2338 2339
struct device *device_create(struct class *class, struct device *parent,
			     dev_t devt, void *drvdata, const char *fmt, ...)
2340 2341 2342 2343 2344 2345 2346 2347 2348
{
	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;
}
2349
EXPORT_SYMBOL_GPL(device_create);
2350

2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394
/**
 * device_create_with_groups - creates a device and registers it with sysfs
 * @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
 * @groups: NULL-terminated list of attribute groups to be created
 * @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.
 * Additional attributes specified in the groups parameter will also
 * be created automatically.
 *
 * 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.
 *
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
struct device *device_create_with_groups(struct class *class,
					 struct device *parent, dev_t devt,
					 void *drvdata,
					 const struct attribute_group **groups,
					 const char *fmt, ...)
{
	va_list vargs;
	struct device *dev;

	va_start(vargs, fmt);
	dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
					 fmt, vargs);
	va_end(vargs);
	return dev;
}
EXPORT_SYMBOL_GPL(device_create_with_groups);

2395
static int __match_devt(struct device *dev, const void *data)
2396
{
2397
	const dev_t *devt = data;
2398

2399
	return dev->devt == *devt;
2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
}

/**
 * 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;
2413

2414
	dev = class_find_device(class, NULL, &devt, __match_devt);
2415 2416
	if (dev) {
		put_device(dev);
2417
		device_unregister(dev);
2418
	}
2419 2420
}
EXPORT_SYMBOL_GPL(device_destroy);
2421 2422 2423 2424 2425

/**
 * device_rename - renames a device
 * @dev: the pointer to the struct device to be renamed
 * @new_name: the new name of the device
2426 2427 2428 2429 2430
 *
 * 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.
2431
 *
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459
 * 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. :)
2460
 */
2461
int device_rename(struct device *dev, const char *new_name)
2462
{
2463
	struct kobject *kobj = &dev->kobj;
2464
	char *old_device_name = NULL;
2465 2466 2467 2468 2469 2470
	int error;

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

2471
	dev_dbg(dev, "renaming to %s\n", new_name);
2472

2473
	old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
2474 2475 2476
	if (!old_device_name) {
		error = -ENOMEM;
		goto out;
2477 2478
	}

2479
	if (dev->class) {
2480 2481 2482
		error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
					     kobj, old_device_name,
					     new_name, kobject_namespace(kobj));
2483 2484 2485
		if (error)
			goto out;
	}
2486

2487
	error = kobject_rename(kobj, new_name);
2488
	if (error)
2489
		goto out;
2490

2491
out:
2492 2493
	put_device(dev);

2494
	kfree(old_device_name);
2495 2496 2497

	return error;
}
2498
EXPORT_SYMBOL_GPL(device_rename);
2499 2500 2501 2502 2503

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

2506 2507 2508 2509 2510 2511
	if (old_parent)
		sysfs_remove_link(&dev->kobj, "device");
	if (new_parent)
		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
					  "device");
	return error;
2512 2513 2514 2515 2516
}

/**
 * device_move - moves a device to a new parent
 * @dev: the pointer to the struct device to be moved
2517
 * @new_parent: the new parent of the device (can by NULL)
2518
 * @dpm_order: how to reorder the dpm_list
2519
 */
2520 2521
int device_move(struct device *dev, struct device *new_parent,
		enum dpm_order dpm_order)
2522 2523 2524
{
	int error;
	struct device *old_parent;
2525
	struct kobject *new_parent_kobj;
2526 2527 2528 2529 2530

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

2531
	device_pm_lock();
2532
	new_parent = get_device(new_parent);
2533
	new_parent_kobj = get_device_parent(dev, new_parent);
2534

2535 2536
	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
		 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
2537
	error = kobject_move(&dev->kobj, new_parent_kobj);
2538
	if (error) {
2539
		cleanup_glue_dir(dev, new_parent_kobj);
2540 2541 2542 2543 2544 2545
		put_device(new_parent);
		goto out;
	}
	old_parent = dev->parent;
	dev->parent = new_parent;
	if (old_parent)
2546
		klist_remove(&dev->p->knode_parent);
2547
	if (new_parent) {
2548 2549
		klist_add_tail(&dev->p->knode_parent,
			       &new_parent->p->klist_children);
2550 2551 2552
		set_dev_node(dev, dev_to_node(new_parent));
	}

2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566
	if (dev->class) {
		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)) {
				if (new_parent)
					klist_remove(&dev->p->knode_parent);
				dev->parent = old_parent;
				if (old_parent) {
					klist_add_tail(&dev->p->knode_parent,
						       &old_parent->p->klist_children);
					set_dev_node(dev, dev_to_node(old_parent));
				}
2567
			}
2568 2569 2570
			cleanup_glue_dir(dev, new_parent_kobj);
			put_device(new_parent);
			goto out;
2571 2572
		}
	}
2573 2574 2575 2576 2577
	switch (dpm_order) {
	case DPM_ORDER_NONE:
		break;
	case DPM_ORDER_DEV_AFTER_PARENT:
		device_pm_move_after(dev, new_parent);
2578
		devices_kset_move_after(dev, new_parent);
2579 2580 2581
		break;
	case DPM_ORDER_PARENT_BEFORE_DEV:
		device_pm_move_before(new_parent, dev);
2582
		devices_kset_move_before(new_parent, dev);
2583 2584 2585
		break;
	case DPM_ORDER_DEV_LAST:
		device_pm_move_last(dev);
2586
		devices_kset_move_last(dev);
2587 2588
		break;
	}
2589

2590 2591
	put_device(old_parent);
out:
2592
	device_pm_unlock();
2593 2594 2595 2596
	put_device(dev);
	return error;
}
EXPORT_SYMBOL_GPL(device_move);
2597 2598 2599 2600 2601 2602

/**
 * device_shutdown - call ->shutdown() on each device to shutdown.
 */
void device_shutdown(void)
{
2603
	struct device *dev, *parent;
2604 2605 2606 2607 2608 2609 2610 2611 2612 2613

	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);
2614 2615 2616 2617 2618 2619

		/*
		 * hold reference count of device's parent to
		 * prevent it from being freed because parent's
		 * lock is to be held
		 */
2620
		parent = get_device(dev->parent);
2621 2622 2623 2624 2625 2626 2627
		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);
2628

2629
		/* hold lock to avoid race with probe/release */
2630 2631
		if (parent)
			device_lock(parent);
2632 2633
		device_lock(dev);

2634 2635 2636
		/* Don't allow any more runtime suspends */
		pm_runtime_get_noresume(dev);
		pm_runtime_barrier(dev);
2637 2638

		if (dev->bus && dev->bus->shutdown) {
2639 2640
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2641 2642
			dev->bus->shutdown(dev);
		} else if (dev->driver && dev->driver->shutdown) {
2643 2644
			if (initcall_debug)
				dev_info(dev, "shutdown\n");
2645 2646
			dev->driver->shutdown(dev);
		}
2647 2648

		device_unlock(dev);
2649 2650
		if (parent)
			device_unlock(parent);
2651

2652
		put_device(dev);
2653
		put_device(parent);
2654 2655

		spin_lock(&devices_kset->list_lock);
2656
	}
2657
	spin_unlock(&devices_kset->list_lock);
2658
}
2659 2660 2661 2662 2663 2664

/*
 * Device logging functions
 */

#ifdef CONFIG_PRINTK
2665 2666
static int
create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2667
{
2668
	const char *subsys;
2669
	size_t pos = 0;
2670

2671 2672 2673 2674 2675
	if (dev->class)
		subsys = dev->class->name;
	else if (dev->bus)
		subsys = dev->bus->name;
	else
2676
		return 0;
2677

2678
	pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2679 2680
	if (pos >= hdrlen)
		goto overflow;
2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695

	/*
	 * Add device identifier DEVICE=:
	 *   b12:8         block dev_t
	 *   c127:3        char dev_t
	 *   n8            netdev ifindex
	 *   +sound:card0  subsystem:devname
	 */
	if (MAJOR(dev->devt)) {
		char c;

		if (strcmp(subsys, "block") == 0)
			c = 'b';
		else
			c = 'c';
2696 2697 2698 2699
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=%c%u:%u",
				c, MAJOR(dev->devt), MINOR(dev->devt));
2700 2701 2702
	} else if (strcmp(subsys, "net") == 0) {
		struct net_device *net = to_net_dev(dev);

2703 2704 2705
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=n%u", net->ifindex);
2706
	} else {
2707 2708 2709
		pos++;
		pos += snprintf(hdr + pos, hdrlen - pos,
				"DEVICE=+%s:%s", subsys, dev_name(dev));
2710
	}
2711

2712 2713 2714
	if (pos >= hdrlen)
		goto overflow;

2715
	return pos;
2716 2717 2718 2719

overflow:
	dev_WARN(dev, "device/subsystem name too long");
	return 0;
2720 2721
}

2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
int dev_vprintk_emit(int level, const struct device *dev,
		     const char *fmt, va_list args)
{
	char hdr[128];
	size_t hdrlen;

	hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));

	return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
}
EXPORT_SYMBOL(dev_vprintk_emit);

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

	va_start(args, fmt);

	r = dev_vprintk_emit(level, dev, fmt, args);

	va_end(args);

	return r;
}
EXPORT_SYMBOL(dev_printk_emit);

2749
static void __dev_printk(const char *level, const struct device *dev,
2750 2751
			struct va_format *vaf)
{
2752 2753 2754 2755 2756
	if (dev)
		dev_printk_emit(level[1] - '0', dev, "%s %s: %pV",
				dev_driver_string(dev), dev_name(dev), vaf);
	else
		printk("%s(NULL device *): %pV", level, vaf);
2757 2758
}

2759 2760
void dev_printk(const char *level, const struct device *dev,
		const char *fmt, ...)
2761 2762 2763 2764 2765 2766 2767 2768 2769
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

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

2770
	__dev_printk(level, dev, &vaf);
2771

2772 2773 2774 2775 2776
	va_end(args);
}
EXPORT_SYMBOL(dev_printk);

#define define_dev_printk_level(func, kern_level)		\
2777
void func(const struct device *dev, const char *fmt, ...)	\
2778 2779 2780 2781 2782 2783 2784 2785 2786
{								\
	struct va_format vaf;					\
	va_list args;						\
								\
	va_start(args, fmt);					\
								\
	vaf.fmt = fmt;						\
	vaf.va = &args;						\
								\
2787
	__dev_printk(kern_level, dev, &vaf);			\
2788
								\
2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801
	va_end(args);						\
}								\
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
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823

static inline bool fwnode_is_primary(struct fwnode_handle *fwnode)
{
	return fwnode && !IS_ERR(fwnode->secondary);
}

/**
 * set_primary_fwnode - Change the primary firmware node of a given device.
 * @dev: Device to handle.
 * @fwnode: New primary firmware node of the device.
 *
 * Set the device's firmware node pointer to @fwnode, but if a secondary
 * firmware node of the device is present, preserve it.
 */
void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
{
	if (fwnode) {
		struct fwnode_handle *fn = dev->fwnode;

		if (fwnode_is_primary(fn))
			fn = fn->secondary;

2824 2825 2826 2827
		if (fn) {
			WARN_ON(fwnode->secondary);
			fwnode->secondary = fn;
		}
2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854
		dev->fwnode = fwnode;
	} else {
		dev->fwnode = fwnode_is_primary(dev->fwnode) ?
			dev->fwnode->secondary : NULL;
	}
}
EXPORT_SYMBOL_GPL(set_primary_fwnode);

/**
 * set_secondary_fwnode - Change the secondary firmware node of a given device.
 * @dev: Device to handle.
 * @fwnode: New secondary firmware node of the device.
 *
 * If a primary firmware node of the device is present, set its secondary
 * pointer to @fwnode.  Otherwise, set the device's firmware node pointer to
 * @fwnode.
 */
void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
{
	if (fwnode)
		fwnode->secondary = ERR_PTR(-ENODEV);

	if (fwnode_is_primary(dev->fwnode))
		dev->fwnode->secondary = fwnode;
	else
		dev->fwnode = fwnode;
}
新手
引导
客服 返回
顶部