nes.cpp

#include "openem.h"
#include "cpu/debug/cpudbg.h"
#include "cpu/M65C02/M65C02.h"
#include "arch/nes/ppu.h"
#include "arch/nes/mmc.h"
#include "arch/nes/joypad.h"
#include "arch/nes/nes.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void NES::pass_message(OE_MESSAGE *mes)
{
}

void NES::dumpdebug(void)
{
    // Dump the 6502's debug list
    CPU_DEBUG_LIST *dlist = &m6502.dbg.list;
    char *tr;
    dlist->seek_first();
    if (dlist->getcur() == NULL) return;
    printf("\n");
    for (;;) {
        tr = m6502.debug_str((CPU_M65C02_DEBUG_STATE *)dlist->getcur()->cstate);
        printf("\n%s",tr);
        free(tr);
        dlist->seek_next();
        if (dlist->getcur() == dlist->getlast()) { break; }
    }
    dlist->clear(); 
}

NES *curnes;
// 0x2000-0x3FFF
void writereg(void *ref, dword addr, byte data)
{
    curnes->ppu.writereg(addr,data);
}

byte readreg(void *ref, dword addr)
{
    return curnes->ppu.readreg(addr);
}

// Generic read/write
void write8(void *ref, dword addr, byte data)
{
}

byte read8(void *ref, dword addr)
{
    return 0;
}


// 0x4000-0x5FFF
void writeodd(void *ref, dword addr, byte data)
{
    if (addr == 0x4014)
        curnes->ppu.writereg(addr,data);
    if (addr == 0x4016)
        curnes->jpad1.writereg(data);
    if (addr == 0x4017)
        curnes->jpad2.writereg(data);
}

byte readodd(void *ref, dword addr)
{
    if (addr == 0x4016)
        return curnes->jpad1.readreg();
    if (addr == 0x4017)
        return curnes->jpad2.readreg();
    return 0;
}

// 0x8000-0xFFFF
void writerom(void *ref, dword addr, byte data)
{
}

void NES::reset(void)
{
    m6502.reset();
}

// Draw a frame!
void NES::doframe(void)
{
    curnes = this;
    // Start the frame
    ppu.start_frame();
    uint32 i;
    // Do all scanlines
    for (i = 0; i < 262; i++) {
        ppu.set_scanline(i);
        m6502.NMI = ppu.NMI;
        m6502.cycle(114);       // About 114 cycles per line (113.9, but yeah...)
        ppu.draw_scanline(i);
    }
    // Now end the ppu's frame
    ppu.end_frame();
}

int NES::load_rom(char *fill)
{
    FILE *fil = 0;
    char *yo;
    int er = 0;
    byte *curbank;
    byte mnum;

    yo = (char *)malloc(100);

    fil = fopen(fill,"rb");
    if (!fil) { printf("nofileopen"); er = -1; goto efunc; }

    // Get the NES format descriptor
    fread(yo,1,4,fil);
    if ((*yo != 'N') && (*(yo+1) != 'E') && (*(yo+2) != 'S') && (*(yo+3) != 0x1A)) { printf("wrongfiletype"); er = -2; goto efunc; }

    // Get the number of ROM and VROM banks, then allocate them!
    fread(yo,1,2,fil);
    numrombanks = *yo;
    numvrombanks = *(yo+1);

    romb = (byte *)malloc(0x4000 * numrombanks);
    vromb = (byte *)malloc(0x2000 * numvrombanks);

    // Setup mirroring and stuff!
    fread(yo,1,2,fil);
    if (*yo & 1) { ppu.mirrormode = MIRROR_VERTICAL; } else { ppu.mirrormode = MIRROR_HORIZONTAL; }
    if (*yo & 2) { sram = true; } else { sram = false; }
    if (*yo & 8) { ppu.mirrormode = MIRROR_FOURWAY; }

    mnum = (((*yo) >> 4) << 4) | (*(yo+1));

    // 8 blank bytes
    fread(yo,1,8,fil);

    // Now load program rom
    curbank = romb;
    int i;
    for (i = 0; i < numrombanks; i++) {
        fread(curbank,1,0x4000,fil);
        curbank += 0x4000;
    }

    // Now the vrom...
    curbank = vromb;
    for (i = 0; i < numvrombanks; i++) {
        fread(curbank,1,0x2000,fil);
        curbank += 0x2000;
    }

    // Now map the memory!!!
    curbank = romb;
    if (numrombanks == 1) {
        // 0xC000... mirrors 0x8000-0xC000
        //for (i = 0x80; i < 0xC0; i++) { memp[i] = memp[i+0x40] = curbank; curbank += 0x0100; }
        memcpy((mem+0x8000),romb,0x4000);
        memcpy((mem+0xC000),romb,0x4000);
    }
    else {
        // 0x8000 and 0xC000 are diff.
        //for (i = 0x80; i < 0x100; i++) { memp[i] = curbank; curbank += 0x100; }
        memcpy((mem+0x8000),romb,0x4000);
        memcpy((mem+0xC000),(romb+0x4000),0x4000);
    }

    if (numvrombanks == 1) {
        memcpy(ppu.vram,vromb,0x2000);
    }

    ppu.setmapper();

efunc:
    if (fil) fclose(fil);
    free(yo);
    return er;
}

void NES::init(void)
{
    // Setup the M6502
    m6502.init();                                   // Init it
    m6502.set_mode(M65C02_MODE_2A03, false);        // Set it to be a regular 2A03 w/ no nonstandard-op support

    // Set up the joyapds
    jpad1.set_type(0, NESJTYPE_REGULAR, 1);         // Joypad 1: regular, connected
    jpad2.set_type(1, NESJTYPE_REGULAR, 0);         // Joypad 2: regular, not connected
    // Reserve 64k of memory
    mem = (byte *)malloc(65536);
    ppu.mem = mem;
    ppu.init();
    ppu.mycpu = &m6502;

    curnes = this;                                  // Set memory functions to work for this
    romloaded = false;
    vromyes = false;

    // Set up memory mapping
    m6502.mem.create_pagetable(256,256);    // 256 pages of 256 bytes each
    dword i;

    // Internal RAM mirrored 4 times, read/writeable
    oe_pagetable_ptrtable *calls = m6502.mem.calls;
    OE_PT_FLAG *flags = m6502.mem.flags;
    byte *mptr = mem;
    byte **e = (byte **)m6502.mem.mem;
    // This doens't need a call table
    for (i = 0; i < 0x08; i++) {
        *flags = *(flags+8) = *(flags+16) = *(flags+24) = (OE_PT_FLAG_READABLE | OE_PT_FLAG_WRITEABLE);
        *e = *(e+8) = *(e+16) = *(e+24) = mptr;
        calls->rm8 = (calls+8)->rm8 = (calls+16)->rm8 = (calls+24)->rm8 = &read8;
        calls->wm8 = (calls+8)->wm8 = (calls+16)->wm8 = (calls+24)->wm8 = &write8;
        mptr+=256;
        e++;
        flags++;
        calls++;
    }

    // mptr, flags, and calls are at 0x07 now. We want them at 0x20.
    flags = (m6502.mem.flags+0x20);
    mptr = (mem+(256*0x20));
    e = (byte **)(m6502.mem.mem + 0x20);
    calls = (m6502.mem.calls+0x20);
    // 0x2000 -  0x3FFF: memory-mapped regs every 8 bytes. So, we call regwrite.
    for (i = 0x20; i < 0x40; i++) {
        *flags = 0;                 // We want it to call the function on read AND write
        *e = mptr;                  // Setup what area of memory it is - even though it will NEVER be accessed
        calls->rm8 = &readreg;      // Setup call table
        calls->wm8 = &writereg;     // Setup call table
        mptr+=256;
        e++;
        flags++;
        calls++;
    }

    // 0x4000-0x5FFF: Funky stuff
    for (i = 0x40; i< 0x60; i++) {
        *flags = 0;
        *e = mptr;
        calls->rm8 = &readodd;
        calls->wm8 = &writeodd;
        mptr+=256;
        e++;
        flags++;
        calls++;
    }

    // 0x6000-0x7FFF: SRAM, but for now let's have it access CPU main memory
    for (i = 0x60; i< 0x80; i++) {
        *flags = OE_PT_FLAG_READABLE | OE_PT_FLAG_WRITEABLE;
        *e = mptr;
        calls->rm8 = &read8;
        calls->wm8 = &write8;
        mptr+=256;
        e++;
        flags++;
        calls++;
    }

    // 0x8000-0xFFFF: ROM cartridge. Set it readable (main memory for now - mapper will fix later), but set up the writerom function.
    for (i = 0x80; i< 0x100; i++) {
        *flags = OE_PT_FLAG_READABLE;
        *e = mptr;
        calls->rm8 = &read8;
        calls->wm8 = &writerom;
        mptr+=256;
        e++;
        flags++;
        calls++;
    }

    // Setup MMC
    mmc.myppu = &ppu;

    // Setup memory writes
//  m6502.read_mem8 = readmem;
//  m6502.write_mem8 = writemem;
}

void NES::uninit(void)
{
    free(mem);
    if (vromyes) free(vromb);
    if (romloaded) free(romb);
    ppu.uninit();
}

---