Commit | Line | Data |
---|---|---|
2f0dfeaa DG |
1 | /* |
2 | * This file does the necessary interface mapping between the bootwrapper | |
3 | * device tree operations and the interface provided by shared source | |
4 | * files flatdevicetree.[ch]. | |
5 | * | |
6 | * Copyright 2007 David Gibson, IBM Corporation. | |
7 | * | |
8 | * This library is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of the | |
11 | * License, or (at your option) any later version. | |
12 | * | |
13 | * This library is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this library; if not, write to the Free Software | |
20 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | |
21 | * 02110-1301 USA | |
22 | */ | |
23 | ||
24 | #include <stddef.h> | |
25 | #include <stdio.h> | |
26 | #include <page.h> | |
27 | #include <libfdt.h> | |
28 | #include "ops.h" | |
29 | ||
30 | #define DEBUG 0 | |
31 | #define BAD_ERROR(err) (((err) < 0) \ | |
32 | && ((err) != -FDT_ERR_NOTFOUND) \ | |
33 | && ((err) != -FDT_ERR_EXISTS)) | |
34 | ||
35 | #define check_err(err) \ | |
36 | ({ \ | |
37 | if (BAD_ERROR(err) || ((err < 0) && DEBUG)) \ | |
e48b1b45 | 38 | printf("%s():%d %s\n\r", __func__, __LINE__, \ |
2f0dfeaa DG |
39 | fdt_strerror(err)); \ |
40 | if (BAD_ERROR(err)) \ | |
41 | exit(); \ | |
42 | (err < 0) ? -1 : 0; \ | |
43 | }) | |
44 | ||
45 | #define offset_devp(off) \ | |
46 | ({ \ | |
754e5f3f SW |
47 | int _offset = (off); \ |
48 | check_err(_offset) ? NULL : (void *)(_offset+1); \ | |
2f0dfeaa DG |
49 | }) |
50 | ||
2a9d2d97 SW |
51 | #define devp_offset_find(devp) (((int)(devp))-1) |
52 | #define devp_offset(devp) (devp ? ((int)(devp))-1 : 0) | |
2f0dfeaa DG |
53 | |
54 | static void *fdt; | |
55 | static void *buf; /* = NULL */ | |
56 | ||
57 | #define EXPAND_GRANULARITY 1024 | |
58 | ||
59 | static void expand_buf(int minexpand) | |
60 | { | |
61 | int size = fdt_totalsize(fdt); | |
62 | int rc; | |
63 | ||
64 | size = _ALIGN(size + minexpand, EXPAND_GRANULARITY); | |
65 | buf = platform_ops.realloc(buf, size); | |
66 | if (!buf) | |
67 | fatal("Couldn't find %d bytes to expand device tree\n\r", size); | |
68 | rc = fdt_open_into(fdt, buf, size); | |
69 | if (rc != 0) | |
70 | fatal("Couldn't expand fdt into new buffer: %s\n\r", | |
71 | fdt_strerror(rc)); | |
72 | ||
73 | fdt = buf; | |
74 | } | |
75 | ||
76 | static void *fdt_wrapper_finddevice(const char *path) | |
77 | { | |
78 | return offset_devp(fdt_path_offset(fdt, path)); | |
79 | } | |
80 | ||
81 | static int fdt_wrapper_getprop(const void *devp, const char *name, | |
82 | void *buf, const int buflen) | |
83 | { | |
84 | const void *p; | |
85 | int len; | |
86 | ||
87 | p = fdt_getprop(fdt, devp_offset(devp), name, &len); | |
88 | if (!p) | |
89 | return check_err(len); | |
90 | memcpy(buf, p, min(len, buflen)); | |
91 | return len; | |
92 | } | |
93 | ||
94 | static int fdt_wrapper_setprop(const void *devp, const char *name, | |
95 | const void *buf, const int len) | |
96 | { | |
97 | int rc; | |
98 | ||
99 | rc = fdt_setprop(fdt, devp_offset(devp), name, buf, len); | |
100 | if (rc == -FDT_ERR_NOSPACE) { | |
101 | expand_buf(len + 16); | |
102 | rc = fdt_setprop(fdt, devp_offset(devp), name, buf, len); | |
103 | } | |
104 | ||
105 | return check_err(rc); | |
106 | } | |
107 | ||
108 | static void *fdt_wrapper_get_parent(const void *devp) | |
109 | { | |
110 | return offset_devp(fdt_parent_offset(fdt, devp_offset(devp))); | |
111 | } | |
112 | ||
113 | static void *fdt_wrapper_create_node(const void *devp, const char *name) | |
114 | { | |
115 | int offset; | |
116 | ||
117 | offset = fdt_add_subnode(fdt, devp_offset(devp), name); | |
118 | if (offset == -FDT_ERR_NOSPACE) { | |
119 | expand_buf(strlen(name) + 16); | |
120 | offset = fdt_add_subnode(fdt, devp_offset(devp), name); | |
121 | } | |
122 | ||
123 | return offset_devp(offset); | |
124 | } | |
125 | ||
126 | static void *fdt_wrapper_find_node_by_prop_value(const void *prev, | |
127 | const char *name, | |
128 | const char *val, | |
129 | int len) | |
130 | { | |
2a9d2d97 SW |
131 | int offset = fdt_node_offset_by_prop_value(fdt, devp_offset_find(prev), |
132 | name, val, len); | |
133 | return offset_devp(offset); | |
2f0dfeaa DG |
134 | } |
135 | ||
b3bea15d KG |
136 | static void *fdt_wrapper_find_node_by_compatible(const void *prev, |
137 | const char *val) | |
138 | { | |
139 | int offset = fdt_node_offset_by_compatible(fdt, devp_offset_find(prev), | |
140 | val); | |
141 | return offset_devp(offset); | |
142 | } | |
143 | ||
2f0dfeaa DG |
144 | static char *fdt_wrapper_get_path(const void *devp, char *buf, int len) |
145 | { | |
146 | int rc; | |
147 | ||
148 | rc = fdt_get_path(fdt, devp_offset(devp), buf, len); | |
149 | if (check_err(rc)) | |
150 | return NULL; | |
151 | return buf; | |
152 | } | |
153 | ||
154 | static unsigned long fdt_wrapper_finalize(void) | |
155 | { | |
156 | int rc; | |
157 | ||
158 | rc = fdt_pack(fdt); | |
159 | if (rc != 0) | |
160 | fatal("Couldn't pack flat tree: %s\n\r", | |
161 | fdt_strerror(rc)); | |
162 | return (unsigned long)fdt; | |
163 | } | |
164 | ||
165 | void fdt_init(void *blob) | |
166 | { | |
167 | int err; | |
168 | ||
169 | dt_ops.finddevice = fdt_wrapper_finddevice; | |
170 | dt_ops.getprop = fdt_wrapper_getprop; | |
171 | dt_ops.setprop = fdt_wrapper_setprop; | |
172 | dt_ops.get_parent = fdt_wrapper_get_parent; | |
173 | dt_ops.create_node = fdt_wrapper_create_node; | |
174 | dt_ops.find_node_by_prop_value = fdt_wrapper_find_node_by_prop_value; | |
b3bea15d | 175 | dt_ops.find_node_by_compatible = fdt_wrapper_find_node_by_compatible; |
2f0dfeaa DG |
176 | dt_ops.get_path = fdt_wrapper_get_path; |
177 | dt_ops.finalize = fdt_wrapper_finalize; | |
178 | ||
179 | /* Make sure the dt blob is the right version and so forth */ | |
180 | fdt = blob; | |
181 | err = fdt_open_into(fdt, fdt, fdt_totalsize(blob)); | |
182 | if (err == -FDT_ERR_NOSPACE) { | |
183 | int bufsize = fdt_totalsize(fdt) + 4; | |
184 | buf = malloc(bufsize); | |
185 | err = fdt_open_into(fdt, buf, bufsize); | |
186 | } | |
187 | ||
188 | if (err != 0) | |
189 | fatal("fdt_init(): %s\n\r", fdt_strerror(err)); | |
190 | ||
191 | if (buf) | |
192 | fdt = buf; | |
193 | } |