Subversion Repositories HelenOS

Rev

Rev 3675 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3675 Rev 4377
Line 40... Line 40...
40
    return balloc(sizeof(ofw_tree_node_t), sizeof(ofw_tree_node_t));
40
    return balloc(sizeof(ofw_tree_node_t), sizeof(ofw_tree_node_t));
41
}
41
}
42
 
42
 
43
static ofw_tree_property_t *ofw_tree_properties_alloc(unsigned count)
43
static ofw_tree_property_t *ofw_tree_properties_alloc(unsigned count)
44
{
44
{
45
    return balloc(count * sizeof(ofw_tree_property_t), sizeof(ofw_tree_property_t));
45
    return balloc(count * sizeof(ofw_tree_property_t),
-
 
46
        sizeof(ofw_tree_property_t));
46
}
47
}
47
 
48
 
48
static void * ofw_tree_space_alloc(size_t size)
49
static void *ofw_tree_space_alloc(size_t size)
49
{
50
{
50
    char *addr;
51
    char *addr;
51
 
52
 
52
    /*
53
    /*
53
     * What we do here is a nasty hack :-)
54
     * What we do here is a nasty hack :-)
Line 63... Line 64...
63
    if (addr)
64
    if (addr)
64
        addr[size] = '\0';
65
        addr[size] = '\0';
65
    return addr;
66
    return addr;
66
}
67
}
67
 
68
 
68
/** Transfer information from one OpenFirmware node into its memory representation.
69
/** Transfer information from one OpenFirmware node into its memory
-
 
70
 * representation.
69
 *
71
 *
70
 * Transfer entire information from the OpenFirmware device tree 'current' node to
72
 * Transfer entire information from the OpenFirmware device tree 'current' node
71
 * its memory representation in 'current_node'. This function recursively processes
73
 * to its memory representation in 'current_node'. This function recursively
72
 * all node's children. Node's peers are processed iteratively in order to prevent
74
 * processes all node's children. Node's peers are processed iteratively in
73
 * stack from overflowing.
75
 * order to prevent stack from overflowing.
74
 *
76
 *
75
 * @param current_node  Pointer to uninitialized ofw_tree_node structure that will
77
 * @param current_node  Pointer to uninitialized ofw_tree_node structure that
76
 *          become the memory represenation of 'current'.
78
 *          will become the memory represenation of 'current'.
77
 * @param parent_node   Parent ofw_tree_node structure or NULL in case of root node.
79
 * @param parent_node   Parent ofw_tree_node structure or NULL in case of root
-
 
80
 *          node.
78
 * @param current   OpenFirmware phandle to the current device tree node.
81
 * @param current   OpenFirmware phandle to the current device tree node.
79
 */
82
 */
80
static void ofw_tree_node_process(ofw_tree_node_t *current_node,
83
static void ofw_tree_node_process(ofw_tree_node_t *current_node,
81
    ofw_tree_node_t *parent_node, phandle current)
84
    ofw_tree_node_t *parent_node, phandle current)
82
{
85
{
83
    static char path[MAX_PATH_LEN+1];
86
    static char path[MAX_PATH_LEN + 1];
84
    static char name[OFW_TREE_PROPERTY_MAX_NAMELEN];
87
    static char name[OFW_TREE_PROPERTY_MAX_NAMELEN];
-
 
88
    static char name2[OFW_TREE_PROPERTY_MAX_NAMELEN];
85
    phandle peer;
89
    phandle peer;
86
    phandle child;
90
    phandle child;
87
    size_t len;
91
    size_t len;
88
    int i;
92
    int i;
89
 
93
 
Line 128... Line 132...
128
        if (child != 0 && child != -1) {
132
        if (child != 0 && child != -1) {
129
            ofw_tree_node_t *child_node;
133
            ofw_tree_node_t *child_node;
130
       
134
       
131
            child_node = ofw_tree_node_alloc();
135
            child_node = ofw_tree_node_alloc();
132
            if (child_node) {
136
            if (child_node) {
133
                ofw_tree_node_process(child_node, current_node, child);
137
                ofw_tree_node_process(child_node, current_node,
-
 
138
                    child);
134
                current_node->child = child_node;
139
                current_node->child = child_node;
135
            }
140
            }
136
        }
141
        }
137
   
142
   
138
        /*
143
        /*
139
         * Count properties.
144
         * Count properties.
140
         */
145
         */
141
        name[0] = '\0';
146
        name[0] = '\0';
142
        while (ofw_next_property(current, name, name) == 1)
147
        while (ofw_next_property(current, name, name2) == 1) {
143
            current_node->properties++;
148
            current_node->properties++;
-
 
149
            memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN);
-
 
150
        }
144
   
151
 
145
        if (!current_node->properties)
152
        if (!current_node->properties)
146
            return;
153
            return;
147
   
154
   
148
        /*
155
        /*
149
         * Copy properties.
156
         * Copy properties.
150
         */
157
         */
-
 
158
        current_node->property =
151
        current_node->property = ofw_tree_properties_alloc(current_node->properties);
159
            ofw_tree_properties_alloc(current_node->properties);
152
        if (!current_node->property)
160
        if (!current_node->property)
153
            return;
161
            return;
154
       
162
       
155
        name[0] = '\0';
163
        name[0] = '\0';
156
        for (i = 0; ofw_next_property(current, name, name) == 1; i++) {
164
        for (i = 0; ofw_next_property(current, name, name2) == 1; i++) {
157
            size_t size;
165
            size_t size;
158
       
166
       
159
            if (i == current_node->properties)
167
            if (i == current_node->properties)
160
                break;
168
                break;
161
       
169
       
-
 
170
            memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN);
162
            memcpy(current_node->property[i].name, name,
171
            memcpy(current_node->property[i].name, name,
163
                OFW_TREE_PROPERTY_MAX_NAMELEN);
172
                OFW_TREE_PROPERTY_MAX_NAMELEN);
-
 
173
            current_node->property[i].name[
164
            current_node->property[i].name[OFW_TREE_PROPERTY_MAX_NAMELEN] = '\0';
174
                OFW_TREE_PROPERTY_MAX_NAMELEN] = '\0';
165
 
175
 
166
            size = ofw_get_proplen(current, name);
176
            size = ofw_get_proplen(current, name);
167
            current_node->property[i].size = size;
177
            current_node->property[i].size = size;
168
            if (size) {
178
            if (size) {
169
                void *buf;
179
                void *buf;
Line 171... Line 181...
171
                buf = ofw_tree_space_alloc(size);
181
                buf = ofw_tree_space_alloc(size);
172
                if (current_node->property[i].value = buf) {
182
                if (current_node->property[i].value = buf) {
173
                    /*
183
                    /*
174
                     * Copy property value to memory node.
184
                     * Copy property value to memory node.
175
                     */
185
                     */
176
                    (void) ofw_get_property(current, name, buf, size);
186
                    (void) ofw_get_property(current, name,
-
 
187
                        buf, size);
177
                }
188
                }
178
            } else {
189
            } else {
179
                current_node->property[i].value = NULL;
190
                current_node->property[i].value = NULL;
180
            }
191
            }
181
        }
192
        }
182
 
193
 
183
        current_node->properties = i;   /* Just in case we ran out of memory. */
194
        /* Just in case we ran out of memory. */
-
 
195
        current_node->properties = i;
184
 
196
 
185
        /*
197
        /*
186
         * Iteratively process the next peer node.
198
         * Iteratively process the next peer node.
187
         * Note that recursion is a bad idea here.
199
         * Note that recursion is a bad idea here.
188
         * Due to the topology of the OpenFirmware device tree,
200
         * Due to the topology of the OpenFirmware device tree,
Line 211... Line 223...
211
    }
223
    }
212
}
224
}
213
 
225
 
214
/** Construct memory representation of OpenFirmware device tree.
226
/** Construct memory representation of OpenFirmware device tree.
215
 *
227
 *
216
 * @return NULL on failure or pointer to the root node.
228
 * @return      NULL on failure or pointer to the root node.
217
 */
229
 */
218
ofw_tree_node_t *ofw_tree_build(void)
230
ofw_tree_node_t *ofw_tree_build(void)
219
{
231
{
220
    ofw_tree_node_t *root;
232
    ofw_tree_node_t *root;
221
    phandle ssm_node;
233
    phandle ssm_node;
Line 232... Line 244...
232
     */
244
     */
233
    ssm_node = ofw_find_device("/ssm@0,0");
245
    ssm_node = ofw_find_device("/ssm@0,0");
234
    if (ssm_node != -1) {
246
    if (ssm_node != -1) {
235
        ssm = ofw_tree_node_alloc();
247
        ssm = ofw_tree_node_alloc();
236
        if (ssm) {
248
        if (ssm) {
237
            ofw_tree_node_process(
249
            ofw_tree_node_process(ssm, root,
238
                ssm, root, ofw_find_device("/ssm@0,0"));
250
                ofw_find_device("/ssm@0,0"));
239
            ssm->peer = root->child;
251
            ssm->peer = root->child;
240
            root->child = ssm;
252
            root->child = ssm;
241
        }
253
        }
242
    }
254
    }
243
   
255