xref: /openbmc/u-boot/scripts/dtc/dtc-parser.y (revision 0931ed3c) 
1 /*
2  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
3  *
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation; either version 2 of the
8  * License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18  *                                                                   USA
19  */
20 %{
21 #include <stdio.h>
22 #include <inttypes.h>
23 
24 #include "dtc.h"
25 #include "srcpos.h"
26 
27 extern int yylex(void);
28 extern void yyerror(char const *s);
29 #define ERROR(loc, ...) \
30 	do { \
31 		srcpos_error((loc), "Error", __VA_ARGS__); \
32 		treesource_error = true; \
33 	} while (0)
34 
35 extern struct dt_info *parser_output;
36 extern bool treesource_error;
37 %}
38 
39 %union {
40 	char *propnodename;
41 	char *labelref;
42 	uint8_t byte;
43 	struct data data;
44 
45 	struct {
46 		struct data	data;
47 		int		bits;
48 	} array;
49 
50 	struct property *prop;
51 	struct property *proplist;
52 	struct node *node;
53 	struct node *nodelist;
54 	struct reserve_info *re;
55 	uint64_t integer;
56 	unsigned int flags;
57 }
58 
59 %token DT_V1
60 %token DT_PLUGIN
61 %token DT_MEMRESERVE
62 %token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
63 %token DT_BITS
64 %token DT_DEL_PROP
65 %token DT_DEL_NODE
66 %token <propnodename> DT_PROPNODENAME
67 %token <integer> DT_LITERAL
68 %token <integer> DT_CHAR_LITERAL
69 %token <byte> DT_BYTE
70 %token <data> DT_STRING
71 %token <labelref> DT_LABEL
72 %token <labelref> DT_REF
73 %token DT_INCBIN
74 
75 %type <data> propdata
76 %type <data> propdataprefix
77 %type <flags> header
78 %type <flags> headers
79 %type <re> memreserve
80 %type <re> memreserves
81 %type <array> arrayprefix
82 %type <data> bytestring
83 %type <prop> propdef
84 %type <proplist> proplist
85 
86 %type <node> devicetree
87 %type <node> nodedef
88 %type <node> subnode
89 %type <nodelist> subnodes
90 
91 %type <integer> integer_prim
92 %type <integer> integer_unary
93 %type <integer> integer_mul
94 %type <integer> integer_add
95 %type <integer> integer_shift
96 %type <integer> integer_rela
97 %type <integer> integer_eq
98 %type <integer> integer_bitand
99 %type <integer> integer_bitxor
100 %type <integer> integer_bitor
101 %type <integer> integer_and
102 %type <integer> integer_or
103 %type <integer> integer_trinary
104 %type <integer> integer_expr
105 
106 %%
107 
108 sourcefile:
109 	  headers memreserves devicetree
110 		{
111 			parser_output = build_dt_info($1, $2, $3,
112 			                              guess_boot_cpuid($3));
113 		}
114 	;
115 
116 header:
117 	  DT_V1 ';'
118 		{
119 			$$ = DTSF_V1;
120 		}
121 	| DT_V1 ';' DT_PLUGIN ';'
122 		{
123 			$$ = DTSF_V1 | DTSF_PLUGIN;
124 		}
125 	;
126 
127 headers:
128 	  header
129 	| header headers
130 		{
131 			if ($2 != $1)
132 				ERROR(&@2, "Header flags don't match earlier ones");
133 			$$ = $1;
134 		}
135 	;
136 
137 memreserves:
138 	  /* empty */
139 		{
140 			$$ = NULL;
141 		}
142 	| memreserve memreserves
143 		{
144 			$$ = chain_reserve_entry($1, $2);
145 		}
146 	;
147 
148 memreserve:
149 	  DT_MEMRESERVE integer_prim integer_prim ';'
150 		{
151 			$$ = build_reserve_entry($2, $3);
152 		}
153 	| DT_LABEL memreserve
154 		{
155 			add_label(&$2->labels, $1);
156 			$$ = $2;
157 		}
158 	;
159 
160 devicetree:
161 	  '/' nodedef
162 		{
163 			$$ = name_node($2, "");
164 		}
165 	| devicetree '/' nodedef
166 		{
167 			$$ = merge_nodes($1, $3);
168 		}
169 
170 	| devicetree DT_LABEL DT_REF nodedef
171 		{
172 			struct node *target = get_node_by_ref($1, $3);
173 
174 			if (target) {
175 				add_label(&target->labels, $2);
176 				merge_nodes(target, $4);
177 			} else
178 				ERROR(&@3, "Label or path %s not found", $3);
179 			$$ = $1;
180 		}
181 	| devicetree DT_REF nodedef
182 		{
183 			struct node *target = get_node_by_ref($1, $2);
184 
185 			if (target) {
186 				merge_nodes(target, $3);
187 			} else {
188 				/*
189 				 * We rely on the rule being always:
190 				 *   versioninfo plugindecl memreserves devicetree
191 				 * so $-1 is what we want (plugindecl)
192 				 */
193 				if ($<flags>-1 & DTSF_PLUGIN)
194 					add_orphan_node($1, $3, $2);
195 				else
196 					ERROR(&@2, "Label or path %s not found", $2);
197 			}
198 			$$ = $1;
199 		}
200 	| devicetree DT_DEL_NODE DT_REF ';'
201 		{
202 			struct node *target = get_node_by_ref($1, $3);
203 
204 			if (target)
205 				delete_node(target);
206 			else
207 				ERROR(&@3, "Label or path %s not found", $3);
208 
209 
210 			$$ = $1;
211 		}
212 	| /* empty */
213 		{
214 			/* build empty node */
215 			$$ = name_node(build_node(NULL, NULL), "");
216 		}
217 	;
218 
219 nodedef:
220 	  '{' proplist subnodes '}' ';'
221 		{
222 			$$ = build_node($2, $3);
223 		}
224 	;
225 
226 proplist:
227 	  /* empty */
228 		{
229 			$$ = NULL;
230 		}
231 	| proplist propdef
232 		{
233 			$$ = chain_property($2, $1);
234 		}
235 	;
236 
237 propdef:
238 	  DT_PROPNODENAME '=' propdata ';'
239 		{
240 			$$ = build_property($1, $3);
241 		}
242 	| DT_PROPNODENAME ';'
243 		{
244 			$$ = build_property($1, empty_data);
245 		}
246 	| DT_DEL_PROP DT_PROPNODENAME ';'
247 		{
248 			$$ = build_property_delete($2);
249 		}
250 	| DT_LABEL propdef
251 		{
252 			add_label(&$2->labels, $1);
253 			$$ = $2;
254 		}
255 	;
256 
257 propdata:
258 	  propdataprefix DT_STRING
259 		{
260 			$$ = data_merge($1, $2);
261 		}
262 	| propdataprefix arrayprefix '>'
263 		{
264 			$$ = data_merge($1, $2.data);
265 		}
266 	| propdataprefix '[' bytestring ']'
267 		{
268 			$$ = data_merge($1, $3);
269 		}
270 	| propdataprefix DT_REF
271 		{
272 			$$ = data_add_marker($1, REF_PATH, $2);
273 		}
274 	| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
275 		{
276 			FILE *f = srcfile_relative_open($4.val, NULL);
277 			struct data d;
278 
279 			if ($6 != 0)
280 				if (fseek(f, $6, SEEK_SET) != 0)
281 					die("Couldn't seek to offset %llu in \"%s\": %s",
282 					    (unsigned long long)$6, $4.val,
283 					    strerror(errno));
284 
285 			d = data_copy_file(f, $8);
286 
287 			$$ = data_merge($1, d);
288 			fclose(f);
289 		}
290 	| propdataprefix DT_INCBIN '(' DT_STRING ')'
291 		{
292 			FILE *f = srcfile_relative_open($4.val, NULL);
293 			struct data d = empty_data;
294 
295 			d = data_copy_file(f, -1);
296 
297 			$$ = data_merge($1, d);
298 			fclose(f);
299 		}
300 	| propdata DT_LABEL
301 		{
302 			$$ = data_add_marker($1, LABEL, $2);
303 		}
304 	;
305 
306 propdataprefix:
307 	  /* empty */
308 		{
309 			$$ = empty_data;
310 		}
311 	| propdata ','
312 		{
313 			$$ = $1;
314 		}
315 	| propdataprefix DT_LABEL
316 		{
317 			$$ = data_add_marker($1, LABEL, $2);
318 		}
319 	;
320 
321 arrayprefix:
322 	DT_BITS DT_LITERAL '<'
323 		{
324 			unsigned long long bits;
325 
326 			bits = $2;
327 
328 			if ((bits !=  8) && (bits != 16) &&
329 			    (bits != 32) && (bits != 64)) {
330 				ERROR(&@2, "Array elements must be"
331 				      " 8, 16, 32 or 64-bits");
332 				bits = 32;
333 			}
334 
335 			$$.data = empty_data;
336 			$$.bits = bits;
337 		}
338 	| '<'
339 		{
340 			$$.data = empty_data;
341 			$$.bits = 32;
342 		}
343 	| arrayprefix integer_prim
344 		{
345 			if ($1.bits < 64) {
346 				uint64_t mask = (1ULL << $1.bits) - 1;
347 				/*
348 				 * Bits above mask must either be all zero
349 				 * (positive within range of mask) or all one
350 				 * (negative and sign-extended). The second
351 				 * condition is true if when we set all bits
352 				 * within the mask to one (i.e. | in the
353 				 * mask), all bits are one.
354 				 */
355 				if (($2 > mask) && (($2 | mask) != -1ULL))
356 					ERROR(&@2, "Value out of range for"
357 					      " %d-bit array element", $1.bits);
358 			}
359 
360 			$$.data = data_append_integer($1.data, $2, $1.bits);
361 		}
362 	| arrayprefix DT_REF
363 		{
364 			uint64_t val = ~0ULL >> (64 - $1.bits);
365 
366 			if ($1.bits == 32)
367 				$1.data = data_add_marker($1.data,
368 							  REF_PHANDLE,
369 							  $2);
370 			else
371 				ERROR(&@2, "References are only allowed in "
372 					    "arrays with 32-bit elements.");
373 
374 			$$.data = data_append_integer($1.data, val, $1.bits);
375 		}
376 	| arrayprefix DT_LABEL
377 		{
378 			$$.data = data_add_marker($1.data, LABEL, $2);
379 		}
380 	;
381 
382 integer_prim:
383 	  DT_LITERAL
384 	| DT_CHAR_LITERAL
385 	| '(' integer_expr ')'
386 		{
387 			$$ = $2;
388 		}
389 	;
390 
391 integer_expr:
392 	integer_trinary
393 	;
394 
395 integer_trinary:
396 	  integer_or
397 	| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
398 	;
399 
400 integer_or:
401 	  integer_and
402 	| integer_or DT_OR integer_and { $$ = $1 || $3; }
403 	;
404 
405 integer_and:
406 	  integer_bitor
407 	| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
408 	;
409 
410 integer_bitor:
411 	  integer_bitxor
412 	| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
413 	;
414 
415 integer_bitxor:
416 	  integer_bitand
417 	| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
418 	;
419 
420 integer_bitand:
421 	  integer_eq
422 	| integer_bitand '&' integer_eq { $$ = $1 & $3; }
423 	;
424 
425 integer_eq:
426 	  integer_rela
427 	| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
428 	| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
429 	;
430 
431 integer_rela:
432 	  integer_shift
433 	| integer_rela '<' integer_shift { $$ = $1 < $3; }
434 	| integer_rela '>' integer_shift { $$ = $1 > $3; }
435 	| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
436 	| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
437 	;
438 
439 integer_shift:
440 	  integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
441 	| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
442 	| integer_add
443 	;
444 
445 integer_add:
446 	  integer_add '+' integer_mul { $$ = $1 + $3; }
447 	| integer_add '-' integer_mul { $$ = $1 - $3; }
448 	| integer_mul
449 	;
450 
451 integer_mul:
452 	  integer_mul '*' integer_unary { $$ = $1 * $3; }
453 	| integer_mul '/' integer_unary
454 		{
455 			if ($3 != 0) {
456 				$$ = $1 / $3;
457 			} else {
458 				ERROR(&@$, "Division by zero");
459 				$$ = 0;
460 			}
461 		}
462 	| integer_mul '%' integer_unary
463 		{
464 			if ($3 != 0) {
465 				$$ = $1 % $3;
466 			} else {
467 				ERROR(&@$, "Division by zero");
468 				$$ = 0;
469 			}
470 		}
471 	| integer_unary
472 	;
473 
474 integer_unary:
475 	  integer_prim
476 	| '-' integer_unary { $$ = -$2; }
477 	| '~' integer_unary { $$ = ~$2; }
478 	| '!' integer_unary { $$ = !$2; }
479 	;
480 
481 bytestring:
482 	  /* empty */
483 		{
484 			$$ = empty_data;
485 		}
486 	| bytestring DT_BYTE
487 		{
488 			$$ = data_append_byte($1, $2);
489 		}
490 	| bytestring DT_LABEL
491 		{
492 			$$ = data_add_marker($1, LABEL, $2);
493 		}
494 	;
495 
496 subnodes:
497 	  /* empty */
498 		{
499 			$$ = NULL;
500 		}
501 	| subnode subnodes
502 		{
503 			$$ = chain_node($1, $2);
504 		}
505 	| subnode propdef
506 		{
507 			ERROR(&@2, "Properties must precede subnodes");
508 			YYERROR;
509 		}
510 	;
511 
512 subnode:
513 	  DT_PROPNODENAME nodedef
514 		{
515 			$$ = name_node($2, $1);
516 		}
517 	| DT_DEL_NODE DT_PROPNODENAME ';'
518 		{
519 			$$ = name_node(build_node_delete(), $2);
520 		}
521 	| DT_LABEL subnode
522 		{
523 			add_label(&$2->labels, $1);
524 			$$ = $2;
525 		}
526 	;
527 
528 %%
529 
530 void yyerror(char const *s)
531 {
532 	ERROR(&yylloc, "%s", s);
533 }
534