David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 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 "dtc.h" |
| 22 | |
| 23 | void data_free(struct data d) |
| 24 | { |
| 25 | struct marker *m, *nm; |
| 26 | |
| 27 | m = d.markers; |
| 28 | while (m) { |
| 29 | nm = m->next; |
| 30 | free(m->ref); |
| 31 | free(m); |
| 32 | m = nm; |
| 33 | } |
| 34 | |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 35 | if (d.val) |
| 36 | free(d.val); |
| 37 | } |
| 38 | |
| 39 | struct data data_grow_for(struct data d, int xlen) |
| 40 | { |
| 41 | struct data nd; |
| 42 | int newsize; |
| 43 | |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 44 | if (xlen == 0) |
| 45 | return d; |
| 46 | |
| 47 | nd = d; |
| 48 | |
| 49 | newsize = xlen; |
| 50 | |
| 51 | while ((d.len + xlen) > newsize) |
| 52 | newsize *= 2; |
| 53 | |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 54 | nd.val = xrealloc(d.val, newsize); |
| 55 | |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 56 | return nd; |
| 57 | } |
| 58 | |
| 59 | struct data data_copy_mem(const char *mem, int len) |
| 60 | { |
| 61 | struct data d; |
| 62 | |
| 63 | d = data_grow_for(empty_data, len); |
| 64 | |
| 65 | d.len = len; |
| 66 | memcpy(d.val, mem, len); |
| 67 | |
| 68 | return d; |
| 69 | } |
| 70 | |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 71 | struct data data_copy_escape_string(const char *s, int len) |
| 72 | { |
| 73 | int i = 0; |
| 74 | struct data d; |
| 75 | char *q; |
| 76 | |
| 77 | d = data_grow_for(empty_data, strlen(s)+1); |
| 78 | |
| 79 | q = d.val; |
| 80 | while (i < len) { |
| 81 | char c = s[i++]; |
| 82 | |
Stephen Warren | cb261f0 | 2012-09-28 21:25:59 +0000 | [diff] [blame] | 83 | if (c == '\\') |
| 84 | c = get_escape_char(s, &i); |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 85 | |
Stephen Warren | cb261f0 | 2012-09-28 21:25:59 +0000 | [diff] [blame] | 86 | q[d.len++] = c; |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 87 | } |
| 88 | |
| 89 | q[d.len++] = '\0'; |
| 90 | return d; |
| 91 | } |
| 92 | |
David Gibson | ed95d74 | 2008-08-07 12:24:17 +1000 | [diff] [blame] | 93 | struct data data_copy_file(FILE *f, size_t maxlen) |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 94 | { |
David Gibson | ed95d74 | 2008-08-07 12:24:17 +1000 | [diff] [blame] | 95 | struct data d = empty_data; |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 96 | |
David Gibson | ed95d74 | 2008-08-07 12:24:17 +1000 | [diff] [blame] | 97 | while (!feof(f) && (d.len < maxlen)) { |
| 98 | size_t chunksize, ret; |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 99 | |
David Gibson | ed95d74 | 2008-08-07 12:24:17 +1000 | [diff] [blame] | 100 | if (maxlen == -1) |
| 101 | chunksize = 4096; |
| 102 | else |
| 103 | chunksize = maxlen - d.len; |
| 104 | |
| 105 | d = data_grow_for(d, chunksize); |
| 106 | ret = fread(d.val + d.len, 1, chunksize, f); |
| 107 | |
| 108 | if (ferror(f)) |
| 109 | die("Error reading file into data: %s", strerror(errno)); |
| 110 | |
| 111 | if (d.len + ret < d.len) |
| 112 | die("Overflow reading file into data\n"); |
| 113 | |
| 114 | d.len += ret; |
| 115 | } |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 116 | |
| 117 | return d; |
| 118 | } |
| 119 | |
| 120 | struct data data_append_data(struct data d, const void *p, int len) |
| 121 | { |
| 122 | d = data_grow_for(d, len); |
| 123 | memcpy(d.val + d.len, p, len); |
| 124 | d.len += len; |
| 125 | return d; |
| 126 | } |
| 127 | |
| 128 | struct data data_insert_at_marker(struct data d, struct marker *m, |
| 129 | const void *p, int len) |
| 130 | { |
| 131 | d = data_grow_for(d, len); |
| 132 | memmove(d.val + m->offset + len, d.val + m->offset, d.len - m->offset); |
| 133 | memcpy(d.val + m->offset, p, len); |
| 134 | d.len += len; |
| 135 | |
| 136 | /* Adjust all markers after the one we're inserting at */ |
| 137 | m = m->next; |
| 138 | for_each_marker(m) |
| 139 | m->offset += len; |
| 140 | return d; |
| 141 | } |
| 142 | |
Josh Triplett | 5ccd991 | 2009-10-16 15:53:55 -0700 | [diff] [blame] | 143 | static struct data data_append_markers(struct data d, struct marker *m) |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 144 | { |
| 145 | struct marker **mp = &d.markers; |
| 146 | |
| 147 | /* Find the end of the markerlist */ |
| 148 | while (*mp) |
| 149 | mp = &((*mp)->next); |
| 150 | *mp = m; |
| 151 | return d; |
| 152 | } |
| 153 | |
| 154 | struct data data_merge(struct data d1, struct data d2) |
| 155 | { |
| 156 | struct data d; |
| 157 | struct marker *m2 = d2.markers; |
| 158 | |
| 159 | d = data_append_markers(data_append_data(d1, d2.val, d2.len), m2); |
| 160 | |
| 161 | /* Adjust for the length of d1 */ |
| 162 | for_each_marker(m2) |
| 163 | m2->offset += d1.len; |
| 164 | |
| 165 | d2.markers = NULL; /* So data_free() doesn't clobber them */ |
| 166 | data_free(d2); |
| 167 | |
| 168 | return d; |
| 169 | } |
| 170 | |
Stephen Warren | cb261f0 | 2012-09-28 21:25:59 +0000 | [diff] [blame] | 171 | struct data data_append_integer(struct data d, uint64_t value, int bits) |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 172 | { |
Stephen Warren | cb261f0 | 2012-09-28 21:25:59 +0000 | [diff] [blame] | 173 | uint8_t value_8; |
| 174 | uint16_t value_16; |
| 175 | uint32_t value_32; |
| 176 | uint64_t value_64; |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 177 | |
Stephen Warren | cb261f0 | 2012-09-28 21:25:59 +0000 | [diff] [blame] | 178 | switch (bits) { |
| 179 | case 8: |
| 180 | value_8 = value; |
| 181 | return data_append_data(d, &value_8, 1); |
| 182 | |
| 183 | case 16: |
| 184 | value_16 = cpu_to_fdt16(value); |
| 185 | return data_append_data(d, &value_16, 2); |
| 186 | |
| 187 | case 32: |
| 188 | value_32 = cpu_to_fdt32(value); |
| 189 | return data_append_data(d, &value_32, 4); |
| 190 | |
| 191 | case 64: |
| 192 | value_64 = cpu_to_fdt64(value); |
| 193 | return data_append_data(d, &value_64, 8); |
| 194 | |
| 195 | default: |
| 196 | die("Invalid literal size (%d)\n", bits); |
| 197 | } |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 198 | } |
| 199 | |
| 200 | struct data data_append_re(struct data d, const struct fdt_reserve_entry *re) |
| 201 | { |
| 202 | struct fdt_reserve_entry bere; |
| 203 | |
David Gibson | ed95d74 | 2008-08-07 12:24:17 +1000 | [diff] [blame] | 204 | bere.address = cpu_to_fdt64(re->address); |
| 205 | bere.size = cpu_to_fdt64(re->size); |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 206 | |
| 207 | return data_append_data(d, &bere, sizeof(bere)); |
| 208 | } |
| 209 | |
Stephen Warren | cb261f0 | 2012-09-28 21:25:59 +0000 | [diff] [blame] | 210 | struct data data_append_cell(struct data d, cell_t word) |
| 211 | { |
| 212 | return data_append_integer(d, word, sizeof(word) * 8); |
| 213 | } |
| 214 | |
David Gibson | ed95d74 | 2008-08-07 12:24:17 +1000 | [diff] [blame] | 215 | struct data data_append_addr(struct data d, uint64_t addr) |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 216 | { |
Stephen Warren | cb261f0 | 2012-09-28 21:25:59 +0000 | [diff] [blame] | 217 | return data_append_integer(d, addr, sizeof(addr) * 8); |
David Gibson | a4da2e3 | 2007-12-18 15:06:42 +1100 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | struct data data_append_byte(struct data d, uint8_t byte) |
| 221 | { |
| 222 | return data_append_data(d, &byte, 1); |
| 223 | } |
| 224 | |
| 225 | struct data data_append_zeroes(struct data d, int len) |
| 226 | { |
| 227 | d = data_grow_for(d, len); |
| 228 | |
| 229 | memset(d.val + d.len, 0, len); |
| 230 | d.len += len; |
| 231 | return d; |
| 232 | } |
| 233 | |
| 234 | struct data data_append_align(struct data d, int align) |
| 235 | { |
| 236 | int newlen = ALIGN(d.len, align); |
| 237 | return data_append_zeroes(d, newlen - d.len); |
| 238 | } |
| 239 | |
| 240 | struct data data_add_marker(struct data d, enum markertype type, char *ref) |
| 241 | { |
| 242 | struct marker *m; |
| 243 | |
| 244 | m = xmalloc(sizeof(*m)); |
| 245 | m->offset = d.len; |
| 246 | m->type = type; |
| 247 | m->ref = ref; |
| 248 | m->next = NULL; |
| 249 | |
| 250 | return data_append_markers(d, m); |
| 251 | } |
| 252 | |
| 253 | int data_is_one_string(struct data d) |
| 254 | { |
| 255 | int i; |
| 256 | int len = d.len; |
| 257 | |
| 258 | if (len == 0) |
| 259 | return 0; |
| 260 | |
| 261 | for (i = 0; i < len-1; i++) |
| 262 | if (d.val[i] == '\0') |
| 263 | return 0; |
| 264 | |
| 265 | if (d.val[len-1] != '\0') |
| 266 | return 0; |
| 267 | |
| 268 | return 1; |
| 269 | } |