uint8_t *load_eeprom(void)
{
char *filename;
int fd;
int rc;
int eeprom_file_size;
const int eeprom_size = 256;
uint8_t *eeprom_data = g_malloc(eeprom_size);
const char *eeprom_file = object_property_get_str(qdev_get_machine(),
"eeprom", NULL);
if ((eeprom_file != NULL) && *eeprom_file) {
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, eeprom_file);
assert(filename);
eeprom_file_size = get_image_size(filename);
if (eeprom_size != eeprom_file_size) {
fprintf(stderr,
"qemu: EEPROM file size != %d bytes. (Is %d bytes)\n",
eeprom_size, eeprom_file_size);
g_free(filename);
exit(1);
return NULL;
}
fd = open(filename, O_RDONLY | O_BINARY);
if (fd < 0) {
fprintf(stderr, "qemu: EEPROM file '%s' could not be opened.\n", filename);
g_free(filename);
exit(1);
return NULL;
}
rc = read(fd, eeprom_data, eeprom_size);
if (rc != eeprom_size) {
fprintf(stderr, "qemu: Could not read the full EEPROM file.\n");
close(fd);
g_free(filename);
exit(1);
return NULL;
}
close(fd);
g_free(filename);
} else {
memcpy(eeprom_data, default_eeprom, eeprom_size);
}
return eeprom_data;
}
int s390_ipl_set_loadparm(uint8_t *loadparm)
{
MachineState *machine = MACHINE(qdev_get_machine());
char *lp = object_property_get_str(OBJECT(machine), "loadparm", NULL);
if (lp) {
int i;
/* lp is an uppercase string without leading/embedded spaces */
for (i = 0; i < 8 && lp[i]; i++) {
loadparm[i] = ascii2ebcdic[(uint8_t) lp[i]];
}
g_free(lp);
return 0;
}
return -1;
}
static void xbox_flash_init(MemoryRegion *rom_memory)
{
char *filename;
int bios_size;
int bootrom_size;
MemoryRegion *bios;
MemoryRegion *map_bios;
uint32_t map_loc;
int rc, fd = -1;
char *bios_data;
/* Locate BIOS ROM image */
if (bios_name == NULL) {
bios_name = "bios.bin";
}
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
if (filename) {
bios_size = get_image_size(filename);
} else {
bios_size = -1;
}
if (bios_size <= 0 ||
(bios_size % 65536) != 0) {
goto bios_error;
}
/* Read BIOS ROM into memory */
bios_data = g_malloc(bios_size);
assert(bios_data != NULL);
fd = open(filename, O_RDONLY | O_BINARY);
assert(fd >= 0);
rc = read(fd, bios_data, bios_size);
assert(rc == bios_size);
close(fd);
g_free(filename);
/* XBOX_FIXME: What follows is a big hack to overlay the MCPX ROM on the
* top 512 bytes of the ROM region. This differs from original XQEMU
* sources which copied it in at lpc init; new QEMU seems to be different
* now in that the BIOS images supplied to rom_add_file_fixed will be
* loaded *after* lpc init is called, so the MCPX ROM would get
* overwritten. Instead, let's just map it in right here while we map in
* BIOS.
*
* Anyway it behaves the same as before--that is, wrongly. Really, we
* should let the CPU execute from MMIO emulating the TSOP access with
* bootrom overlay being controlled by the magic bit..but this is "good
* enough" for now ;).
*/
/* Locate and overlay MCPX ROM image into new copy of BIOS if provided */
const char *bootrom_file = object_property_get_str(qdev_get_machine(),
"bootrom", NULL);
if ((bootrom_file != NULL) && *bootrom_file) {
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bootrom_file);
assert(filename);
bootrom_size = get_image_size(filename);
if (bootrom_size != 512) {
fprintf(stderr, "MCPX bootrom should be 512 bytes, got %d\n",
bootrom_size);
exit(1);
return;
}
/* Read in MCPX ROM over last 512 bytes of BIOS data */
fd = open(filename, O_RDONLY | O_BINARY);
assert(fd >= 0);
rc = read(fd, &bios_data[bios_size - bootrom_size], bootrom_size);
assert(rc == bootrom_size);
close(fd);
g_free(filename);
}
/* Create BIOS region */
bios = g_malloc(sizeof(*bios));
assert(bios != NULL);
memory_region_init_ram(bios, NULL, "xbox.bios", bios_size, &error_fatal);
memory_region_set_readonly(bios, true);
rom_add_blob_fixed("xbox.bios", bios_data, bios_size,
(uint32_t)(-2 * bios_size));
/* Assuming bios_data will be needed for duration of execution
* so no free(bios) here.
*/
/* Mirror ROM from 0xff000000 - 0xffffffff */
for (map_loc = (uint32_t)(-bios_size);
map_loc >= 0xff000000;
map_loc -= bios_size) {
map_bios = g_malloc(sizeof(*map_bios));
memory_region_init_alias(map_bios, NULL, "pci-bios", bios, 0, bios_size);
memory_region_add_subregion(rom_memory, map_loc, map_bios);
memory_region_set_readonly(map_bios, true);
}
return;
bios_error:
fprintf(stderr, "qemu: could not load xbox BIOS '%s'\n", bios_name);
exit(1);
}
