Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/sfr/ofcons (2cb7e714) · Commits · 戴 / test

arch/powerpc/Kconfig

+3 −0

Original line number	Diff line number	Diff line
		@@ -92,6 +92,9 @@ config ARCH_MAY_HAVE_PC_FDC
		config PPC_OF
		def_bool y

		config OF
		def_bool y

		config PPC_UDBG_16550
		bool
		default n

arch/powerpc/kernel/of_device.c

+1 −121

Original line number	Diff line number	Diff line
		#include <linux/string.h>
		#include <linux/kernel.h>
		#include <linux/of.h>
		#include <linux/init.h>
		#include <linux/module.h>
		#include <linux/mod_devicetable.h>
		@@ -8,118 +9,6 @@
		#include <asm/errno.h>
		#include <asm/of_device.h>

		/**
		* of_match_node - Tell if an device_node has a matching of_match structure
		* @ids: array of of device match structures to search in
		* @node: the of device structure to match against
		*
		* Low level utility function used by device matching.
		*/
		const struct of_device_id of_match_node(const struct of_device_id matches,
		const struct device_node *node)
		{
		while (matches->name[0] \|\| matches->type[0] \|\| matches->compatible[0]) {
		int match = 1;
		if (matches->name[0])
		match &= node->name
		&& !strcmp(matches->name, node->name);
		if (matches->type[0])
		match &= node->type
		&& !strcmp(matches->type, node->type);
		if (matches->compatible[0])
		match &= of_device_is_compatible(node,
		matches->compatible);
		if (match)
		return matches;
		matches++;
		}
		return NULL;
		}

		/**
		* of_match_device - Tell if an of_device structure has a matching
		* of_match structure
		* @ids: array of of device match structures to search in
		* @dev: the of device structure to match against
		*
		* Used by a driver to check whether an of_device present in the
		* system is in its list of supported devices.
		*/
		const struct of_device_id of_match_device(const struct of_device_id matches,
		const struct of_device *dev)
		{
		if (!dev->node)
		return NULL;
		return of_match_node(matches, dev->node);
		}

		struct of_device of_dev_get(struct of_device dev)
		{
		struct device *tmp;

		if (!dev)
		return NULL;
		tmp = get_device(&dev->dev);
		if (tmp)
		return to_of_device(tmp);
		else
		return NULL;
		}

		void of_dev_put(struct of_device *dev)
		{
		if (dev)
		put_device(&dev->dev);
		}

		static ssize_t dev_show_devspec(struct device *dev,
		struct device_attribute attr, char buf)
		{
		struct of_device *ofdev;

		ofdev = to_of_device(dev);
		return sprintf(buf, "%s", ofdev->node->full_name);
		}

		static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);

		/**
		* of_release_dev - free an of device structure when all users of it are finished.
		* @dev: device that's been disconnected
		*
		* Will be called only by the device core when all users of this of device are
		* done.
		*/
		void of_release_dev(struct device *dev)
		{
		struct of_device *ofdev;

		ofdev = to_of_device(dev);
		of_node_put(ofdev->node);
		kfree(ofdev);
		}

		int of_device_register(struct of_device *ofdev)
		{
		int rc;

		BUG_ON(ofdev->node == NULL);

		rc = device_register(&ofdev->dev);
		if (rc)
		return rc;

		return device_create_file(&ofdev->dev, &dev_attr_devspec);
		}

		void of_device_unregister(struct of_device *ofdev)
		{
		device_remove_file(&ofdev->dev, &dev_attr_devspec);

		device_unregister(&ofdev->dev);
		}


		ssize_t of_device_get_modalias(struct of_device *ofdev,
		char *str, ssize_t len)
		{
		@@ -229,14 +118,5 @@ int of_device_uevent(struct device *dev,

		return 0;
		}


		EXPORT_SYMBOL(of_match_node);
		EXPORT_SYMBOL(of_match_device);
		EXPORT_SYMBOL(of_device_register);
		EXPORT_SYMBOL(of_device_unregister);
		EXPORT_SYMBOL(of_dev_get);
		EXPORT_SYMBOL(of_dev_put);
		EXPORT_SYMBOL(of_release_dev);
		EXPORT_SYMBOL(of_device_uevent);
		EXPORT_SYMBOL(of_device_get_modalias);

arch/powerpc/kernel/of_platform.c

+1 −81

Original line number	Diff line number	Diff line
		@@ -55,94 +55,14 @@ static struct of_device_id of_default_bus_ids[] = {

		static atomic_t bus_no_reg_magic;

		/*
		*
		* OF platform device type definition & base infrastructure
		*
		*/

		static int of_platform_bus_match(struct device dev, struct device_driver drv)
		{
		struct of_device * of_dev = to_of_device(dev);
		struct of_platform_driver * of_drv = to_of_platform_driver(drv);
		const struct of_device_id * matches = of_drv->match_table;

		if (!matches)
		return 0;

		return of_match_device(matches, of_dev) != NULL;
		}

		static int of_platform_device_probe(struct device *dev)
		{
		int error = -ENODEV;
		struct of_platform_driver *drv;
		struct of_device *of_dev;
		const struct of_device_id *match;

		drv = to_of_platform_driver(dev->driver);
		of_dev = to_of_device(dev);

		if (!drv->probe)
		return error;

		of_dev_get(of_dev);

		match = of_match_device(drv->match_table, of_dev);
		if (match)
		error = drv->probe(of_dev, match);
		if (error)
		of_dev_put(of_dev);

		return error;
		}

		static int of_platform_device_remove(struct device *dev)
		{
		struct of_device * of_dev = to_of_device(dev);
		struct of_platform_driver * drv = to_of_platform_driver(dev->driver);

		if (dev->driver && drv->remove)
		drv->remove(of_dev);
		return 0;
		}

		static int of_platform_device_suspend(struct device *dev, pm_message_t state)
		{
		struct of_device * of_dev = to_of_device(dev);
		struct of_platform_driver * drv = to_of_platform_driver(dev->driver);
		int error = 0;

		if (dev->driver && drv->suspend)
		error = drv->suspend(of_dev, state);
		return error;
		}

		static int of_platform_device_resume(struct device * dev)
		{
		struct of_device * of_dev = to_of_device(dev);
		struct of_platform_driver * drv = to_of_platform_driver(dev->driver);
		int error = 0;

		if (dev->driver && drv->resume)
		error = drv->resume(of_dev);
		return error;
		}

		struct bus_type of_platform_bus_type = {
		.name = "of_platform",
		.match = of_platform_bus_match,
		.uevent = of_device_uevent,
		.probe = of_platform_device_probe,
		.remove = of_platform_device_remove,
		.suspend = of_platform_device_suspend,
		.resume = of_platform_device_resume,
		};
		EXPORT_SYMBOL(of_platform_bus_type);

		static int __init of_bus_driver_init(void)
		{
		return bus_register(&of_platform_bus_type);
		return of_bus_type_init(&of_platform_bus_type, "of_platform");
		}

		postcore_initcall(of_bus_driver_init);

arch/powerpc/kernel/prom.c

+2 −248

Original line number	Diff line number	Diff line
		@@ -78,12 +78,9 @@ static struct boot_param_header *initial_boot_params __initdata;
		struct boot_param_header *initial_boot_params;
		#endif

		static struct device_node *allnodes = NULL;
		extern struct device_node allnodes; / temporary while merging */

		/* use when traversing tree through the allnext, child, sibling,
		* or parent members of struct device_node.
		*/
		static DEFINE_RWLOCK(devtree_lock);
		extern rwlock_t devtree_lock; /* temporary while merging */

		/* export that to outside world */
		struct device_node *of_chosen;
		@@ -1056,60 +1053,6 @@ void __init early_init_devtree(void *params)
		DBG(" <- early_init_devtree()\n");
		}

		int of_n_addr_cells(struct device_node* np)
		{
		const int *ip;
		do {
		if (np->parent)
		np = np->parent;
		ip = of_get_property(np, "#address-cells", NULL);
		if (ip != NULL)
		return *ip;
		} while (np->parent);
		/* No #address-cells property for the root node, default to 1 */
		return 1;
		}
		EXPORT_SYMBOL(of_n_addr_cells);

		int of_n_size_cells(struct device_node* np)
		{
		const int* ip;
		do {
		if (np->parent)
		np = np->parent;
		ip = of_get_property(np, "#size-cells", NULL);
		if (ip != NULL)
		return *ip;
		} while (np->parent);
		/* No #size-cells property for the root node, default to 1 */
		return 1;
		}
		EXPORT_SYMBOL(of_n_size_cells);

		/** Checks if the given "compat" string matches one of the strings in
		* the device's "compatible" property
		*/
		int of_device_is_compatible(const struct device_node *device,
		const char *compat)
		{
		const char* cp;
		int cplen, l;

		cp = of_get_property(device, "compatible", &cplen);
		if (cp == NULL)
		return 0;
		while (cplen > 0) {
		if (strncasecmp(cp, compat, strlen(compat)) == 0)
		return 1;
		l = strlen(cp) + 1;
		cp += l;
		cplen -= l;
		}

		return 0;
		}
		EXPORT_SYMBOL(of_device_is_compatible);


		/**
		* Indicates whether the root node has a given value in its
		@@ -1140,119 +1083,6 @@ EXPORT_SYMBOL(machine_is_compatible);
		*
		*******/

		/**
		* of_find_node_by_name - Find a node by its "name" property
		* @from: The node to start searching from or NULL, the node
		* you pass will not be searched, only the next one
		* will; typically, you pass what the previous call
		* returned. of_node_put() will be called on it
		* @name: The name string to match against
		*
		* Returns a node pointer with refcount incremented, use
		* of_node_put() on it when done.
		*/
		struct device_node of_find_node_by_name(struct device_node from,
		const char *name)
		{
		struct device_node *np;

		read_lock(&devtree_lock);
		np = from ? from->allnext : allnodes;
		for (; np != NULL; np = np->allnext)
		if (np->name != NULL && strcasecmp(np->name, name) == 0
		&& of_node_get(np))
		break;
		of_node_put(from);
		read_unlock(&devtree_lock);
		return np;
		}
		EXPORT_SYMBOL(of_find_node_by_name);

		/**
		* of_find_node_by_type - Find a node by its "device_type" property
		* @from: The node to start searching from, or NULL to start searching
		* the entire device tree. The node you pass will not be
		* searched, only the next one will; typically, you pass
		* what the previous call returned. of_node_put() will be
		* called on from for you.
		* @type: The type string to match against
		*
		* Returns a node pointer with refcount incremented, use
		* of_node_put() on it when done.
		*/
		struct device_node of_find_node_by_type(struct device_node from,
		const char *type)
		{
		struct device_node *np;

		read_lock(&devtree_lock);
		np = from ? from->allnext : allnodes;
		for (; np != 0; np = np->allnext)
		if (np->type != 0 && strcasecmp(np->type, type) == 0
		&& of_node_get(np))
		break;
		of_node_put(from);
		read_unlock(&devtree_lock);
		return np;
		}
		EXPORT_SYMBOL(of_find_node_by_type);

		/**
		* of_find_compatible_node - Find a node based on type and one of the
		* tokens in its "compatible" property
		* @from: The node to start searching from or NULL, the node
		* you pass will not be searched, only the next one
		* will; typically, you pass what the previous call
		* returned. of_node_put() will be called on it
		* @type: The type string to match "device_type" or NULL to ignore
		* @compatible: The string to match to one of the tokens in the device
		* "compatible" list.
		*
		* Returns a node pointer with refcount incremented, use
		* of_node_put() on it when done.
		*/
		struct device_node of_find_compatible_node(struct device_node from,
		const char type, const char compatible)
		{
		struct device_node *np;

		read_lock(&devtree_lock);
		np = from ? from->allnext : allnodes;
		for (; np != 0; np = np->allnext) {
		if (type != NULL
		&& !(np->type != 0 && strcasecmp(np->type, type) == 0))
		continue;
		if (of_device_is_compatible(np, compatible) && of_node_get(np))
		break;
		}
		of_node_put(from);
		read_unlock(&devtree_lock);
		return np;
		}
		EXPORT_SYMBOL(of_find_compatible_node);

		/**
		* of_find_node_by_path - Find a node matching a full OF path
		* @path: The full path to match
		*
		* Returns a node pointer with refcount incremented, use
		* of_node_put() on it when done.
		*/
		struct device_node of_find_node_by_path(const char path)
		{
		struct device_node *np = allnodes;

		read_lock(&devtree_lock);
		for (; np != 0; np = np->allnext) {
		if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0
		&& of_node_get(np))
		break;
		}
		read_unlock(&devtree_lock);
		return np;
		}
		EXPORT_SYMBOL(of_find_node_by_path);

		/**
		* of_find_node_by_phandle - Find a node given a phandle
		* @handle: phandle of the node to find
		@@ -1297,51 +1127,6 @@ struct device_node of_find_all_nodes(struct device_node prev)
		}
		EXPORT_SYMBOL(of_find_all_nodes);

		/**
		* of_get_parent - Get a node's parent if any
		* @node: Node to get parent
		*
		* Returns a node pointer with refcount incremented, use
		* of_node_put() on it when done.
		*/
		struct device_node of_get_parent(const struct device_node node)
		{
		struct device_node *np;

		if (!node)
		return NULL;

		read_lock(&devtree_lock);
		np = of_node_get(node->parent);
		read_unlock(&devtree_lock);
		return np;
		}
		EXPORT_SYMBOL(of_get_parent);

		/**
		* of_get_next_child - Iterate a node childs
		* @node: parent node
		* @prev: previous child of the parent node, or NULL to get first
		*
		* Returns a node pointer with refcount incremented, use
		* of_node_put() on it when done.
		*/
		struct device_node of_get_next_child(const struct device_node node,
		struct device_node *prev)
		{
		struct device_node *next;

		read_lock(&devtree_lock);
		next = prev ? prev->sibling : node->child;
		for (; next != 0; next = next->sibling)
		if (of_node_get(next))
		break;
		of_node_put(prev);
		read_unlock(&devtree_lock);
		return next;
		}
		EXPORT_SYMBOL(of_get_next_child);

		/**
		* of_node_get - Increment refcount of a node
		* @node: Node to inc refcount, NULL is supported to
		@@ -1543,37 +1328,6 @@ static int __init prom_reconfig_setup(void)
		__initcall(prom_reconfig_setup);
		#endif

		struct property of_find_property(const struct device_node np,
		const char *name,
		int *lenp)
		{
		struct property *pp;

		read_lock(&devtree_lock);
		for (pp = np->properties; pp != 0; pp = pp->next)
		if (strcmp(pp->name, name) == 0) {
		if (lenp != 0)
		*lenp = pp->length;
		break;
		}
		read_unlock(&devtree_lock);

		return pp;
		}
		EXPORT_SYMBOL(of_find_property);

		/*
		* Find a property with a given name for a given node
		* and return the value.
		*/
		const void of_get_property(const struct device_node np, const char *name,
		int *lenp)
		{
		struct property *pp = of_find_property(np,name,lenp);
		return pp ? pp->value : NULL;
		}
		EXPORT_SYMBOL(of_get_property);

		/*
		* Add a property to a node
		*/

arch/sparc/Kconfig

+3 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,9 @@ config GENERIC_ISA_DMA
		config ARCH_NO_VIRT_TO_BUS
		def_bool y

		config OF
		def_bool y

		source "init/Kconfig"

		menu "General machine setup"

Admin message