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 static int prom_node_to_node(const char *type, int node)
  20 {
  21         unsigned long args[5];
  22
  23         args[0] = (unsigned long) type;
  24         args[1] = 1;
  25         args[2] = 1;
  26         args[3] = (unsigned int) node;
  27         args[4] = (unsigned long) -1;
  28
  29         p1275_cmd_direct(args);
  30
  31         return (int) args[4];
  32 }
  33
  34 /* Return the child of node 'node' or zero if no this node has no
  35  * direct descendent.
  36  */
  37 inline int __prom_getchild(int node)
  38 {
  39         return prom_node_to_node("child", node);
  40 }
  41
  42 inline int prom_getchild(int node)
  43 {
  44         int cnode;
  45
  46         if (node == -1)
  47                 return 0;
  48         cnode = __prom_getchild(node);
  49         if (cnode == -1)
  50                 return 0;
  51         return cnode;
  52 }
  53 EXPORT_SYMBOL(prom_getchild);
  54
  55 inline int prom_getparent(int node)
  56 {
  57         int cnode;
  58
  59         if (node == -1)
  60                 return 0;
  61         cnode = prom_node_to_node("parent", node);
  62         if (cnode == -1)
  63                 return 0;
  64         return cnode;
  65 }
  66
  67 /* Return the next sibling of node 'node' or zero if no more siblings
  68  * at this level of depth in the tree.
  69  */
  70 inline int __prom_getsibling(int node)
  71 {
  72         return prom_node_to_node(prom_peer_name, node);
  73 }
  74
  75 inline int prom_getsibling(int node)
  76 {
  77         int sibnode;
  78
  79         if (node == -1)
  80                 return 0;
  81         sibnode = __prom_getsibling(node);
  82         if (sibnode == -1)
  83                 return 0;
  84
  85         return sibnode;
  86 }
  87 EXPORT_SYMBOL(prom_getsibling);
  88
  89 /* Return the length in bytes of property 'prop' at node 'node'.
  90  * Return -1 on error.
  91  */
  92 inline int prom_getproplen(int node, const char *prop)
  93 {
  94         unsigned long args[6];
  95
  96         if (!node || !prop)
  97                 return -1;
  98
  99         args[0] = (unsigned long) "getproplen";
 100         args[1] = 2;
 101         args[2] = 1;
 102         args[3] = (unsigned int) node;
 103         args[4] = (unsigned long) prop;
 104         args[5] = (unsigned long) -1;
 105
 106         p1275_cmd_direct(args);
 107
 108         return (int) args[5];
 109 }
 110 EXPORT_SYMBOL(prom_getproplen);
 111
 112 /* Acquire a property 'prop' at node 'node' and place it in
 113  * 'buffer' which has a size of 'bufsize'.  If the acquisition
 114  * was successful the length will be returned, else -1 is returned.
 115  */
 116 inline int prom_getproperty(int node, const char *prop,
 117                             char *buffer, int bufsize)
 118 {
 119         unsigned long args[8];
 120         int plen;
 121
 122         plen = prom_getproplen(node, prop);
 123         if ((plen > bufsize) || (plen == 0) || (plen == -1))
 124                 return -1;
 125
 126         args[0] = (unsigned long) prom_getprop_name;
 127         args[1] = 4;
 128         args[2] = 1;
 129         args[3] = (unsigned int) node;
 130         args[4] = (unsigned long) prop;
 131         args[5] = (unsigned long) buffer;
 132         args[6] = bufsize;
 133         args[7] = (unsigned long) -1;
 134
 135         p1275_cmd_direct(args);
 136
 137         return (int) args[7];
 138 }
 139 EXPORT_SYMBOL(prom_getproperty);
 140
 141 /* Acquire an integer property and return its value.  Returns -1
 142  * on failure.
 143  */
 144 inline int prom_getint(int node, const char *prop)
 145 {
 146         int intprop;
 147
 148         if (prom_getproperty(node, prop, (char *) &intprop, sizeof(int)) != -1)
 149                 return intprop;
 150
 151         return -1;
 152 }
 153 EXPORT_SYMBOL(prom_getint);
 154
 155 /* Acquire an integer property, upon error return the passed default
 156  * integer.
 157  */
 158
 159 int prom_getintdefault(int node, const char *property, int deflt)
 160 {
 161         int retval;
 162
 163         retval = prom_getint(node, property);
 164         if (retval == -1)
 165                 return deflt;
 166
 167         return retval;
 168 }
 169 EXPORT_SYMBOL(prom_getintdefault);
 170
 171 /* Acquire a boolean property, 1=TRUE 0=FALSE. */
 172 int prom_getbool(int node, const char *prop)
 173 {
 174         int retval;
 175
 176         retval = prom_getproplen(node, prop);
 177         if (retval == -1)
 178                 return 0;
 179         return 1;
 180 }
 181 EXPORT_SYMBOL(prom_getbool);
 182
 183 /* Acquire a property whose value is a string, returns a null
 184  * string on error.  The char pointer is the user supplied string
 185  * buffer.
 186  */
 187 void prom_getstring(int node, const char *prop, char *user_buf, int ubuf_size)
 188 {
 189         int len;
 190
 191         len = prom_getproperty(node, prop, user_buf, ubuf_size);
 192         if (len != -1)
 193                 return;
 194         user_buf[0] = 0;
 195         return;
 196 }
 197 EXPORT_SYMBOL(prom_getstring);
 198
 199 /* Does the device at node 'node' have name 'name'?
 200  * YES = 1   NO = 0
 201  */
 202 int prom_nodematch(int node, const char *name)
 203 {
 204         char namebuf[128];
 205         prom_getproperty(node, "name", namebuf, sizeof(namebuf));
 206         if (strcmp(namebuf, name) == 0)
 207                 return 1;
 208         return 0;
 209 }
 210
 211 /* Search siblings at 'node_start' for a node with name
 212  * 'nodename'.  Return node if successful, zero if not.
 213  */
 214 int prom_searchsiblings(int node_start, const char *nodename)
 215 {
 216
 217         int thisnode, error;
 218         char promlib_buf[128];
 219
 220         for(thisnode = node_start; thisnode;
 221             thisnode=prom_getsibling(thisnode)) {
 222                 error = prom_getproperty(thisnode, "name", promlib_buf,
 223                                          sizeof(promlib_buf));
 224                 /* Should this ever happen? */
 225                 if(error == -1) continue;
 226                 if(strcmp(nodename, promlib_buf)==0) return thisnode;
 227         }
 228
 229         return 0;
 230 }
 231 EXPORT_SYMBOL(prom_searchsiblings);
 232
 233 static const char *prom_nextprop_name = "nextprop";
 234
 235 /* Return the first property type for node 'node'.
 236  * buffer should be at least 32B in length
 237  */
 238 inline char *prom_firstprop(int node, char *buffer)
 239 {
 240         unsigned long args[7];
 241
 242         *buffer = 0;
 243         if (node == -1)
 244                 return buffer;
 245
 246         args[0] = (unsigned long) prom_nextprop_name;
 247         args[1] = 3;
 248         args[2] = 1;
 249         args[3] = (unsigned int) node;
 250         args[4] = 0;
 251         args[5] = (unsigned long) buffer;
 252         args[6] = (unsigned long) -1;
 253
 254         p1275_cmd_direct(args);
 255
 256         return buffer;
 257 }
 258 EXPORT_SYMBOL(prom_firstprop);
 259
 260 /* Return the property type string after property type 'oprop'
 261  * at node 'node' .  Returns NULL string if no more
 262  * property types for this node.
 263  */
 264 inline char *prom_nextprop(int node, const char *oprop, char *buffer)
 265 {
 266         unsigned long args[7];
 267         char buf[32];
 268
 269         if (node == -1) {
 270                 *buffer = 0;
 271                 return buffer;
 272         }
 273         if (oprop == buffer) {
 274                 strcpy (buf, oprop);
 275                 oprop = buf;
 276         }
 277
 278         args[0] = (unsigned long) prom_nextprop_name;
 279         args[1] = 3;
 280         args[2] = 1;
 281         args[3] = (unsigned int) node;
 282         args[4] = (unsigned long) oprop;
 283         args[5] = (unsigned long) buffer;
 284         args[6] = (unsigned long) -1;
 285
 286         p1275_cmd_direct(args);
 287
 288         return buffer;
 289 }
 290 EXPORT_SYMBOL(prom_nextprop);
 291
 292 int
 293 prom_finddevice(const char *name)
 294 {
 295         unsigned long args[5];
 296
 297         if (!name)
 298                 return 0;
 299         args[0] = (unsigned long) "finddevice";
 300         args[1] = 1;
 301         args[2] = 1;
 302         args[3] = (unsigned long) name;
 303         args[4] = (unsigned long) -1;
 304
 305         p1275_cmd_direct(args);
 306
 307         return (int) args[4];
 308 }
 309 EXPORT_SYMBOL(prom_finddevice);
 310
 311 int prom_node_has_property(int node, const char *prop)
 312 {
 313         char buf [32];
 314
 315         *buf = 0;
 316         do {
 317                 prom_nextprop(node, buf, buf);
 318                 if (!strcmp(buf, prop))
 319                         return 1;
 320         } while (*buf);
 321         return 0;
 322 }
 323 EXPORT_SYMBOL(prom_node_has_property);
 324
 325 /* Set property 'pname' at node 'node' to value 'value' which has a length
 326  * of 'size' bytes.  Return the number of bytes the prom accepted.
 327  */
 328 int
 329 prom_setprop(int node, const char *pname, char *value, int size)
 330 {
 331         unsigned long args[8];
 332
 333         if (size == 0)
 334                 return 0;
 335         if ((pname == 0) || (value == 0))
 336                 return 0;
 337
 338 #ifdef CONFIG_SUN_LDOMS
 339         if (ldom_domaining_enabled) {
 340                 ldom_set_var(pname, value);
 341                 return 0;
 342         }
 343 #endif
 344         args[0] = (unsigned long) "setprop";
 345         args[1] = 4;
 346         args[2] = 1;
 347         args[3] = (unsigned int) node;
 348         args[4] = (unsigned long) pname;
 349         args[5] = (unsigned long) value;
 350         args[6] = size;
 351         args[7] = (unsigned long) -1;
 352
 353         p1275_cmd_direct(args);
 354
 355         return (int) args[7];
 356 }
 357 EXPORT_SYMBOL(prom_setprop);
 358
 359 inline int prom_inst2pkg(int inst)
 360 {
 361         unsigned long args[5];
 362         int node;
 363
 364         args[0] = (unsigned long) "instance-to-package";
 365         args[1] = 1;
 366         args[2] = 1;
 367         args[3] = (unsigned int) inst;
 368         args[4] = (unsigned long) -1;
 369
 370         p1275_cmd_direct(args);
 371
 372         node = (int) args[4];
 373         if (node == -1)
 374                 return 0;
 375         return node;
 376 }
 377
 378 /* Return 'node' assigned to a particular prom 'path'
 379  * FIXME: Should work for v0 as well
 380  */
 381 int
 382 prom_pathtoinode(const char *path)
 383 {
 384         int node, inst;
 385
 386         inst = prom_devopen (path);
 387         if (inst == 0)
 388                 return 0;
 389         node = prom_inst2pkg(inst);
 390         prom_devclose(inst);
 391         if (node == -1)
 392                 return 0;
 393         return node;
 394 }
 395
 396 int prom_ihandle2path(int handle, char *buffer, int bufsize)
 397 {
 398         unsigned long args[7];
 399
 400         args[0] = (unsigned long) "instance-to-path";
 401         args[1] = 3;
 402         args[2] = 1;
 403         args[3] = (unsigned int) handle;
 404         args[4] = (unsigned long) buffer;
 405         args[5] = bufsize;
 406         args[6] = (unsigned long) -1;
 407
 408         p1275_cmd_direct(args);
 409
 410         return (int) args[6];
 411 }