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 OPER_REMOVE_NODE, /* Delete a node */ 36 OPER_DELETE_PROP, /* Delete a property in a node */ 37 }; 38 39 struct display_info { 40 enum oper_type oper; /* operation to perform */ 41 int type; /* data type (s/i/u/x or 0 for default) */ 42 int size; /* data size (1/2/4) */ 43 int verbose; /* verbose output */ 44 int auto_path; /* automatically create all path components */ 45 }; 46 47 48 /** 49 * Report an error with a particular node. 50 * 51 * @param name Node name to report error on 52 * @param namelen Length of node name, or -1 to use entire string 53 * @param err Error number to report (-FDT_ERR_...) 54 */ 55 static void report_error(const char *name, int namelen, int err) 56 { 57 if (namelen == -1) 58 namelen = strlen(name); 59 fprintf(stderr, "Error at '%1.*s': %s\n", namelen, name, 60 fdt_strerror(err)); 61 } 62 63 /** 64 * Encode a series of arguments in a property value. 65 * 66 * @param disp Display information / options 67 * @param arg List of arguments from command line 68 * @param arg_count Number of arguments (may be 0) 69 * @param valuep Returns buffer containing value 70 * @param *value_len Returns length of value encoded 71 */ 72 static int encode_value(struct display_info *disp, char **arg, int arg_count, 73 char **valuep, int *value_len) 74 { 75 char *value = NULL; /* holding area for value */ 76 int value_size = 0; /* size of holding area */ 77 char *ptr; /* pointer to current value position */ 78 int len; /* length of this cell/string/byte */ 79 int ival; 80 int upto; /* the number of bytes we have written to buf */ 81 char fmt[3]; 82 83 upto = 0; 84 85 if (disp->verbose) 86 fprintf(stderr, "Decoding value:\n"); 87 88 fmt[0] = '%'; 89 fmt[1] = disp->type ? disp->type : 'd'; 90 fmt[2] = '\0'; 91 for (; arg_count > 0; arg++, arg_count--, upto += len) { 92 /* assume integer unless told otherwise */ 93 if (disp->type == 's') 94 len = strlen(*arg) + 1; 95 else 96 len = disp->size == -1 ? 4 : disp->size; 97 98 /* enlarge our value buffer by a suitable margin if needed */ 99 if (upto + len > value_size) { 100 value_size = (upto + len) + 500; 101 value = xrealloc(value, value_size); 102 } 103 104 ptr = value + upto; 105 if (disp->type == 's') { 106 memcpy(ptr, *arg, len); 107 if (disp->verbose) 108 fprintf(stderr, "\tstring: '%s'\n", ptr); 109 } else { 110 int *iptr = (int *)ptr; 111 sscanf(*arg, fmt, &ival); 112 if (len == 4) 113 *iptr = cpu_to_fdt32(ival); 114 else 115 *ptr = (uint8_t)ival; 116 if (disp->verbose) { 117 fprintf(stderr, "\t%s: %d\n", 118 disp->size == 1 ? "byte" : 119 disp->size == 2 ? "short" : "int", 120 ival); 121 } 122 } 123 } 124 *value_len = upto; 125 *valuep = value; 126 if (disp->verbose) 127 fprintf(stderr, "Value size %d\n", upto); 128 return 0; 129 } 130 131 #define ALIGN(x) (((x) + (FDT_TAGSIZE) - 1) & ~((FDT_TAGSIZE) - 1)) 132 133 static char *_realloc_fdt(char *fdt, int delta) 134 { 135 int new_sz = fdt_totalsize(fdt) + delta; 136 fdt = xrealloc(fdt, new_sz); 137 fdt_open_into(fdt, fdt, new_sz); 138 return fdt; 139 } 140 141 static char *realloc_node(char *fdt, const char *name) 142 { 143 int delta; 144 /* FDT_BEGIN_NODE, node name in off_struct and FDT_END_NODE */ 145 delta = sizeof(struct fdt_node_header) + ALIGN(strlen(name) + 1) 146 + FDT_TAGSIZE; 147 return _realloc_fdt(fdt, delta); 148 } 149 150 static char *realloc_property(char *fdt, int nodeoffset, 151 const char *name, int newlen) 152 { 153 int delta = 0; 154 int oldlen = 0; 155 156 if (!fdt_get_property(fdt, nodeoffset, name, &oldlen)) 157 /* strings + property header */ 158 delta = sizeof(struct fdt_property) + strlen(name) + 1; 159 160 if (newlen > oldlen) 161 /* actual value in off_struct */ 162 delta += ALIGN(newlen) - ALIGN(oldlen); 163 164 return _realloc_fdt(fdt, delta); 165 } 166 167 static int store_key_value(char **blob, const char *node_name, 168 const char *property, const char *buf, int len) 169 { 170 int node; 171 int err; 172 173 node = fdt_path_offset(*blob, node_name); 174 if (node < 0) { 175 report_error(node_name, -1, node); 176 return -1; 177 } 178 179 err = fdt_setprop(*blob, node, property, buf, len); 180 if (err == -FDT_ERR_NOSPACE) { 181 *blob = realloc_property(*blob, node, property, len); 182 err = fdt_setprop(*blob, node, property, buf, len); 183 } 184 if (err) { 185 report_error(property, -1, err); 186 return -1; 187 } 188 return 0; 189 } 190 191 /** 192 * Create paths as needed for all components of a path 193 * 194 * Any components of the path that do not exist are created. Errors are 195 * reported. 196 * 197 * @param blob FDT blob to write into 198 * @param in_path Path to process 199 * @return 0 if ok, -1 on error 200 */ 201 static int create_paths(char **blob, const char *in_path) 202 { 203 const char *path = in_path; 204 const char *sep; 205 int node, offset = 0; 206 207 /* skip leading '/' */ 208 while (*path == '/') 209 path++; 210 211 for (sep = path; *sep; path = sep + 1, offset = node) { 212 /* equivalent to strchrnul(), but it requires _GNU_SOURCE */ 213 sep = strchr(path, '/'); 214 if (!sep) 215 sep = path + strlen(path); 216 217 node = fdt_subnode_offset_namelen(*blob, offset, path, 218 sep - path); 219 if (node == -FDT_ERR_NOTFOUND) { 220 *blob = realloc_node(*blob, path); 221 node = fdt_add_subnode_namelen(*blob, offset, path, 222 sep - path); 223 } 224 if (node < 0) { 225 report_error(path, sep - path, node); 226 return -1; 227 } 228 } 229 230 return 0; 231 } 232 233 /** 234 * Create a new node in the fdt. 235 * 236 * This will overwrite the node_name string. Any error is reported. 237 * 238 * TODO: Perhaps create fdt_path_offset_namelen() so we don't need to do this. 239 * 240 * @param blob FDT blob to write into 241 * @param node_name Name of node to create 242 * @return new node offset if found, or -1 on failure 243 */ 244 static int create_node(char **blob, const char *node_name) 245 { 246 int node = 0; 247 char *p; 248 249 p = strrchr(node_name, '/'); 250 if (!p) { 251 report_error(node_name, -1, -FDT_ERR_BADPATH); 252 return -1; 253 } 254 *p = '\0'; 255 256 *blob = realloc_node(*blob, p + 1); 257 258 if (p > node_name) { 259 node = fdt_path_offset(*blob, node_name); 260 if (node < 0) { 261 report_error(node_name, -1, node); 262 return -1; 263 } 264 } 265 266 node = fdt_add_subnode(*blob, node, p + 1); 267 if (node < 0) { 268 report_error(p + 1, -1, node); 269 return -1; 270 } 271 272 return 0; 273 } 274 275 /** 276 * Delete a property of a node in the fdt. 277 * 278 * @param blob FDT blob to write into 279 * @param node_name Path to node containing the property to delete 280 * @param prop_name Name of property to delete 281 * @return 0 on success, or -1 on failure 282 */ 283 static int delete_prop(char *blob, const char *node_name, const char *prop_name) 284 { 285 int node = 0; 286 287 node = fdt_path_offset(blob, node_name); 288 if (node < 0) { 289 report_error(node_name, -1, node); 290 return -1; 291 } 292 293 node = fdt_delprop(blob, node, prop_name); 294 if (node < 0) { 295 report_error(node_name, -1, node); 296 return -1; 297 } 298 299 return 0; 300 } 301 302 /** 303 * Delete a node in the fdt. 304 * 305 * @param blob FDT blob to write into 306 * @param node_name Name of node to delete 307 * @return 0 on success, or -1 on failure 308 */ 309 static int delete_node(char *blob, const char *node_name) 310 { 311 int node = 0; 312 313 node = fdt_path_offset(blob, node_name); 314 if (node < 0) { 315 report_error(node_name, -1, node); 316 return -1; 317 } 318 319 node = fdt_del_node(blob, node); 320 if (node < 0) { 321 report_error(node_name, -1, node); 322 return -1; 323 } 324 325 return 0; 326 } 327 328 static int do_fdtput(struct display_info *disp, const char *filename, 329 char **arg, int arg_count) 330 { 331 char *value = NULL; 332 char *blob; 333 char *node; 334 int len, ret = 0; 335 336 blob = utilfdt_read(filename); 337 if (!blob) 338 return -1; 339 340 switch (disp->oper) { 341 case OPER_WRITE_PROP: 342 /* 343 * Convert the arguments into a single binary value, then 344 * store them into the property. 345 */ 346 assert(arg_count >= 2); 347 if (disp->auto_path && create_paths(&blob, *arg)) 348 return -1; 349 if (encode_value(disp, arg + 2, arg_count - 2, &value, &len) || 350 store_key_value(&blob, *arg, arg[1], value, len)) 351 ret = -1; 352 break; 353 case OPER_CREATE_NODE: 354 for (; ret >= 0 && arg_count--; arg++) { 355 if (disp->auto_path) 356 ret = create_paths(&blob, *arg); 357 else 358 ret = create_node(&blob, *arg); 359 } 360 break; 361 case OPER_REMOVE_NODE: 362 for (; ret >= 0 && arg_count--; arg++) 363 ret = delete_node(blob, *arg); 364 break; 365 case OPER_DELETE_PROP: 366 node = *arg; 367 for (arg++; ret >= 0 && arg_count-- > 1; arg++) 368 ret = delete_prop(blob, node, *arg); 369 break; 370 } 371 if (ret >= 0) { 372 fdt_pack(blob); 373 ret = utilfdt_write(filename, blob); 374 } 375 376 free(blob); 377 378 if (value) { 379 free(value); 380 } 381 382 return ret; 383 } 384 385 /* Usage related data. */ 386 static const char usage_synopsis[] = 387 "write a property value to a device tree\n" 388 " fdtput <options> <dt file> <node> <property> [<value>...]\n" 389 " fdtput -c <options> <dt file> [<node>...]\n" 390 " fdtput -r <options> <dt file> [<node>...]\n" 391 " fdtput -d <options> <dt file> <node> [<property>...]\n" 392 "\n" 393 "The command line arguments are joined together into a single value.\n" 394 USAGE_TYPE_MSG; 395 static const char usage_short_opts[] = "crdpt:v" USAGE_COMMON_SHORT_OPTS; 396 static struct option const usage_long_opts[] = { 397 {"create", no_argument, NULL, 'c'}, 398 {"remove", no_argument, NULL, 'r'}, 399 {"delete", no_argument, NULL, 'd'}, 400 {"auto-path", no_argument, NULL, 'p'}, 401 {"type", a_argument, NULL, 't'}, 402 {"verbose", no_argument, NULL, 'v'}, 403 USAGE_COMMON_LONG_OPTS, 404 }; 405 static const char * const usage_opts_help[] = { 406 "Create nodes if they don't already exist", 407 "Delete nodes (and any subnodes) if they already exist", 408 "Delete properties if they already exist", 409 "Automatically create nodes as needed for the node path", 410 "Type of data", 411 "Display each value decoded from command line", 412 USAGE_COMMON_OPTS_HELP 413 }; 414 415 int main(int argc, char *argv[]) 416 { 417 int opt; 418 struct display_info disp; 419 char *filename = NULL; 420 421 memset(&disp, '\0', sizeof(disp)); 422 disp.size = -1; 423 disp.oper = OPER_WRITE_PROP; 424 while ((opt = util_getopt_long()) != EOF) { 425 /* 426 * TODO: add options to: 427 * - rename node 428 * - pack fdt before writing 429 * - set amount of free space when writing 430 */ 431 switch (opt) { 432 case_USAGE_COMMON_FLAGS 433 434 case 'c': 435 disp.oper = OPER_CREATE_NODE; 436 break; 437 case 'r': 438 disp.oper = OPER_REMOVE_NODE; 439 break; 440 case 'd': 441 disp.oper = OPER_DELETE_PROP; 442 break; 443 case 'p': 444 disp.auto_path = 1; 445 break; 446 case 't': 447 if (utilfdt_decode_type(optarg, &disp.type, 448 &disp.size)) 449 usage("Invalid type string"); 450 break; 451 452 case 'v': 453 disp.verbose = 1; 454 break; 455 } 456 } 457 458 if (optind < argc) 459 filename = argv[optind++]; 460 if (!filename) 461 usage("missing filename"); 462 463 argv += optind; 464 argc -= optind; 465 466 if (disp.oper == OPER_WRITE_PROP) { 467 if (argc < 1) 468 usage("missing node"); 469 if (argc < 2) 470 usage("missing property"); 471 } 472 473 if (disp.oper == OPER_DELETE_PROP) 474 if (argc < 1) 475 usage("missing node"); 476 477 if (do_fdtput(&disp, filename, argv, argc)) 478 return 1; 479 return 0; 480 } 481
