linux-user, arm: add syscall table generation support
[qemu.git] / hw / i386 / pc_sysfw.c
1 /*
2 * QEMU PC System Firmware
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 * Copyright (c) 2011-2012 Intel Corporation
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
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 * We don't have a theoretically justifiable exact lower bound on the base
44 * address of any flash mapping. In practice, the IO-APIC MMIO range is
45 * [0xFEE00000..0xFEE01000] -- see IO_APIC_DEFAULT_ADDRESS --, leaving free
46 * only 18MB-4KB below 4G. For now, restrict the cumulative mapping to 8MB in
47 * size.
48 */
49 #define FLASH_SIZE_LIMIT (8 * MiB)
50
51 #define FLASH_SECTOR_SIZE 4096
52
53 static 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 /* map the last 128KB of the BIOS in ISA space */
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 /* copy ISA rom image from top of flash memory */
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
84 static 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
100 void 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
112 static 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 * Map the pcms->flash[] from 4GiB downward, and realize.
134 * Map them in descending order, i.e. pcms->flash[0] at the top,
135 * without gaps.
136 * Stop at the first pcms->flash[0] lacking a block backend.
137 * Set each flash's size from its block backend. Fatal error if the
138 * size isn't a non-zero multiple of 4KiB, or the total size exceeds
139 * FLASH_SIZE_LIMIT.
140 *
141 * If pcms->flash[0] has a block backend, its memory is passed to
142 * pc_isa_bios_init(). Merging several flash devices for isa-bios is
143 * not supported.
144 */
145 static 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 /* Encrypt the pflash boot ROM */
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
213 void 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 /* Map legacy -drive if=pflash to machine properties */
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 /* Reject gaps */
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 /* Machine property pflash0 not set, use ROM mode */
242 x86_bios_rom_init(rom_memory, false);
243 } else {
244 if (kvm_enabled() && !kvm_readonly_mem_enabled()) {
245 /*
246 * Older KVM cannot execute from device memory. So, flash
247 * memory cannot be used unless the readonly memory kvm
248 * capability is present.
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 }