Commit | Line | Data |
---|---|---|
cd296721 SW |
1 | /* |
2 | * Copyright (c) 2011 The Chromium OS Authors. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public License as | |
6 | * published by the Free Software Foundation; either version 2 of | |
7 | * the License, or (at your option) any later version. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program; if not, write to the Free Software | |
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
17 | * MA 02111-1307 USA | |
18 | */ | |
19 | ||
20 | #include <assert.h> | |
21 | #include <ctype.h> | |
22 | #include <getopt.h> | |
23 | #include <stdio.h> | |
24 | #include <stdlib.h> | |
25 | #include <string.h> | |
26 | ||
27 | #include <libfdt.h> | |
28 | ||
29 | #include "util.h" | |
30 | ||
31 | /* These are the operations we support */ | |
32 | enum oper_type { | |
33 | OPER_WRITE_PROP, /* Write a property in a node */ | |
34 | OPER_CREATE_NODE, /* Create a new node */ | |
35 | }; | |
36 | ||
37 | struct display_info { | |
38 | enum oper_type oper; /* operation to perform */ | |
39 | int type; /* data type (s/i/u/x or 0 for default) */ | |
40 | int size; /* data size (1/2/4) */ | |
41 | int verbose; /* verbose output */ | |
42 | int auto_path; /* automatically create all path components */ | |
43 | }; | |
44 | ||
45 | ||
46 | /** | |
47 | * Report an error with a particular node. | |
48 | * | |
49 | * @param name Node name to report error on | |
50 | * @param namelen Length of node name, or -1 to use entire string | |
51 | * @param err Error number to report (-FDT_ERR_...) | |
52 | */ | |
53 | static void report_error(const char *name, int namelen, int err) | |
54 | { | |
55 | if (namelen == -1) | |
56 | namelen = strlen(name); | |
57 | fprintf(stderr, "Error at '%1.*s': %s\n", namelen, name, | |
58 | fdt_strerror(err)); | |
59 | } | |
60 | ||
61 | /** | |
62 | * Encode a series of arguments in a property value. | |
63 | * | |
64 | * @param disp Display information / options | |
65 | * @param arg List of arguments from command line | |
66 | * @param arg_count Number of arguments (may be 0) | |
67 | * @param valuep Returns buffer containing value | |
68 | * @param *value_len Returns length of value encoded | |
69 | */ | |
70 | static int encode_value(struct display_info *disp, char **arg, int arg_count, | |
71 | char **valuep, int *value_len) | |
72 | { | |
73 | char *value = NULL; /* holding area for value */ | |
74 | int value_size = 0; /* size of holding area */ | |
75 | char *ptr; /* pointer to current value position */ | |
76 | int len; /* length of this cell/string/byte */ | |
77 | int ival; | |
78 | int upto; /* the number of bytes we have written to buf */ | |
79 | char fmt[3]; | |
80 | ||
81 | upto = 0; | |
82 | ||
83 | if (disp->verbose) | |
84 | fprintf(stderr, "Decoding value:\n"); | |
85 | ||
86 | fmt[0] = '%'; | |
87 | fmt[1] = disp->type ? disp->type : 'd'; | |
88 | fmt[2] = '\0'; | |
89 | for (; arg_count > 0; arg++, arg_count--, upto += len) { | |
90 | /* assume integer unless told otherwise */ | |
91 | if (disp->type == 's') | |
92 | len = strlen(*arg) + 1; | |
93 | else | |
94 | len = disp->size == -1 ? 4 : disp->size; | |
95 | ||
96 | /* enlarge our value buffer by a suitable margin if needed */ | |
97 | if (upto + len > value_size) { | |
98 | value_size = (upto + len) + 500; | |
99 | value = realloc(value, value_size); | |
100 | if (!value) { | |
101 | fprintf(stderr, "Out of mmory: cannot alloc " | |
102 | "%d bytes\n", value_size); | |
103 | return -1; | |
104 | } | |
105 | } | |
106 | ||
107 | ptr = value + upto; | |
108 | if (disp->type == 's') { | |
109 | memcpy(ptr, *arg, len); | |
110 | if (disp->verbose) | |
111 | fprintf(stderr, "\tstring: '%s'\n", ptr); | |
112 | } else { | |
113 | int *iptr = (int *)ptr; | |
114 | sscanf(*arg, fmt, &ival); | |
115 | if (len == 4) | |
116 | *iptr = cpu_to_fdt32(ival); | |
117 | else | |
118 | *ptr = (uint8_t)ival; | |
119 | if (disp->verbose) { | |
120 | fprintf(stderr, "\t%s: %d\n", | |
121 | disp->size == 1 ? "byte" : | |
122 | disp->size == 2 ? "short" : "int", | |
123 | ival); | |
124 | } | |
125 | } | |
126 | } | |
127 | *value_len = upto; | |
128 | *valuep = value; | |
129 | if (disp->verbose) | |
130 | fprintf(stderr, "Value size %d\n", upto); | |
131 | return 0; | |
132 | } | |
133 | ||
134 | static int store_key_value(void *blob, const char *node_name, | |
135 | const char *property, const char *buf, int len) | |
136 | { | |
137 | int node; | |
138 | int err; | |
139 | ||
140 | node = fdt_path_offset(blob, node_name); | |
141 | if (node < 0) { | |
142 | report_error(node_name, -1, node); | |
143 | return -1; | |
144 | } | |
145 | ||
146 | err = fdt_setprop(blob, node, property, buf, len); | |
147 | if (err) { | |
148 | report_error(property, -1, err); | |
149 | return -1; | |
150 | } | |
151 | return 0; | |
152 | } | |
153 | ||
154 | /** | |
155 | * Create paths as needed for all components of a path | |
156 | * | |
157 | * Any components of the path that do not exist are created. Errors are | |
158 | * reported. | |
159 | * | |
160 | * @param blob FDT blob to write into | |
161 | * @param in_path Path to process | |
162 | * @return 0 if ok, -1 on error | |
163 | */ | |
164 | static int create_paths(void *blob, const char *in_path) | |
165 | { | |
166 | const char *path = in_path; | |
167 | const char *sep; | |
168 | int node, offset = 0; | |
169 | ||
170 | /* skip leading '/' */ | |
171 | while (*path == '/') | |
172 | path++; | |
173 | ||
174 | for (sep = path; *sep; path = sep + 1, offset = node) { | |
175 | /* equivalent to strchrnul(), but it requires _GNU_SOURCE */ | |
176 | sep = strchr(path, '/'); | |
177 | if (!sep) | |
178 | sep = path + strlen(path); | |
179 | ||
180 | node = fdt_subnode_offset_namelen(blob, offset, path, | |
181 | sep - path); | |
182 | if (node == -FDT_ERR_NOTFOUND) { | |
183 | node = fdt_add_subnode_namelen(blob, offset, path, | |
184 | sep - path); | |
185 | } | |
186 | if (node < 0) { | |
187 | report_error(path, sep - path, node); | |
188 | return -1; | |
189 | } | |
190 | } | |
191 | ||
192 | return 0; | |
193 | } | |
194 | ||
195 | /** | |
196 | * Create a new node in the fdt. | |
197 | * | |
198 | * This will overwrite the node_name string. Any error is reported. | |
199 | * | |
200 | * TODO: Perhaps create fdt_path_offset_namelen() so we don't need to do this. | |
201 | * | |
202 | * @param blob FDT blob to write into | |
203 | * @param node_name Name of node to create | |
204 | * @return new node offset if found, or -1 on failure | |
205 | */ | |
206 | static int create_node(void *blob, const char *node_name) | |
207 | { | |
208 | int node = 0; | |
209 | char *p; | |
210 | ||
211 | p = strrchr(node_name, '/'); | |
212 | if (!p) { | |
213 | report_error(node_name, -1, -FDT_ERR_BADPATH); | |
214 | return -1; | |
215 | } | |
216 | *p = '\0'; | |
217 | ||
218 | if (p > node_name) { | |
219 | node = fdt_path_offset(blob, node_name); | |
220 | if (node < 0) { | |
221 | report_error(node_name, -1, node); | |
222 | return -1; | |
223 | } | |
224 | } | |
225 | ||
226 | node = fdt_add_subnode(blob, node, p + 1); | |
227 | if (node < 0) { | |
228 | report_error(p + 1, -1, node); | |
229 | return -1; | |
230 | } | |
231 | ||
232 | return 0; | |
233 | } | |
234 | ||
235 | static int do_fdtput(struct display_info *disp, const char *filename, | |
236 | char **arg, int arg_count) | |
237 | { | |
238 | char *value; | |
239 | char *blob; | |
240 | int len, ret = 0; | |
241 | ||
242 | blob = utilfdt_read(filename); | |
243 | if (!blob) | |
244 | return -1; | |
245 | ||
246 | switch (disp->oper) { | |
247 | case OPER_WRITE_PROP: | |
248 | /* | |
249 | * Convert the arguments into a single binary value, then | |
250 | * store them into the property. | |
251 | */ | |
252 | assert(arg_count >= 2); | |
253 | if (disp->auto_path && create_paths(blob, *arg)) | |
254 | return -1; | |
255 | if (encode_value(disp, arg + 2, arg_count - 2, &value, &len) || | |
256 | store_key_value(blob, *arg, arg[1], value, len)) | |
257 | ret = -1; | |
258 | break; | |
259 | case OPER_CREATE_NODE: | |
260 | for (; ret >= 0 && arg_count--; arg++) { | |
261 | if (disp->auto_path) | |
262 | ret = create_paths(blob, *arg); | |
263 | else | |
264 | ret = create_node(blob, *arg); | |
265 | } | |
266 | break; | |
267 | } | |
268 | if (ret >= 0) | |
269 | ret = utilfdt_write(filename, blob); | |
270 | ||
271 | free(blob); | |
272 | return ret; | |
273 | } | |
274 | ||
275 | static const char *usage_msg = | |
276 | "fdtput - write a property value to a device tree\n" | |
277 | "\n" | |
278 | "The command line arguments are joined together into a single value.\n" | |
279 | "\n" | |
280 | "Usage:\n" | |
281 | " fdtput <options> <dt file> <node> <property> [<value>...]\n" | |
282 | " fdtput -c <options> <dt file> [<node>...]\n" | |
283 | "Options:\n" | |
284 | "\t-c\t\tCreate nodes if they don't already exist\n" | |
285 | "\t-p\t\tAutomatically create nodes as needed for the node path\n" | |
286 | "\t-t <type>\tType of data\n" | |
287 | "\t-v\t\tVerbose: display each value decoded from command line\n" | |
288 | "\t-h\t\tPrint this help\n\n" | |
289 | USAGE_TYPE_MSG; | |
290 | ||
291 | static void usage(const char *msg) | |
292 | { | |
293 | if (msg) | |
294 | fprintf(stderr, "Error: %s\n\n", msg); | |
295 | ||
296 | fprintf(stderr, "%s", usage_msg); | |
297 | exit(2); | |
298 | } | |
299 | ||
300 | int main(int argc, char *argv[]) | |
301 | { | |
302 | struct display_info disp; | |
303 | char *filename = NULL; | |
304 | ||
305 | memset(&disp, '\0', sizeof(disp)); | |
306 | disp.size = -1; | |
307 | disp.oper = OPER_WRITE_PROP; | |
308 | for (;;) { | |
309 | int c = getopt(argc, argv, "chpt:v"); | |
310 | if (c == -1) | |
311 | break; | |
312 | ||
313 | /* | |
314 | * TODO: add options to: | |
315 | * - delete property | |
316 | * - delete node (optionally recursively) | |
317 | * - rename node | |
318 | * - pack fdt before writing | |
319 | * - set amount of free space when writing | |
320 | * - expand fdt if value doesn't fit | |
321 | */ | |
322 | switch (c) { | |
323 | case 'c': | |
324 | disp.oper = OPER_CREATE_NODE; | |
325 | break; | |
326 | case 'h': | |
327 | case '?': | |
328 | usage(NULL); | |
329 | case 'p': | |
330 | disp.auto_path = 1; | |
331 | break; | |
332 | case 't': | |
333 | if (utilfdt_decode_type(optarg, &disp.type, | |
334 | &disp.size)) | |
335 | usage("Invalid type string"); | |
336 | break; | |
337 | ||
338 | case 'v': | |
339 | disp.verbose = 1; | |
340 | break; | |
341 | } | |
342 | } | |
343 | ||
344 | if (optind < argc) | |
345 | filename = argv[optind++]; | |
346 | if (!filename) | |
347 | usage("Missing filename"); | |
348 | ||
349 | argv += optind; | |
350 | argc -= optind; | |
351 | ||
352 | if (disp.oper == OPER_WRITE_PROP) { | |
353 | if (argc < 1) | |
354 | usage("Missing node"); | |
355 | if (argc < 2) | |
356 | usage("Missing property"); | |
357 | } | |
358 | ||
359 | if (do_fdtput(&disp, filename, argv, argc)) | |
360 | return 1; | |
361 | return 0; | |
362 | } |