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 phandle prom_node_to_node(const char *type, phandle 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 (phandle) 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 phandle __prom_getchild(phandle node)
  38 {
  39         return prom_node_to_node("child", node);
  40 }
  41
  42 inline phandle prom_getchild(phandle node)
  43 {
  44         phandle cnode;
  45
  46         if ((s32)node == -1)
  47                 return 0;
  48         cnode = __prom_getchild(node);
  49         if ((s32)cnode == -1)
  50                 return 0;
  51         return cnode;
  52 }
  53 EXPORT_SYMBOL(prom_getchild);
  54
  55 inline phandle prom_getparent(phandle node)
  56 {
  57         phandle cnode;
  58
  59         if ((s32)node == -1)
  60                 return 0;
  61         cnode = prom_node_to_node("parent", node);
  62         if ((s32)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 phandle __prom_getsibling(phandle node)
  71 {
  72         return prom_node_to_node(prom_peer_name, node);
  73 }
  74
  75 inline phandle prom_getsibling(phandle node)
  76 {
  77         phandle sibnode;
  78
  79         if ((s32)node == -1)
  80                 return 0;
  81         sibnode = __prom_getsibling(node);
  82         if ((s32)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(phandle 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(phandle 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(phandle 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(phandle 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(phandle 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(phandle node, const char *prop, char *user_buf,
 188                 int ubuf_size)
 189 {
 190         int len;
 191
 192         len = prom_getproperty(node, prop, user_buf, ubuf_size);
 193         if (len != -1)
 194                 return;
 195         user_buf[0] = 0;
 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(phandle 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 phandle prom_searchsiblings(phandle node_start, const char *nodename)
 215 {
 216         phandle thisnode;
 217         int 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(phandle node, char *buffer)
 239 {
 240         unsigned long args[7];
 241
 242         *buffer = 0;
 243         if ((s32)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(phandle node, const char *oprop, char *buffer)
 265 {
 266         unsigned long args[7];
 267         char buf[32];
 268
 269         if ((s32)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 phandle prom_finddevice(const char *name)
 293 {
 294         unsigned long args[5];
 295
 296         if (!name)
 297                 return 0;
 298         args[0] = (unsigned long) "finddevice";
 299         args[1] = 1;
 300         args[2] = 1;
 301         args[3] = (unsigned long) name;
 302         args[4] = (unsigned long) -1;
 303
 304         p1275_cmd_direct(args);
 305
 306         return (int) args[4];
 307 }
 308 EXPORT_SYMBOL(prom_finddevice);
 309
 310 int prom_node_has_property(phandle node, const char *prop)
 311 {
 312         char buf [32];
 313
 314         *buf = 0;
 315         do {
 316                 prom_nextprop(node, buf, buf);
 317                 if (!strcmp(buf, prop))
 318                         return 1;
 319         } while (*buf);
 320         return 0;
 321 }
 322 EXPORT_SYMBOL(prom_node_has_property);
 323
 324 /* Set property 'pname' at node 'node' to value 'value' which has a length
 325  * of 'size' bytes.  Return the number of bytes the prom accepted.
 326  */
 327 int
 328 prom_setprop(phandle node, const char *pname, char *value, int size)
 329 {
 330         unsigned long args[8];
 331
 332         if (size == 0)
 333                 return 0;
 334         if ((pname == 0) || (value == 0))
 335                 return 0;
 336
 337 #ifdef CONFIG_SUN_LDOMS
 338         if (ldom_domaining_enabled) {
 339                 ldom_set_var(pname, value);
 340                 return 0;
 341         }
 342 #endif
 343         args[0] = (unsigned long) "setprop";
 344         args[1] = 4;
 345         args[2] = 1;
 346         args[3] = (unsigned int) node;
 347         args[4] = (unsigned long) pname;
 348         args[5] = (unsigned long) value;
 349         args[6] = size;
 350         args[7] = (unsigned long) -1;
 351
 352         p1275_cmd_direct(args);
 353
 354         return (int) args[7];
 355 }
 356 EXPORT_SYMBOL(prom_setprop);
 357
 358 inline phandle prom_inst2pkg(int inst)
 359 {
 360         unsigned long args[5];
 361         phandle node;
 362
 363         args[0] = (unsigned long) "instance-to-package";
 364         args[1] = 1;
 365         args[2] = 1;
 366         args[3] = (unsigned int) inst;
 367         args[4] = (unsigned long) -1;
 368
 369         p1275_cmd_direct(args);
 370
 371         node = (int) args[4];
 372         if ((s32)node == -1)
 373                 return 0;
 374         return node;
 375 }
 376
 377 int prom_ihandle2path(int handle, char *buffer, int bufsize)
 378 {
 379         unsigned long args[7];
 380
 381         args[0] = (unsigned long) "instance-to-path";
 382         args[1] = 3;
 383         args[2] = 1;
 384         args[3] = (unsigned int) handle;
 385         args[4] = (unsigned long) buffer;
 386         args[5] = bufsize;
 387         args[6] = (unsigned long) -1;
 388
 389         p1275_cmd_direct(args);
 390
 391         return (int) args[6];
 392 }