577 lines
11 KiB
Plaintext
577 lines
11 KiB
Plaintext
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.
|
|
*/
|
|
%locations
|
|
|
|
%{
|
|
#include <stdio.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "dtc.h"
|
|
#include "srcpos.h"
|
|
|
|
extern int yylex(void);
|
|
extern void yyerror(char const *s);
|
|
#define ERROR(loc, ...) \
|
|
do { \
|
|
srcpos_error((loc), "Error", __VA_ARGS__); \
|
|
treesource_error = true; \
|
|
} while (0)
|
|
|
|
#define YYERROR_CALL(msg) yyerror(msg)
|
|
|
|
extern struct dt_info *parser_output;
|
|
extern bool treesource_error;
|
|
%}
|
|
|
|
%union {
|
|
char *propnodename;
|
|
char *labelref;
|
|
uint8_t byte;
|
|
struct data data;
|
|
|
|
struct {
|
|
struct data data;
|
|
int bits;
|
|
} array;
|
|
|
|
struct property *prop;
|
|
struct property *proplist;
|
|
struct node *node;
|
|
struct node *nodelist;
|
|
struct reserve_info *re;
|
|
uint64_t integer;
|
|
unsigned int flags;
|
|
}
|
|
|
|
%token DT_V1
|
|
%token DT_PLUGIN
|
|
%token DT_MEMRESERVE
|
|
%token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
|
|
%token DT_BITS
|
|
%token DT_DEL_PROP
|
|
%token DT_DEL_NODE
|
|
%token DT_OMIT_NO_REF
|
|
%token <propnodename> DT_PROPNODENAME
|
|
%token <integer> DT_LITERAL
|
|
%token <integer> DT_CHAR_LITERAL
|
|
%token <byte> DT_BYTE
|
|
%token <data> DT_STRING
|
|
%token <labelref> DT_LABEL
|
|
%token <labelref> DT_LABEL_REF
|
|
%token <labelref> DT_PATH_REF
|
|
%token DT_INCBIN
|
|
|
|
%type <data> propdata
|
|
%type <data> propdataprefix
|
|
%type <flags> header
|
|
%type <flags> headers
|
|
%type <re> memreserve
|
|
%type <re> memreserves
|
|
%type <array> arrayprefix
|
|
%type <data> bytestring
|
|
%type <prop> propdef
|
|
%type <proplist> proplist
|
|
%type <labelref> dt_ref
|
|
|
|
%type <node> devicetree
|
|
%type <node> nodedef
|
|
%type <node> subnode
|
|
%type <nodelist> subnodes
|
|
|
|
%type <integer> integer_prim
|
|
%type <integer> integer_unary
|
|
%type <integer> integer_mul
|
|
%type <integer> integer_add
|
|
%type <integer> integer_shift
|
|
%type <integer> integer_rela
|
|
%type <integer> integer_eq
|
|
%type <integer> integer_bitand
|
|
%type <integer> integer_bitxor
|
|
%type <integer> integer_bitor
|
|
%type <integer> integer_and
|
|
%type <integer> integer_or
|
|
%type <integer> integer_trinary
|
|
%type <integer> integer_expr
|
|
|
|
%%
|
|
|
|
sourcefile:
|
|
headers memreserves devicetree
|
|
{
|
|
parser_output = build_dt_info($1, $2, $3,
|
|
guess_boot_cpuid($3));
|
|
}
|
|
;
|
|
|
|
header:
|
|
DT_V1 ';'
|
|
{
|
|
$$ = DTSF_V1;
|
|
}
|
|
| DT_V1 ';' DT_PLUGIN ';'
|
|
{
|
|
$$ = DTSF_V1 | DTSF_PLUGIN;
|
|
}
|
|
;
|
|
|
|
headers:
|
|
header
|
|
| header headers
|
|
{
|
|
if ($2 != $1)
|
|
ERROR(&@2, "Header flags don't match earlier ones");
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
memreserves:
|
|
/* empty */
|
|
{
|
|
$$ = NULL;
|
|
}
|
|
| memreserve memreserves
|
|
{
|
|
$$ = chain_reserve_entry($1, $2);
|
|
}
|
|
;
|
|
|
|
memreserve:
|
|
DT_MEMRESERVE integer_prim integer_prim ';'
|
|
{
|
|
$$ = build_reserve_entry($2, $3);
|
|
}
|
|
| DT_LABEL memreserve
|
|
{
|
|
add_label(&$2->labels, $1);
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
dt_ref: DT_LABEL_REF | DT_PATH_REF;
|
|
|
|
devicetree:
|
|
'/' nodedef
|
|
{
|
|
$$ = name_node($2, "");
|
|
}
|
|
| devicetree '/' nodedef
|
|
{
|
|
$$ = merge_nodes($1, $3);
|
|
}
|
|
| dt_ref nodedef
|
|
{
|
|
/*
|
|
* We rely on the rule being always:
|
|
* versioninfo plugindecl memreserves devicetree
|
|
* so $-1 is what we want (plugindecl)
|
|
*/
|
|
if (!($<flags>-1 & DTSF_PLUGIN))
|
|
ERROR(&@2, "Label or path %s not found", $1);
|
|
$$ = add_orphan_node(
|
|
name_node(build_node(NULL, NULL, NULL),
|
|
""),
|
|
$2, $1);
|
|
}
|
|
| devicetree DT_LABEL dt_ref nodedef
|
|
{
|
|
struct node *target = get_node_by_ref($1, $3);
|
|
|
|
if (target) {
|
|
add_label(&target->labels, $2);
|
|
merge_nodes(target, $4);
|
|
} else
|
|
ERROR(&@3, "Label or path %s not found", $3);
|
|
$$ = $1;
|
|
}
|
|
| devicetree DT_PATH_REF nodedef
|
|
{
|
|
/*
|
|
* We rely on the rule being always:
|
|
* versioninfo plugindecl memreserves devicetree
|
|
* so $-1 is what we want (plugindecl)
|
|
*/
|
|
if ($<flags>-1 & DTSF_PLUGIN) {
|
|
add_orphan_node($1, $3, $2);
|
|
} else {
|
|
struct node *target = get_node_by_ref($1, $2);
|
|
|
|
if (target)
|
|
merge_nodes(target, $3);
|
|
else
|
|
ERROR(&@2, "Label or path %s not found", $2);
|
|
}
|
|
$$ = $1;
|
|
}
|
|
| devicetree DT_LABEL_REF nodedef
|
|
{
|
|
struct node *target = get_node_by_ref($1, $2);
|
|
|
|
if (target) {
|
|
merge_nodes(target, $3);
|
|
} else {
|
|
/*
|
|
* We rely on the rule being always:
|
|
* versioninfo plugindecl memreserves devicetree
|
|
* so $-1 is what we want (plugindecl)
|
|
*/
|
|
if ($<flags>-1 & DTSF_PLUGIN)
|
|
add_orphan_node($1, $3, $2);
|
|
else
|
|
ERROR(&@2, "Label or path %s not found", $2);
|
|
}
|
|
$$ = $1;
|
|
}
|
|
| devicetree DT_DEL_NODE dt_ref ';'
|
|
{
|
|
struct node *target = get_node_by_ref($1, $3);
|
|
|
|
if (target)
|
|
delete_node(target);
|
|
else
|
|
ERROR(&@3, "Label or path %s not found", $3);
|
|
|
|
|
|
$$ = $1;
|
|
}
|
|
| devicetree DT_OMIT_NO_REF dt_ref ';'
|
|
{
|
|
struct node *target = get_node_by_ref($1, $3);
|
|
|
|
if (target)
|
|
omit_node_if_unused(target);
|
|
else
|
|
ERROR(&@3, "Label or path %s not found", $3);
|
|
|
|
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
nodedef:
|
|
'{' proplist subnodes '}' ';'
|
|
{
|
|
$$ = build_node($2, $3, &@$);
|
|
}
|
|
;
|
|
|
|
proplist:
|
|
/* empty */
|
|
{
|
|
$$ = NULL;
|
|
}
|
|
| proplist propdef
|
|
{
|
|
$$ = chain_property($2, $1);
|
|
}
|
|
;
|
|
|
|
propdef:
|
|
DT_PROPNODENAME '=' propdata ';'
|
|
{
|
|
$$ = build_property($1, $3, &@$);
|
|
}
|
|
| DT_PROPNODENAME ';'
|
|
{
|
|
$$ = build_property($1, empty_data, &@$);
|
|
}
|
|
| DT_DEL_PROP DT_PROPNODENAME ';'
|
|
{
|
|
$$ = build_property_delete($2);
|
|
}
|
|
| DT_LABEL propdef
|
|
{
|
|
add_label(&$2->labels, $1);
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
propdata:
|
|
propdataprefix DT_STRING
|
|
{
|
|
$$ = data_merge($1, $2);
|
|
}
|
|
| propdataprefix arrayprefix '>'
|
|
{
|
|
$$ = data_merge($1, $2.data);
|
|
}
|
|
| propdataprefix '[' bytestring ']'
|
|
{
|
|
$$ = data_merge($1, $3);
|
|
}
|
|
| propdataprefix dt_ref
|
|
{
|
|
$1 = data_add_marker($1, TYPE_STRING, $2);
|
|
$$ = data_add_marker($1, REF_PATH, $2);
|
|
}
|
|
| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
|
|
{
|
|
FILE *f = srcfile_relative_open($4.val, NULL);
|
|
struct data d;
|
|
|
|
if ($6 != 0)
|
|
if (fseek(f, $6, SEEK_SET) != 0)
|
|
die("Couldn't seek to offset %llu in \"%s\": %s",
|
|
(unsigned long long)$6, $4.val,
|
|
strerror(errno));
|
|
|
|
d = data_copy_file(f, $8);
|
|
|
|
$$ = data_merge($1, d);
|
|
fclose(f);
|
|
}
|
|
| propdataprefix DT_INCBIN '(' DT_STRING ')'
|
|
{
|
|
FILE *f = srcfile_relative_open($4.val, NULL);
|
|
struct data d = empty_data;
|
|
|
|
d = data_copy_file(f, -1);
|
|
|
|
$$ = data_merge($1, d);
|
|
fclose(f);
|
|
}
|
|
| propdata DT_LABEL
|
|
{
|
|
$$ = data_add_marker($1, LABEL, $2);
|
|
}
|
|
;
|
|
|
|
propdataprefix:
|
|
/* empty */
|
|
{
|
|
$$ = empty_data;
|
|
}
|
|
| propdata ','
|
|
{
|
|
$$ = $1;
|
|
}
|
|
| propdataprefix DT_LABEL
|
|
{
|
|
$$ = data_add_marker($1, LABEL, $2);
|
|
}
|
|
;
|
|
|
|
arrayprefix:
|
|
DT_BITS DT_LITERAL '<'
|
|
{
|
|
unsigned long long bits;
|
|
enum markertype type = TYPE_UINT32;
|
|
|
|
bits = $2;
|
|
|
|
switch (bits) {
|
|
case 8: type = TYPE_UINT8; break;
|
|
case 16: type = TYPE_UINT16; break;
|
|
case 32: type = TYPE_UINT32; break;
|
|
case 64: type = TYPE_UINT64; break;
|
|
default:
|
|
ERROR(&@2, "Array elements must be"
|
|
" 8, 16, 32 or 64-bits");
|
|
bits = 32;
|
|
}
|
|
|
|
$$.data = data_add_marker(empty_data, type, NULL);
|
|
$$.bits = bits;
|
|
}
|
|
| '<'
|
|
{
|
|
$$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
|
|
$$.bits = 32;
|
|
}
|
|
| arrayprefix integer_prim
|
|
{
|
|
if ($1.bits < 64) {
|
|
uint64_t mask = (1ULL << $1.bits) - 1;
|
|
/*
|
|
* Bits above mask must either be all zero
|
|
* (positive within range of mask) or all one
|
|
* (negative and sign-extended). The second
|
|
* condition is true if when we set all bits
|
|
* within the mask to one (i.e. | in the
|
|
* mask), all bits are one.
|
|
*/
|
|
if (($2 > mask) && (($2 | mask) != -1ULL))
|
|
ERROR(&@2, "Value out of range for"
|
|
" %d-bit array element", $1.bits);
|
|
}
|
|
|
|
$$.data = data_append_integer($1.data, $2, $1.bits);
|
|
}
|
|
| arrayprefix dt_ref
|
|
{
|
|
uint64_t val = ~0ULL >> (64 - $1.bits);
|
|
|
|
if ($1.bits == 32)
|
|
$1.data = data_add_marker($1.data,
|
|
REF_PHANDLE,
|
|
$2);
|
|
else
|
|
ERROR(&@2, "References are only allowed in "
|
|
"arrays with 32-bit elements.");
|
|
|
|
$$.data = data_append_integer($1.data, val, $1.bits);
|
|
}
|
|
| arrayprefix DT_LABEL
|
|
{
|
|
$$.data = data_add_marker($1.data, LABEL, $2);
|
|
}
|
|
;
|
|
|
|
integer_prim:
|
|
DT_LITERAL
|
|
| DT_CHAR_LITERAL
|
|
| '(' integer_expr ')'
|
|
{
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
integer_expr:
|
|
integer_trinary
|
|
;
|
|
|
|
integer_trinary:
|
|
integer_or
|
|
| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
|
|
;
|
|
|
|
integer_or:
|
|
integer_and
|
|
| integer_or DT_OR integer_and { $$ = $1 || $3; }
|
|
;
|
|
|
|
integer_and:
|
|
integer_bitor
|
|
| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
|
|
;
|
|
|
|
integer_bitor:
|
|
integer_bitxor
|
|
| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
|
|
;
|
|
|
|
integer_bitxor:
|
|
integer_bitand
|
|
| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
|
|
;
|
|
|
|
integer_bitand:
|
|
integer_eq
|
|
| integer_bitand '&' integer_eq { $$ = $1 & $3; }
|
|
;
|
|
|
|
integer_eq:
|
|
integer_rela
|
|
| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
|
|
| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
|
|
;
|
|
|
|
integer_rela:
|
|
integer_shift
|
|
| integer_rela '<' integer_shift { $$ = $1 < $3; }
|
|
| integer_rela '>' integer_shift { $$ = $1 > $3; }
|
|
| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
|
|
| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
|
|
;
|
|
|
|
integer_shift:
|
|
integer_shift DT_LSHIFT integer_add { $$ = ($3 < 64) ? ($1 << $3) : 0; }
|
|
| integer_shift DT_RSHIFT integer_add { $$ = ($3 < 64) ? ($1 >> $3) : 0; }
|
|
| integer_add
|
|
;
|
|
|
|
integer_add:
|
|
integer_add '+' integer_mul { $$ = $1 + $3; }
|
|
| integer_add '-' integer_mul { $$ = $1 - $3; }
|
|
| integer_mul
|
|
;
|
|
|
|
integer_mul:
|
|
integer_mul '*' integer_unary { $$ = $1 * $3; }
|
|
| integer_mul '/' integer_unary
|
|
{
|
|
if ($3 != 0) {
|
|
$$ = $1 / $3;
|
|
} else {
|
|
ERROR(&@$, "Division by zero");
|
|
$$ = 0;
|
|
}
|
|
}
|
|
| integer_mul '%' integer_unary
|
|
{
|
|
if ($3 != 0) {
|
|
$$ = $1 % $3;
|
|
} else {
|
|
ERROR(&@$, "Division by zero");
|
|
$$ = 0;
|
|
}
|
|
}
|
|
| integer_unary
|
|
;
|
|
|
|
integer_unary:
|
|
integer_prim
|
|
| '-' integer_unary { $$ = -$2; }
|
|
| '~' integer_unary { $$ = ~$2; }
|
|
| '!' integer_unary { $$ = !$2; }
|
|
;
|
|
|
|
bytestring:
|
|
/* empty */
|
|
{
|
|
$$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
|
|
}
|
|
| bytestring DT_BYTE
|
|
{
|
|
$$ = data_append_byte($1, $2);
|
|
}
|
|
| bytestring DT_LABEL
|
|
{
|
|
$$ = data_add_marker($1, LABEL, $2);
|
|
}
|
|
;
|
|
|
|
subnodes:
|
|
/* empty */
|
|
{
|
|
$$ = NULL;
|
|
}
|
|
| subnode subnodes
|
|
{
|
|
$$ = chain_node($1, $2);
|
|
}
|
|
| subnode propdef
|
|
{
|
|
ERROR(&@2, "Properties must precede subnodes");
|
|
YYERROR;
|
|
}
|
|
;
|
|
|
|
subnode:
|
|
DT_PROPNODENAME nodedef
|
|
{
|
|
$$ = name_node($2, $1);
|
|
}
|
|
| DT_DEL_NODE DT_PROPNODENAME ';'
|
|
{
|
|
$$ = name_node(build_node_delete(&@$), $2);
|
|
}
|
|
| DT_OMIT_NO_REF subnode
|
|
{
|
|
$$ = omit_node_if_unused($2);
|
|
}
|
|
| DT_LABEL subnode
|
|
{
|
|
add_label(&$2->labels, $1);
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
%%
|
|
|
|
void yyerror(char const *s)
|
|
{
|
|
ERROR(&yylloc, "%s", s);
|
|
}
|