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