1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27#include "qemu-common.h"
28#include "qapi/error.h"
29#include "sysemu/block-backend.h"
30#include "qemu/error-report.h"
31#include "qemu/option.h"
32#include "qemu/units.h"
33#include "hw/sysbus.h"
34#include "hw/hw.h"
35#include "hw/i386/pc.h"
36#include "hw/boards.h"
37#include "hw/loader.h"
38#include "sysemu/sysemu.h"
39#include "hw/block/flash.h"
40#include "sysemu/kvm.h"
41
42#define BIOS_FILENAME "bios.bin"
43
44
45
46
47
48
49
50
51#define FLASH_SIZE_LIMIT (8 * MiB)
52
53#define FLASH_SECTOR_SIZE 4096
54
55static void pc_isa_bios_init(MemoryRegion *rom_memory,
56 MemoryRegion *flash_mem,
57 int ram_size)
58{
59 int isa_bios_size;
60 MemoryRegion *isa_bios;
61 uint64_t flash_size;
62 void *flash_ptr, *isa_bios_ptr;
63
64 flash_size = memory_region_size(flash_mem);
65
66
67 isa_bios_size = MIN(flash_size, 128 * KiB);
68 isa_bios = g_malloc(sizeof(*isa_bios));
69 memory_region_init_ram(isa_bios, NULL, "isa-bios", isa_bios_size,
70 &error_fatal);
71 memory_region_add_subregion_overlap(rom_memory,
72 0x100000 - isa_bios_size,
73 isa_bios,
74 1);
75
76
77 flash_ptr = memory_region_get_ram_ptr(flash_mem);
78 isa_bios_ptr = memory_region_get_ram_ptr(isa_bios);
79 memcpy(isa_bios_ptr,
80 ((uint8_t*)flash_ptr) + (flash_size - isa_bios_size),
81 isa_bios_size);
82
83 memory_region_set_readonly(isa_bios, true);
84}
85
86static PFlashCFI01 *pc_pflash_create(PCMachineState *pcms,
87 const char *name,
88 const char *alias_prop_name)
89{
90 DeviceState *dev = qdev_create(NULL, TYPE_PFLASH_CFI01);
91
92 qdev_prop_set_uint64(dev, "sector-length", FLASH_SECTOR_SIZE);
93 qdev_prop_set_uint8(dev, "width", 1);
94 qdev_prop_set_string(dev, "name", name);
95 object_property_add_child(OBJECT(pcms), name, OBJECT(dev),
96 &error_abort);
97 object_property_add_alias(OBJECT(pcms), alias_prop_name,
98 OBJECT(dev), "drive", &error_abort);
99 return PFLASH_CFI01(dev);
100}
101
102void pc_system_flash_create(PCMachineState *pcms)
103{
104 PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
105
106 if (pcmc->pci_enabled) {
107 pcms->flash[0] = pc_pflash_create(pcms, "system.flash0",
108 "pflash0");
109 pcms->flash[1] = pc_pflash_create(pcms, "system.flash1",
110 "pflash1");
111 }
112}
113
114static void pc_system_flash_cleanup_unused(PCMachineState *pcms)
115{
116 char *prop_name;
117 int i;
118 Object *dev_obj;
119
120 assert(PC_MACHINE_GET_CLASS(pcms)->pci_enabled);
121
122 for (i = 0; i < ARRAY_SIZE(pcms->flash); i++) {
123 dev_obj = OBJECT(pcms->flash[i]);
124 if (!object_property_get_bool(dev_obj, "realized", &error_abort)) {
125 prop_name = g_strdup_printf("pflash%d", i);
126 object_property_del(OBJECT(pcms), prop_name, &error_abort);
127 g_free(prop_name);
128 object_unparent(dev_obj);
129 pcms->flash[i] = NULL;
130 }
131 }
132}
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147static void pc_system_flash_map(PCMachineState *pcms,
148 MemoryRegion *rom_memory)
149{
150 hwaddr total_size = 0;
151 int i;
152 BlockBackend *blk;
153 int64_t size;
154 PFlashCFI01 *system_flash;
155 MemoryRegion *flash_mem;
156 void *flash_ptr;
157 int ret, flash_size;
158
159 assert(PC_MACHINE_GET_CLASS(pcms)->pci_enabled);
160
161 for (i = 0; i < ARRAY_SIZE(pcms->flash); i++) {
162 system_flash = pcms->flash[i];
163 blk = pflash_cfi01_get_blk(system_flash);
164 if (!blk) {
165 break;
166 }
167 size = blk_getlength(blk);
168 if (size < 0) {
169 error_report("can't get size of block device %s: %s",
170 blk_name(blk), strerror(-size));
171 exit(1);
172 }
173 if (size == 0 || size % FLASH_SECTOR_SIZE != 0) {
174 error_report("system firmware block device %s has invalid size "
175 "%" PRId64,
176 blk_name(blk), size);
177 info_report("its size must be a non-zero multiple of 0x%x",
178 FLASH_SECTOR_SIZE);
179 exit(1);
180 }
181 if ((hwaddr)size != size
182 || total_size > HWADDR_MAX - size
183 || total_size + size > FLASH_SIZE_LIMIT) {
184 error_report("combined size of system firmware exceeds "
185 "%" PRIu64 " bytes",
186 FLASH_SIZE_LIMIT);
187 exit(1);
188 }
189
190 total_size += size;
191 qdev_prop_set_uint32(DEVICE(system_flash), "num-blocks",
192 size / FLASH_SECTOR_SIZE);
193 qdev_init_nofail(DEVICE(system_flash));
194 sysbus_mmio_map(SYS_BUS_DEVICE(system_flash), 0,
195 0x100000000ULL - total_size);
196
197 if (i == 0) {
198 flash_mem = pflash_cfi01_get_memory(system_flash);
199 pc_isa_bios_init(rom_memory, flash_mem, size);
200
201
202 if (kvm_memcrypt_enabled()) {
203 flash_ptr = memory_region_get_ram_ptr(flash_mem);
204 flash_size = memory_region_size(flash_mem);
205 ret = kvm_memcrypt_encrypt_data(flash_ptr, flash_size);
206 if (ret) {
207 error_report("failed to encrypt pflash rom");
208 exit(1);
209 }
210 }
211 }
212 }
213}
214
215static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw)
216{
217 char *filename;
218 MemoryRegion *bios, *isa_bios;
219 int bios_size, isa_bios_size;
220 int ret;
221
222
223 if (bios_name == NULL) {
224 bios_name = BIOS_FILENAME;
225 }
226 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
227 if (filename) {
228 bios_size = get_image_size(filename);
229 } else {
230 bios_size = -1;
231 }
232 if (bios_size <= 0 ||
233 (bios_size % 65536) != 0) {
234 goto bios_error;
235 }
236 bios = g_malloc(sizeof(*bios));
237 memory_region_init_ram(bios, NULL, "pc.bios", bios_size, &error_fatal);
238 if (!isapc_ram_fw) {
239 memory_region_set_readonly(bios, true);
240 }
241 ret = rom_add_file_fixed(bios_name, (uint32_t)(-bios_size), -1);
242 if (ret != 0) {
243 bios_error:
244 fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name);
245 exit(1);
246 }
247 g_free(filename);
248
249
250 isa_bios_size = MIN(bios_size, 128 * KiB);
251 isa_bios = g_malloc(sizeof(*isa_bios));
252 memory_region_init_alias(isa_bios, NULL, "isa-bios", bios,
253 bios_size - isa_bios_size, isa_bios_size);
254 memory_region_add_subregion_overlap(rom_memory,
255 0x100000 - isa_bios_size,
256 isa_bios,
257 1);
258 if (!isapc_ram_fw) {
259 memory_region_set_readonly(isa_bios, true);
260 }
261
262
263 memory_region_add_subregion(rom_memory,
264 (uint32_t)(-bios_size),
265 bios);
266}
267
268void pc_system_firmware_init(PCMachineState *pcms,
269 MemoryRegion *rom_memory)
270{
271 PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
272 int i;
273 BlockBackend *pflash_blk[ARRAY_SIZE(pcms->flash)];
274
275 if (!pcmc->pci_enabled) {
276 old_pc_system_rom_init(rom_memory, true);
277 return;
278 }
279
280
281 for (i = 0; i < ARRAY_SIZE(pcms->flash); i++) {
282 pflash_cfi01_legacy_drive(pcms->flash[i],
283 drive_get(IF_PFLASH, 0, i));
284 pflash_blk[i] = pflash_cfi01_get_blk(pcms->flash[i]);
285 }
286
287
288 for (i = 1; i < ARRAY_SIZE(pcms->flash); i++) {
289 if (pflash_blk[i] && !pflash_blk[i - 1]) {
290 error_report("pflash%d requires pflash%d", i, i - 1);
291 exit(1);
292 }
293 }
294
295 if (!pflash_blk[0]) {
296
297 old_pc_system_rom_init(rom_memory, false);
298 } else {
299 if (kvm_enabled() && !kvm_readonly_mem_enabled()) {
300
301
302
303
304
305 error_report("pflash with kvm requires KVM readonly memory support");
306 exit(1);
307 }
308
309 pc_system_flash_map(pcms, rom_memory);
310 }
311
312 pc_system_flash_cleanup_unused(pcms);
313}
314