86Box/src/mem/smram.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;
}