[deliverable/linux.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. */
int __prom_getchild(int node)
{
	unsigned long flags;
	int 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.
 */
int prom_getchild(int node)
{
	int 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. */
int __prom_getsibling(int node)
{
	unsigned long flags;
	int 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.
 */
int prom_getsibling(int node)
{
	int 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(int 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(int 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(int 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(int 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(int 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(int 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(int 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.
 */
int prom_searchsiblings(int node_start, char *nodename)
{

	int thisnode, 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(int 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(int 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(int node, char *oprop, char *buffer)
{
	if (node == 0 || node == -1)
		return "";

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

int prom_finddevice(char *name)
{
	char nbuf[128];
	char *s = name, *d;
	int 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(int 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(int 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);

int prom_inst2pkg(int inst)
{
	int 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;
}

/* Return 'node' assigned to a particular prom 'path'
 * FIXME: Should work for v0 as well
 */
int prom_pathtoinode(char *path)
{
	int node, inst;
	
	inst = prom_devopen (path);
	if (inst == -1) return 0;
	node = prom_inst2pkg (inst);
	prom_devclose (inst);
	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. */
	23	int __prom_getchild(int node)
	24	{
	25	unsigned long flags;
	26	int cnode;
	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	*/
	39	int prom_getchild(int node)
	40	{
	41	int cnode;
	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
	54	/* Internal version of prom_getsibling that does not alter return values. */
	55	int __prom_getsibling(int node)
	56	{
	57	unsigned long flags;
	58	int cnode;
	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	*/
	71	int prom_getsibling(int node)
	72	{
	73	int sibnode;
	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	*/
ab04323e	89	int prom_getproplen(int 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	*/
ab04323e	109	int prom_getproperty(int 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	*/
	129	int prom_getint(int node, char *prop)
	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	*/
	143	int prom_getintdefault(int node, char *property, int deflt)
	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
	154	/* Acquire a boolean property, 1=TRUE 0=FALSE. */
	155	int prom_getbool(int node, char *prop)
	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	*/
	169	void prom_getstring(int node, char prop, char user_buf, int ubuf_size)
	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	*/
	183	int prom_nodematch(int node, char *name)
	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	*/
	197	int prom_searchsiblings(int node_start, char *nodename)
	198	{
	199
	200	int thisnode, error;
	201
	202	for(thisnode = node_start; thisnode;
	203	thisnode=prom_getsibling(thisnode)) {
	204	error = prom_getproperty(thisnode, "name", promlib_buf,
	205	sizeof(promlib_buf));
	206	/* Should this ever happen? */
	207	if(error == -1) continue;
	208	if(strcmp(nodename, promlib_buf)==0) return thisnode;
	209	}
	210
	211	return 0;
	212	}
6943f3da	213	EXPORT_SYMBOL(prom_searchsiblings);
1da177e4	214
1da177e4 LT	215	/* Interal version of nextprop that does not alter return values. */
	216	char * __prom_nextprop(int node, char * oprop)
	217	{
	218	unsigned long flags;
	219	char *prop;
	220
	221	spin_lock_irqsave(&prom_lock, flags);
	222	prop = prom_nodeops->no_nextprop(node, oprop);
	223	restore_current();
	224	spin_unlock_irqrestore(&prom_lock, flags);
	225
	226	return prop;
	227	}
	228
	229	/* Return the first property name for node 'node'. */
	230	/* buffer is unused argument, but as v9 uses it, we need to have the same interface */
	231	char * prom_firstprop(int node, char *bufer)
	232	{
	233	if (node == 0 \|\| node == -1)
	234	return "";
	235
	236	return __prom_nextprop(node, "");
	237	}
6943f3da	238	EXPORT_SYMBOL(prom_firstprop);
1da177e4 LT	239
	240	/* Return the property type string after property type 'oprop'
	241	* at node 'node' . Returns empty string if no more
	242	* property types for this node.
	243	*/
	244	char * prom_nextprop(int node, char oprop, char buffer)
	245	{
	246	if (node == 0 \|\| node == -1)
	247	return "";
	248
	249	return __prom_nextprop(node, oprop);
	250	}
6943f3da	251	EXPORT_SYMBOL(prom_nextprop);
1da177e4 LT	252
	253	int prom_finddevice(char *name)
	254	{
	255	char nbuf[128];
	256	char s = name, d;
	257	int node = prom_root_node, node2;
	258	unsigned int which_io, phys_addr;
	259	struct linux_prom_registers reg[PROMREG_MAX];
	260
	261	while (*s++) {
	262	if (!s) return node; / path '.../' is legal */
	263	node = prom_getchild(node);
	264
	265	for (d = nbuf; s != 0 && s != '@' && *s != '/';)
	266	d++ = s++;
	267	*d = 0;
	268
	269	node = prom_searchsiblings(node, nbuf);
	270	if (!node)
	271	return 0;
	272
	273	if (*s == '@') {
	274	if (isxdigit(s[1]) && s[2] == ',') {
	275	which_io = simple_strtoul(s+1, NULL, 16);
	276	phys_addr = simple_strtoul(s+3, &d, 16);
	277	if (d != s + 3 && (!d \|\| d == '/')
	278	&& d <= s + 3 + 8) {
	279	node2 = node;
	280	while (node2 && node2 != -1) {
	281	if (prom_getproperty (node2, "reg", (char *)reg, sizeof (reg)) > 0) {
	282	if (which_io == reg[0].which_io && phys_addr == reg[0].phys_addr) {
	283	node = node2;
	284	break;
	285	}
	286	}
	287	node2 = prom_getsibling(node2);
	288	if (!node2 \|\| node2 == -1)
	289	break;
	290	node2 = prom_searchsiblings(prom_getsibling(node2), nbuf);
	291	}
	292	}
	293	}
	294	while (s != 0 && s != '/') s++;
	295	}
	296	}
	297	return node;
	298	}
6943f3da	299	EXPORT_SYMBOL(prom_finddevice);
1da177e4 LT	300
	301	int prom_node_has_property(int node, char *prop)
	302	{
	303	char *current_property = "";
	304
	305	do {
	306	current_property = prom_nextprop(node, current_property, NULL);
	307	if(!strcmp(current_property, prop))
	308	return 1;
	309	} while (*current_property);
	310	return 0;
	311	}
6943f3da	312	EXPORT_SYMBOL(prom_node_has_property);
1da177e4 LT	313
	314	/* Set property 'pname' at node 'node' to value 'value' which has a length
	315	* of 'size' bytes. Return the number of bytes the prom accepted.
	316	*/
ab04323e	317	int prom_setprop(int node, const char pname, char value, int size)
1da177e4 LT	318	{
	319	unsigned long flags;
	320	int ret;
	321
	322	if(size == 0) return 0;
	323	if((pname == 0) \|\| (value == 0)) return 0;
	324	spin_lock_irqsave(&prom_lock, flags);
	325	ret = prom_nodeops->no_setprop(node, pname, value, size);
	326	restore_current();
	327	spin_unlock_irqrestore(&prom_lock, flags);
	328	return ret;
	329	}
6943f3da	330	EXPORT_SYMBOL(prom_setprop);
1da177e4 LT	331
	332	int prom_inst2pkg(int inst)
	333	{
	334	int node;
	335	unsigned long flags;
	336
	337	spin_lock_irqsave(&prom_lock, flags);
	338	node = (*romvec->pv_v2devops.v2_inst2pkg)(inst);
	339	restore_current();
	340	spin_unlock_irqrestore(&prom_lock, flags);
	341	if (node == -1) return 0;
	342	return node;
	343	}
	344
	345	/* Return 'node' assigned to a particular prom 'path'
	346	* FIXME: Should work for v0 as well
	347	*/
	348	int prom_pathtoinode(char *path)
	349	{
	350	int node, inst;
	351
	352	inst = prom_devopen (path);
	353	if (inst == -1) return 0;
	354	node = prom_inst2pkg (inst);
	355	prom_devclose (inst);
	356	if (node == -1) return 0;
	357	return node;
	358	}