xref: /openbmc/linux/scripts/dtc/dtc-parser.y (revision 9a29ad52) 
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 DT_OMIT_NO_REF
67 %token <propnodename> DT_PROPNODENAME
68 %token <integer> DT_LITERAL
69 %token <integer> DT_CHAR_LITERAL
70 %token <byte> DT_BYTE
71 %token <data> DT_STRING
72 %token <labelref> DT_LABEL
73 %token <labelref> DT_REF
74 %token DT_INCBIN
75 
76 %type <data> propdata
77 %type <data> propdataprefix
78 %type <flags> header
79 %type <flags> headers
80 %type <re> memreserve
81 %type <re> memreserves
82 %type <array> arrayprefix
83 %type <data> bytestring
84 %type <prop> propdef
85 %type <proplist> proplist
86 
87 %type <node> devicetree
88 %type <node> nodedef
89 %type <node> subnode
90 %type <nodelist> subnodes
91 
92 %type <integer> integer_prim
93 %type <integer> integer_unary
94 %type <integer> integer_mul
95 %type <integer> integer_add
96 %type <integer> integer_shift
97 %type <integer> integer_rela
98 %type <integer> integer_eq
99 %type <integer> integer_bitand
100 %type <integer> integer_bitxor
101 %type <integer> integer_bitor
102 %type <integer> integer_and
103 %type <integer> integer_or
104 %type <integer> integer_trinary
105 %type <integer> integer_expr
106 
107 %%
108 
109 sourcefile:
110 	  headers memreserves devicetree
111 		{
112 			parser_output = build_dt_info($1, $2, $3,
113 			                              guess_boot_cpuid($3));
114 		}
115 	;
116 
117 header:
118 	  DT_V1 ';'
119 		{
120 			$$ = DTSF_V1;
121 		}
122 	| DT_V1 ';' DT_PLUGIN ';'
123 		{
124 			$$ = DTSF_V1 | DTSF_PLUGIN;
125 		}
126 	;
127 
128 headers:
129 	  header
130 	| header headers
131 		{
132 			if ($2 != $1)
133 				ERROR(&@2, "Header flags don't match earlier ones");
134 			$$ = $1;
135 		}
136 	;
137 
138 memreserves:
139 	  /* empty */
140 		{
141 			$$ = NULL;
142 		}
143 	| memreserve memreserves
144 		{
145 			$$ = chain_reserve_entry($1, $2);
146 		}
147 	;
148 
149 memreserve:
150 	  DT_MEMRESERVE integer_prim integer_prim ';'
151 		{
152 			$$ = build_reserve_entry($2, $3);
153 		}
154 	| DT_LABEL memreserve
155 		{
156 			add_label(&$2->labels, $1);
157 			$$ = $2;
158 		}
159 	;
160 
161 devicetree:
162 	  '/' nodedef
163 		{
164 			$$ = name_node($2, "");
165 		}
166 	| devicetree '/' nodedef
167 		{
168 			$$ = merge_nodes($1, $3);
169 		}
170 	| DT_REF nodedef
171 		{
172 			/*
173 			 * We rely on the rule being always:
174 			 *   versioninfo plugindecl memreserves devicetree
175 			 * so $-1 is what we want (plugindecl)
176 			 */
177 			if (!($<flags>-1 & DTSF_PLUGIN))
178 				ERROR(&@2, "Label or path %s not found", $1);
179 			$$ = add_orphan_node(name_node(build_node(NULL, NULL), ""), $2, $1);
180 		}
181 	| devicetree DT_LABEL DT_REF nodedef
182 		{
183 			struct node *target = get_node_by_ref($1, $3);
184 
185 			if (target) {
186 				add_label(&target->labels, $2);
187 				merge_nodes(target, $4);
188 			} else
189 				ERROR(&@3, "Label or path %s not found", $3);
190 			$$ = $1;
191 		}
192 	| devicetree DT_REF nodedef
193 		{
194 			/*
195 			 * We rely on the rule being always:
196 			 *   versioninfo plugindecl memreserves devicetree
197 			 * so $-1 is what we want (plugindecl)
198 			 */
199 			if ($<flags>-1 & DTSF_PLUGIN) {
200 				add_orphan_node($1, $3, $2);
201 			} else {
202 				struct node *target = get_node_by_ref($1, $2);
203 
204 				if (target)
205 					merge_nodes(target, $3);
206 				else
207 					ERROR(&@2, "Label or path %s not found", $2);
208 			}
209 			$$ = $1;
210 		}
211 	| devicetree DT_DEL_NODE DT_REF ';'
212 		{
213 			struct node *target = get_node_by_ref($1, $3);
214 
215 			if (target)
216 				delete_node(target);
217 			else
218 				ERROR(&@3, "Label or path %s not found", $3);
219 
220 
221 			$$ = $1;
222 		}
223 	| devicetree DT_OMIT_NO_REF DT_REF ';'
224 		{
225 			struct node *target = get_node_by_ref($1, $3);
226 
227 			if (target)
228 				omit_node_if_unused(target);
229 			else
230 				ERROR(&@3, "Label or path %s not found", $3);
231 
232 
233 			$$ = $1;
234 		}
235 	;
236 
237 nodedef:
238 	  '{' proplist subnodes '}' ';'
239 		{
240 			$$ = build_node($2, $3);
241 		}
242 	;
243 
244 proplist:
245 	  /* empty */
246 		{
247 			$$ = NULL;
248 		}
249 	| proplist propdef
250 		{
251 			$$ = chain_property($2, $1);
252 		}
253 	;
254 
255 propdef:
256 	  DT_PROPNODENAME '=' propdata ';'
257 		{
258 			$$ = build_property($1, $3);
259 		}
260 	| DT_PROPNODENAME ';'
261 		{
262 			$$ = build_property($1, empty_data);
263 		}
264 	| DT_DEL_PROP DT_PROPNODENAME ';'
265 		{
266 			$$ = build_property_delete($2);
267 		}
268 	| DT_LABEL propdef
269 		{
270 			add_label(&$2->labels, $1);
271 			$$ = $2;
272 		}
273 	;
274 
275 propdata:
276 	  propdataprefix DT_STRING
277 		{
278 			$$ = data_merge($1, $2);
279 		}
280 	| propdataprefix arrayprefix '>'
281 		{
282 			$$ = data_merge($1, $2.data);
283 		}
284 	| propdataprefix '[' bytestring ']'
285 		{
286 			$$ = data_merge($1, $3);
287 		}
288 	| propdataprefix DT_REF
289 		{
290 			$$ = data_add_marker($1, REF_PATH, $2);
291 		}
292 	| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
293 		{
294 			FILE *f = srcfile_relative_open($4.val, NULL);
295 			struct data d;
296 
297 			if ($6 != 0)
298 				if (fseek(f, $6, SEEK_SET) != 0)
299 					die("Couldn't seek to offset %llu in \"%s\": %s",
300 					    (unsigned long long)$6, $4.val,
301 					    strerror(errno));
302 
303 			d = data_copy_file(f, $8);
304 
305 			$$ = data_merge($1, d);
306 			fclose(f);
307 		}
308 	| propdataprefix DT_INCBIN '(' DT_STRING ')'
309 		{
310 			FILE *f = srcfile_relative_open($4.val, NULL);
311 			struct data d = empty_data;
312 
313 			d = data_copy_file(f, -1);
314 
315 			$$ = data_merge($1, d);
316 			fclose(f);
317 		}
318 	| propdata DT_LABEL
319 		{
320 			$$ = data_add_marker($1, LABEL, $2);
321 		}
322 	;
323 
324 propdataprefix:
325 	  /* empty */
326 		{
327 			$$ = empty_data;
328 		}
329 	| propdata ','
330 		{
331 			$$ = $1;
332 		}
333 	| propdataprefix DT_LABEL
334 		{
335 			$$ = data_add_marker($1, LABEL, $2);
336 		}
337 	;
338 
339 arrayprefix:
340 	DT_BITS DT_LITERAL '<'
341 		{
342 			unsigned long long bits;
343 
344 			bits = $2;
345 
346 			if ((bits !=  8) && (bits != 16) &&
347 			    (bits != 32) && (bits != 64)) {
348 				ERROR(&@2, "Array elements must be"
349 				      " 8, 16, 32 or 64-bits");
350 				bits = 32;
351 			}
352 
353 			$$.data = empty_data;
354 			$$.bits = bits;
355 		}
356 	| '<'
357 		{
358 			$$.data = empty_data;
359 			$$.bits = 32;
360 		}
361 	| arrayprefix integer_prim
362 		{
363 			if ($1.bits < 64) {
364 				uint64_t mask = (1ULL << $1.bits) - 1;
365 				/*
366 				 * Bits above mask must either be all zero
367 				 * (positive within range of mask) or all one
368 				 * (negative and sign-extended). The second
369 				 * condition is true if when we set all bits
370 				 * within the mask to one (i.e. | in the
371 				 * mask), all bits are one.
372 				 */
373 				if (($2 > mask) && (($2 | mask) != -1ULL))
374 					ERROR(&@2, "Value out of range for"
375 					      " %d-bit array element", $1.bits);
376 			}
377 
378 			$$.data = data_append_integer($1.data, $2, $1.bits);
379 		}
380 	| arrayprefix DT_REF
381 		{
382 			uint64_t val = ~0ULL >> (64 - $1.bits);
383 
384 			if ($1.bits == 32)
385 				$1.data = data_add_marker($1.data,
386 							  REF_PHANDLE,
387 							  $2);
388 			else
389 				ERROR(&@2, "References are only allowed in "
390 					    "arrays with 32-bit elements.");
391 
392 			$$.data = data_append_integer($1.data, val, $1.bits);
393 		}
394 	| arrayprefix DT_LABEL
395 		{
396 			$$.data = data_add_marker($1.data, LABEL, $2);
397 		}
398 	;
399 
400 integer_prim:
401 	  DT_LITERAL
402 	| DT_CHAR_LITERAL
403 	| '(' integer_expr ')'
404 		{
405 			$$ = $2;
406 		}
407 	;
408 
409 integer_expr:
410 	integer_trinary
411 	;
412 
413 integer_trinary:
414 	  integer_or
415 	| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
416 	;
417 
418 integer_or:
419 	  integer_and
420 	| integer_or DT_OR integer_and { $$ = $1 || $3; }
421 	;
422 
423 integer_and:
424 	  integer_bitor
425 	| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
426 	;
427 
428 integer_bitor:
429 	  integer_bitxor
430 	| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
431 	;
432 
433 integer_bitxor:
434 	  integer_bitand
435 	| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
436 	;
437 
438 integer_bitand:
439 	  integer_eq
440 	| integer_bitand '&' integer_eq { $$ = $1 & $3; }
441 	;
442 
443 integer_eq:
444 	  integer_rela
445 	| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
446 	| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
447 	;
448 
449 integer_rela:
450 	  integer_shift
451 	| integer_rela '<' integer_shift { $$ = $1 < $3; }
452 	| integer_rela '>' integer_shift { $$ = $1 > $3; }
453 	| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
454 	| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
455 	;
456 
457 integer_shift:
458 	  integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
459 	| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
460 	| integer_add
461 	;
462 
463 integer_add:
464 	  integer_add '+' integer_mul { $$ = $1 + $3; }
465 	| integer_add '-' integer_mul { $$ = $1 - $3; }
466 	| integer_mul
467 	;
468 
469 integer_mul:
470 	  integer_mul '*' integer_unary { $$ = $1 * $3; }
471 	| integer_mul '/' integer_unary
472 		{
473 			if ($3 != 0) {
474 				$$ = $1 / $3;
475 			} else {
476 				ERROR(&@$, "Division by zero");
477 				$$ = 0;
478 			}
479 		}
480 	| integer_mul '%' integer_unary
481 		{
482 			if ($3 != 0) {
483 				$$ = $1 % $3;
484 			} else {
485 				ERROR(&@$, "Division by zero");
486 				$$ = 0;
487 			}
488 		}
489 	| integer_unary
490 	;
491 
492 integer_unary:
493 	  integer_prim
494 	| '-' integer_unary { $$ = -$2; }
495 	| '~' integer_unary { $$ = ~$2; }
496 	| '!' integer_unary { $$ = !$2; }
497 	;
498 
499 bytestring:
500 	  /* empty */
501 		{
502 			$$ = empty_data;
503 		}
504 	| bytestring DT_BYTE
505 		{
506 			$$ = data_append_byte($1, $2);
507 		}
508 	| bytestring DT_LABEL
509 		{
510 			$$ = data_add_marker($1, LABEL, $2);
511 		}
512 	;
513 
514 subnodes:
515 	  /* empty */
516 		{
517 			$$ = NULL;
518 		}
519 	| subnode subnodes
520 		{
521 			$$ = chain_node($1, $2);
522 		}
523 	| subnode propdef
524 		{
525 			ERROR(&@2, "Properties must precede subnodes");
526 			YYERROR;
527 		}
528 	;
529 
530 subnode:
531 	  DT_PROPNODENAME nodedef
532 		{
533 			$$ = name_node($2, $1);
534 		}
535 	| DT_DEL_NODE DT_PROPNODENAME ';'
536 		{
537 			$$ = name_node(build_node_delete(), $2);
538 		}
539 	| DT_OMIT_NO_REF subnode
540 		{
541 			$$ = omit_node_if_unused($2);
542 		}
543 	| DT_LABEL subnode
544 		{
545 			add_label(&$2->labels, $1);
546 			$$ = $2;
547 		}
548 	;
549 
550 %%
551 
552 void yyerror(char const *s)
553 {
554 	ERROR(&yylloc, "%s", s);
555 }
556