blob: 4c50b1259556720bbb0e28916ab8120aeed2adf8 [file] [log] [blame]
David Gibsonfc14dad2005-06-08 17:18:34 +10001/*
2 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.
3 *
David Gibson63dc9c72007-09-18 11:44:04 +10004 *
David Gibsonfc14dad2005-06-08 17:18:34 +10005 * 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 Gibson63dc9c72007-09-18 11:44:04 +100014 *
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 Gibsonfc14dad2005-06-08 17:18:34 +100019 */
20
21#include "dtc.h"
22
David Gibsonfc14dad2005-06-08 17:18:34 +100023void data_free(struct data d)
24{
David Gibsondc941772007-11-22 14:39:23 +110025 struct marker *m, *nm;
David Gibson81f2e892005-06-16 17:04:00 +100026
David Gibsondc941772007-11-22 14:39:23 +110027 m = d.markers;
28 while (m) {
29 nm = m->next;
30 free(m->ref);
31 free(m);
32 m = nm;
David Gibson81f2e892005-06-16 17:04:00 +100033 }
34
David Gibsonfc14dad2005-06-08 17:18:34 +100035 if (d.val)
36 free(d.val);
37}
38
39struct data data_grow_for(struct data d, int xlen)
40{
41 struct data nd;
42 int newsize;
43
David Gibsonfc14dad2005-06-08 17:18:34 +100044 if (xlen == 0)
45 return d;
46
Milton Miller46779e82007-07-07 01:18:49 -050047 nd = d;
48
David Gibsonfc14dad2005-06-08 17:18:34 +100049 newsize = xlen;
50
51 while ((d.len + xlen) > newsize)
52 newsize *= 2;
53
David Gibsonfc14dad2005-06-08 17:18:34 +100054 nd.val = xrealloc(d.val, newsize);
David Gibsonfc14dad2005-06-08 17:18:34 +100055
David Gibsonfc14dad2005-06-08 17:18:34 +100056 return nd;
57}
58
David Gibson92cb9a22007-12-04 14:26:15 +110059struct data data_copy_mem(const char *mem, int len)
David Gibsonfc14dad2005-06-08 17:18:34 +100060{
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 Gibson92cb9a22007-12-04 14:26:15 +110071struct data data_copy_escape_string(const char *s, int len)
David Gibsonfc14dad2005-06-08 17:18:34 +100072{
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
Anton Staafb43335a2011-09-09 12:16:29 -070083 if (c == '\\')
84 c = get_escape_char(s, &i);
David Gibsonfc14dad2005-06-08 17:18:34 +100085
Anton Staafb43335a2011-09-09 12:16:29 -070086 q[d.len++] = c;
David Gibsonfc14dad2005-06-08 17:18:34 +100087 }
88
89 q[d.len++] = '\0';
90 return d;
91}
92
David Gibsone37ec7d2008-06-11 11:58:39 +100093struct data data_copy_file(FILE *f, size_t maxlen)
David Gibsonfc14dad2005-06-08 17:18:34 +100094{
David Gibsone37ec7d2008-06-11 11:58:39 +100095 struct data d = empty_data;
David Gibsonfc14dad2005-06-08 17:18:34 +100096
David Gibsone37ec7d2008-06-11 11:58:39 +100097 while (!feof(f) && (d.len < maxlen)) {
98 size_t chunksize, ret;
David Gibsonfc14dad2005-06-08 17:18:34 +100099
David Gibsone37ec7d2008-06-11 11:58:39 +1000100 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 Gibsonfc14dad2005-06-08 17:18:34 +1000116
117 return d;
118}
119
David Gibson92cb9a22007-12-04 14:26:15 +1100120struct data data_append_data(struct data d, const void *p, int len)
David Gibsonfc14dad2005-06-08 17:18:34 +1000121{
122 d = data_grow_for(d, len);
123 memcpy(d.val + d.len, p, len);
124 d.len += len;
125 return d;
126}
127
David Gibsonefbbef82007-12-05 10:43:50 +1100128struct 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
David Gibson01a2d8a2008-08-04 15:30:13 +1000143static struct data data_append_markers(struct data d, struct marker *m)
David Gibson32da4752007-02-07 16:37:50 +1100144{
David Gibsondc941772007-11-22 14:39:23 +1100145 struct marker **mp = &d.markers;
David Gibson32da4752007-02-07 16:37:50 +1100146
David Gibsondc941772007-11-22 14:39:23 +1100147 /* Find the end of the markerlist */
148 while (*mp)
149 mp = &((*mp)->next);
150 *mp = m;
151 return d;
Milton Miller6a99b132007-07-07 01:18:51 -0500152}
153
154struct data data_merge(struct data d1, struct data d2)
155{
156 struct data d;
David Gibsondc941772007-11-22 14:39:23 +1100157 struct marker *m2 = d2.markers;
Milton Miller6a99b132007-07-07 01:18:51 -0500158
David Gibsondc941772007-11-22 14:39:23 +1100159 d = data_append_markers(data_append_data(d1, d2.val, d2.len), m2);
Milton Miller6a99b132007-07-07 01:18:51 -0500160
David Gibsondc941772007-11-22 14:39:23 +1100161 /* Adjust for the length of d1 */
162 for_each_marker(m2)
163 m2->offset += d1.len;
David Gibson32da4752007-02-07 16:37:50 +1100164
David Gibsondc941772007-11-22 14:39:23 +1100165 d2.markers = NULL; /* So data_free() doesn't clobber them */
David Gibson32da4752007-02-07 16:37:50 +1100166 data_free(d2);
167
168 return d;
169}
170
Anton Staafa4b515c2011-10-11 10:22:28 -0700171struct data data_append_integer(struct data d, uint64_t value, int bits)
David Gibsonfc14dad2005-06-08 17:18:34 +1000172{
Anton Staafa4b515c2011-10-11 10:22:28 -0700173 uint8_t value_8;
174 uint16_t value_16;
175 uint32_t value_32;
176 uint64_t value_64;
David Gibsonfc14dad2005-06-08 17:18:34 +1000177
Anton Staafa4b515c2011-10-11 10:22:28 -0700178 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 Gibsonfc14dad2005-06-08 17:18:34 +1000198}
199
David Gibson92cb9a22007-12-04 14:26:15 +1100200struct data data_append_re(struct data d, const struct fdt_reserve_entry *re)
David Gibsonf040d952005-10-24 18:18:38 +1000201{
David Gibsonfb7c7ac2007-09-26 13:11:05 +1000202 struct fdt_reserve_entry bere;
David Gibsonf040d952005-10-24 18:18:38 +1000203
David Gibsonc8c374b2008-06-25 14:27:53 +1000204 bere.address = cpu_to_fdt64(re->address);
205 bere.size = cpu_to_fdt64(re->size);
David Gibsonf040d952005-10-24 18:18:38 +1000206
207 return data_append_data(d, &bere, sizeof(bere));
208}
209
Anton Staafa4b515c2011-10-11 10:22:28 -0700210struct data data_append_cell(struct data d, cell_t word)
211{
212 return data_append_integer(d, word, sizeof(word) * 8);
213}
214
David Gibson53359012008-06-25 13:53:07 +1000215struct data data_append_addr(struct data d, uint64_t addr)
David Gibsonf0517db2005-07-15 17:14:24 +1000216{
Anton Staafa4b515c2011-10-11 10:22:28 -0700217 return data_append_integer(d, addr, sizeof(addr) * 8);
David Gibsonf0517db2005-07-15 17:14:24 +1000218}
219
David Gibsonfc14dad2005-06-08 17:18:34 +1000220struct data data_append_byte(struct data d, uint8_t byte)
221{
222 return data_append_data(d, &byte, 1);
223}
224
225struct 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
234struct 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
David Gibsondc941772007-11-22 14:39:23 +1100240struct data data_add_marker(struct data d, enum markertype type, char *ref)
David Gibson81f2e892005-06-16 17:04:00 +1000241{
David Gibsondc941772007-11-22 14:39:23 +1100242 struct marker *m;
David Gibson81f2e892005-06-16 17:04:00 +1000243
David Gibsondc941772007-11-22 14:39:23 +1100244 m = xmalloc(sizeof(*m));
245 m->offset = d.len;
246 m->type = type;
247 m->ref = ref;
248 m->next = NULL;
David Gibson81f2e892005-06-16 17:04:00 +1000249
David Gibsondc941772007-11-22 14:39:23 +1100250 return data_append_markers(d, m);
Milton Miller6a99b132007-07-07 01:18:51 -0500251}
252
David Gibson17625372013-10-28 21:06:53 +1100253bool data_is_one_string(struct data d)
David Gibsonfc14dad2005-06-08 17:18:34 +1000254{
255 int i;
256 int len = d.len;
257
258 if (len == 0)
David Gibson17625372013-10-28 21:06:53 +1100259 return false;
David Gibsonfc14dad2005-06-08 17:18:34 +1000260
261 for (i = 0; i < len-1; i++)
262 if (d.val[i] == '\0')
David Gibson17625372013-10-28 21:06:53 +1100263 return false;
David Gibsonfc14dad2005-06-08 17:18:34 +1000264
265 if (d.val[len-1] != '\0')
David Gibson17625372013-10-28 21:06:53 +1100266 return false;
David Gibsonfc14dad2005-06-08 17:18:34 +1000267
David Gibson17625372013-10-28 21:06:53 +1100268 return true;
David Gibsonfc14dad2005-06-08 17:18:34 +1000269}