2019-06-20 23:19:38 +02:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
#include <ctype.h>
|
|
|
|
|
#include <getopt.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
|
|
#include <libfdt.h>
|
|
|
|
|
|
|
|
|
|
#include "util.h"
|
|
|
|
|
|
2012-07-12 17:52:48 +02:00
|
|
|
/* These are the operations we support */
|
|
|
|
|
enum oper_type {
|
|
|
|
|
OPER_WRITE_PROP, /* Write a property in a node */
|
2012-07-12 17:52:49 +02:00
|
|
|
OPER_CREATE_NODE, /* Create a new node */
|
2015-01-23 02:25:20 +01:00
|
|
|
OPER_REMOVE_NODE, /* Delete a node */
|
|
|
|
|
OPER_DELETE_PROP, /* Delete a property in a node */
|
2012-07-12 17:52:48 +02:00
|
|
|
};
|
|
|
|
|
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
struct display_info {
|
2012-07-12 17:52:48 +02:00
|
|
|
enum oper_type oper; /* operation to perform */
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
int type; /* data type (s/i/u/x or 0 for default) */
|
|
|
|
|
int size; /* data size (1/2/4) */
|
|
|
|
|
int verbose; /* verbose output */
|
2012-07-12 17:52:51 +02:00
|
|
|
int auto_path; /* automatically create all path components */
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
};
|
|
|
|
|
|
2012-07-10 14:56:47 +02:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Report an error with a particular node.
|
|
|
|
|
*
|
|
|
|
|
* @param name Node name to report error on
|
|
|
|
|
* @param namelen Length of node name, or -1 to use entire string
|
|
|
|
|
* @param err Error number to report (-FDT_ERR_...)
|
|
|
|
|
*/
|
|
|
|
|
static void report_error(const char *name, int namelen, int err)
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
{
|
2012-07-10 14:56:47 +02:00
|
|
|
if (namelen == -1)
|
|
|
|
|
namelen = strlen(name);
|
|
|
|
|
fprintf(stderr, "Error at '%1.*s': %s\n", namelen, name,
|
|
|
|
|
fdt_strerror(err));
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Encode a series of arguments in a property value.
|
|
|
|
|
*
|
|
|
|
|
* @param disp Display information / options
|
|
|
|
|
* @param arg List of arguments from command line
|
|
|
|
|
* @param arg_count Number of arguments (may be 0)
|
|
|
|
|
* @param valuep Returns buffer containing value
|
2017-03-04 14:26:47 +01:00
|
|
|
* @param value_len Returns length of value encoded
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
*/
|
|
|
|
|
static int encode_value(struct display_info *disp, char **arg, int arg_count,
|
|
|
|
|
char **valuep, int *value_len)
|
|
|
|
|
{
|
|
|
|
|
char *value = NULL; /* holding area for value */
|
|
|
|
|
int value_size = 0; /* size of holding area */
|
|
|
|
|
char *ptr; /* pointer to current value position */
|
|
|
|
|
int len; /* length of this cell/string/byte */
|
|
|
|
|
int ival;
|
|
|
|
|
int upto; /* the number of bytes we have written to buf */
|
|
|
|
|
char fmt[3];
|
|
|
|
|
|
|
|
|
|
upto = 0;
|
|
|
|
|
|
|
|
|
|
if (disp->verbose)
|
|
|
|
|
fprintf(stderr, "Decoding value:\n");
|
|
|
|
|
|
|
|
|
|
fmt[0] = '%';
|
|
|
|
|
fmt[1] = disp->type ? disp->type : 'd';
|
|
|
|
|
fmt[2] = '\0';
|
|
|
|
|
for (; arg_count > 0; arg++, arg_count--, upto += len) {
|
|
|
|
|
/* assume integer unless told otherwise */
|
|
|
|
|
if (disp->type == 's')
|
|
|
|
|
len = strlen(*arg) + 1;
|
|
|
|
|
else
|
|
|
|
|
len = disp->size == -1 ? 4 : disp->size;
|
|
|
|
|
|
|
|
|
|
/* enlarge our value buffer by a suitable margin if needed */
|
|
|
|
|
if (upto + len > value_size) {
|
|
|
|
|
value_size = (upto + len) + 500;
|
2014-03-02 21:39:01 +01:00
|
|
|
value = xrealloc(value, value_size);
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ptr = value + upto;
|
|
|
|
|
if (disp->type == 's') {
|
|
|
|
|
memcpy(ptr, *arg, len);
|
|
|
|
|
if (disp->verbose)
|
|
|
|
|
fprintf(stderr, "\tstring: '%s'\n", ptr);
|
|
|
|
|
} else {
|
2017-03-06 02:08:53 +01:00
|
|
|
fdt32_t *iptr = (fdt32_t *)ptr;
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
sscanf(*arg, fmt, &ival);
|
|
|
|
|
if (len == 4)
|
|
|
|
|
*iptr = cpu_to_fdt32(ival);
|
|
|
|
|
else
|
|
|
|
|
*ptr = (uint8_t)ival;
|
|
|
|
|
if (disp->verbose) {
|
|
|
|
|
fprintf(stderr, "\t%s: %d\n",
|
|
|
|
|
disp->size == 1 ? "byte" :
|
|
|
|
|
disp->size == 2 ? "short" : "int",
|
|
|
|
|
ival);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*value_len = upto;
|
|
|
|
|
*valuep = value;
|
|
|
|
|
if (disp->verbose)
|
|
|
|
|
fprintf(stderr, "Value size %d\n", upto);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-29 04:47:38 +02:00
|
|
|
#define ALIGN(x) (((x) + (FDT_TAGSIZE) - 1) & ~((FDT_TAGSIZE) - 1))
|
|
|
|
|
|
2017-10-18 07:59:43 +02:00
|
|
|
static char *realloc_fdt(char *fdt, int delta)
|
2013-05-29 04:47:38 +02:00
|
|
|
{
|
|
|
|
|
int new_sz = fdt_totalsize(fdt) + delta;
|
|
|
|
|
fdt = xrealloc(fdt, new_sz);
|
|
|
|
|
fdt_open_into(fdt, fdt, new_sz);
|
|
|
|
|
return fdt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *realloc_node(char *fdt, const char *name)
|
|
|
|
|
{
|
|
|
|
|
int delta;
|
|
|
|
|
/* FDT_BEGIN_NODE, node name in off_struct and FDT_END_NODE */
|
|
|
|
|
delta = sizeof(struct fdt_node_header) + ALIGN(strlen(name) + 1)
|
|
|
|
|
+ FDT_TAGSIZE;
|
2017-10-18 07:59:43 +02:00
|
|
|
return realloc_fdt(fdt, delta);
|
2013-05-29 04:47:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *realloc_property(char *fdt, int nodeoffset,
|
|
|
|
|
const char *name, int newlen)
|
|
|
|
|
{
|
|
|
|
|
int delta = 0;
|
|
|
|
|
int oldlen = 0;
|
|
|
|
|
|
|
|
|
|
if (!fdt_get_property(fdt, nodeoffset, name, &oldlen))
|
|
|
|
|
/* strings + property header */
|
|
|
|
|
delta = sizeof(struct fdt_property) + strlen(name) + 1;
|
|
|
|
|
|
|
|
|
|
if (newlen > oldlen)
|
|
|
|
|
/* actual value in off_struct */
|
|
|
|
|
delta += ALIGN(newlen) - ALIGN(oldlen);
|
|
|
|
|
|
2017-10-18 07:59:43 +02:00
|
|
|
return realloc_fdt(fdt, delta);
|
2013-05-29 04:47:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int store_key_value(char **blob, const char *node_name,
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
const char *property, const char *buf, int len)
|
|
|
|
|
{
|
|
|
|
|
int node;
|
|
|
|
|
int err;
|
|
|
|
|
|
2013-05-29 04:47:38 +02:00
|
|
|
node = fdt_path_offset(*blob, node_name);
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
if (node < 0) {
|
2012-07-10 14:56:47 +02:00
|
|
|
report_error(node_name, -1, node);
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-29 04:47:38 +02:00
|
|
|
err = fdt_setprop(*blob, node, property, buf, len);
|
|
|
|
|
if (err == -FDT_ERR_NOSPACE) {
|
|
|
|
|
*blob = realloc_property(*blob, node, property, len);
|
|
|
|
|
err = fdt_setprop(*blob, node, property, buf, len);
|
|
|
|
|
}
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
if (err) {
|
2012-07-10 14:56:47 +02:00
|
|
|
report_error(property, -1, err);
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 17:52:51 +02:00
|
|
|
/**
|
|
|
|
|
* Create paths as needed for all components of a path
|
|
|
|
|
*
|
|
|
|
|
* Any components of the path that do not exist are created. Errors are
|
|
|
|
|
* reported.
|
|
|
|
|
*
|
|
|
|
|
* @param blob FDT blob to write into
|
|
|
|
|
* @param in_path Path to process
|
|
|
|
|
* @return 0 if ok, -1 on error
|
|
|
|
|
*/
|
2013-05-29 04:47:38 +02:00
|
|
|
static int create_paths(char **blob, const char *in_path)
|
2012-07-12 17:52:51 +02:00
|
|
|
{
|
|
|
|
|
const char *path = in_path;
|
|
|
|
|
const char *sep;
|
|
|
|
|
int node, offset = 0;
|
|
|
|
|
|
|
|
|
|
/* skip leading '/' */
|
|
|
|
|
while (*path == '/')
|
|
|
|
|
path++;
|
|
|
|
|
|
|
|
|
|
for (sep = path; *sep; path = sep + 1, offset = node) {
|
|
|
|
|
/* equivalent to strchrnul(), but it requires _GNU_SOURCE */
|
|
|
|
|
sep = strchr(path, '/');
|
|
|
|
|
if (!sep)
|
|
|
|
|
sep = path + strlen(path);
|
|
|
|
|
|
2013-05-29 04:47:38 +02:00
|
|
|
node = fdt_subnode_offset_namelen(*blob, offset, path,
|
2012-07-12 17:52:51 +02:00
|
|
|
sep - path);
|
|
|
|
|
if (node == -FDT_ERR_NOTFOUND) {
|
2013-05-29 04:47:38 +02:00
|
|
|
*blob = realloc_node(*blob, path);
|
|
|
|
|
node = fdt_add_subnode_namelen(*blob, offset, path,
|
2012-07-12 17:52:51 +02:00
|
|
|
sep - path);
|
|
|
|
|
}
|
|
|
|
|
if (node < 0) {
|
|
|
|
|
report_error(path, sep - path, node);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 17:52:49 +02:00
|
|
|
/**
|
|
|
|
|
* Create a new node in the fdt.
|
|
|
|
|
*
|
|
|
|
|
* This will overwrite the node_name string. Any error is reported.
|
|
|
|
|
*
|
|
|
|
|
* TODO: Perhaps create fdt_path_offset_namelen() so we don't need to do this.
|
|
|
|
|
*
|
|
|
|
|
* @param blob FDT blob to write into
|
|
|
|
|
* @param node_name Name of node to create
|
|
|
|
|
* @return new node offset if found, or -1 on failure
|
|
|
|
|
*/
|
2013-05-29 04:47:38 +02:00
|
|
|
static int create_node(char **blob, const char *node_name)
|
2012-07-12 17:52:49 +02:00
|
|
|
{
|
|
|
|
|
int node = 0;
|
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
|
|
p = strrchr(node_name, '/');
|
|
|
|
|
if (!p) {
|
2012-07-10 14:56:47 +02:00
|
|
|
report_error(node_name, -1, -FDT_ERR_BADPATH);
|
2012-07-12 17:52:49 +02:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
*p = '\0';
|
|
|
|
|
|
2013-05-29 04:47:38 +02:00
|
|
|
*blob = realloc_node(*blob, p + 1);
|
|
|
|
|
|
2012-07-12 17:52:49 +02:00
|
|
|
if (p > node_name) {
|
2013-05-29 04:47:38 +02:00
|
|
|
node = fdt_path_offset(*blob, node_name);
|
2012-07-12 17:52:49 +02:00
|
|
|
if (node < 0) {
|
2012-07-10 14:56:47 +02:00
|
|
|
report_error(node_name, -1, node);
|
2012-07-12 17:52:49 +02:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-29 04:47:38 +02:00
|
|
|
node = fdt_add_subnode(*blob, node, p + 1);
|
2012-07-12 17:52:49 +02:00
|
|
|
if (node < 0) {
|
2012-07-10 14:56:47 +02:00
|
|
|
report_error(p + 1, -1, node);
|
2012-07-12 17:52:49 +02:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-23 02:25:20 +01:00
|
|
|
/**
|
|
|
|
|
* Delete a property of a node in the fdt.
|
|
|
|
|
*
|
|
|
|
|
* @param blob FDT blob to write into
|
|
|
|
|
* @param node_name Path to node containing the property to delete
|
|
|
|
|
* @param prop_name Name of property to delete
|
|
|
|
|
* @return 0 on success, or -1 on failure
|
|
|
|
|
*/
|
|
|
|
|
static int delete_prop(char *blob, const char *node_name, const char *prop_name)
|
|
|
|
|
{
|
|
|
|
|
int node = 0;
|
|
|
|
|
|
|
|
|
|
node = fdt_path_offset(blob, node_name);
|
|
|
|
|
if (node < 0) {
|
|
|
|
|
report_error(node_name, -1, node);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
node = fdt_delprop(blob, node, prop_name);
|
|
|
|
|
if (node < 0) {
|
|
|
|
|
report_error(node_name, -1, node);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Delete a node in the fdt.
|
|
|
|
|
*
|
|
|
|
|
* @param blob FDT blob to write into
|
|
|
|
|
* @param node_name Name of node to delete
|
|
|
|
|
* @return 0 on success, or -1 on failure
|
|
|
|
|
*/
|
|
|
|
|
static int delete_node(char *blob, const char *node_name)
|
|
|
|
|
{
|
|
|
|
|
int node = 0;
|
|
|
|
|
|
|
|
|
|
node = fdt_path_offset(blob, node_name);
|
|
|
|
|
if (node < 0) {
|
|
|
|
|
report_error(node_name, -1, node);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
node = fdt_del_node(blob, node);
|
|
|
|
|
if (node < 0) {
|
|
|
|
|
report_error(node_name, -1, node);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
static int do_fdtput(struct display_info *disp, const char *filename,
|
|
|
|
|
char **arg, int arg_count)
|
|
|
|
|
{
|
2016-07-13 00:36:21 +02:00
|
|
|
char *value = NULL;
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
char *blob;
|
2015-01-23 02:25:20 +01:00
|
|
|
char *node;
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
int len, ret = 0;
|
|
|
|
|
|
2018-03-16 08:27:03 +01:00
|
|
|
blob = utilfdt_read(filename, NULL);
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
if (!blob)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2012-07-12 17:52:48 +02:00
|
|
|
switch (disp->oper) {
|
|
|
|
|
case OPER_WRITE_PROP:
|
|
|
|
|
/*
|
|
|
|
|
* Convert the arguments into a single binary value, then
|
|
|
|
|
* store them into the property.
|
|
|
|
|
*/
|
|
|
|
|
assert(arg_count >= 2);
|
2013-05-29 04:47:38 +02:00
|
|
|
if (disp->auto_path && create_paths(&blob, *arg))
|
2012-07-12 17:52:51 +02:00
|
|
|
return -1;
|
2012-07-12 17:52:48 +02:00
|
|
|
if (encode_value(disp, arg + 2, arg_count - 2, &value, &len) ||
|
2013-05-29 04:47:38 +02:00
|
|
|
store_key_value(&blob, *arg, arg[1], value, len))
|
2012-07-12 17:52:48 +02:00
|
|
|
ret = -1;
|
|
|
|
|
break;
|
2012-07-12 17:52:49 +02:00
|
|
|
case OPER_CREATE_NODE:
|
2012-07-12 17:52:51 +02:00
|
|
|
for (; ret >= 0 && arg_count--; arg++) {
|
|
|
|
|
if (disp->auto_path)
|
2013-05-29 04:47:38 +02:00
|
|
|
ret = create_paths(&blob, *arg);
|
2012-07-12 17:52:51 +02:00
|
|
|
else
|
2013-05-29 04:47:38 +02:00
|
|
|
ret = create_node(&blob, *arg);
|
2012-07-12 17:52:51 +02:00
|
|
|
}
|
2012-07-12 17:52:49 +02:00
|
|
|
break;
|
2015-01-23 02:25:20 +01:00
|
|
|
case OPER_REMOVE_NODE:
|
|
|
|
|
for (; ret >= 0 && arg_count--; arg++)
|
|
|
|
|
ret = delete_node(blob, *arg);
|
|
|
|
|
break;
|
|
|
|
|
case OPER_DELETE_PROP:
|
|
|
|
|
node = *arg;
|
|
|
|
|
for (arg++; ret >= 0 && arg_count-- > 1; arg++)
|
|
|
|
|
ret = delete_prop(blob, node, *arg);
|
|
|
|
|
break;
|
2012-07-12 17:52:48 +02:00
|
|
|
}
|
2013-05-29 04:47:38 +02:00
|
|
|
if (ret >= 0) {
|
|
|
|
|
fdt_pack(blob);
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
ret = utilfdt_write(filename, blob);
|
2013-05-29 04:47:38 +02:00
|
|
|
}
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
|
|
|
|
|
free(blob);
|
2016-07-13 00:36:21 +02:00
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
|
free(value);
|
|
|
|
|
}
|
|
|
|
|
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-24 10:02:35 +02:00
|
|
|
/* Usage related data. */
|
|
|
|
|
static const char usage_synopsis[] =
|
|
|
|
|
"write a property value to a device tree\n"
|
2012-07-10 14:56:44 +02:00
|
|
|
" fdtput <options> <dt file> <node> <property> [<value>...]\n"
|
2012-07-12 17:52:49 +02:00
|
|
|
" fdtput -c <options> <dt file> [<node>...]\n"
|
2015-01-23 02:25:20 +01:00
|
|
|
" fdtput -r <options> <dt file> [<node>...]\n"
|
|
|
|
|
" fdtput -d <options> <dt file> <node> [<property>...]\n"
|
2013-05-24 10:02:35 +02:00
|
|
|
"\n"
|
|
|
|
|
"The command line arguments are joined together into a single value.\n"
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
USAGE_TYPE_MSG;
|
2015-01-23 02:25:20 +01:00
|
|
|
static const char usage_short_opts[] = "crdpt:v" USAGE_COMMON_SHORT_OPTS;
|
2013-05-24 10:02:35 +02:00
|
|
|
static struct option const usage_long_opts[] = {
|
|
|
|
|
{"create", no_argument, NULL, 'c'},
|
2015-01-23 02:25:20 +01:00
|
|
|
{"remove", no_argument, NULL, 'r'},
|
|
|
|
|
{"delete", no_argument, NULL, 'd'},
|
2013-05-24 10:02:35 +02:00
|
|
|
{"auto-path", no_argument, NULL, 'p'},
|
|
|
|
|
{"type", a_argument, NULL, 't'},
|
|
|
|
|
{"verbose", no_argument, NULL, 'v'},
|
|
|
|
|
USAGE_COMMON_LONG_OPTS,
|
|
|
|
|
};
|
|
|
|
|
static const char * const usage_opts_help[] = {
|
|
|
|
|
"Create nodes if they don't already exist",
|
2015-01-23 02:25:20 +01:00
|
|
|
"Delete nodes (and any subnodes) if they already exist",
|
|
|
|
|
"Delete properties if they already exist",
|
2013-05-24 10:02:35 +02:00
|
|
|
"Automatically create nodes as needed for the node path",
|
|
|
|
|
"Type of data",
|
|
|
|
|
"Display each value decoded from command line",
|
|
|
|
|
USAGE_COMMON_OPTS_HELP
|
|
|
|
|
};
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
|
|
|
|
|
int main(int argc, char *argv[])
|
|
|
|
|
{
|
2013-05-24 10:02:35 +02:00
|
|
|
int opt;
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
struct display_info disp;
|
|
|
|
|
char *filename = NULL;
|
|
|
|
|
|
|
|
|
|
memset(&disp, '\0', sizeof(disp));
|
|
|
|
|
disp.size = -1;
|
2012-07-12 17:52:48 +02:00
|
|
|
disp.oper = OPER_WRITE_PROP;
|
2013-05-24 10:02:35 +02:00
|
|
|
while ((opt = util_getopt_long()) != EOF) {
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
/*
|
|
|
|
|
* TODO: add options to:
|
|
|
|
|
* - rename node
|
|
|
|
|
* - pack fdt before writing
|
|
|
|
|
* - set amount of free space when writing
|
|
|
|
|
*/
|
2013-05-24 10:02:35 +02:00
|
|
|
switch (opt) {
|
|
|
|
|
case_USAGE_COMMON_FLAGS
|
|
|
|
|
|
2012-07-12 17:52:49 +02:00
|
|
|
case 'c':
|
|
|
|
|
disp.oper = OPER_CREATE_NODE;
|
|
|
|
|
break;
|
2015-01-23 02:25:20 +01:00
|
|
|
case 'r':
|
|
|
|
|
disp.oper = OPER_REMOVE_NODE;
|
|
|
|
|
break;
|
|
|
|
|
case 'd':
|
|
|
|
|
disp.oper = OPER_DELETE_PROP;
|
|
|
|
|
break;
|
2012-07-12 17:52:51 +02:00
|
|
|
case 'p':
|
|
|
|
|
disp.auto_path = 1;
|
|
|
|
|
break;
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
case 't':
|
|
|
|
|
if (utilfdt_decode_type(optarg, &disp.type,
|
|
|
|
|
&disp.size))
|
2013-05-24 10:04:43 +02:00
|
|
|
usage("Invalid type string");
|
2021-12-09 07:14:20 +01:00
|
|
|
if (disp.type == 'r')
|
|
|
|
|
usage("Unsupported raw data type");
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'v':
|
|
|
|
|
disp.verbose = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (optind < argc)
|
|
|
|
|
filename = argv[optind++];
|
|
|
|
|
if (!filename)
|
2013-05-24 10:04:43 +02:00
|
|
|
usage("missing filename");
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
|
|
|
|
|
argv += optind;
|
|
|
|
|
argc -= optind;
|
|
|
|
|
|
2012-07-12 17:52:48 +02:00
|
|
|
if (disp.oper == OPER_WRITE_PROP) {
|
|
|
|
|
if (argc < 1)
|
2013-05-24 10:04:43 +02:00
|
|
|
usage("missing node");
|
2012-07-12 17:52:48 +02:00
|
|
|
if (argc < 2)
|
2013-05-24 10:04:43 +02:00
|
|
|
usage("missing property");
|
2012-07-12 17:52:48 +02:00
|
|
|
}
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
|
2015-01-23 02:25:20 +01:00
|
|
|
if (disp.oper == OPER_DELETE_PROP)
|
|
|
|
|
if (argc < 1)
|
|
|
|
|
usage("missing node");
|
|
|
|
|
|
Add fdtput utility to write property values to a device tree
This simple utility allows writing of values into a device tree from the
command line. It aimes to be the opposite of fdtget.
What is it for:
- Updating fdt values when a binary blob already exists
(even though source may be available it might be easier to use this
utility rather than sed, etc.)
- Writing machine-specific fdt values within a build system
To use it, specify the fdt binary file on command line followed by the node
and property to set. Then, provide a list of values to put into that
property. Often there will be just one, but fdtput also supports arrays and
string lists.
fdtput does not try to guess the type of the property based on looking at
the arguments. Instead it always assumes that an integer is provided. To
indicate that you want to write a string, use -ts. You can also provide
hex values with -tx.
The command line arguments are joined together into a single value. For
strings, a nul terminator is placed between each string when it is packed
into the property. To avoid this, pass the string as a single argument.
Usage:
fdtput <options> <dt file> <<node> <property> [<value>...]
Options:
-t <type> Type of data
-v Verbose: display each value decoded from command line
-h Print this help
<type> s=string, i=int, u=unsigned, x=hex
Optional modifier prefix:
hh or b=byte, h=2 byte, l=4 byte (default)
To read from stdin and write to stdout, use - as the file. So you can do:
cat somefile.dtb | fdtput -ts - /node prop "My string value" > newfile.dtb
This commit also adds basic tests to verify the major features.
Signed-off-by: Simon Glass <sjg@chromium.org>
2012-01-21 19:14:48 +01:00
|
|
|
if (do_fdtput(&disp, filename, argv, argc))
|
|
|
|
|
return 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
