[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)
 */

#define PROMLIB_INTERNAL

#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;
}
EXPORT_SYMBOL(__prom_getchild);

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

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