gbammu.cpp

一个任天堂掌上游戏机NDS的源代码

/**************************************************************************
* DSemu - The Next Generation                                             *
* GBA memory management: Plugin implementation [gbammu.cpp]               *
* Copyright Imran Nazar, 2005; released under the BSD public licence.     *
**************************************************************************/

#include <string>
#include <fstream>
#include "defs.h"
#include "gbammu.h"
#include "plgcpu.h"
#include "config.h"
#include "log.h"
#include "err.h"
#include "font5x7.h"
#include "byteswap.h"

//---Static private class members------------------------------------------
// Every plugin has an INFO structure attached, with info about the plugin.

PLUGININFO gbaMMU::pInfo={
    PLUGIN_TYPE_MMU,
    0x00010001,
    "GBA memory manager",
    "DSemu-ng"
};

u8  *gbaMMU::EWRAM , *gbaMMU::IWRAM , *gbaMMU::BIOS , *gbaMMU::ROM ;
u16 *gbaMMU::EWRAMh, *gbaMMU::IWRAMh, *gbaMMU::BIOSh, *gbaMMU::ROMh;
u32 *gbaMMU::EWRAMw, *gbaMMU::IWRAMw, *gbaMMU::BIOSw, *gbaMMU::ROMw;

std::string gbaMMU::pluginName;

GUIPlugin *gbaMMU::GUI=NULL;
CPUPlugin *gbaMMU::CPU=NULL;

int gbaMMU::dmpwinID;
u32 *gbaMMU::dmpbuffer;
u32 gbaMMU::dmpaddr = 0x04000000;

gbaMMU::PAGE gbaMMU::mmioPages[256];
gbaMMU::IOREG gbaMMU::interruptIO[4];

u32 gbaMMU::ROMsize;
u32 gbaMMU::BIOSsize;

int gbaMMU::waitSRAM, gbaMMU::waitROM0;
int gbaMMU::waitROM1, gbaMMU::waitROM2;
int gbaMMU::waitROM0s, gbaMMU::waitROM1s, gbaMMU::waitROM2s;
u32 gbaMMU::prevROMaddr;

// Pointer to the DMA subhandler
gbaMMU::DMA *gbaMMU::dma=NULL;

//---Implementation--------------------------------------------------------

// Load a binary
void gbaMMU::load(std::string fname)
{
    std::ifstream input(fname.c_str(), std::ios::binary);

    input.seekg(0, std::ios::end);
    ROMsize = input.tellg();
    input.seekg(0, std::ios::beg);
    
    ROM = new u8[nlpo2(ROMsize)];
    if(!ROM)
        throw Exception(ERR_MMU_INIT, pName,
                        "Allocation of ROM space failed.");
    ROMh=(u16*)ROM;
    ROMw=(u32*)ROM;
    
    input.read((char*)ROM, ROMsize);
    input.close();
    
    ROMsize = nlpo2(ROMsize)-1;
    
    Logger::log(pName) << fname << " (" << ROMsize+1 <<" bytes) loaded.";
/*
    char str[256];
    for(int i=0; i<ROMsize; i+=16)
    {
	str[0] = '\0';
	for(int j=0; j<16; j+=4)
            sprintf(str, "%s%08X ", str, ROMw[(i+j)>>2]);
	Logger::log(pName) << str;
    }
*/

    // Register with the I/O functions
    for(int i=0; i<96; ++i)
        rangeReg(0x80+i, rdB_ROM, rdH_ROM, rdW_ROM, wrB_BAD, wrH_BAD, wrW_BAD);
}

// Switch privilege levels (totally ignored in GBA's MMU)
void gbaMMU::priv(u8 level) { }

void gbaMMU::waitstates(u16 r)
{
    switch(r&0x0003)
    {
	case 0: waitSRAM=4; break; case 1: waitSRAM=3; break;
	case 2: waitSRAM=2; break; case 3: waitSRAM=8; break;
    }
    switch(r&0x000C)
    {
	case 0x0000: waitROM0=4; break; case 0x0004: waitROM0=3; break;
	case 0x0008: waitROM0=2; break; case 0x000C: waitROM0=8; break;
    }
    waitROM0s=(r&0x0010)?1:2;
    switch(r&0x0060)
    {
	case 0x0000: waitROM1=4; break; case 0x0020: waitROM1=3; break;
	case 0x0040: waitROM1=2; break; case 0x0060: waitROM1=8; break;
    }
    waitROM1s=(r&0x0080)?1:4;
    switch(r&0x0300)
    {
	case 0x0000: waitROM2=4; break; case 0x0100: waitROM2=3; break;
	case 0x0200: waitROM2=2; break; case 0x0300: waitROM2=8; break;
    }
    waitROM2s=(r&0x0400)?1:8;
    prevROMaddr=0;
}

// NOTE: The MMU works by splitting the address space into pages, each of
// which may be assigned a set of access handlers. The default handlers
// simply signal an unknown access; these are overwritten if a plugin
// wants to do something interesting.

// Register a range (set the pagetable entry)
void gbaMMU::rangeReg(u8 page, rdBptr _rdB, rdHptr _rdH, rdWptr _rdW,
                               wrBptr _wrB, wrHptr _wrH, wrWptr _wrW)
{
    if(!pagetable[page].set)
    {
        if(_rdB) pagetable[page].rdB=_rdB;
        if(_rdH) pagetable[page].rdH=_rdH;
        if(_rdW) pagetable[page].rdW=_rdW;
        if(_wrB) pagetable[page].wrB=_wrB;
        if(_wrH) pagetable[page].wrH=_wrH;
        if(_wrW) pagetable[page].wrW=_wrW;
	pagetable[page].set = 1;
    }
}

// Wrappers for the pagetable entry for a given address
// NOTE: Endianness is automatically adjusted between host and emulation
u8 gbaMMU::rdB(u32 addr) { return pagetable[PAGE_INDEX].rdB(addr); }
u16 gbaMMU::rdH(u32 addr){ return mtohs(pagetable[PAGE_INDEX].rdH(addr)); }
u32 gbaMMU::rdW(u32 addr){ return mtohl(pagetable[PAGE_INDEX].rdW(addr)); }

void gbaMMU::wrB(u32 addr, u8 data) { pagetable[PAGE_INDEX].wrB(addr, data); }
void gbaMMU::wrH(u32 addr, u16 data){ pagetable[PAGE_INDEX].wrH(addr, htoms(data)); }
void gbaMMU::wrW(u32 addr, u32 data){ pagetable[PAGE_INDEX].wrW(addr, htoml(data)); }

// Region-specific I/O
// NOTE: The BIOS and ROM are (of course) non-writable
u8  gbaMMU::rdB_EWRAM(u32 addr) { CPU->clockAdd(2); return EWRAM [(addr&0x0003FFFF)   ]; }
u16 gbaMMU::rdH_EWRAM(u32 addr) { CPU->clockAdd(2); return EWRAMh[(addr&0x0003FFFF)>>1]; }
u32 gbaMMU::rdW_EWRAM(u32 addr) { CPU->clockAdd(5); return EWRAMw[(addr&0x0003FFFF)>>2]; }
u8  gbaMMU::rdB_IWRAM(u32 addr) { return IWRAM [(addr&0x00007FFF)   ]; }
u16 gbaMMU::rdH_IWRAM(u32 addr) { return IWRAMh[(addr&0x00007FFF)>>1]; }
u32 gbaMMU::rdW_IWRAM(u32 addr) { return IWRAMw[(addr&0x00007FFF)>>2]; }
u8  gbaMMU::rdB_BIOS (u32 addr) { return BIOS  [(addr&BIOSsize  )   ]; }
u16 gbaMMU::rdH_BIOS (u32 addr) { return BIOSh [(addr&BIOSsize  )>>1]; }
u32 gbaMMU::rdW_BIOS (u32 addr) { return BIOSw [(addr&BIOSsize  )>>2]; }

u8  gbaMMU::rdB_ROM  (u32 addr)
{
    switch(addr&0x0E000000)
    {
	case 0x08000000: CPU->clockAdd((addr==(prevROMaddr+1))?waitROM0s:waitROM0); break;
	case 0x0A000000: CPU->clockAdd((addr==(prevROMaddr+1))?waitROM1s:waitROM1); break;
	case 0x0C000000: CPU->clockAdd((addr==(prevROMaddr+1))?waitROM2s:waitROM2); break;
    }
    prevROMaddr=addr;
    return ROM   [(addr&ROMsize   )   ];
}

u16 gbaMMU::rdH_ROM  (u32 addr)
{
    switch(addr&0x0E000000)
    {
	case 0x08000000: CPU->clockAdd((addr==(prevROMaddr+2))?waitROM0s:waitROM0); break;
	case 0x0A000000: CPU->clockAdd((addr==(prevROMaddr+2))?waitROM1s:waitROM1); break;
	case 0x0C000000: CPU->clockAdd((addr==(prevROMaddr+2))?waitROM2s:waitROM2); break;
    }
    prevROMaddr=addr;
    return ROMh  [(addr&ROMsize   )>>1];
}

u32 gbaMMU::rdW_ROM  (u32 addr)
{
    switch(addr&0x0E000000)
    {
	case 0x08000000: CPU->clockAdd((addr==(prevROMaddr+4))?waitROM0s+3:waitROM0+3); break;
	case 0x0A000000: CPU->clockAdd((addr==(prevROMaddr+4))?waitROM1s+3:waitROM1+3); break;
	case 0x0C000000: CPU->clockAdd((addr==(prevROMaddr+4))?waitROM2s+3:waitROM2+3); break;
    }
    prevROMaddr=addr;
    return ROMw  [(addr&ROMsize   )>>2];
}

void gbaMMU::wrB_EWRAM(u32 a, u8  d) { CPU->clockAdd(2); EWRAM [(a&0x0003FFFF)   ]=d; }
void gbaMMU::wrH_EWRAM(u32 a, u16 d) { CPU->clockAdd(2); EWRAMh[(a&0x0003FFFF)>>1]=d; }
void gbaMMU::wrW_EWRAM(u32 a, u32 d) { CPU->clockAdd(5); EWRAMw[(a&0x0003FFFF)>>2]=d; }
void gbaMMU::wrB_IWRAM(u32 a, u8  d) { IWRAM [(a&0x00007FFF)   ]=d; }
void gbaMMU::wrH_IWRAM(u32 a, u16 d) { IWRAMh[(a&0x00007FFF)>>1]=d; }
void gbaMMU::wrW_IWRAM(u32 a, u32 d) { IWRAMw[(a&0x00007FFF)>>2]=d; }
void gbaMMU::wrB_BIOS (u32 a, u8  d) { }
void gbaMMU::wrH_BIOS (u32 a, u16 d) { }
void gbaMMU::wrW_BIOS (u32 a, u32 d) { }
void gbaMMU::wrB_ROM  (u32 a, u8  d) { }
void gbaMMU::wrH_ROM  (u32 a, u16 d) { }
void gbaMMU::wrW_ROM  (u32 a, u32 d) { }

// Default pagetable entries (signal that something bad happened)
u8 gbaMMU::rdB_BAD(u32 a)
{
    char str[128];
    sprintf(str, "Bad access: rdB %08X", a);
//    Logger::log(pluginName) << str;
    return 0;
}

u16 gbaMMU::rdH_BAD(u32 a)
{
    char str[128];
    sprintf(str, "Bad access: rdH %08X", a);
//    Logger::log(pluginName) << str;
    return 0;
}

u32 gbaMMU::rdW_BAD(u32 a)
{
    char str[128];
    sprintf(str, "Bad access: rdW %08X", a);
//    Logger::log(pluginName) << str;
    return 0;
}

void gbaMMU::wrB_BAD(u32 a, u8 d)
{
    char str[128];
    sprintf(str, "Bad access: wrB %08X, %02X", a, d);
    Logger::log(pluginName) << str;
}

void gbaMMU::wrH_BAD(u32 a, u16 d)
{
    char str[128];
    sprintf(str, "Bad access: wrH %08X, %04X", a, d);
    Logger::log(pluginName) << str;
}

void gbaMMU::wrW_BAD(u32 a, u32 d)
{
    char str[128];
    sprintf(str, "Bad access: wrW %08X, %08X", a, d);
    Logger::log(pluginName) << str;
}

// Memory-mapped I/O registration. This works similarly to main memory,
// by paging the space. Of course, each page is much smaller.

void gbaMMU::mmioReg(u8 page, rdBptr _rdB, rdHptr _rdH, rdWptr _rdW,
                              wrBptr _wrB, wrHptr _wrH, wrWptr _wrW)
{
    if(!mmioPages[page].set)
    {
        if(_rdB) mmioPages[page].rdB=_rdB;
        if(_rdH) mmioPages[page].rdH=_rdH;
        if(_rdW) mmioPages[page].rdW=_rdW;
        if(_wrB) mmioPages[page].wrB=_wrB;