drm/i915: Create stolen memory region from local memory
[linux-2.6-microblaze.git] / scripts / dtc / treesource.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
4  */
5
6 #include "dtc.h"
7 #include "srcpos.h"
8
9 extern FILE *yyin;
10 extern int yyparse(void);
11 extern YYLTYPE yylloc;
12
13 struct dt_info *parser_output;
14 bool treesource_error;
15
16 struct dt_info *dt_from_source(const char *fname)
17 {
18         parser_output = NULL;
19         treesource_error = false;
20
21         srcfile_push(fname);
22         yyin = current_srcfile->f;
23         yylloc.file = current_srcfile;
24
25         if (yyparse() != 0)
26                 die("Unable to parse input tree\n");
27
28         if (treesource_error)
29                 die("Syntax error parsing input tree\n");
30
31         return parser_output;
32 }
33
34 static void write_prefix(FILE *f, int level)
35 {
36         int i;
37
38         for (i = 0; i < level; i++)
39                 fputc('\t', f);
40 }
41
42 static bool isstring(char c)
43 {
44         return (isprint((unsigned char)c)
45                 || (c == '\0')
46                 || strchr("\a\b\t\n\v\f\r", c));
47 }
48
49 static void write_propval_string(FILE *f, const char *s, size_t len)
50 {
51         const char *end = s + len - 1;
52
53         if (!len)
54                 return;
55
56         assert(*end == '\0');
57
58         fprintf(f, "\"");
59         while (s < end) {
60                 char c = *s++;
61                 switch (c) {
62                 case '\a':
63                         fprintf(f, "\\a");
64                         break;
65                 case '\b':
66                         fprintf(f, "\\b");
67                         break;
68                 case '\t':
69                         fprintf(f, "\\t");
70                         break;
71                 case '\n':
72                         fprintf(f, "\\n");
73                         break;
74                 case '\v':
75                         fprintf(f, "\\v");
76                         break;
77                 case '\f':
78                         fprintf(f, "\\f");
79                         break;
80                 case '\r':
81                         fprintf(f, "\\r");
82                         break;
83                 case '\\':
84                         fprintf(f, "\\\\");
85                         break;
86                 case '\"':
87                         fprintf(f, "\\\"");
88                         break;
89                 case '\0':
90                         fprintf(f, "\\0");
91                         break;
92                 default:
93                         if (isprint((unsigned char)c))
94                                 fprintf(f, "%c", c);
95                         else
96                                 fprintf(f, "\\x%02"PRIx8, c);
97                 }
98         }
99         fprintf(f, "\"");
100 }
101
102 static void write_propval_int(FILE *f, const char *p, size_t len, size_t width)
103 {
104         const char *end = p + len;
105         assert(len % width == 0);
106
107         for (; p < end; p += width) {
108                 switch (width) {
109                 case 1:
110                         fprintf(f, "%02"PRIx8, *(const uint8_t*)p);
111                         break;
112                 case 2:
113                         fprintf(f, "0x%02"PRIx16, dtb_ld16(p));
114                         break;
115                 case 4:
116                         fprintf(f, "0x%02"PRIx32, dtb_ld32(p));
117                         break;
118                 case 8:
119                         fprintf(f, "0x%02"PRIx64, dtb_ld64(p));
120                         break;
121                 }
122                 if (p + width < end)
123                         fputc(' ', f);
124         }
125 }
126
127 static bool has_data_type_information(struct marker *m)
128 {
129         return m->type >= TYPE_UINT8;
130 }
131
132 static struct marker *next_type_marker(struct marker *m)
133 {
134         while (m && !has_data_type_information(m))
135                 m = m->next;
136         return m;
137 }
138
139 size_t type_marker_length(struct marker *m)
140 {
141         struct marker *next = next_type_marker(m->next);
142
143         if (next)
144                 return next->offset - m->offset;
145         return 0;
146 }
147
148 static const char *delim_start[] = {
149         [TYPE_UINT8] = "[",
150         [TYPE_UINT16] = "/bits/ 16 <",
151         [TYPE_UINT32] = "<",
152         [TYPE_UINT64] = "/bits/ 64 <",
153         [TYPE_STRING] = "",
154 };
155 static const char *delim_end[] = {
156         [TYPE_UINT8] = "]",
157         [TYPE_UINT16] = ">",
158         [TYPE_UINT32] = ">",
159         [TYPE_UINT64] = ">",
160         [TYPE_STRING] = "",
161 };
162
163 static enum markertype guess_value_type(struct property *prop)
164 {
165         int len = prop->val.len;
166         const char *p = prop->val.val;
167         struct marker *m = prop->val.markers;
168         int nnotstring = 0, nnul = 0;
169         int nnotstringlbl = 0, nnotcelllbl = 0;
170         int i;
171
172         for (i = 0; i < len; i++) {
173                 if (! isstring(p[i]))
174                         nnotstring++;
175                 if (p[i] == '\0')
176                         nnul++;
177         }
178
179         for_each_marker_of_type(m, LABEL) {
180                 if ((m->offset > 0) && (prop->val.val[m->offset - 1] != '\0'))
181                         nnotstringlbl++;
182                 if ((m->offset % sizeof(cell_t)) != 0)
183                         nnotcelllbl++;
184         }
185
186         if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul <= (len-nnul))
187             && (nnotstringlbl == 0)) {
188                 return TYPE_STRING;
189         } else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) {
190                 return TYPE_UINT32;
191         }
192
193         return TYPE_UINT8;
194 }
195
196 static void write_propval(FILE *f, struct property *prop)
197 {
198         size_t len = prop->val.len;
199         struct marker *m = prop->val.markers;
200         struct marker dummy_marker;
201         enum markertype emit_type = TYPE_NONE;
202         char *srcstr;
203
204         if (len == 0) {
205                 fprintf(f, ";");
206                 if (annotate) {
207                         srcstr = srcpos_string_first(prop->srcpos, annotate);
208                         if (srcstr) {
209                                 fprintf(f, " /* %s */", srcstr);
210                                 free(srcstr);
211                         }
212                 }
213                 fprintf(f, "\n");
214                 return;
215         }
216
217         fprintf(f, " =");
218
219         if (!next_type_marker(m)) {
220                 /* data type information missing, need to guess */
221                 dummy_marker.type = guess_value_type(prop);
222                 dummy_marker.next = prop->val.markers;
223                 dummy_marker.offset = 0;
224                 dummy_marker.ref = NULL;
225                 m = &dummy_marker;
226         }
227
228         for_each_marker(m) {
229                 size_t chunk_len = (m->next ? m->next->offset : len) - m->offset;
230                 size_t data_len = type_marker_length(m) ? : len - m->offset;
231                 const char *p = &prop->val.val[m->offset];
232
233                 if (has_data_type_information(m)) {
234                         emit_type = m->type;
235                         fprintf(f, " %s", delim_start[emit_type]);
236                 } else if (m->type == LABEL)
237                         fprintf(f, " %s:", m->ref);
238                 else if (m->offset)
239                         fputc(' ', f);
240
241                 if (emit_type == TYPE_NONE) {
242                         assert(chunk_len == 0);
243                         continue;
244                 }
245
246                 switch(emit_type) {
247                 case TYPE_UINT16:
248                         write_propval_int(f, p, chunk_len, 2);
249                         break;
250                 case TYPE_UINT32:
251                         write_propval_int(f, p, chunk_len, 4);
252                         break;
253                 case TYPE_UINT64:
254                         write_propval_int(f, p, chunk_len, 8);
255                         break;
256                 case TYPE_STRING:
257                         write_propval_string(f, p, chunk_len);
258                         break;
259                 default:
260                         write_propval_int(f, p, chunk_len, 1);
261                 }
262
263                 if (chunk_len == data_len) {
264                         size_t pos = m->offset + chunk_len;
265                         fprintf(f, pos == len ? "%s" : "%s,",
266                                 delim_end[emit_type] ? : "");
267                         emit_type = TYPE_NONE;
268                 }
269         }
270         fprintf(f, ";");
271         if (annotate) {
272                 srcstr = srcpos_string_first(prop->srcpos, annotate);
273                 if (srcstr) {
274                         fprintf(f, " /* %s */", srcstr);
275                         free(srcstr);
276                 }
277         }
278         fprintf(f, "\n");
279 }
280
281 static void write_tree_source_node(FILE *f, struct node *tree, int level)
282 {
283         struct property *prop;
284         struct node *child;
285         struct label *l;
286         char *srcstr;
287
288         write_prefix(f, level);
289         for_each_label(tree->labels, l)
290                 fprintf(f, "%s: ", l->label);
291         if (tree->name && (*tree->name))
292                 fprintf(f, "%s {", tree->name);
293         else
294                 fprintf(f, "/ {");
295
296         if (annotate) {
297                 srcstr = srcpos_string_first(tree->srcpos, annotate);
298                 if (srcstr) {
299                         fprintf(f, " /* %s */", srcstr);
300                         free(srcstr);
301                 }
302         }
303         fprintf(f, "\n");
304
305         for_each_property(tree, prop) {
306                 write_prefix(f, level+1);
307                 for_each_label(prop->labels, l)
308                         fprintf(f, "%s: ", l->label);
309                 fprintf(f, "%s", prop->name);
310                 write_propval(f, prop);
311         }
312         for_each_child(tree, child) {
313                 fprintf(f, "\n");
314                 write_tree_source_node(f, child, level+1);
315         }
316         write_prefix(f, level);
317         fprintf(f, "};");
318         if (annotate) {
319                 srcstr = srcpos_string_last(tree->srcpos, annotate);
320                 if (srcstr) {
321                         fprintf(f, " /* %s */", srcstr);
322                         free(srcstr);
323                 }
324         }
325         fprintf(f, "\n");
326 }
327
328 void dt_to_source(FILE *f, struct dt_info *dti)
329 {
330         struct reserve_info *re;
331
332         fprintf(f, "/dts-v1/;\n\n");
333
334         for (re = dti->reservelist; re; re = re->next) {
335                 struct label *l;
336
337                 for_each_label(re->labels, l)
338                         fprintf(f, "%s: ", l->label);
339                 fprintf(f, "/memreserve/\t0x%016llx 0x%016llx;\n",
340                         (unsigned long long)re->address,
341                         (unsigned long long)re->size);
342         }
343
344         write_tree_source_node(f, dti->dt, 0);
345 }