rom/openfirmware/of_init.c

   1 /*
   2     Copyright © 2008-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 1
   7
   8 #include <inttypes.h>
   9 #include <aros/kernel.h>
  10 #include <aros/symbolsets.h>
  11 #include <aros/debug.h>
  12 #include <exec/nodes.h>
  13 #include <exec/lists.h>
  14 #include <utility/tagitem.h>
  15 #include <proto/kernel.h>
  16 #include <proto/utility.h>
  17
  18 #include "of_intern.h"
  19 #include LC_LIBDEFS_FILE
  20
  21 AROS_LH1(void *, OF_OpenKey,
  22          AROS_LHA(char *, Key, A0),
  23          struct OpenFirmwareBase *, OpenFirmwareBase, 1, Openfirmware)
  24 {
  25     AROS_LIBFUNC_INIT
  26
  27     char ptrbuf[64];
  28     int i;
  29     of_node_t *node, *root = NULL;
  30
  31     D(bug("[OF] OpenKey('%s')\n", Key));
  32
  33     if (*Key != '/')
  34     {
  35         D(bug("[OF] Key must have absolute path\n"));
  36     }
  37     else
  38     {
  39         root = LIBBASE->of_Root;
  40
  41         while(*Key)
  42         {
  43                 Key++;
  44                 for (i=0; i < 63; i++)
  45                 {
  46                         if (*Key == '/' || *Key == 0)
  47                                 break;
  48                         ptrbuf[i] = *Key;
  49                         Key++;
  50                 }
  51
  52                 ptrbuf[i] = 0;
  53
  54                 D(bug("[OF] looking for child '%s'\n", ptrbuf));
  55
  56                 ForeachNode(&root->on_children, node)
  57                 {
  58                         if (!strcmp(node->on_name, ptrbuf))
  59                         {
  60                                 root = node;
  61                                 break;
  62                         }
  63                 }
  64         }
  65     }
  66
  67     return root;
  68
  69     AROS_LIBFUNC_EXIT
  70 }
  71
  72 AROS_LH1I(void, OF_CloseKey,
  73          AROS_LHA(void *, Key, A0),
  74          struct OpenFirmwareBase *, OpenFirmwareBase, 2, Openfirmware)
  75 {
  76     AROS_LIBFUNC_INIT
  77
  78     AROS_LIBFUNC_EXIT
  79 }
  80
  81 AROS_LH2I(void *, OF_GetChild,
  82          AROS_LHA(void *, Key, A0),
  83          AROS_LHA(void *, Prev, A1),
  84          struct OpenFirmwareBase *, OpenFirmwareBase, 3, Openfirmware)
  85 {
  86     AROS_LIBFUNC_INIT
  87
  88     of_node_t *node = (of_node_t *)Key;
  89     of_node_t *last = (of_node_t *)Prev;
  90
  91     if (last)
  92         return GetSucc(last);
  93     else
  94         return GetHead(&node->on_children);
  95
  96     AROS_LIBFUNC_EXIT
  97 }
  98
  99 AROS_LH2I(void *, OF_FindProperty,
 100          AROS_LHA(void *, Key, A0),
 101          AROS_LHA(char *, name, A1),
 102          struct OpenFirmwareBase *, OpenFirmwareBase, 4, Openfirmware)
 103 {
 104     AROS_LIBFUNC_INIT
 105
 106     of_node_t *node = (of_node_t *)Key;
 107     of_property_t *p, *prop = NULL;
 108
 109     ForeachNode(&node->on_properties, p)
 110     {
 111         if (!strcmp(p->op_name, name))
 112         {
 113                 prop = p;
 114                         break;
 115                 }
 116     }
 117
 118         return prop;
 119
 120     AROS_LIBFUNC_EXIT
 121 }
 122
 123 AROS_LH2I(void *, OF_GetProperty,
 124          AROS_LHA(void *, Key, A0),
 125          AROS_LHA(void *, Prev, A1),
 126          struct OpenFirmwareBase *, OpenFirmwareBase, 5, Openfirmware)
 127 {
 128     AROS_LIBFUNC_INIT
 129
 130     of_node_t *node = (of_node_t *)Key;
 131     of_property_t *last = (of_property_t *)Prev;
 132
 133     if (last)
 134         return GetSucc(last);
 135     else
 136         return GetHead(&node->on_properties);
 137
 138     AROS_LIBFUNC_EXIT
 139 }
 140
 141 AROS_LH1I(uint32_t, OF_GetPropLen,
 142          AROS_LHA(void *, Key, A0),
 143          struct OpenFirmwareBase *, OpenFirmwareBase, 6, Openfirmware)
 144 {
 145     AROS_LIBFUNC_INIT
 146
 147     of_property_t *prop = (of_property_t *)Key;
 148
 149     if (prop)
 150         return prop->op_length;
 151     else
 152         return 0;
 153
 154     AROS_LIBFUNC_EXIT
 155 }
 156
 157 AROS_LH1I(char *, OF_GetPropName,
 158          AROS_LHA(void *, Key, A0),
 159          struct OpenFirmwareBase *, OpenFirmwareBase, 8, Openfirmware)
 160 {
 161     AROS_LIBFUNC_INIT
 162
 163     of_property_t *prop = (of_property_t *)Key;
 164
 165     if (prop)
 166         return prop->op_name;
 167     else
 168         return "(null)";
 169
 170     AROS_LIBFUNC_EXIT
 171 }
 172
 173 AROS_LH1I(void *, OF_GetPropValue,
 174          AROS_LHA(void *, Key, A0),
 175          struct OpenFirmwareBase *, OpenFirmwareBase, 7, Openfirmware)
 176 {
 177     AROS_LIBFUNC_INIT
 178
 179     of_property_t *prop = (of_property_t *)Key;
 180
 181     if (prop)
 182         return prop->op_value;
 183     else
 184         return NULL;
 185
 186     AROS_LIBFUNC_EXIT
 187 }
 188
 189
 190 static int OF_Init(LIBBASETYPEPTR LIBBASE)
 191 {
 192         void *KernelBase = OpenResource("kernel.resource");
 193
 194         D(bug("[OF] OpenFirmware_Init\n"));
 195
 196         if (KernelBase)
 197         {
 198                 struct TagItem *tags = KrnGetBootInfo();
 199
 200                 if (tags)
 201                 {
 202                         intptr_t oftree;
 203                         D(bug("[OF] BootInto @ %08x\n", tags));
 204
 205                         oftree = GetTagData(KRN_OpenFirmwareTree, 0, tags);
 206
 207                         if (oftree)
 208                         {
 209                                 D(bug("[OF] OpenFirmware root at %08x\n", oftree));
 210                                 LIBBASE->of_Root = (of_node_t *)oftree;
 211
 212                                 return TRUE;
 213                         }
 214                         D(else bug("[OF] No OpenFirmware tree passed from bootloader\n"));
 215                 }
 216                 D(else bug("[OF] No BootInfo found\n"));
 217         }
 218
 219         return FALSE;
 220 }
 221
 222 ADD2INITLIB(OF_Init, 0)