Statistics
| Branch: | Revision:

root / device_tree.c @ ce36252c

History | View | Annotate | Download (5.5 kB)

1
/*
2
 * Functions to help device tree manipulation using libfdt.
3
 * It also provides functions to read entries from device tree proc
4
 * interface.
5
 *
6
 * Copyright 2008 IBM Corporation.
7
 * Authors: Jerone Young <jyoung5@us.ibm.com>
8
 *          Hollis Blanchard <hollisb@us.ibm.com>
9
 *
10
 * This work is licensed under the GNU GPL license version 2 or later.
11
 *
12
 */
13

    
14
#include <stdio.h>
15
#include <sys/types.h>
16
#include <sys/stat.h>
17
#include <fcntl.h>
18
#include <unistd.h>
19
#include <stdlib.h>
20

    
21
#include "config.h"
22
#include "qemu-common.h"
23
#include "device_tree.h"
24
#include "hw/loader.h"
25

    
26
#include <libfdt.h>
27

    
28
#define FDT_MAX_SIZE  0x10000
29

    
30
void *create_device_tree(int *sizep)
31
{
32
    void *fdt;
33
    int ret;
34

    
35
    *sizep = FDT_MAX_SIZE;
36
    fdt = g_malloc0(FDT_MAX_SIZE);
37
    ret = fdt_create(fdt, FDT_MAX_SIZE);
38
    if (ret < 0) {
39
        goto fail;
40
    }
41
    ret = fdt_begin_node(fdt, "");
42
    if (ret < 0) {
43
        goto fail;
44
    }
45
    ret = fdt_end_node(fdt);
46
    if (ret < 0) {
47
        goto fail;
48
    }
49
    ret = fdt_finish(fdt);
50
    if (ret < 0) {
51
        goto fail;
52
    }
53
    ret = fdt_open_into(fdt, fdt, *sizep);
54
    if (ret) {
55
        fprintf(stderr, "Unable to copy device tree in memory\n");
56
        exit(1);
57
    }
58

    
59
    return fdt;
60
fail:
61
    fprintf(stderr, "%s Couldn't create dt: %s\n", __func__, fdt_strerror(ret));
62
    exit(1);
63
}
64

    
65
void *load_device_tree(const char *filename_path, int *sizep)
66
{
67
    int dt_size;
68
    int dt_file_load_size;
69
    int ret;
70
    void *fdt = NULL;
71

    
72
    *sizep = 0;
73
    dt_size = get_image_size(filename_path);
74
    if (dt_size < 0) {
75
        printf("Unable to get size of device tree file '%s'\n",
76
            filename_path);
77
        goto fail;
78
    }
79

    
80
    /* Expand to 2x size to give enough room for manipulation.  */
81
    dt_size += 10000;
82
    dt_size *= 2;
83
    /* First allocate space in qemu for device tree */
84
    fdt = g_malloc0(dt_size);
85

    
86
    dt_file_load_size = load_image(filename_path, fdt);
87
    if (dt_file_load_size < 0) {
88
        printf("Unable to open device tree file '%s'\n",
89
               filename_path);
90
        goto fail;
91
    }
92

    
93
    ret = fdt_open_into(fdt, fdt, dt_size);
94
    if (ret) {
95
        printf("Unable to copy device tree in memory\n");
96
        goto fail;
97
    }
98

    
99
    /* Check sanity of device tree */
100
    if (fdt_check_header(fdt)) {
101
        printf ("Device tree file loaded into memory is invalid: %s\n",
102
            filename_path);
103
        goto fail;
104
    }
105
    *sizep = dt_size;
106
    return fdt;
107

    
108
fail:
109
    g_free(fdt);
110
    return NULL;
111
}
112

    
113
static int findnode_nofail(void *fdt, const char *node_path)
114
{
115
    int offset;
116

    
117
    offset = fdt_path_offset(fdt, node_path);
118
    if (offset < 0) {
119
        fprintf(stderr, "%s Couldn't find node %s: %s\n", __func__, node_path,
120
                fdt_strerror(offset));
121
        exit(1);
122
    }
123

    
124
    return offset;
125
}
126

    
127
int qemu_devtree_setprop(void *fdt, const char *node_path,
128
                         const char *property, void *val_array, int size)
129
{
130
    int r;
131

    
132
    r = fdt_setprop(fdt, findnode_nofail(fdt, node_path), property, val_array, size);
133
    if (r < 0) {
134
        fprintf(stderr, "%s: Couldn't set %s/%s: %s\n", __func__, node_path,
135
                property, fdt_strerror(r));
136
        exit(1);
137
    }
138

    
139
    return r;
140
}
141

    
142
int qemu_devtree_setprop_cell(void *fdt, const char *node_path,
143
                              const char *property, uint32_t val)
144
{
145
    int r;
146

    
147
    r = fdt_setprop_cell(fdt, findnode_nofail(fdt, node_path), property, val);
148
    if (r < 0) {
149
        fprintf(stderr, "%s: Couldn't set %s/%s = %#08x: %s\n", __func__,
150
                node_path, property, val, fdt_strerror(r));
151
        exit(1);
152
    }
153

    
154
    return r;
155
}
156

    
157
int qemu_devtree_setprop_string(void *fdt, const char *node_path,
158
                                const char *property, const char *string)
159
{
160
    int r;
161

    
162
    r = fdt_setprop_string(fdt, findnode_nofail(fdt, node_path), property, string);
163
    if (r < 0) {
164
        fprintf(stderr, "%s: Couldn't set %s/%s = %s: %s\n", __func__,
165
                node_path, property, string, fdt_strerror(r));
166
        exit(1);
167
    }
168

    
169
    return r;
170
}
171

    
172
uint32_t qemu_devtree_get_phandle(void *fdt, const char *path)
173
{
174
    uint32_t r;
175

    
176
    r = fdt_get_phandle(fdt, findnode_nofail(fdt, path));
177
    if (r <= 0) {
178
        fprintf(stderr, "%s: Couldn't get phandle for %s: %s\n", __func__,
179
                path, fdt_strerror(r));
180
        exit(1);
181
    }
182

    
183
    return r;
184
}
185

    
186
int qemu_devtree_setprop_phandle(void *fdt, const char *node_path,
187
                                 const char *property,
188
                                 const char *target_node_path)
189
{
190
    uint32_t phandle = qemu_devtree_get_phandle(fdt, target_node_path);
191
    return qemu_devtree_setprop_cell(fdt, node_path, property, phandle);
192
}
193

    
194
int qemu_devtree_nop_node(void *fdt, const char *node_path)
195
{
196
    int r;
197

    
198
    r = fdt_nop_node(fdt, findnode_nofail(fdt, node_path));
199
    if (r < 0) {
200
        fprintf(stderr, "%s: Couldn't nop node %s: %s\n", __func__, node_path,
201
                fdt_strerror(r));
202
        exit(1);
203
    }
204

    
205
    return r;
206
}
207

    
208
int qemu_devtree_add_subnode(void *fdt, const char *name)
209
{
210
    char *dupname = g_strdup(name);
211
    char *basename = strrchr(dupname, '/');
212
    int retval;
213
    int parent = 0;
214

    
215
    if (!basename) {
216
        g_free(dupname);
217
        return -1;
218
    }
219

    
220
    basename[0] = '\0';
221
    basename++;
222

    
223
    if (dupname[0]) {
224
        parent = findnode_nofail(fdt, dupname);
225
    }
226

    
227
    retval = fdt_add_subnode(fdt, parent, basename);
228
#if 0
229
    if (retval < 0) {
230
        fprintf(stderr, "FDT: Failed to create subnode %s: %s\n", name,
231
                fdt_strerror(retval));
232
        exit(1);
233
    }
234
#endif
235

    
236
    g_free(dupname);
237
    return retval;
238
}