David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005. |
| 3 | * |
David Gibson | 63dc9c7 | 2007-09-18 11:44:04 +1000 | [diff] [blame] | 4 | * |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 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. |
David Gibson | 63dc9c7 | 2007-09-18 11:44:04 +1000 | [diff] [blame] | 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 |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 19 | */ |
| 20 | |
| 21 | #include "dtc.h" |
Jon Loeliger | e45e6fd | 2007-03-23 15:18:41 -0500 | [diff] [blame] | 22 | #include "srcpos.h" |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 23 | |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 24 | extern FILE *yyin; |
| 25 | extern int yyparse(void); |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 26 | extern void yyerror(char const *); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 27 | |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 28 | struct boot_info *the_boot_info; |
| 29 | |
Jon Loeliger | e45e6fd | 2007-03-23 15:18:41 -0500 | [diff] [blame] | 30 | struct boot_info *dt_from_source(const char *fname) |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 31 | { |
| 32 | the_boot_info = NULL; |
| 33 | |
Jon Loeliger | e45e6fd | 2007-03-23 15:18:41 -0500 | [diff] [blame] | 34 | push_input_file(fname); |
| 35 | |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 36 | if (yyparse() != 0) |
| 37 | return NULL; |
| 38 | |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 39 | fill_fullpaths(the_boot_info->dt, ""); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 40 | |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 41 | return the_boot_info; |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 42 | } |
| 43 | |
| 44 | static void write_prefix(FILE *f, int level) |
| 45 | { |
| 46 | int i; |
| 47 | |
| 48 | for (i = 0; i < level; i++) |
| 49 | fputc('\t', f); |
| 50 | } |
| 51 | |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 52 | int isstring(char c) |
| 53 | { |
| 54 | return (isprint(c) |
| 55 | || (c == '\0') |
| 56 | || strchr("\a\b\t\n\v\f\r", c)); |
| 57 | } |
| 58 | |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 59 | static void write_propval_string(FILE *f, struct data val) |
| 60 | { |
| 61 | char *str = val.val; |
| 62 | int i; |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 63 | int newchunk = 1; |
| 64 | struct fixup *l = val.labels; |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 65 | |
| 66 | assert(str[val.len-1] == '\0'); |
| 67 | |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 68 | for (i = 0; i < (val.len-1); i++) { |
| 69 | char c = str[i]; |
| 70 | |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 71 | if (newchunk) { |
| 72 | while (l && (l->offset <= i)) { |
| 73 | assert(l->offset == i); |
| 74 | fprintf(f, "%s: ", l->ref); |
| 75 | l = l->next; |
| 76 | } |
| 77 | fprintf(f, "\""); |
| 78 | newchunk = 0; |
| 79 | } |
| 80 | |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 81 | switch (c) { |
| 82 | case '\a': |
| 83 | fprintf(f, "\\a"); |
| 84 | break; |
| 85 | case '\b': |
| 86 | fprintf(f, "\\b"); |
| 87 | break; |
| 88 | case '\t': |
| 89 | fprintf(f, "\\t"); |
| 90 | break; |
| 91 | case '\n': |
| 92 | fprintf(f, "\\n"); |
| 93 | break; |
| 94 | case '\v': |
| 95 | fprintf(f, "\\v"); |
| 96 | break; |
| 97 | case '\f': |
| 98 | fprintf(f, "\\f"); |
| 99 | break; |
| 100 | case '\r': |
| 101 | fprintf(f, "\\r"); |
| 102 | break; |
| 103 | case '\\': |
| 104 | fprintf(f, "\\\\"); |
| 105 | break; |
| 106 | case '\"': |
| 107 | fprintf(f, "\\\""); |
| 108 | break; |
| 109 | case '\0': |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 110 | fprintf(f, "\", "); |
| 111 | newchunk = 1; |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 112 | break; |
| 113 | default: |
| 114 | if (isprint(c)) |
| 115 | fprintf(f, "%c", c); |
| 116 | else |
| 117 | fprintf(f, "\\x%02hhx", c); |
| 118 | } |
| 119 | } |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 120 | fprintf(f, "\""); |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 121 | |
| 122 | /* Wrap up any labels at the end of the value */ |
| 123 | while (l) { |
| 124 | assert (l->offset == val.len); |
| 125 | fprintf(f, " %s:", l->ref); |
| 126 | l = l->next; |
| 127 | } |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 128 | } |
| 129 | |
| 130 | static void write_propval_cells(FILE *f, struct data val) |
| 131 | { |
| 132 | void *propend = val.val + val.len; |
| 133 | cell_t *cp = (cell_t *)val.val; |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 134 | struct fixup *l = val.labels; |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 135 | |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 136 | fprintf(f, "<"); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 137 | for (;;) { |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 138 | while (l && (l->offset <= ((char *)cp - val.val))) { |
| 139 | assert(l->offset == ((char *)cp - val.val)); |
| 140 | fprintf(f, "%s: ", l->ref); |
| 141 | l = l->next; |
| 142 | } |
| 143 | |
David Gibson | 91967ac | 2007-11-07 11:17:37 +1100 | [diff] [blame^] | 144 | fprintf(f, "0x%x", be32_to_cpu(*cp++)); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 145 | if ((void *)cp >= propend) |
| 146 | break; |
| 147 | fprintf(f, " "); |
| 148 | } |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 149 | |
| 150 | /* Wrap up any labels at the end of the value */ |
| 151 | while (l) { |
| 152 | assert (l->offset == val.len); |
| 153 | fprintf(f, " %s:", l->ref); |
| 154 | l = l->next; |
| 155 | } |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 156 | fprintf(f, ">"); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | static void write_propval_bytes(FILE *f, struct data val) |
| 160 | { |
| 161 | void *propend = val.val + val.len; |
| 162 | char *bp = val.val; |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 163 | struct fixup *l = val.labels; |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 164 | |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 165 | fprintf(f, "["); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 166 | for (;;) { |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 167 | while (l && (l->offset == (bp-val.val))) { |
| 168 | fprintf(f, "%s: ", l->ref); |
| 169 | l = l->next; |
| 170 | } |
| 171 | |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 172 | fprintf(f, "%02hhx", *bp++); |
| 173 | if ((void *)bp >= propend) |
| 174 | break; |
| 175 | fprintf(f, " "); |
| 176 | } |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 177 | |
| 178 | /* Wrap up any labels at the end of the value */ |
| 179 | while (l) { |
| 180 | assert (l->offset == val.len); |
| 181 | fprintf(f, " %s:", l->ref); |
| 182 | l = l->next; |
| 183 | } |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 184 | fprintf(f, "]"); |
| 185 | } |
| 186 | |
| 187 | static void write_propval(FILE *f, struct property *prop) |
| 188 | { |
| 189 | int len = prop->val.len; |
| 190 | char *p = prop->val.val; |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 191 | struct fixup *l; |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 192 | int nnotstring = 0, nnul = 0; |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 193 | int nnotstringlbl = 0, nnotcelllbl = 0; |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 194 | int i; |
| 195 | |
| 196 | if (len == 0) { |
| 197 | fprintf(f, ";\n"); |
| 198 | return; |
| 199 | } |
| 200 | |
| 201 | for (i = 0; i < len; i++) { |
| 202 | if (! isstring(p[i])) |
| 203 | nnotstring++; |
| 204 | if (p[i] == '\0') |
| 205 | nnul++; |
| 206 | } |
| 207 | |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 208 | for (l = prop->val.labels; l; l = l->next) { |
| 209 | if ((l->offset > 0) && (prop->val.val[l->offset - 1] != '\0')) |
| 210 | nnotstringlbl++; |
| 211 | if ((l->offset % sizeof(cell_t)) != 0) |
| 212 | nnotcelllbl++; |
| 213 | } |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 214 | |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 215 | fprintf(f, " = "); |
| 216 | if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul < (len-nnul)) |
| 217 | && (nnotstringlbl == 0)) { |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 218 | write_propval_string(f, prop->val); |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 219 | } else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) { |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 220 | write_propval_cells(f, prop->val); |
| 221 | } else { |
| 222 | write_propval_bytes(f, prop->val); |
| 223 | } |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 224 | |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 225 | fprintf(f, ";\n"); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 226 | } |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 227 | |
David Gibson | 230f253 | 2005-08-29 12:48:02 +1000 | [diff] [blame] | 228 | static void write_tree_source_node(FILE *f, struct node *tree, int level) |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 229 | { |
| 230 | struct property *prop; |
| 231 | struct node *child; |
| 232 | |
| 233 | write_prefix(f, level); |
David Gibson | 02563ad | 2007-11-02 16:10:30 +1100 | [diff] [blame] | 234 | if (tree->label) |
| 235 | fprintf(f, "%s: ", tree->label); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 236 | if (tree->name && (*tree->name)) |
| 237 | fprintf(f, "%s {\n", tree->name); |
| 238 | else |
| 239 | fprintf(f, "/ {\n"); |
| 240 | |
| 241 | for_each_property(tree, prop) { |
David Gibson | 02563ad | 2007-11-02 16:10:30 +1100 | [diff] [blame] | 242 | write_prefix(f, level+1); |
| 243 | if (prop->label) |
| 244 | fprintf(f, "%s: ", prop->label); |
| 245 | fprintf(f, "%s", prop->name); |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 246 | write_propval(f, prop); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 247 | } |
| 248 | for_each_child(tree, child) { |
| 249 | fprintf(f, "\n"); |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 250 | write_tree_source_node(f, child, level+1); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 251 | } |
| 252 | write_prefix(f, level); |
| 253 | fprintf(f, "};\n"); |
| 254 | } |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 255 | |
| 256 | |
David Gibson | 712e52e | 2005-10-26 16:56:26 +1000 | [diff] [blame] | 257 | void dt_to_source(FILE *f, struct boot_info *bi) |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 258 | { |
David Gibson | f040d95 | 2005-10-24 18:18:38 +1000 | [diff] [blame] | 259 | struct reserve_info *re; |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 260 | |
David Gibson | 91967ac | 2007-11-07 11:17:37 +1100 | [diff] [blame^] | 261 | fprintf(f, "/dts-v1/;\n\n"); |
| 262 | |
David Gibson | f040d95 | 2005-10-24 18:18:38 +1000 | [diff] [blame] | 263 | for (re = bi->reservelist; re; re = re->next) { |
David Gibson | 02563ad | 2007-11-02 16:10:30 +1100 | [diff] [blame] | 264 | if (re->label) |
| 265 | fprintf(f, "%s: ", re->label); |
David Gibson | 91967ac | 2007-11-07 11:17:37 +1100 | [diff] [blame^] | 266 | fprintf(f, "/memreserve/\t0x%016llx 0x%016llx;\n", |
David Gibson | f040d95 | 2005-10-24 18:18:38 +1000 | [diff] [blame] | 267 | (unsigned long long)re->re.address, |
David Gibson | 91967ac | 2007-11-07 11:17:37 +1100 | [diff] [blame^] | 268 | (unsigned long long)re->re.size); |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | write_tree_source_node(f, bi->dt, 0); |
| 272 | } |
| 273 | |