arch/sparc/prom/tree_64.c

   1 /*
   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  * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   7  */
   8
   9 #include <linux/string.h>
  10 #include <linux/types.h>
  11 #include <linux/kernel.h>
  12 #include <linux/sched.h>
  13 #include <linux/module.h>
  14
  15 #include <asm/openprom.h>
  16 #include <asm/oplib.h>
  17 #include <asm/ldc.h>
  18
  19 /* Return the child of node 'node' or zero if no this node has no
  20  * direct descendent.
  21  */
  22 inline int __prom_getchild(int node)
  23 {
  24         return p1275_cmd ("child", P1275_INOUT(1, 1), node);
  25 }
  26
  27 inline int prom_getchild(int node)
  28 {
  29         int cnode;
  30
  31         if(node == -1) return 0;
  32         cnode = __prom_getchild(node);
  33         if(cnode == -1) return 0;
  34         return (int)cnode;
  35 }
  36 EXPORT_SYMBOL(prom_getchild);
  37
  38 inline int prom_getparent(int node)
  39 {
  40         int cnode;
  41
  42         if(node == -1) return 0;
  43         cnode = p1275_cmd ("parent", P1275_INOUT(1, 1), node);
  44         if(cnode == -1) return 0;
  45         return (int)cnode;
  46 }
  47
  48 /* Return the next sibling of node 'node' or zero if no more siblings
  49  * at this level of depth in the tree.
  50  */
  51 inline int __prom_getsibling(int node)
  52 {
  53         return p1275_cmd(prom_peer_name, P1275_INOUT(1, 1), node);
  54 }
  55
  56 inline int prom_getsibling(int node)
  57 {
  58         int sibnode;
  59
  60         if (node == -1)
  61                 return 0;
  62         sibnode = __prom_getsibling(node);
  63         if (sibnode == -1)
  64                 return 0;
  65
  66         return sibnode;
  67 }
  68 EXPORT_SYMBOL(prom_getsibling);
  69
  70 /* Return the length in bytes of property 'prop' at node 'node'.
  71  * Return -1 on error.
  72  */
  73 inline int prom_getproplen(int node, const char *prop)
  74 {
  75         if((!node) || (!prop)) return -1;
  76         return p1275_cmd ("getproplen",
  77                           P1275_ARG(1,P1275_ARG_IN_STRING)|
  78                           P1275_INOUT(2, 1),
  79                           node, prop);
  80 }
  81 EXPORT_SYMBOL(prom_getproplen);
  82
  83 /* Acquire a property 'prop' at node 'node' and place it in
  84  * 'buffer' which has a size of 'bufsize'.  If the acquisition
  85  * was successful the length will be returned, else -1 is returned.
  86  */
  87 inline int prom_getproperty(int node, const char *prop,
  88                             char *buffer, int bufsize)
  89 {
  90         int plen;
  91
  92         plen = prom_getproplen(node, prop);
  93         if ((plen > bufsize) || (plen == 0) || (plen == -1)) {
  94                 return -1;
  95         } else {
  96                 /* Ok, things seem all right. */
  97                 return p1275_cmd(prom_getprop_name,
  98                                  P1275_ARG(1,P1275_ARG_IN_STRING)|
  99                                  P1275_ARG(2,P1275_ARG_OUT_BUF)|
 100                                  P1275_INOUT(4, 1),
 101                                  node, prop, buffer, P1275_SIZE(plen));
 102         }
 103 }
 104 EXPORT_SYMBOL(prom_getproperty);
 105
 106 /* Acquire an integer property and return its value.  Returns -1
 107  * on failure.
 108  */
 109 inline int prom_getint(int node, const char *prop)
 110 {
 111         int intprop;
 112
 113         if(prom_getproperty(node, prop, (char *) &intprop, sizeof(int)) != -1)
 114                 return intprop;
 115
 116         return -1;
 117 }
 118 EXPORT_SYMBOL(prom_getint);
 119
 120 /* Acquire an integer property, upon error return the passed default
 121  * integer.
 122  */
 123
 124 int prom_getintdefault(int node, const char *property, int deflt)
 125 {
 126         int retval;
 127
 128         retval = prom_getint(node, property);
 129         if(retval == -1) return deflt;
 130
 131         return retval;
 132 }
 133 EXPORT_SYMBOL(prom_getintdefault);
 134
 135 /* Acquire a boolean property, 1=TRUE 0=FALSE. */
 136 int prom_getbool(int node, const char *prop)
 137 {
 138         int retval;
 139
 140         retval = prom_getproplen(node, prop);
 141         if(retval == -1) return 0;
 142         return 1;
 143 }
 144 EXPORT_SYMBOL(prom_getbool);
 145
 146 /* Acquire a property whose value is a string, returns a null
 147  * string on error.  The char pointer is the user supplied string
 148  * buffer.
 149  */
 150 void prom_getstring(int node, const char *prop, char *user_buf, int ubuf_size)
 151 {
 152         int len;
 153
 154         len = prom_getproperty(node, prop, user_buf, ubuf_size);
 155         if(len != -1) return;
 156         user_buf[0] = 0;
 157 }
 158 EXPORT_SYMBOL(prom_getstring);
 159
 160 /* Does the device at node 'node' have name 'name'?
 161  * YES = 1   NO = 0
 162  */
 163 int prom_nodematch(int node, const char *name)
 164 {
 165         char namebuf[128];
 166         prom_getproperty(node, "name", namebuf, sizeof(namebuf));
 167         if(strcmp(namebuf, name) == 0) return 1;
 168         return 0;
 169 }
 170
 171 /* Search siblings at 'node_start' for a node with name
 172  * 'nodename'.  Return node if successful, zero if not.
 173  */
 174 int prom_searchsiblings(int node_start, const char *nodename)
 175 {
 176
 177         int thisnode, error;
 178         char promlib_buf[128];
 179
 180         for(thisnode = node_start; thisnode;
 181             thisnode=prom_getsibling(thisnode)) {
 182                 error = prom_getproperty(thisnode, "name", promlib_buf,
 183                                          sizeof(promlib_buf));
 184                 /* Should this ever happen? */
 185                 if(error == -1) continue;
 186                 if(strcmp(nodename, promlib_buf)==0) return thisnode;
 187         }
 188
 189         return 0;
 190 }
 191 EXPORT_SYMBOL(prom_searchsiblings);
 192
 193 /* Return the first property type for node 'node'.
 194  * buffer should be at least 32B in length
 195  */
 196 inline char *prom_firstprop(int node, char *buffer)
 197 {
 198         *buffer = 0;
 199         if(node == -1) return buffer;
 200         p1275_cmd ("nextprop", P1275_ARG(2,P1275_ARG_OUT_32B)|
 201                                P1275_INOUT(3, 0),
 202                                node, (char *) 0x0, buffer);
 203         return buffer;
 204 }
 205 EXPORT_SYMBOL(prom_firstprop);
 206
 207 /* Return the property type string after property type 'oprop'
 208  * at node 'node' .  Returns NULL string if no more
 209  * property types for this node.
 210  */
 211 inline char *prom_nextprop(int node, const char *oprop, char *buffer)
 212 {
 213         char buf[32];
 214
 215         if(node == -1) {
 216                 *buffer = 0;
 217                 return buffer;
 218         }
 219         if (oprop == buffer) {
 220                 strcpy (buf, oprop);
 221                 oprop = buf;
 222         }
 223         p1275_cmd ("nextprop", P1275_ARG(1,P1275_ARG_IN_STRING)|
 224                                     P1275_ARG(2,P1275_ARG_OUT_32B)|
 225                                     P1275_INOUT(3, 0),
 226                                     node, oprop, buffer);
 227         return buffer;
 228 }
 229 EXPORT_SYMBOL(prom_nextprop);
 230
 231 int
 232 prom_finddevice(const char *name)
 233 {
 234         if (!name)
 235                 return 0;
 236         return p1275_cmd(prom_finddev_name,
 237                          P1275_ARG(0,P1275_ARG_IN_STRING)|
 238                          P1275_INOUT(1, 1),
 239                          name);
 240 }
 241 EXPORT_SYMBOL(prom_finddevice);
 242
 243 int prom_node_has_property(int node, const char *prop)
 244 {
 245         char buf [32];
 246
 247         *buf = 0;
 248         do {
 249                 prom_nextprop(node, buf, buf);
 250                 if(!strcmp(buf, prop))
 251                         return 1;
 252         } while (*buf);
 253         return 0;
 254 }
 255 EXPORT_SYMBOL(prom_node_has_property);
 256
 257 /* Set property 'pname' at node 'node' to value 'value' which has a length
 258  * of 'size' bytes.  Return the number of bytes the prom accepted.
 259  */
 260 int
 261 prom_setprop(int node, const char *pname, char *value, int size)
 262 {
 263         if (size == 0)
 264                 return 0;
 265         if ((pname == 0) || (value == 0))
 266                 return 0;
 267
 268 #ifdef CONFIG_SUN_LDOMS
 269         if (ldom_domaining_enabled) {
 270                 ldom_set_var(pname, value);
 271                 return 0;
 272         }
 273 #endif
 274         return p1275_cmd ("setprop", P1275_ARG(1,P1275_ARG_IN_STRING)|
 275                                           P1275_ARG(2,P1275_ARG_IN_BUF)|
 276                                           P1275_INOUT(4, 1),
 277                                           node, pname, value, P1275_SIZE(size));
 278 }
 279 EXPORT_SYMBOL(prom_setprop);
 280
 281 inline int prom_inst2pkg(int inst)
 282 {
 283         int node;
 284
 285         node = p1275_cmd ("instance-to-package", P1275_INOUT(1, 1), inst);
 286         if (node == -1) return 0;
 287         return node;
 288 }
 289
 290 /* Return 'node' assigned to a particular prom 'path'
 291  * FIXME: Should work for v0 as well
 292  */
 293 int
 294 prom_pathtoinode(const char *path)
 295 {
 296         int node, inst;
 297
 298         inst = prom_devopen (path);
 299         if (inst == 0) return 0;
 300         node = prom_inst2pkg (inst);
 301         prom_devclose (inst);
 302         if (node == -1) return 0;
 303         return node;
 304 }
 305
 306 int prom_ihandle2path(int handle, char *buffer, int bufsize)
 307 {
 308         return p1275_cmd("instance-to-path",
 309                          P1275_ARG(1,P1275_ARG_OUT_BUF)|
 310                          P1275_INOUT(3, 1),
 311                          handle, buffer, P1275_SIZE(bufsize));
 312 }