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/i386/x86.h"
35#include "hw/i386/pc.h"
36#include "hw/loader.h"
37#include "hw/qdev-properties.h"
38#include "sysemu/sysemu.h"
39#include "hw/block/flash.h"
40#include "sysemu/kvm.h"
41
42
43
44
45
46
47
48
49#define FLASH_SIZE_LIMIT (8 * MiB)
50
51#define FLASH_SECTOR_SIZE 4096
52
53static void pc_isa_bios_init(MemoryRegion *rom_memory,
54 MemoryRegion *flash_mem,
55 int ram_size)
56{
57 int isa_bios_size;
58 MemoryRegion *isa_bios;
59 uint64_t flash_size;
60 void *flash_ptr, *isa_bios_ptr;
61
62 flash_size = memory_region_size(flash_mem);
63
64
65 isa_bios_size = MIN(flash_size, 128 * KiB);
66 isa_bios = g_malloc(sizeof(*isa_bios));
67 memory_region_init_ram(isa_bios, NULL, "isa-bios", isa_bios_size,
68 &error_fatal);
69 memory_region_add_subregion_overlap(rom_memory,
70 0x100000 - isa_bios_size,
71 isa_bios,
72 1);
73
74
75 flash_ptr = memory_region_get_ram_ptr(flash_mem);
76 isa_bios_ptr = memory_region_get_ram_ptr(isa_bios);
77 memcpy(isa_bios_ptr,
78 ((uint8_t*)flash_ptr) + (flash_size - isa_bios_size),
79 isa_bios_size);
80
81 memory_region_set_readonly(isa_bios, true);
82}
83
84static PFlashCFI01 *pc_pflash_create(PCMachineState *pcms,
85 const char *name,
86 const char *alias_prop_name)
87{
88 DeviceState *dev = qdev_create(NULL, TYPE_PFLASH_CFI01);
89
90 qdev_prop_set_uint64(dev, "sector-length", FLASH_SECTOR_SIZE);
91 qdev_prop_set_uint8(dev, "width", 1);
92 qdev_prop_set_string(dev, "name", name);
93 object_property_add_child(OBJECT(pcms), name, OBJECT(dev),
94 &error_abort);
95 object_property_add_alias(OBJECT(pcms), alias_prop_name,
96 OBJECT(dev), "drive", &error_abort);
97 return PFLASH_CFI01(dev);
98}
99
100void pc_system_flash_create(PCMachineState *pcms)
101{
102 PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
103
104 if (pcmc->pci_enabled) {
105 pcms->flash[0] = pc_pflash_create(pcms, "system.flash0",
106 "pflash0");
107 pcms->flash[1] = pc_pflash_create(pcms, "system.flash1",
108 "pflash1");
109 }
110}
111
112static void pc_system_flash_cleanup_unused(PCMachineState *pcms)
113{
114 char *prop_name;
115 int i;
116 Object *dev_obj;
117
118 assert(PC_MACHINE_GET_CLASS(pcms)->pci_enabled);
119
120 for (i = 0; i < ARRAY_SIZE(pcms->flash); i++) {
121 dev_obj = OBJECT(pcms->flash[i]);
122 if (!object_property_get_bool(dev_obj, "realized", &error_abort)) {
123 prop_name = g_strdup_printf("pflash%d", i);
124 object_property_del(OBJECT(pcms), prop_name, &error_abort);
125 g_free(prop_name);
126 object_unparent(dev_obj);
127 pcms->flash[i] = NULL;
128 }
129 }
130}
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145static void pc_system_flash_map(PCMachineState *pcms,
146 MemoryRegion *rom_memory)
147{
148 hwaddr total_size = 0;
149 int i;
150 BlockBackend *blk;
151 int64_t size;
152 PFlashCFI01 *system_flash;
153 MemoryRegion *flash_mem;
154 void *flash_ptr;
155 int ret, flash_size;
156
157 assert(PC_MACHINE_GET_CLASS(pcms)->pci_enabled);
158
159 for (i = 0; i < ARRAY_SIZE(pcms->flash); i++) {
160 system_flash = pcms->flash[i];
161 blk = pflash_cfi01_get_blk(system_flash);
162 if (!blk) {
163 break;
164 }
165 size = blk_getlength(blk);
166 if (size < 0) {
167 error_report("can't get size of block device %s: %s",
168 blk_name(blk), strerror(-size));
169 exit(1);
170 }
171 if (size == 0 || size % FLASH_SECTOR_SIZE != 0) {
172 error_report("system firmware block device %s has invalid size "
173 "%" PRId64,
174 blk_name(blk), size);
175 info_report("its size must be a non-zero multiple of 0x%x",
176 FLASH_SECTOR_SIZE);
177 exit(1);
178 }
179 if ((hwaddr)size != size
180 || total_size > HWADDR_MAX - size
181 || total_size + size > FLASH_SIZE_LIMIT) {
182 error_report("combined size of system firmware exceeds "
183 "%" PRIu64 " bytes",
184 FLASH_SIZE_LIMIT);
185 exit(1);
186 }
187
188 total_size += size;
189 qdev_prop_set_uint32(DEVICE(system_flash), "num-blocks",
190 size / FLASH_SECTOR_SIZE);
191 qdev_init_nofail(DEVICE(system_flash));
192 sysbus_mmio_map(SYS_BUS_DEVICE(system_flash), 0,
193 0x100000000ULL - total_size);
194
195 if (i == 0) {
196 flash_mem = pflash_cfi01_get_memory(system_flash);
197 pc_isa_bios_init(rom_memory, flash_mem, size);
198
199
200 if (kvm_memcrypt_enabled()) {
201 flash_ptr = memory_region_get_ram_ptr(flash_mem);
202 flash_size = memory_region_size(flash_mem);
203 ret = kvm_memcrypt_encrypt_data(flash_ptr, flash_size);
204 if (ret) {
205 error_report("failed to encrypt pflash rom");
206 exit(1);
207 }
208 }
209 }
210 }
211}
212
213void pc_system_firmware_init(PCMachineState *pcms,
214 MemoryRegion *rom_memory)
215{
216 PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
217 int i;
218 BlockBackend *pflash_blk[ARRAY_SIZE(pcms->flash)];
219
220 if (!pcmc->pci_enabled) {
221 x86_bios_rom_init(rom_memory, true);
222 return;
223 }
224
225
226 for (i = 0; i < ARRAY_SIZE(pcms->flash); i++) {
227 pflash_cfi01_legacy_drive(pcms->flash[i],
228 drive_get(IF_PFLASH, 0, i));
229 pflash_blk[i] = pflash_cfi01_get_blk(pcms->flash[i]);
230 }
231
232
233 for (i = 1; i < ARRAY_SIZE(pcms->flash); i++) {
234 if (pflash_blk[i] && !pflash_blk[i - 1]) {
235 error_report("pflash%d requires pflash%d", i, i - 1);
236 exit(1);
237 }
238 }
239
240 if (!pflash_blk[0]) {
241
242 x86_bios_rom_init(rom_memory, false);
243 } else {
244 if (kvm_enabled() && !kvm_readonly_mem_enabled()) {
245
246
247
248
249
250 error_report("pflash with kvm requires KVM readonly memory support");
251 exit(1);
252 }
253
254 pc_system_flash_map(pcms, rom_memory);
255 }
256
257 pc_system_flash_cleanup_unused(pcms);
258}
259