Subversion Repositories HelenOS

Rev

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

Rev 3796 Rev 3797
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];
85
    static char name2[OFW_TREE_PROPERTY_MAX_NAMELEN];
88
    static char name2[OFW_TREE_PROPERTY_MAX_NAMELEN];
86
    phandle peer;
89
    phandle peer;
87
    phandle child;
90
    phandle child;
88
    size_t len;
91
    size_t len;
Line 129... Line 132...
129
        if (child != 0 && child != -1) {
132
        if (child != 0 && child != -1) {
130
            ofw_tree_node_t *child_node;
133
            ofw_tree_node_t *child_node;
131
       
134
       
132
            child_node = ofw_tree_node_alloc();
135
            child_node = ofw_tree_node_alloc();
133
            if (child_node) {
136
            if (child_node) {
134
                ofw_tree_node_process(child_node, current_node, child);
137
                ofw_tree_node_process(child_node, current_node,
-
 
138
                    child);
135
                current_node->child = child_node;
139
                current_node->child = child_node;
136
            }
140
            }
137
        }
141
        }
138
   
142
   
139
        /*
143
        /*
Line 149... Line 153...
149
            return;
153
            return;
150
   
154
   
151
        /*
155
        /*
152
         * Copy properties.
156
         * Copy properties.
153
         */
157
         */
-
 
158
        current_node->property =
154
        current_node->property = ofw_tree_properties_alloc(current_node->properties);
159
            ofw_tree_properties_alloc(current_node->properties);
155
        if (!current_node->property)
160
        if (!current_node->property)
156
            return;
161
            return;
157
       
162
       
158
        name[0] = '\0';
163
        name[0] = '\0';
159
        for (i = 0; ofw_next_property(current, name, name2) == 1; i++) {
164
        for (i = 0; ofw_next_property(current, name, name2) == 1; i++) {
Line 162... Line 167...
162
            if (i == current_node->properties)
167
            if (i == current_node->properties)
163
                break;
168
                break;
164
       
169
       
165
            memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN);
170
            memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN);
166
            memcpy(current_node->property[i].name, name,
171
            memcpy(current_node->property[i].name, name,
167
                OFW_TREE_PROPERTY_MAX_NAMELEN);
172
                OFW_TREE_PROPERTY_MAX_NAMELEN);
-
 
173
            current_node->property[i].name[
168
            current_node->property[i].name[OFW_TREE_PROPERTY_MAX_NAMELEN] = '\0';
174
                OFW_TREE_PROPERTY_MAX_NAMELEN] = '\0';
169
 
175
 
170
            size = ofw_get_proplen(current, name);
176
            size = ofw_get_proplen(current, name);
171
            current_node->property[i].size = size;
177
            current_node->property[i].size = size;
172
            if (size) {
178
            if (size) {
173
                void *buf;
179
                void *buf;
Line 175... Line 181...
175
                buf = ofw_tree_space_alloc(size);
181
                buf = ofw_tree_space_alloc(size);
176
                if (current_node->property[i].value = buf) {
182
                if (current_node->property[i].value = buf) {
177
                    /*
183
                    /*
178
                     * Copy property value to memory node.
184
                     * Copy property value to memory node.
179
                     */
185
                     */
180
                    (void) ofw_get_property(current, name, buf, size);
186
                    (void) ofw_get_property(current, name,
-
 
187
                        buf, size);
181
                }
188
                }
182
            } else {
189
            } else {
183
                current_node->property[i].value = NULL;
190
                current_node->property[i].value = NULL;
184
            }
191
            }
185
        }
192
        }
186
 
193
 
187
        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;
188
 
196
 
189
        /*
197
        /*
190
         * Iteratively process the next peer node.
198
         * Iteratively process the next peer node.
191
         * Note that recursion is a bad idea here.
199
         * Note that recursion is a bad idea here.
192
         * Due to the topology of the OpenFirmware device tree,
200
         * Due to the topology of the OpenFirmware device tree,
Line 215... Line 223...
215
    }
223
    }
216
}
224
}
217
 
225
 
218
/** Construct memory representation of OpenFirmware device tree.
226
/** Construct memory representation of OpenFirmware device tree.
219
 *
227
 *
220
 * @return NULL on failure or pointer to the root node.
228
 * @return      NULL on failure or pointer to the root node.
221
 */
229
 */
222
ofw_tree_node_t *ofw_tree_build(void)
230
ofw_tree_node_t *ofw_tree_build(void)
223
{
231
{
224
    ofw_tree_node_t *root;
232
    ofw_tree_node_t *root;
225
    phandle ssm_node;
233
    phandle ssm_node;
Line 236... Line 244...
236
     */
244
     */
237
    ssm_node = ofw_find_device("/ssm@0,0");
245
    ssm_node = ofw_find_device("/ssm@0,0");
238
    if (ssm_node != -1) {
246
    if (ssm_node != -1) {
239
        ssm = ofw_tree_node_alloc();
247
        ssm = ofw_tree_node_alloc();
240
        if (ssm) {
248
        if (ssm) {
241
            ofw_tree_node_process(
249
            ofw_tree_node_process(ssm, root,
242
                ssm, root, ofw_find_device("/ssm@0,0"));
250
                ofw_find_device("/ssm@0,0"));
243
            ssm->peer = root->child;
251
            ssm->peer = root->child;
244
            root->child = ssm;
252
            root->child = ssm;
245
        }
253
        }
246
    }
254
    }
247
   
255