kernel
/
dtc
mirror of https://git.kernel.org/pub/scm/utils/dtc/dtc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Preserve datatype markers when emitting dts format 

If datatype markers are present in the property value, use them to
output the data in the correct format instead of trying to guess the
datatype. This also will preserve data grouping, such as in an
interrupts list.

This is a step forward for preserving and using datatype information
when processing DTS/DTB files. Schema validation tools can use the
datatype information to make sure a DT is correctly formed and
intepreted.

Signed-off-by: Grant Likely <grant.likely@arm.com>
[robh: rework marker handling and fix label output]
Signed-off-by: Rob Herring <robh@kernel.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
main
Grant Likely 7 years ago committed by David Gibson
parent
6dcb8ba408
commit
32b9c61307
4 changed files with 167 additions and 91 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      dtc.h
  2. 7
      tests/run_tests.sh
  3. 28
      tests/type-preservation.dts
  4. 222
      treesource.c

1
dtc.h
Unescape View File

@ -74,6 +74,7 @@ typedef uint32_t cell_t;


/* Data blobs */ /* Data blobs */
enum markertype { enum markertype {
TYPE_NONE,
REF_PHANDLE, REF_PHANDLE,
REF_PATH, REF_PATH,
LABEL, LABEL,

7
tests/run_tests.sh
Unescape View File

@ -551,6 +551,13 @@ dtc_tests () {
run_test dtbs_equal_ordered $tree odts_$tree.test.dtb run_test dtbs_equal_ordered $tree odts_$tree.test.dtb
done done


# Check -Odts preserving type information
for tree in type-preservation.dts; do
run_dtc_test -I dts -O dts -o $tree.test.dts $tree
run_dtc_test -I dts -O dts $tree.test.dts
run_wrap_test cmp $tree $tree.test.dts
done

# Check version conversions # Check version conversions
for tree in test_tree1.dtb ; do for tree in test_tree1.dtb ; do
for aver in 1 2 3 16 17; do for aver in 1 2 3 16 17; do

28
tests/type-preservation.dts
Unescape View File

@ -0,0 +1,28 @@
/dts-v1/;

/ {
#address-cells = < 0x01 >;
#size-cells = < 0x00 >;

sub1: subnode@1 {
prop_label: compatible = value_label: "subnode1";
reg = < 0x01 >;
int-array = < 0x00 0x01 >, int_value_label: < 0x02 0x03 >;
int8 = [ 56 ];
int8-array = [ 00 12 34 56 label: ];
int16 = /bits/ 16 < 0x3210 >;
int16-array = /bits/ 16 < 0x1234 0x5678 0x90ab 0xcdef >;
int16-matrix = /bits/ 16 < 0x1234 0x5678 >, < 0x90ab 0xcdef >;
int64 = /bits/ 64 < 0x200000000 >;
int64-array = /bits/ 64 < 0x100000000 0x00 int64_array_label_end: >;
a-string-with-nulls = "foo\0bar", "baz";

subsub1: subsubnode {
compatible = "subsubnode1", "subsubnode";

subsubsub1: subsubsubnode {
compatible = "subsubsubnode1", < 0x1234 >, valuea: valueb: "subsubsubnode";
};
};
};
};

222
treesource.c
Unescape View File

@ -61,24 +61,14 @@ static bool isstring(char c)
|| strchr("\a\b\t\n\v\f\r", c)); || strchr("\a\b\t\n\v\f\r", c));
} }


static void write_propval_string(FILE *f, struct data val) static void write_propval_string(FILE *f, const char *s, size_t len)
{ {
const char *str = val.val; const char *end = s + len - 1;
int i; assert(*end == '\0');
struct marker *m = val.markers;

assert(str[val.len-1] == '\0');


while (m && (m->offset == 0)) {
if (m->type == LABEL)
fprintf(f, "%s: ", m->ref);
m = m->next;
}
fprintf(f, "\""); fprintf(f, "\"");

while (s < end) {
for (i = 0; i < (val.len-1); i++) { char c = *s++;
char c = str[i];

switch (c) { switch (c) {
case '\a': case '\a':
fprintf(f, "\\a"); fprintf(f, "\\a");
@ -108,91 +98,73 @@ static void write_propval_string(FILE *f, struct data val)
fprintf(f, "\\\""); fprintf(f, "\\\"");
break; break;
case '\0': case '\0':
fprintf(f, "\", "); fprintf(f, "\\0");
while (m && (m->offset <= (i + 1))) {
if (m->type == LABEL) {
assert(m->offset == (i+1));
fprintf(f, "%s: ", m->ref);
}
m = m->next;
}
fprintf(f, "\"");
break; break;
default: default:
if (isprint((unsigned char)c)) if (isprint((unsigned char)c))
fprintf(f, "%c", c); fprintf(f, "%c", c);
else else
fprintf(f, "\\x%02hhx", c); fprintf(f, "\\x%02"PRIx8, c);
} }
} }
fprintf(f, "\""); fprintf(f, "\"");

/* Wrap up any labels at the end of the value */
for_each_marker_of_type(m, LABEL) {
assert (m->offset == val.len);
fprintf(f, " %s:", m->ref);
}
} }


static void write_propval_cells(FILE *f, struct data val) static void write_propval_int(FILE *f, const char *p, size_t len, size_t width)
{ {
void *propend = val.val + val.len; const char *end = p + len;
fdt32_t *cp = (fdt32_t *)val.val; assert(len % width == 0);
struct marker *m = val.markers;

fprintf(f, "<");
for (;;) {
while (m && (m->offset <= ((char *)cp - val.val))) {
if (m->type == LABEL) {
assert(m->offset == ((char *)cp - val.val));
fprintf(f, "%s: ", m->ref);
}
m = m->next;
}


fprintf(f, "0x%x", fdt32_to_cpu(*cp++)); for (; p < end; p += width) {
if ((void *)cp >= propend) switch (width) {
case 1:
fprintf(f, " %02"PRIx8, *(const uint8_t*)p);
break; break;
fprintf(f, " "); case 2:
} fprintf(f, " 0x%02"PRIx16, fdt16_to_cpu(*(const fdt16_t*)p));

break;
/* Wrap up any labels at the end of the value */ case 4:
for_each_marker_of_type(m, LABEL) { fprintf(f, " 0x%02"PRIx32, fdt32_to_cpu(*(const fdt32_t*)p));
assert (m->offset == val.len); break;
fprintf(f, " %s:", m->ref); case 8:
fprintf(f, " 0x%02"PRIx64, fdt64_to_cpu(*(const fdt64_t*)p));
break;
}
} }
fprintf(f, ">");
} }


static void write_propval_bytes(FILE *f, struct data val) static struct marker *next_type_marker(struct marker *m)
{ {
void *propend = val.val + val.len; while (m && (m->type == LABEL || m->type == REF_PHANDLE || m->type == REF_PATH))
const char *bp = val.val; m = m->next;
struct marker *m = val.markers; return m;

}
fprintf(f, "[");
for (;;) {
while (m && (m->offset == (bp-val.val))) {
if (m->type == LABEL)
fprintf(f, "%s: ", m->ref);
m = m->next;
}


fprintf(f, "%02hhx", (unsigned char)(*bp++)); static size_t type_marker_length(struct marker *m)
if ((const void *)bp >= propend) {
break; struct marker *next = next_type_marker(m->next);
fprintf(f, " ");
}


/* Wrap up any labels at the end of the value */ if (next)
for_each_marker_of_type(m, LABEL) { return next->offset - m->offset;
assert (m->offset == val.len); return 0;
fprintf(f, " %s:", m->ref);
}
fprintf(f, "]");
} }


static void write_propval(FILE *f, struct property *prop) static const char *delim_start[] = {
[TYPE_UINT8] = "[",
[TYPE_UINT16] = "/bits/ 16 <",
[TYPE_UINT32] = "<",
[TYPE_UINT64] = "/bits/ 64 <",
[TYPE_STRING] = "",
};
static const char *delim_end[] = {
[TYPE_UINT8] = " ]",
[TYPE_UINT16] = " >",
[TYPE_UINT32] = " >",
[TYPE_UINT64] = " >",
[TYPE_STRING] = "",
};

static enum markertype guess_value_type(struct property *prop)
{ {
int len = prop->val.len; int len = prop->val.len;
const char *p = prop->val.val; const char *p = prop->val.val;
@ -201,11 +173,6 @@ static void write_propval(FILE *f, struct property *prop)
int nnotstringlbl = 0, nnotcelllbl = 0; int nnotstringlbl = 0, nnotcelllbl = 0;
int i; int i;


if (len == 0) {
fprintf(f, ";\n");
return;
}

for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (! isstring(p[i])) if (! isstring(p[i]))
nnotstring++; nnotstring++;
@ -220,17 +187,91 @@ static void write_propval(FILE *f, struct property *prop)
nnotcelllbl++; nnotcelllbl++;
} }


fprintf(f, " = ");
if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul < (len-nnul)) if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul < (len-nnul))
&& (nnotstringlbl == 0)) { && (nnotstringlbl == 0)) {
write_propval_string(f, prop->val); return TYPE_STRING;
} else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) { } else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) {
write_propval_cells(f, prop->val); return TYPE_UINT32;
} else {
write_propval_bytes(f, prop->val);
} }


fprintf(f, ";\n"); return TYPE_UINT8;
}

static void write_propval(FILE *f, struct property *prop)
{
size_t len = prop->val.len;
struct marker *m = prop->val.markers;
struct marker dummy_marker;
enum markertype emit_type = TYPE_NONE;

if (len == 0) {
fprintf(f, ";\n");
return;
}

fprintf(f, " = ");

if (!next_type_marker(m)) {
/* data type information missing, need to guess */
dummy_marker.type = guess_value_type(prop);
dummy_marker.next = prop->val.markers;
dummy_marker.offset = 0;
dummy_marker.ref = NULL;
m = &dummy_marker;
}

struct marker *m_label = prop->val.markers;
for_each_marker(m) {
size_t chunk_len;
const char *p = &prop->val.val[m->offset];

if (m->type < TYPE_UINT8)
continue;

chunk_len = type_marker_length(m);
if (!chunk_len)
chunk_len = len - m->offset;

if (emit_type != TYPE_NONE)
fprintf(f, "%s, ", delim_end[emit_type]);
emit_type = m->type;

for_each_marker_of_type(m_label, LABEL) {
if (m_label->offset > m->offset)
break;
fprintf(f, "%s: ", m_label->ref);
}

fprintf(f, "%s", delim_start[emit_type]);

if (chunk_len <= 0)
continue;

switch(emit_type) {
case TYPE_UINT16:
write_propval_int(f, p, chunk_len, 2);
break;
case TYPE_UINT32:
write_propval_int(f, p, chunk_len, 4);
break;
case TYPE_UINT64:
write_propval_int(f, p, chunk_len, 8);
break;
case TYPE_STRING:
write_propval_string(f, p, chunk_len);
break;
default:
write_propval_int(f, p, chunk_len, 1);
}
}

/* Wrap up any labels at the end of the value */
for_each_marker_of_type(m_label, LABEL) {
assert (m_label->offset == len);
fprintf(f, " %s:", m_label->ref);
}

fprintf(f, "%s;\n", delim_end[emit_type] ? : "");
} }


static void write_tree_source_node(FILE *f, struct node *tree, int level) static void write_tree_source_node(FILE *f, struct node *tree, int level)
@ -281,4 +322,3 @@ void dt_to_source(FILE *f, struct dt_info *dti)


write_tree_source_node(f, dti->dt, 0); write_tree_source_node(f, dti->dt, 0);
} }


Write Preview
Loading…
Cancel
Save