]>
Commit | Line | Data |
---|---|---|
3cce6243 BS |
1 | /* |
2 | * QEMU Firmware configuration device emulation | |
3 | * | |
4 | * Copyright (c) 2008 Gleb Natapov | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | #include "hw.h" | |
084a197a | 25 | #include "sysemu.h" |
3cce6243 BS |
26 | #include "isa.h" |
27 | #include "fw_cfg.h" | |
3a5c16fc | 28 | #include "sysbus.h" |
3cce6243 BS |
29 | |
30 | /* debug firmware config */ | |
31 | //#define DEBUG_FW_CFG | |
32 | ||
33 | #ifdef DEBUG_FW_CFG | |
001faf32 BS |
34 | #define FW_CFG_DPRINTF(fmt, ...) \ |
35 | do { printf("FW_CFG: " fmt , ## __VA_ARGS__); } while (0) | |
3cce6243 | 36 | #else |
001faf32 | 37 | #define FW_CFG_DPRINTF(fmt, ...) |
3cce6243 BS |
38 | #endif |
39 | ||
40 | #define FW_CFG_SIZE 2 | |
41 | ||
b96ae2da | 42 | typedef struct FWCfgEntry { |
ff06108b | 43 | uint32_t len; |
3cce6243 BS |
44 | uint8_t *data; |
45 | void *callback_opaque; | |
46 | FWCfgCallback callback; | |
47 | } FWCfgEntry; | |
48 | ||
b96ae2da | 49 | struct FWCfgState { |
3a5c16fc BS |
50 | SysBusDevice busdev; |
51 | uint32_t ctl_iobase, data_iobase; | |
3cce6243 | 52 | FWCfgEntry entries[2][FW_CFG_MAX_ENTRY]; |
abe147e0 | 53 | FWCfgFiles *files; |
3cce6243 | 54 | uint16_t cur_entry; |
ff06108b | 55 | uint32_t cur_offset; |
c2b5bda4 | 56 | }; |
3cce6243 BS |
57 | |
58 | static void fw_cfg_write(FWCfgState *s, uint8_t value) | |
59 | { | |
60 | int arch = !!(s->cur_entry & FW_CFG_ARCH_LOCAL); | |
61 | FWCfgEntry *e = &s->entries[arch][s->cur_entry & FW_CFG_ENTRY_MASK]; | |
62 | ||
63 | FW_CFG_DPRINTF("write %d\n", value); | |
64 | ||
65 | if (s->cur_entry & FW_CFG_WRITE_CHANNEL && s->cur_offset < e->len) { | |
66 | e->data[s->cur_offset++] = value; | |
67 | if (s->cur_offset == e->len) { | |
68 | e->callback(e->callback_opaque, e->data); | |
69 | s->cur_offset = 0; | |
70 | } | |
71 | } | |
72 | } | |
73 | ||
74 | static int fw_cfg_select(FWCfgState *s, uint16_t key) | |
75 | { | |
76 | int ret; | |
77 | ||
78 | s->cur_offset = 0; | |
79 | if ((key & FW_CFG_ENTRY_MASK) >= FW_CFG_MAX_ENTRY) { | |
80 | s->cur_entry = FW_CFG_INVALID; | |
81 | ret = 0; | |
82 | } else { | |
83 | s->cur_entry = key; | |
84 | ret = 1; | |
85 | } | |
86 | ||
87 | FW_CFG_DPRINTF("select key %d (%sfound)\n", key, ret ? "" : "not "); | |
88 | ||
89 | return ret; | |
90 | } | |
91 | ||
92 | static uint8_t fw_cfg_read(FWCfgState *s) | |
93 | { | |
94 | int arch = !!(s->cur_entry & FW_CFG_ARCH_LOCAL); | |
95 | FWCfgEntry *e = &s->entries[arch][s->cur_entry & FW_CFG_ENTRY_MASK]; | |
96 | uint8_t ret; | |
97 | ||
98 | if (s->cur_entry == FW_CFG_INVALID || !e->data || s->cur_offset >= e->len) | |
99 | ret = 0; | |
100 | else | |
101 | ret = e->data[s->cur_offset++]; | |
102 | ||
103 | FW_CFG_DPRINTF("read %d\n", ret); | |
104 | ||
105 | return ret; | |
106 | } | |
107 | ||
108 | static uint32_t fw_cfg_io_readb(void *opaque, uint32_t addr) | |
109 | { | |
110 | return fw_cfg_read(opaque); | |
111 | } | |
112 | ||
113 | static void fw_cfg_io_writeb(void *opaque, uint32_t addr, uint32_t value) | |
114 | { | |
7442511c | 115 | fw_cfg_write(opaque, (uint8_t)value); |
3cce6243 BS |
116 | } |
117 | ||
118 | static void fw_cfg_io_writew(void *opaque, uint32_t addr, uint32_t value) | |
119 | { | |
120 | fw_cfg_select(opaque, (uint16_t)value); | |
121 | } | |
122 | ||
c227f099 | 123 | static uint32_t fw_cfg_mem_readb(void *opaque, target_phys_addr_t addr) |
3cce6243 BS |
124 | { |
125 | return fw_cfg_read(opaque); | |
126 | } | |
127 | ||
c227f099 | 128 | static void fw_cfg_mem_writeb(void *opaque, target_phys_addr_t addr, |
3cce6243 BS |
129 | uint32_t value) |
130 | { | |
7442511c | 131 | fw_cfg_write(opaque, (uint8_t)value); |
3cce6243 BS |
132 | } |
133 | ||
c227f099 | 134 | static void fw_cfg_mem_writew(void *opaque, target_phys_addr_t addr, |
3cce6243 BS |
135 | uint32_t value) |
136 | { | |
137 | fw_cfg_select(opaque, (uint16_t)value); | |
138 | } | |
139 | ||
d60efc6b | 140 | static CPUReadMemoryFunc * const fw_cfg_ctl_mem_read[3] = { |
3cce6243 BS |
141 | NULL, |
142 | NULL, | |
143 | NULL, | |
144 | }; | |
145 | ||
d60efc6b | 146 | static CPUWriteMemoryFunc * const fw_cfg_ctl_mem_write[3] = { |
3cce6243 BS |
147 | NULL, |
148 | fw_cfg_mem_writew, | |
149 | NULL, | |
150 | }; | |
151 | ||
d60efc6b | 152 | static CPUReadMemoryFunc * const fw_cfg_data_mem_read[3] = { |
3cce6243 BS |
153 | fw_cfg_mem_readb, |
154 | NULL, | |
155 | NULL, | |
156 | }; | |
157 | ||
d60efc6b | 158 | static CPUWriteMemoryFunc * const fw_cfg_data_mem_write[3] = { |
3cce6243 BS |
159 | fw_cfg_mem_writeb, |
160 | NULL, | |
161 | NULL, | |
162 | }; | |
163 | ||
3a5c16fc | 164 | static void fw_cfg_reset(DeviceState *d) |
3cce6243 | 165 | { |
3a5c16fc | 166 | FWCfgState *s = DO_UPCAST(FWCfgState, busdev.qdev, d); |
3cce6243 BS |
167 | |
168 | fw_cfg_select(s, 0); | |
169 | } | |
170 | ||
ff06108b JQ |
171 | /* Save restore 32 bit int as uint16_t |
172 | This is a Big hack, but it is how the old state did it. | |
173 | Or we broke compatibility in the state, or we can't use struct tm | |
174 | */ | |
175 | ||
176 | static int get_uint32_as_uint16(QEMUFile *f, void *pv, size_t size) | |
177 | { | |
178 | uint32_t *v = pv; | |
179 | *v = qemu_get_be16(f); | |
180 | return 0; | |
181 | } | |
182 | ||
183 | static void put_unused(QEMUFile *f, void *pv, size_t size) | |
184 | { | |
66c80e75 | 185 | fprintf(stderr, "uint32_as_uint16 is only used for backward compatibility.\n"); |
ff06108b JQ |
186 | fprintf(stderr, "This functions shouldn't be called.\n"); |
187 | } | |
188 | ||
d05ac8fa | 189 | static const VMStateInfo vmstate_hack_uint32_as_uint16 = { |
ff06108b JQ |
190 | .name = "int32_as_uint16", |
191 | .get = get_uint32_as_uint16, | |
192 | .put = put_unused, | |
193 | }; | |
194 | ||
195 | #define VMSTATE_UINT16_HACK(_f, _s, _t) \ | |
196 | VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_hack_uint32_as_uint16, uint32_t) | |
197 | ||
198 | ||
199 | static bool is_version_1(void *opaque, int version_id) | |
200 | { | |
201 | return version_id == 1; | |
202 | } | |
203 | ||
7d2edd40 JQ |
204 | static const VMStateDescription vmstate_fw_cfg = { |
205 | .name = "fw_cfg", | |
ff06108b | 206 | .version_id = 2, |
7d2edd40 JQ |
207 | .minimum_version_id = 1, |
208 | .minimum_version_id_old = 1, | |
209 | .fields = (VMStateField []) { | |
210 | VMSTATE_UINT16(cur_entry, FWCfgState), | |
ff06108b JQ |
211 | VMSTATE_UINT16_HACK(cur_offset, FWCfgState, is_version_1), |
212 | VMSTATE_UINT32_V(cur_offset, FWCfgState, 2), | |
7d2edd40 JQ |
213 | VMSTATE_END_OF_LIST() |
214 | } | |
215 | }; | |
3cce6243 | 216 | |
c2b5bda4 | 217 | int fw_cfg_add_bytes(FWCfgState *s, uint16_t key, uint8_t *data, uint32_t len) |
3cce6243 | 218 | { |
3cce6243 BS |
219 | int arch = !!(key & FW_CFG_ARCH_LOCAL); |
220 | ||
221 | key &= FW_CFG_ENTRY_MASK; | |
222 | ||
223 | if (key >= FW_CFG_MAX_ENTRY) | |
224 | return 0; | |
225 | ||
226 | s->entries[arch][key].data = data; | |
227 | s->entries[arch][key].len = len; | |
228 | ||
229 | return 1; | |
230 | } | |
231 | ||
c2b5bda4 | 232 | int fw_cfg_add_i16(FWCfgState *s, uint16_t key, uint16_t value) |
3cce6243 BS |
233 | { |
234 | uint16_t *copy; | |
235 | ||
236 | copy = qemu_malloc(sizeof(value)); | |
3cce6243 | 237 | *copy = cpu_to_le16(value); |
c2b5bda4 | 238 | return fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value)); |
3cce6243 BS |
239 | } |
240 | ||
c2b5bda4 | 241 | int fw_cfg_add_i32(FWCfgState *s, uint16_t key, uint32_t value) |
3cce6243 BS |
242 | { |
243 | uint32_t *copy; | |
244 | ||
245 | copy = qemu_malloc(sizeof(value)); | |
3cce6243 | 246 | *copy = cpu_to_le32(value); |
c2b5bda4 | 247 | return fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value)); |
3cce6243 BS |
248 | } |
249 | ||
c2b5bda4 | 250 | int fw_cfg_add_i64(FWCfgState *s, uint16_t key, uint64_t value) |
3cce6243 BS |
251 | { |
252 | uint64_t *copy; | |
253 | ||
254 | copy = qemu_malloc(sizeof(value)); | |
3cce6243 | 255 | *copy = cpu_to_le64(value); |
c2b5bda4 | 256 | return fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value)); |
3cce6243 BS |
257 | } |
258 | ||
c2b5bda4 | 259 | int fw_cfg_add_callback(FWCfgState *s, uint16_t key, FWCfgCallback callback, |
3cce6243 BS |
260 | void *callback_opaque, uint8_t *data, size_t len) |
261 | { | |
3cce6243 BS |
262 | int arch = !!(key & FW_CFG_ARCH_LOCAL); |
263 | ||
85df0de4 BS |
264 | if (!(key & FW_CFG_WRITE_CHANNEL)) |
265 | return 0; | |
266 | ||
3cce6243 BS |
267 | key &= FW_CFG_ENTRY_MASK; |
268 | ||
85df0de4 | 269 | if (key >= FW_CFG_MAX_ENTRY || len > 65535) |
3cce6243 BS |
270 | return 0; |
271 | ||
272 | s->entries[arch][key].data = data; | |
273 | s->entries[arch][key].len = len; | |
274 | s->entries[arch][key].callback_opaque = callback_opaque; | |
275 | s->entries[arch][key].callback = callback; | |
276 | ||
277 | return 1; | |
278 | } | |
279 | ||
abe147e0 GH |
280 | int fw_cfg_add_file(FWCfgState *s, const char *dir, const char *filename, |
281 | uint8_t *data, uint32_t len) | |
282 | { | |
283 | const char *basename; | |
de9352bc | 284 | int i, index; |
abe147e0 GH |
285 | |
286 | if (!s->files) { | |
287 | int dsize = sizeof(uint32_t) + sizeof(FWCfgFile) * FW_CFG_FILE_SLOTS; | |
288 | s->files = qemu_mallocz(dsize); | |
289 | fw_cfg_add_bytes(s, FW_CFG_FILE_DIR, (uint8_t*)s->files, dsize); | |
290 | } | |
291 | ||
292 | index = be32_to_cpu(s->files->count); | |
293 | if (index == FW_CFG_FILE_SLOTS) { | |
294 | fprintf(stderr, "fw_cfg: out of file slots\n"); | |
295 | return 0; | |
296 | } | |
297 | ||
298 | fw_cfg_add_bytes(s, FW_CFG_FILE_FIRST + index, data, len); | |
299 | ||
300 | basename = strrchr(filename, '/'); | |
301 | if (basename) { | |
302 | basename++; | |
303 | } else { | |
304 | basename = filename; | |
305 | } | |
de9352bc GH |
306 | |
307 | snprintf(s->files->f[index].name, sizeof(s->files->f[index].name), | |
308 | "%s/%s", dir, basename); | |
309 | for (i = 0; i < index; i++) { | |
310 | if (strcmp(s->files->f[index].name, s->files->f[i].name) == 0) { | |
311 | FW_CFG_DPRINTF("%s: skip duplicate: %s\n", __FUNCTION__, | |
312 | s->files->f[index].name); | |
313 | return 1; | |
314 | } | |
abe147e0 | 315 | } |
de9352bc | 316 | |
abe147e0 GH |
317 | s->files->f[index].size = cpu_to_be32(len); |
318 | s->files->f[index].select = cpu_to_be16(FW_CFG_FILE_FIRST + index); | |
319 | FW_CFG_DPRINTF("%s: #%d: %s (%d bytes)\n", __FUNCTION__, | |
320 | index, s->files->f[index].name, len); | |
321 | ||
322 | s->files->count = cpu_to_be32(index+1); | |
323 | return 1; | |
324 | } | |
325 | ||
c2b5bda4 GH |
326 | FWCfgState *fw_cfg_init(uint32_t ctl_port, uint32_t data_port, |
327 | target_phys_addr_t ctl_addr, target_phys_addr_t data_addr) | |
3cce6243 | 328 | { |
3a5c16fc BS |
329 | DeviceState *dev; |
330 | SysBusDevice *d; | |
3cce6243 | 331 | FWCfgState *s; |
3cce6243 | 332 | |
3a5c16fc BS |
333 | dev = qdev_create(NULL, "fw_cfg"); |
334 | qdev_prop_set_uint32(dev, "ctl_iobase", ctl_port); | |
335 | qdev_prop_set_uint32(dev, "data_iobase", data_port); | |
336 | qdev_init_nofail(dev); | |
337 | d = sysbus_from_qdev(dev); | |
338 | ||
339 | s = DO_UPCAST(FWCfgState, busdev.qdev, dev); | |
3cce6243 | 340 | |
3cce6243 | 341 | if (ctl_addr) { |
3a5c16fc | 342 | sysbus_mmio_map(d, 0, ctl_addr); |
3cce6243 BS |
343 | } |
344 | if (data_addr) { | |
3a5c16fc | 345 | sysbus_mmio_map(d, 1, data_addr); |
3cce6243 BS |
346 | } |
347 | fw_cfg_add_bytes(s, FW_CFG_SIGNATURE, (uint8_t *)"QEMU", 4); | |
084a197a | 348 | fw_cfg_add_bytes(s, FW_CFG_UUID, qemu_uuid, 16); |
993fbfdb | 349 | fw_cfg_add_i16(s, FW_CFG_NOGRAPHIC, (uint16_t)(display_type == DT_NOGRAPHIC)); |
905fdcb5 | 350 | fw_cfg_add_i16(s, FW_CFG_NB_CPUS, (uint16_t)smp_cpus); |
6be68d7e | 351 | fw_cfg_add_i16(s, FW_CFG_MAX_CPUS, (uint16_t)max_cpus); |
95387491 | 352 | fw_cfg_add_i16(s, FW_CFG_BOOT_MENU, (uint16_t)boot_menu); |
905fdcb5 | 353 | |
3cce6243 BS |
354 | return s; |
355 | } | |
3a5c16fc BS |
356 | |
357 | static int fw_cfg_init1(SysBusDevice *dev) | |
358 | { | |
359 | FWCfgState *s = FROM_SYSBUS(FWCfgState, dev); | |
360 | int io_ctl_memory, io_data_memory; | |
361 | ||
362 | io_ctl_memory = cpu_register_io_memory(fw_cfg_ctl_mem_read, | |
363 | fw_cfg_ctl_mem_write, s); | |
364 | sysbus_init_mmio(dev, FW_CFG_SIZE, io_ctl_memory); | |
365 | ||
366 | io_data_memory = cpu_register_io_memory(fw_cfg_data_mem_read, | |
367 | fw_cfg_data_mem_write, s); | |
368 | sysbus_init_mmio(dev, FW_CFG_SIZE, io_data_memory); | |
369 | ||
370 | if (s->ctl_iobase) { | |
371 | register_ioport_write(s->ctl_iobase, 2, 2, fw_cfg_io_writew, s); | |
372 | } | |
373 | if (s->data_iobase) { | |
374 | register_ioport_read(s->data_iobase, 1, 1, fw_cfg_io_readb, s); | |
375 | register_ioport_write(s->data_iobase, 1, 1, fw_cfg_io_writeb, s); | |
376 | } | |
377 | return 0; | |
378 | } | |
379 | ||
380 | static SysBusDeviceInfo fw_cfg_info = { | |
381 | .init = fw_cfg_init1, | |
382 | .qdev.name = "fw_cfg", | |
383 | .qdev.size = sizeof(FWCfgState), | |
384 | .qdev.vmsd = &vmstate_fw_cfg, | |
385 | .qdev.reset = fw_cfg_reset, | |
386 | .qdev.no_user = 1, | |
387 | .qdev.props = (Property[]) { | |
388 | DEFINE_PROP_HEX32("ctl_iobase", FWCfgState, ctl_iobase, -1), | |
389 | DEFINE_PROP_HEX32("data_iobase", FWCfgState, data_iobase, -1), | |
390 | DEFINE_PROP_END_OF_LIST(), | |
391 | }, | |
392 | }; | |
393 | ||
394 | static void fw_cfg_register_devices(void) | |
395 | { | |
396 | sysbus_register_withprop(&fw_cfg_info); | |
397 | } | |
398 | ||
399 | device_init(fw_cfg_register_devices) |