408 lines
11 KiB
C
408 lines
11 KiB
C
/*
|
|
* 86Box A hypervisor and IBM PC system emulator that specializes in
|
|
* running old operating systems and software designed for IBM
|
|
* PC systems and compatibles from 1981 through fairly recent
|
|
* system designs based on the PCI bus.
|
|
*
|
|
* This file is part of the 86Box distribution.
|
|
*
|
|
* SMRAM handling.
|
|
*
|
|
* Authors: Miran Grca, <mgrca8@gmail.com>
|
|
*
|
|
* Copyright 2016-2020 Miran Grca.
|
|
*/
|
|
#include <inttypes.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <wchar.h>
|
|
#define HAVE_STDARG_H
|
|
#include <86box/86box.h>
|
|
#include "cpu.h"
|
|
#include "x86_ops.h"
|
|
#include "x86.h"
|
|
#include <86box/config.h>
|
|
#include <86box/io.h>
|
|
#include <86box/mem.h>
|
|
#include <86box/smram.h>
|
|
|
|
static smram_t *base_smram, *last_smram;
|
|
|
|
static uint8_t use_separate_smram = 0;
|
|
static uint8_t smram[0x40000];
|
|
|
|
#ifdef ENABLE_SMRAM_LOG
|
|
int smram_do_log = ENABLE_SMRAM_LOG;
|
|
|
|
static void
|
|
smram_log(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
if (smram_do_log) {
|
|
va_start(ap, fmt);
|
|
pclog_ex(fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
}
|
|
#else
|
|
# define smram_log(fmt, ...)
|
|
#endif
|
|
|
|
static uint8_t
|
|
smram_read(uint32_t addr, void *priv)
|
|
{
|
|
smram_t *dev = (smram_t *) priv;
|
|
uint32_t new_addr = addr - dev->host_base + dev->ram_base;
|
|
|
|
if (new_addr >= (1 << 30))
|
|
return mem_read_ram_2gb(new_addr, priv);
|
|
else if (!use_separate_smram || (new_addr >= 0xa0000))
|
|
return mem_read_ram(new_addr, priv);
|
|
else
|
|
return dev->mapping.exec[addr - dev->host_base];
|
|
}
|
|
|
|
static uint16_t
|
|
smram_readw(uint32_t addr, void *priv)
|
|
{
|
|
smram_t *dev = (smram_t *) priv;
|
|
uint32_t new_addr = addr - dev->host_base + dev->ram_base;
|
|
|
|
if (new_addr >= (1 << 30))
|
|
return mem_read_ram_2gbw(new_addr, priv);
|
|
else if (!use_separate_smram || (new_addr >= 0xa0000))
|
|
return mem_read_ramw(new_addr, priv);
|
|
else
|
|
return *(uint16_t *) &(dev->mapping.exec[addr - dev->host_base]);
|
|
}
|
|
|
|
static uint32_t
|
|
smram_readl(uint32_t addr, void *priv)
|
|
{
|
|
smram_t *dev = (smram_t *) priv;
|
|
uint32_t new_addr = addr - dev->host_base + dev->ram_base;
|
|
|
|
if (new_addr >= (1 << 30))
|
|
return mem_read_ram_2gbl(new_addr, priv);
|
|
else if (!use_separate_smram || (new_addr >= 0xa0000))
|
|
return mem_read_raml(new_addr, priv);
|
|
else
|
|
return *(uint32_t *) &(dev->mapping.exec[addr - dev->host_base]);
|
|
}
|
|
|
|
static void
|
|
smram_write(uint32_t addr, uint8_t val, void *priv)
|
|
{
|
|
smram_t *dev = (smram_t *) priv;
|
|
uint32_t new_addr = addr - dev->host_base + dev->ram_base;
|
|
|
|
if (!use_separate_smram || (new_addr >= 0xa0000))
|
|
mem_write_ram(new_addr, val, priv);
|
|
else
|
|
dev->mapping.exec[addr - dev->host_base] = val;
|
|
}
|
|
|
|
static void
|
|
smram_writew(uint32_t addr, uint16_t val, void *priv)
|
|
{
|
|
smram_t *dev = (smram_t *) priv;
|
|
uint32_t new_addr = addr - dev->host_base + dev->ram_base;
|
|
|
|
if (!use_separate_smram || (new_addr >= 0xa0000))
|
|
mem_write_ramw(new_addr, val, priv);
|
|
else
|
|
*(uint16_t *) &(dev->mapping.exec[addr - dev->host_base]) = val;
|
|
}
|
|
|
|
static void
|
|
smram_writel(uint32_t addr, uint32_t val, void *priv)
|
|
{
|
|
smram_t *dev = (smram_t *) priv;
|
|
uint32_t new_addr = addr - dev->host_base + dev->ram_base;
|
|
|
|
if (!use_separate_smram || (new_addr >= 0xa0000))
|
|
mem_write_raml(new_addr, val, priv);
|
|
else
|
|
*(uint32_t *) &(dev->mapping.exec[addr - dev->host_base]) = val;
|
|
}
|
|
|
|
/* Make a backup copy of host_base and size of all the SMRAM structs, needed so that if
|
|
the SMRAM mappings change while in SMM, they will be recalculated on return. */
|
|
void
|
|
smram_backup_all(void)
|
|
{
|
|
smram_t *temp_smram = base_smram, *next;
|
|
|
|
while (temp_smram != NULL) {
|
|
temp_smram->old_host_base = temp_smram->host_base;
|
|
temp_smram->old_size = temp_smram->size;
|
|
|
|
next = temp_smram->next;
|
|
temp_smram = next;
|
|
}
|
|
}
|
|
|
|
/* Recalculate any mappings, including the backup if returning from SMM. */
|
|
void
|
|
smram_recalc_all(int ret)
|
|
{
|
|
smram_t *temp_smram = base_smram, *next;
|
|
|
|
if (base_smram == NULL)
|
|
return;
|
|
|
|
if (ret) {
|
|
while (temp_smram != NULL) {
|
|
if (temp_smram->old_size != 0x00000000)
|
|
mem_mapping_recalc(temp_smram->old_host_base, temp_smram->old_size);
|
|
temp_smram->old_host_base = temp_smram->old_size = 0x00000000;
|
|
|
|
next = temp_smram->next;
|
|
temp_smram = next;
|
|
}
|
|
}
|
|
|
|
temp_smram = base_smram;
|
|
|
|
while (temp_smram != NULL) {
|
|
if (temp_smram->size != 0x00000000)
|
|
mem_mapping_recalc(temp_smram->host_base, temp_smram->size);
|
|
|
|
next = temp_smram->next;
|
|
temp_smram = next;
|
|
}
|
|
|
|
flushmmucache();
|
|
}
|
|
|
|
/* Delete a SMRAM mapping. */
|
|
void
|
|
smram_del(smram_t *smr)
|
|
{
|
|
/* Do a sanity check */
|
|
if ((base_smram == NULL) && (last_smram != NULL)) {
|
|
fatal("smram_del(): NULL base SMRAM with non-NULL last SMRAM\n");
|
|
return;
|
|
} else if ((base_smram != NULL) && (last_smram == NULL)) {
|
|
fatal("smram_del(): Non-NULL base SMRAM with NULL last SMRAM\n");
|
|
return;
|
|
} else if ((base_smram != NULL) && (base_smram->prev != NULL)) {
|
|
fatal("smram_del(): Base SMRAM with a preceding SMRAM\n");
|
|
return;
|
|
} else if ((last_smram != NULL) && (last_smram->next != NULL)) {
|
|
fatal("smram_del(): Last SMRAM with a following SMRAM\n");
|
|
return;
|
|
}
|
|
|
|
if (smr == NULL) {
|
|
fatal("smram_del(): Invalid SMRAM mapping\n");
|
|
return;
|
|
}
|
|
|
|
/* Disable the entry. */
|
|
smram_disable(smr);
|
|
|
|
/* Zap it from the list. */
|
|
if (smr->prev != NULL)
|
|
smr->prev->next = smr->next;
|
|
if (smr->next != NULL)
|
|
smr->next->prev = smr->prev;
|
|
|
|
/* Check if it's the first or the last mapping. */
|
|
if (base_smram == smr)
|
|
base_smram = smr->next;
|
|
if (last_smram == smr)
|
|
last_smram = smr->prev;
|
|
|
|
free(smr);
|
|
}
|
|
|
|
/* Add a SMRAM mapping. */
|
|
smram_t *
|
|
smram_add(void)
|
|
{
|
|
smram_t *temp_smram;
|
|
|
|
/* Do a sanity check */
|
|
if ((base_smram == NULL) && (last_smram != NULL)) {
|
|
fatal("smram_add(): NULL base SMRAM with non-NULL last SMRAM\n");
|
|
return NULL;
|
|
} else if ((base_smram != NULL) && (last_smram == NULL)) {
|
|
fatal("smram_add(): Non-NULL base SMRAM with NULL last SMRAM\n");
|
|
return NULL;
|
|
} else if ((base_smram != NULL) && (base_smram->prev != NULL)) {
|
|
fatal("smram_add(): Base SMRAM with a preceding SMRAM\n");
|
|
return NULL;
|
|
} else if ((last_smram != NULL) && (last_smram->next != NULL)) {
|
|
fatal("smram_add(): Last SMRAM with a following SMRAM\n");
|
|
return NULL;
|
|
}
|
|
|
|
temp_smram = (smram_t *) malloc(sizeof(smram_t));
|
|
if (temp_smram == NULL) {
|
|
fatal("smram_add(): temp_smram malloc failed\n");
|
|
return NULL;
|
|
}
|
|
memset(temp_smram, 0x00, sizeof(smram_t));
|
|
memset(&(temp_smram->mapping), 0x00, sizeof(mem_mapping_t));
|
|
|
|
/* Add struct to the beginning of the list if necessary.*/
|
|
if (base_smram == NULL)
|
|
base_smram = temp_smram;
|
|
|
|
/* Add struct to the end of the list.*/
|
|
if (last_smram == NULL)
|
|
temp_smram->prev = NULL;
|
|
else {
|
|
temp_smram->prev = last_smram;
|
|
last_smram->next = temp_smram;
|
|
}
|
|
last_smram = temp_smram;
|
|
|
|
mem_mapping_add(&(temp_smram->mapping), 0x00000000, 0x00000000,
|
|
smram_read, smram_readw, smram_readl,
|
|
smram_write, smram_writew, smram_writel,
|
|
ram, MEM_MAPPING_SMRAM, temp_smram);
|
|
|
|
smram_set_separate_smram(0);
|
|
|
|
return temp_smram;
|
|
}
|
|
|
|
/* Set memory state in the specified model (normal or SMM) according to the specified flags,
|
|
separately for bus and CPU. */
|
|
void
|
|
smram_map_ex(int bus, int smm, uint32_t addr, uint32_t size, int is_smram)
|
|
{
|
|
if (bus)
|
|
mem_set_access_smram_bus(smm, addr, size, is_smram);
|
|
else
|
|
mem_set_access_smram_cpu(smm, addr, size, is_smram);
|
|
}
|
|
|
|
/* Set memory state in the specified model (normal or SMM) according to the specified flags. */
|
|
void
|
|
smram_map(int smm, uint32_t addr, uint32_t size, int is_smram)
|
|
{
|
|
smram_map_ex(0, smm, addr, size, is_smram);
|
|
smram_map_ex(1, smm, addr, size, is_smram);
|
|
}
|
|
|
|
/* Disable a specific SMRAM mapping. */
|
|
void
|
|
smram_disable(smram_t *smr)
|
|
{
|
|
if (smr == NULL) {
|
|
fatal("smram_disable(): Invalid SMRAM mapping\n");
|
|
return;
|
|
}
|
|
|
|
if (smr->size != 0x00000000) {
|
|
smram_map(0, smr->host_base, smr->size, 0);
|
|
smram_map(1, smr->host_base, smr->size, 0);
|
|
|
|
smr->host_base = smr->ram_base = 0x00000000;
|
|
smr->size = 0x00000000;
|
|
|
|
mem_mapping_disable(&(smr->mapping));
|
|
}
|
|
}
|
|
|
|
/* Disable all SMRAM mappings. */
|
|
void
|
|
smram_disable_all(void)
|
|
{
|
|
smram_t *temp_smram = base_smram, *next;
|
|
|
|
while (temp_smram != NULL) {
|
|
smram_disable(temp_smram);
|
|
|
|
next = temp_smram->next;
|
|
temp_smram = next;
|
|
}
|
|
}
|
|
|
|
/* Enable SMRAM mappings according to flags for both normal and SMM modes, separately for bus
|
|
and CPU. */
|
|
void
|
|
smram_enable_ex(smram_t *smr, uint32_t host_base, uint32_t ram_base, uint32_t size,
|
|
int flags_normal, int flags_normal_bus, int flags_smm, int flags_smm_bus)
|
|
{
|
|
if (smr == NULL) {
|
|
fatal("smram_add(): Invalid SMRAM mapping\n");
|
|
return;
|
|
}
|
|
|
|
if ((size != 0x00000000) && (flags_normal || flags_smm)) {
|
|
smr->host_base = host_base;
|
|
smr->ram_base = ram_base,
|
|
smr->size = size;
|
|
|
|
mem_mapping_set_addr(&(smr->mapping), smr->host_base, smr->size);
|
|
if (!use_separate_smram || (smr->ram_base >= 0x000a0000)) {
|
|
if (smr->ram_base < (1 << 30))
|
|
mem_mapping_set_exec(&(smr->mapping), ram + smr->ram_base);
|
|
else
|
|
mem_mapping_set_exec(&(smr->mapping), ram2 + smr->ram_base - (1 << 30));
|
|
} else {
|
|
if (smr->ram_base == 0x00030000)
|
|
mem_mapping_set_exec(&(smr->mapping), smram);
|
|
else if (smr->ram_base == 0x00040000)
|
|
mem_mapping_set_exec(&(smr->mapping), smram + 0x10000);
|
|
else if (smr->ram_base == 0x00060000)
|
|
mem_mapping_set_exec(&(smr->mapping), smram + 0x20000);
|
|
else if (smr->ram_base == 0x00070000)
|
|
mem_mapping_set_exec(&(smr->mapping), smram + 0x30000);
|
|
}
|
|
|
|
smram_map_ex(0, 0, host_base, size, flags_normal);
|
|
smram_map_ex(1, 0, host_base, size, flags_normal_bus);
|
|
smram_map_ex(0, 1, host_base, size, flags_smm);
|
|
smram_map_ex(1, 1, host_base, size, flags_smm_bus);
|
|
} else
|
|
smram_disable(smr);
|
|
}
|
|
|
|
/* Enable SMRAM mappings according to flags for both normal and SMM modes. */
|
|
void
|
|
smram_enable(smram_t *smr, uint32_t host_base, uint32_t ram_base, uint32_t size, int flags_normal, int flags_smm)
|
|
{
|
|
smram_enable_ex(smr, host_base, ram_base, size, flags_normal, flags_normal, flags_smm, flags_smm);
|
|
}
|
|
|
|
/* Checks if a SMRAM mapping is enabled or not. */
|
|
int
|
|
smram_enabled(smram_t *smr)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (smr == NULL)
|
|
ret = 0;
|
|
else
|
|
ret = (smr->size != 0x00000000);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Changes the SMRAM state. */
|
|
void
|
|
smram_state_change(smram_t *smr, int smm, int flags)
|
|
{
|
|
if (smr == NULL) {
|
|
fatal("smram_tate_change(): Invalid SMRAM mapping\n");
|
|
return;
|
|
}
|
|
|
|
smram_map(smm, smr->host_base, smr->size, flags);
|
|
}
|
|
|
|
void
|
|
smram_set_separate_smram(uint8_t set)
|
|
{
|
|
use_separate_smram = set;
|
|
}
|