xref: /openbmc/linux/scripts/dtc/dtc-parser.y (revision 4bf3bd0f) 
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 			$1 = data_add_marker($1, TYPE_STRING, $2);
291 			$$ = data_add_marker($1, REF_PATH, $2);
292 		}
293 	| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
294 		{
295 			FILE *f = srcfile_relative_open($4.val, NULL);
296 			struct data d;
297 
298 			if ($6 != 0)
299 				if (fseek(f, $6, SEEK_SET) != 0)
300 					die("Couldn't seek to offset %llu in \"%s\": %s",
301 					    (unsigned long long)$6, $4.val,
302 					    strerror(errno));
303 
304 			d = data_copy_file(f, $8);
305 
306 			$$ = data_merge($1, d);
307 			fclose(f);
308 		}
309 	| propdataprefix DT_INCBIN '(' DT_STRING ')'
310 		{
311 			FILE *f = srcfile_relative_open($4.val, NULL);
312 			struct data d = empty_data;
313 
314 			d = data_copy_file(f, -1);
315 
316 			$$ = data_merge($1, d);
317 			fclose(f);
318 		}
319 	| propdata DT_LABEL
320 		{
321 			$$ = data_add_marker($1, LABEL, $2);
322 		}
323 	;
324 
325 propdataprefix:
326 	  /* empty */
327 		{
328 			$$ = empty_data;
329 		}
330 	| propdata ','
331 		{
332 			$$ = $1;
333 		}
334 	| propdataprefix DT_LABEL
335 		{
336 			$$ = data_add_marker($1, LABEL, $2);
337 		}
338 	;
339 
340 arrayprefix:
341 	DT_BITS DT_LITERAL '<'
342 		{
343 			unsigned long long bits;
344 			enum markertype type = TYPE_UINT32;
345 
346 			bits = $2;
347 
348 			switch (bits) {
349 			case 8: type = TYPE_UINT8; break;
350 			case 16: type = TYPE_UINT16; break;
351 			case 32: type = TYPE_UINT32; break;
352 			case 64: type = TYPE_UINT64; break;
353 			default:
354 				ERROR(&@2, "Array elements must be"
355 				      " 8, 16, 32 or 64-bits");
356 				bits = 32;
357 			}
358 
359 			$$.data = data_add_marker(empty_data, type, NULL);
360 			$$.bits = bits;
361 		}
362 	| '<'
363 		{
364 			$$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
365 			$$.bits = 32;
366 		}
367 	| arrayprefix integer_prim
368 		{
369 			if ($1.bits < 64) {
370 				uint64_t mask = (1ULL << $1.bits) - 1;
371 				/*
372 				 * Bits above mask must either be all zero
373 				 * (positive within range of mask) or all one
374 				 * (negative and sign-extended). The second
375 				 * condition is true if when we set all bits
376 				 * within the mask to one (i.e. | in the
377 				 * mask), all bits are one.
378 				 */
379 				if (($2 > mask) && (($2 | mask) != -1ULL))
380 					ERROR(&@2, "Value out of range for"
381 					      " %d-bit array element", $1.bits);
382 			}
383 
384 			$$.data = data_append_integer($1.data, $2, $1.bits);
385 		}
386 	| arrayprefix DT_REF
387 		{
388 			uint64_t val = ~0ULL >> (64 - $1.bits);
389 
390 			if ($1.bits == 32)
391 				$1.data = data_add_marker($1.data,
392 							  REF_PHANDLE,
393 							  $2);
394 			else
395 				ERROR(&@2, "References are only allowed in "
396 					    "arrays with 32-bit elements.");
397 
398 			$$.data = data_append_integer($1.data, val, $1.bits);
399 		}
400 	| arrayprefix DT_LABEL
401 		{
402 			$$.data = data_add_marker($1.data, LABEL, $2);
403 		}
404 	;
405 
406 integer_prim:
407 	  DT_LITERAL
408 	| DT_CHAR_LITERAL
409 	| '(' integer_expr ')'
410 		{
411 			$$ = $2;
412 		}
413 	;
414 
415 integer_expr:
416 	integer_trinary
417 	;
418 
419 integer_trinary:
420 	  integer_or
421 	| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
422 	;
423 
424 integer_or:
425 	  integer_and
426 	| integer_or DT_OR integer_and { $$ = $1 || $3; }
427 	;
428 
429 integer_and:
430 	  integer_bitor
431 	| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
432 	;
433 
434 integer_bitor:
435 	  integer_bitxor
436 	| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
437 	;
438 
439 integer_bitxor:
440 	  integer_bitand
441 	| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
442 	;
443 
444 integer_bitand:
445 	  integer_eq
446 	| integer_bitand '&' integer_eq { $$ = $1 & $3; }
447 	;
448 
449 integer_eq:
450 	  integer_rela
451 	| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
452 	| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
453 	;
454 
455 integer_rela:
456 	  integer_shift
457 	| integer_rela '<' integer_shift { $$ = $1 < $3; }
458 	| integer_rela '>' integer_shift { $$ = $1 > $3; }
459 	| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
460 	| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
461 	;
462 
463 integer_shift:
464 	  integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
465 	| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
466 	| integer_add
467 	;
468 
469 integer_add:
470 	  integer_add '+' integer_mul { $$ = $1 + $3; }
471 	| integer_add '-' integer_mul { $$ = $1 - $3; }
472 	| integer_mul
473 	;
474 
475 integer_mul:
476 	  integer_mul '*' integer_unary { $$ = $1 * $3; }
477 	| integer_mul '/' integer_unary
478 		{
479 			if ($3 != 0) {
480 				$$ = $1 / $3;
481 			} else {
482 				ERROR(&@$, "Division by zero");
483 				$$ = 0;
484 			}
485 		}
486 	| integer_mul '%' integer_unary
487 		{
488 			if ($3 != 0) {
489 				$$ = $1 % $3;
490 			} else {
491 				ERROR(&@$, "Division by zero");
492 				$$ = 0;
493 			}
494 		}
495 	| integer_unary
496 	;
497 
498 integer_unary:
499 	  integer_prim
500 	| '-' integer_unary { $$ = -$2; }
501 	| '~' integer_unary { $$ = ~$2; }
502 	| '!' integer_unary { $$ = !$2; }
503 	;
504 
505 bytestring:
506 	  /* empty */
507 		{
508 			$$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
509 		}
510 	| bytestring DT_BYTE
511 		{
512 			$$ = data_append_byte($1, $2);
513 		}
514 	| bytestring DT_LABEL
515 		{
516 			$$ = data_add_marker($1, LABEL, $2);
517 		}
518 	;
519 
520 subnodes:
521 	  /* empty */
522 		{
523 			$$ = NULL;
524 		}
525 	| subnode subnodes
526 		{
527 			$$ = chain_node($1, $2);
528 		}
529 	| subnode propdef
530 		{
531 			ERROR(&@2, "Properties must precede subnodes");
532 			YYERROR;
533 		}
534 	;
535 
536 subnode:
537 	  DT_PROPNODENAME nodedef
538 		{
539 			$$ = name_node($2, $1);
540 		}
541 	| DT_DEL_NODE DT_PROPNODENAME ';'
542 		{
543 			$$ = name_node(build_node_delete(), $2);
544 		}
545 	| DT_OMIT_NO_REF subnode
546 		{
547 			$$ = omit_node_if_unused($2);
548 		}
549 	| DT_LABEL subnode
550 		{
551 			add_label(&$2->labels, $1);
552 			$$ = $2;
553 		}
554 	;
555 
556 %%
557 
558 void yyerror(char const *s)
559 {
560 	ERROR(&yylloc, "%s", s);
561 }
562