[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / sparc / prom / tree_32.c

/*
 * tree.c: Basic device tree traversal/scanning for the Linux
 *         prom library.
 *
 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
 */

#include <linux/string.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/ctype.h>
#include <linux/module.h>

#include <asm/openprom.h>
#include <asm/oplib.h>

extern void restore_current(void);

static char promlib_buf[128];

/* Internal version of prom_getchild that does not alter return values. */
phandle __prom_getchild(phandle node)
{
	unsigned long flags;
	phandle cnode;

	spin_lock_irqsave(&prom_lock, flags);
	cnode = prom_nodeops->no_child(node);
	restore_current();
	spin_unlock_irqrestore(&prom_lock, flags);

	return cnode;
}

/* Return the child of node 'node' or zero if no this node has no
 * direct descendent.
 */
phandle prom_getchild(phandle node)
{
	phandle cnode;

	if (node == -1)
		return 0;

	cnode = __prom_getchild(node);
	if (cnode == 0 || cnode == -1)
		return 0;

	return cnode;
}
EXPORT_SYMBOL(prom_getchild);

/* Internal version of prom_getsibling that does not alter return values. */
phandle __prom_getsibling(phandle node)
{
	unsigned long flags;
	phandle cnode;

	spin_lock_irqsave(&prom_lock, flags);
	cnode = prom_nodeops->no_nextnode(node);
	restore_current();
	spin_unlock_irqrestore(&prom_lock, flags);

	return cnode;
}

/* Return the next sibling of node 'node' or zero if no more siblings
 * at this level of depth in the tree.
 */
phandle prom_getsibling(phandle node)
{
	phandle sibnode;

	if (node == -1)
		return 0;

	sibnode = __prom_getsibling(node);
	if (sibnode == 0 || sibnode == -1)
		return 0;

	return sibnode;
}
EXPORT_SYMBOL(prom_getsibling);

/* Return the length in bytes of property 'prop' at node 'node'.
 * Return -1 on error.
 */
int prom_getproplen(phandle node, const char *prop)
{
	int ret;
	unsigned long flags;

	if((!node) || (!prop))
		return -1;
		
	spin_lock_irqsave(&prom_lock, flags);
	ret = prom_nodeops->no_proplen(node, prop);
	restore_current();
	spin_unlock_irqrestore(&prom_lock, flags);
	return ret;
}
EXPORT_SYMBOL(prom_getproplen);

/* Acquire a property 'prop' at node 'node' and place it in
 * 'buffer' which has a size of 'bufsize'.  If the acquisition
 * was successful the length will be returned, else -1 is returned.
 */
int prom_getproperty(phandle node, const char *prop, char *buffer, int bufsize)
{
	int plen, ret;
	unsigned long flags;

	plen = prom_getproplen(node, prop);
	if((plen > bufsize) || (plen == 0) || (plen == -1))
		return -1;
	/* Ok, things seem all right. */
	spin_lock_irqsave(&prom_lock, flags);
	ret = prom_nodeops->no_getprop(node, prop, buffer);
	restore_current();
	spin_unlock_irqrestore(&prom_lock, flags);
	return ret;
}
EXPORT_SYMBOL(prom_getproperty);

/* Acquire an integer property and return its value.  Returns -1
 * on failure.
 */
int prom_getint(phandle node, char *prop)
{
	static int intprop;

	if(prom_getproperty(node, prop, (char *) &intprop, sizeof(int)) != -1)
		return intprop;

	return -1;
}
EXPORT_SYMBOL(prom_getint);

/* Acquire an integer property, upon error return the passed default
 * integer.
 */
int prom_getintdefault(phandle node, char *property, int deflt)
{
	int retval;

	retval = prom_getint(node, property);
	if(retval == -1) return deflt;

	return retval;
}
EXPORT_SYMBOL(prom_getintdefault);

/* Acquire a boolean property, 1=TRUE 0=FALSE. */
int prom_getbool(phandle node, char *prop)
{
	int retval;

	retval = prom_getproplen(node, prop);
	if(retval == -1) return 0;
	return 1;
}
EXPORT_SYMBOL(prom_getbool);

/* Acquire a property whose value is a string, returns a null
 * string on error.  The char pointer is the user supplied string
 * buffer.
 */
void prom_getstring(phandle node, char *prop, char *user_buf, int ubuf_size)
{
	int len;

	len = prom_getproperty(node, prop, user_buf, ubuf_size);
	if(len != -1) return;
	user_buf[0] = 0;
}
EXPORT_SYMBOL(prom_getstring);


/* Does the device at node 'node' have name 'name'?
 * YES = 1   NO = 0
 */
int prom_nodematch(phandle node, char *name)
{
	int error;

	static char namebuf[128];
	error = prom_getproperty(node, "name", namebuf, sizeof(namebuf));
	if (error == -1) return 0;
	if(strcmp(namebuf, name) == 0) return 1;
	return 0;
}

/* Search siblings at 'node_start' for a node with name
 * 'nodename'.  Return node if successful, zero if not.
 */
phandle prom_searchsiblings(phandle node_start, char *nodename)
{

	phandle thisnode;
	int error;

	for(thisnode = node_start; thisnode;
	    thisnode=prom_getsibling(thisnode)) {
		error = prom_getproperty(thisnode, "name", promlib_buf,
					 sizeof(promlib_buf));
		/* Should this ever happen? */
		if(error == -1) continue;
		if(strcmp(nodename, promlib_buf)==0) return thisnode;
	}

	return 0;
}
EXPORT_SYMBOL(prom_searchsiblings);

/* Interal version of nextprop that does not alter return values. */
char *__prom_nextprop(phandle node, char * oprop)
{
	unsigned long flags;
	char *prop;

	spin_lock_irqsave(&prom_lock, flags);
	prop = prom_nodeops->no_nextprop(node, oprop);
	restore_current();
	spin_unlock_irqrestore(&prom_lock, flags);

	return prop;
}

/* Return the first property name for node 'node'. */
/* buffer is unused argument, but as v9 uses it, we need to have the same interface */
char *prom_firstprop(phandle node, char *bufer)
{
	if (node == 0 || node == -1)
		return "";

	return __prom_nextprop(node, "");
}
EXPORT_SYMBOL(prom_firstprop);

/* Return the property type string after property type 'oprop'
 * at node 'node' .  Returns empty string if no more
 * property types for this node.
 */
char *prom_nextprop(phandle node, char *oprop, char *buffer)
{
	if (node == 0 || node == -1)
		return "";

	return __prom_nextprop(node, oprop);
}
EXPORT_SYMBOL(prom_nextprop);

phandle prom_finddevice(char *name)
{
	char nbuf[128];
	char *s = name, *d;
	phandle node = prom_root_node, node2;
	unsigned int which_io, phys_addr;
	struct linux_prom_registers reg[PROMREG_MAX];

	while (*s++) {
		if (!*s) return node; /* path '.../' is legal */
		node = prom_getchild(node);

		for (d = nbuf; *s != 0 && *s != '@' && *s != '/';)
			*d++ = *s++;
		*d = 0;
		
		node = prom_searchsiblings(node, nbuf);
		if (!node)
			return 0;

		if (*s == '@') {
			if (isxdigit(s[1]) && s[2] == ',') {
				which_io = simple_strtoul(s+1, NULL, 16);
				phys_addr = simple_strtoul(s+3, &d, 16);
				if (d != s + 3 && (!*d || *d == '/')
				    && d <= s + 3 + 8) {
					node2 = node;
					while (node2 && node2 != -1) {
						if (prom_getproperty (node2, "reg", (char *)reg, sizeof (reg)) > 0) {
							if (which_io == reg[0].which_io && phys_addr == reg[0].phys_addr) {
								node = node2;
								break;
							}
						}
						node2 = prom_getsibling(node2);
						if (!node2 || node2 == -1)
							break;
						node2 = prom_searchsiblings(prom_getsibling(node2), nbuf);
					}
				}
			}
			while (*s != 0 && *s != '/') s++;
		}
	}
	return node;
}
EXPORT_SYMBOL(prom_finddevice);

int prom_node_has_property(phandle node, char *prop)
{
	char *current_property = "";

	do {
		current_property = prom_nextprop(node, current_property, NULL);
		if(!strcmp(current_property, prop))
		   return 1;
	} while (*current_property);
	return 0;
}
EXPORT_SYMBOL(prom_node_has_property);

/* Set property 'pname' at node 'node' to value 'value' which has a length
 * of 'size' bytes.  Return the number of bytes the prom accepted.
 */
int prom_setprop(phandle node, const char *pname, char *value, int size)
{
	unsigned long flags;
	int ret;

	if(size == 0) return 0;
	if((pname == 0) || (value == 0)) return 0;
	spin_lock_irqsave(&prom_lock, flags);
	ret = prom_nodeops->no_setprop(node, pname, value, size);
	restore_current();
	spin_unlock_irqrestore(&prom_lock, flags);
	return ret;
}
EXPORT_SYMBOL(prom_setprop);

phandle prom_inst2pkg(int inst)
{
	phandle node;
	unsigned long flags;
	
	spin_lock_irqsave(&prom_lock, flags);
	node = (*romvec->pv_v2devops.v2_inst2pkg)(inst);
	restore_current();
	spin_unlock_irqrestore(&prom_lock, flags);
	if (node == -1) return 0;
	return node;
}
Commit	Line	Data
88278ca2	1	/*
1da177e4 LT	2	* tree.c: Basic device tree traversal/scanning for the Linux
	3	* prom library.
	4	*
	5	* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
	6	*/
	7
1da177e4 LT	8	#include <linux/string.h>
	9	#include <linux/types.h>
	10	#include <linux/kernel.h>
	11	#include <linux/sched.h>
	12	#include <linux/ctype.h>
6943f3da	13	#include <linux/module.h>
1da177e4 LT	14
	15	#include <asm/openprom.h>
	16	#include <asm/oplib.h>
	17
	18	extern void restore_current(void);
	19
	20	static char promlib_buf[128];
	21
	22	/* Internal version of prom_getchild that does not alter return values. */
8d125562	23	phandle __prom_getchild(phandle node)
1da177e4 LT	24	{
1da177e4 LT	25	unsigned long flags;
8d125562	26	phandle cnode;
1da177e4 LT	27
	28	spin_lock_irqsave(&prom_lock, flags);
	29	cnode = prom_nodeops->no_child(node);
	30	restore_current();
	31	spin_unlock_irqrestore(&prom_lock, flags);
	32
	33	return cnode;
	34	}
	35
	36	/* Return the child of node 'node' or zero if no this node has no
	37	* direct descendent.
	38	*/
8d125562	39	phandle prom_getchild(phandle node)
1da177e4	40	{
8d125562	41	phandle cnode;
1da177e4 LT	42
	43	if (node == -1)
	44	return 0;
	45
	46	cnode = __prom_getchild(node);
	47	if (cnode == 0 \|\| cnode == -1)
	48	return 0;
	49
	50	return cnode;
	51	}
6943f3da	52	EXPORT_SYMBOL(prom_getchild);
1da177e4 LT	53
1da177e4 LT	54	/* Internal version of prom_getsibling that does not alter return values. */
8d125562	55	phandle __prom_getsibling(phandle node)
1da177e4 LT	56	{
1da177e4 LT	57	unsigned long flags;
8d125562	58	phandle cnode;
1da177e4 LT	59
	60	spin_lock_irqsave(&prom_lock, flags);
	61	cnode = prom_nodeops->no_nextnode(node);
	62	restore_current();
	63	spin_unlock_irqrestore(&prom_lock, flags);
	64
	65	return cnode;
	66	}
	67
	68	/* Return the next sibling of node 'node' or zero if no more siblings
	69	* at this level of depth in the tree.
	70	*/
8d125562	71	phandle prom_getsibling(phandle node)
1da177e4	72	{
8d125562	73	phandle sibnode;
1da177e4 LT	74
	75	if (node == -1)
	76	return 0;
	77
	78	sibnode = __prom_getsibling(node);
	79	if (sibnode == 0 \|\| sibnode == -1)
	80	return 0;
	81
	82	return sibnode;
	83	}
6943f3da	84	EXPORT_SYMBOL(prom_getsibling);
1da177e4 LT	85
	86	/* Return the length in bytes of property 'prop' at node 'node'.
	87	* Return -1 on error.
	88	*/
8d125562	89	int prom_getproplen(phandle node, const char *prop)
1da177e4 LT	90	{
	91	int ret;
	92	unsigned long flags;
	93
	94	if((!node) \|\| (!prop))
	95	return -1;
	96
	97	spin_lock_irqsave(&prom_lock, flags);
	98	ret = prom_nodeops->no_proplen(node, prop);
	99	restore_current();
	100	spin_unlock_irqrestore(&prom_lock, flags);
	101	return ret;
	102	}
6943f3da	103	EXPORT_SYMBOL(prom_getproplen);
1da177e4 LT	104
	105	/* Acquire a property 'prop' at node 'node' and place it in
	106	* 'buffer' which has a size of 'bufsize'. If the acquisition
	107	* was successful the length will be returned, else -1 is returned.
	108	*/
8d125562	109	int prom_getproperty(phandle node, const char prop, char buffer, int bufsize)
1da177e4 LT	110	{
	111	int plen, ret;
	112	unsigned long flags;
	113
	114	plen = prom_getproplen(node, prop);
	115	if((plen > bufsize) \|\| (plen == 0) \|\| (plen == -1))
	116	return -1;
	117	/* Ok, things seem all right. */
	118	spin_lock_irqsave(&prom_lock, flags);
	119	ret = prom_nodeops->no_getprop(node, prop, buffer);
	120	restore_current();
	121	spin_unlock_irqrestore(&prom_lock, flags);
	122	return ret;
	123	}
6943f3da	124	EXPORT_SYMBOL(prom_getproperty);
1da177e4 LT	125
	126	/* Acquire an integer property and return its value. Returns -1
	127	* on failure.
	128	*/
8d125562	129	int prom_getint(phandle node, char *prop)
1da177e4 LT	130	{
	131	static int intprop;
	132
	133	if(prom_getproperty(node, prop, (char *) &intprop, sizeof(int)) != -1)
	134	return intprop;
	135
	136	return -1;
	137	}
6943f3da	138	EXPORT_SYMBOL(prom_getint);
1da177e4 LT	139
	140	/* Acquire an integer property, upon error return the passed default
	141	* integer.
	142	*/
8d125562	143	int prom_getintdefault(phandle node, char *property, int deflt)
1da177e4 LT	144	{
	145	int retval;
	146
	147	retval = prom_getint(node, property);
	148	if(retval == -1) return deflt;
	149
	150	return retval;
	151	}
6943f3da	152	EXPORT_SYMBOL(prom_getintdefault);
1da177e4 LT	153
1da177e4 LT	154	/* Acquire a boolean property, 1=TRUE 0=FALSE. */
8d125562	155	int prom_getbool(phandle node, char *prop)
1da177e4 LT	156	{
	157	int retval;
	158
	159	retval = prom_getproplen(node, prop);
	160	if(retval == -1) return 0;
	161	return 1;
	162	}
6943f3da	163	EXPORT_SYMBOL(prom_getbool);
1da177e4 LT	164
	165	/* Acquire a property whose value is a string, returns a null
	166	* string on error. The char pointer is the user supplied string
	167	* buffer.
	168	*/
8d125562	169	void prom_getstring(phandle node, char prop, char user_buf, int ubuf_size)
1da177e4 LT	170	{
	171	int len;
	172
	173	len = prom_getproperty(node, prop, user_buf, ubuf_size);
	174	if(len != -1) return;
	175	user_buf[0] = 0;
1da177e4	176	}
6943f3da	177	EXPORT_SYMBOL(prom_getstring);
1da177e4 LT	178
	179
	180	/* Does the device at node 'node' have name 'name'?
	181	* YES = 1 NO = 0
	182	*/
8d125562	183	int prom_nodematch(phandle node, char *name)
1da177e4 LT	184	{
	185	int error;
	186
	187	static char namebuf[128];
	188	error = prom_getproperty(node, "name", namebuf, sizeof(namebuf));
	189	if (error == -1) return 0;
	190	if(strcmp(namebuf, name) == 0) return 1;
	191	return 0;
	192	}
	193
	194	/* Search siblings at 'node_start' for a node with name
	195	* 'nodename'. Return node if successful, zero if not.
	196	*/
8d125562	197	phandle prom_searchsiblings(phandle node_start, char *nodename)
1da177e4 LT	198	{
1da177e4 LT	199
8d125562 AS	200	phandle thisnode;
8d125562 AS	201	int error;
1da177e4 LT	202
	203	for(thisnode = node_start; thisnode;
	204	thisnode=prom_getsibling(thisnode)) {
	205	error = prom_getproperty(thisnode, "name", promlib_buf,
	206	sizeof(promlib_buf));
	207	/* Should this ever happen? */
	208	if(error == -1) continue;
	209	if(strcmp(nodename, promlib_buf)==0) return thisnode;
	210	}
	211
	212	return 0;
	213	}
6943f3da	214	EXPORT_SYMBOL(prom_searchsiblings);
1da177e4	215
1da177e4	216	/* Interal version of nextprop that does not alter return values. */
8d125562	217	char __prom_nextprop(phandle node, char oprop)
1da177e4 LT	218	{
	219	unsigned long flags;
	220	char *prop;
	221
	222	spin_lock_irqsave(&prom_lock, flags);
	223	prop = prom_nodeops->no_nextprop(node, oprop);
	224	restore_current();
	225	spin_unlock_irqrestore(&prom_lock, flags);
	226
	227	return prop;
	228	}
	229
	230	/* Return the first property name for node 'node'. */
	231	/* buffer is unused argument, but as v9 uses it, we need to have the same interface */
8d125562	232	char prom_firstprop(phandle node, char bufer)
1da177e4 LT	233	{
	234	if (node == 0 \|\| node == -1)
	235	return "";
	236
	237	return __prom_nextprop(node, "");
	238	}
6943f3da	239	EXPORT_SYMBOL(prom_firstprop);
1da177e4 LT	240
	241	/* Return the property type string after property type 'oprop'
	242	* at node 'node' . Returns empty string if no more
	243	* property types for this node.
	244	*/
8d125562	245	char prom_nextprop(phandle node, char oprop, char *buffer)
1da177e4 LT	246	{
	247	if (node == 0 \|\| node == -1)
	248	return "";
	249
	250	return __prom_nextprop(node, oprop);
	251	}
6943f3da	252	EXPORT_SYMBOL(prom_nextprop);
1da177e4	253
8d125562	254	phandle prom_finddevice(char *name)
1da177e4 LT	255	{
	256	char nbuf[128];
	257	char s = name, d;
8d125562	258	phandle node = prom_root_node, node2;
1da177e4 LT	259	unsigned int which_io, phys_addr;
	260	struct linux_prom_registers reg[PROMREG_MAX];
	261
	262	while (*s++) {
	263	if (!s) return node; / path '.../' is legal */
	264	node = prom_getchild(node);
	265
	266	for (d = nbuf; s != 0 && s != '@' && *s != '/';)
	267	d++ = s++;
	268	*d = 0;
	269
	270	node = prom_searchsiblings(node, nbuf);
	271	if (!node)
	272	return 0;
	273
	274	if (*s == '@') {
	275	if (isxdigit(s[1]) && s[2] == ',') {
	276	which_io = simple_strtoul(s+1, NULL, 16);
	277	phys_addr = simple_strtoul(s+3, &d, 16);
	278	if (d != s + 3 && (!d \|\| d == '/')
	279	&& d <= s + 3 + 8) {
	280	node2 = node;
	281	while (node2 && node2 != -1) {
	282	if (prom_getproperty (node2, "reg", (char *)reg, sizeof (reg)) > 0) {
	283	if (which_io == reg[0].which_io && phys_addr == reg[0].phys_addr) {
	284	node = node2;
	285	break;
	286	}
	287	}
	288	node2 = prom_getsibling(node2);
	289	if (!node2 \|\| node2 == -1)
	290	break;
	291	node2 = prom_searchsiblings(prom_getsibling(node2), nbuf);
	292	}
	293	}
	294	}
	295	while (s != 0 && s != '/') s++;
	296	}
	297	}
	298	return node;
	299	}
6943f3da	300	EXPORT_SYMBOL(prom_finddevice);
1da177e4	301
8d125562	302	int prom_node_has_property(phandle node, char *prop)
1da177e4 LT	303	{
	304	char *current_property = "";
	305
	306	do {
	307	current_property = prom_nextprop(node, current_property, NULL);
	308	if(!strcmp(current_property, prop))
	309	return 1;
	310	} while (*current_property);
	311	return 0;
	312	}
6943f3da	313	EXPORT_SYMBOL(prom_node_has_property);
1da177e4 LT	314
	315	/* Set property 'pname' at node 'node' to value 'value' which has a length
	316	* of 'size' bytes. Return the number of bytes the prom accepted.
	317	*/
8d125562	318	int prom_setprop(phandle node, const char pname, char value, int size)
1da177e4 LT	319	{
	320	unsigned long flags;
	321	int ret;
	322
	323	if(size == 0) return 0;
	324	if((pname == 0) \|\| (value == 0)) return 0;
	325	spin_lock_irqsave(&prom_lock, flags);
	326	ret = prom_nodeops->no_setprop(node, pname, value, size);
	327	restore_current();
	328	spin_unlock_irqrestore(&prom_lock, flags);
	329	return ret;
	330	}
6943f3da	331	EXPORT_SYMBOL(prom_setprop);
1da177e4	332
8d125562	333	phandle prom_inst2pkg(int inst)
1da177e4	334	{
8d125562	335	phandle node;
1da177e4 LT	336	unsigned long flags;
	337
	338	spin_lock_irqsave(&prom_lock, flags);
	339	node = (*romvec->pv_v2devops.v2_inst2pkg)(inst);
	340	restore_current();
	341	spin_unlock_irqrestore(&prom_lock, flags);
	342	if (node == -1) return 0;
	343	return node;
	344	}