Emulating a BBC Micro

What's a BBC Micro?

• BBC Computer Literacy Project
• 1981

Why me?

Why me?

What's in a BBC Micro?

• 2MHz 6502 CPU
• 32KB RAM / 32KB ROM
• Memory-mapped hardware:
  • Video
  • Sound
  • Tape / floppy disc
  • ADC / Econet / 2nd processor
• Video hardware
  • "Teletext" character map
  • Various bitmap modes up
    • 640x256 in 2-colour
    • 160x256 in 8-colour

What's inside?

Flags

• Z & N set on ALU/load instruction
• C set by shifts & arithmetic
• V set by arithmetic
• D, V, C and I controlled by special instructions

So now we have:

case 0x69: /*ADC #xx*/
    a += readbyte(pc); pc++;
    if (p.c) a++; // previous carry
    p.c = a > 0xff; // new carry
    a &= 0xff;
    p.z = !!a;
    p.n = !!(a & 0x80);
    break;
case 0xb1: /*LDA (xx),Y*/
    zp = readbyte(pc); pc++;
    addr = readbyte(zp) | (readbyte(zp+1)>>8);
    a = readbyte(addr + y);
    p.z = !!a;
    p.n = !!(a & 0x80);
    break;
                         

Memory

var ram = new Uint8Array(0x8000);
var os = load("OS");
var romsel = 0;
var roms = [];
roms[15] = load("BASIC");

function readmem(addr) {
    if (addr < 0x8000) return ram[addr];
    if (addr < 0xc000) return roms[romsel][addr - 0x8000];
    if ((addr >= 0xfe00 && addr < 0xff00)
        || (addr >= 0xfc00 && addr < 0xfd00)) return readhw(addr);
    return os[addr - 0xc000];
}

function writemem(addr, b) {
    if (addr < 0x8000) ram[addr] = b;
    if (addr >= 0xfe00 && addr < 0xff00) writehw(addr, b);
    // else does nothing - it's ROM
}
                         

Hardware

• Keyboard
• I/O & Timers
• Video circuitry

Keyboard

Scanning

function updateKeys() {
    if (freescanning) {
        for (i = 0; i < 10; ++i) {
            for (j = 1; j < 8; ++j) if (keys[i][j]) setca2();
        }
    } else {
        for (j = 1; j < 8; ++j) if (keys[curCol[j]) setca2();
    }
}
                         

I/O & Timers

6522 Versatile Interface Adapter

• Interface with peripherals at 1MHz
• Source of interrupts
• BBC has two VIAs:
  • $fe40-$fe4f System: keyboard, sound, LEDs, system timers
  • $fe60-$fe6f User: printer, user, mouse, user timers
• Each VIA has two timers
• Timers can count down, latch, cause IRQ
• Shift registers for serial

One timer

function tickTimer1() {
    count--;
    if (count == -3 && !suppressed) {
        // Timer fired!
        timerFlags |= T1HIT; // mark we hit in timer flags
        // Send an IRQ if needed
        if (irqEnabled & timerFlags)
            cpu.interrupt();
        // If we're in one-shot mode, prevent further IRQs
        if (!(configFlags & 0x40)) suppressed = true;
    }
    // Reload timer value
    if (count == 3) count += latch + 4;
}
                         

Video interface

• Pixel generator shares RAM with CPU
• Video has 12 registers
  • Screen mem addr
  • Number of colours
  • Resolution, etc
• $fe00 - register select
• $fe01 - register value

Interrupts & Timing

• 2MHz clock
• So emulate 2,000,000 cycles per second
• Intructions take different times:

  
  LDA #42         ; 2 cycles
  LDA &70         ; 3 cycles
  LDA &1234       ; 4 cycles
  LDA (&70), Y    ; 5-6 cycles
  INC &1234, X    ; 7 cycles
                           

• Interrupts checked at instruction end

Our code now looks like

function runCpu(clocks) {
    while (clocks > 0) {
        var opcode = readbyte(pc); pc++;
        switch (opcode) {
            case 0xb1: /*LDA (xx),Y*/
                zp = readbyte(pc); pc++;
                addr = readbyte(zp) | (readbyte(zp+1)>>8);
                a = readbyte(addr + y);
                p.z = !!a; p.n = !!(a & 0x80);
                clocks -= 5;
                break;
            // ...and other opcodes...
        }
        if (irqFlag && p.i == false) {
            pc = irqHandler;  // ...and much more...
        }
    }
}
                     

But!

• More complicated than that!
• Mid-instruction reads...
• Multiple reads and redundant writes
• IRQs actually checked on penultimate cycle
• 1MHz bus cycle-stretching
• ...probably too much to cover here

Real implementation

• Many similar opcodes
• Similar addressing modes
• Code generate from disassembly table:

var opcodes6502 = {
    0x00: "BRK",
    0x01: "ORA (,x)",
    0x03: "SLO (,x)",
    0x04: "NOP zp",
    0x05: "ORA zp",
    // skipping a few...
    0xFD: "SBC abs,x",
    0xFE: "INC abs,x",
    0xFF: "ISB abs,x",
};
                     

High-level code - 'op'

function getOp(op) {
    switch (op) {
        case "NOP": return { op: [] }
        case "LDA": return { op: ["cpu.a = REG", "cpu.setzn(REG);"], read: true }
        case "STA": return { op: ["REG = cpu.a"], write: true }
        case "LDX": return { op: ["cpu.x = REG", "cpu.setzn(REG);"], read: true }
        //...
        case "INC": return {
            op: ["REG = (REG + 1) & 0xff;", "cpu.setzn(REG);" ],
            read: true, write: true
        };
        //...
    }
}
                         

High-level code - addressing mode

function gen(op, addrMode) {
    var ig = InstructionGen();
    var op = getOp(op);
    switch (addrMode) {
        case "abs":
            ig.tick(3);
            ig.append("var addr = cpu.getw();");
            if (op.read) {
                ig.readOp("addr", "REG");
                if (op.write) ig.writeOp("addr", "REG"); // spurious write
            }
            ig.append(op.op);
            if (op.write ig.writeOp("addr", "REG");
            return ig.render();
        //...
    }
}
                         

InstructionGen

• Knows about weird memory rules
• Schedules "ticks"
• Optimizes
• Renders as Javascript source

INC abs

var REG = 0|0;
var addr = cpu.getw();
cpu.polltimeAddr(4, addr);
REG = cpu.readmem(addr);
cpu.polltimeAddr(1, addr);
cpu.checkInt();
cpu.writemem(addr, REG);
REG = (REG + 1) & 0xff;
cpu.setzn(REG);
cpu.polltimeAddr(1, addr);
cpu.writemem(addr, REG);
                         

Emulating the video

• Co-routine with processor
• Every clock cycle:
  • reads one byte of RAM
  • generate 8 TV pixels based on settings
• Generate IRQs at top of screen

Something like

scrx += 8;
var b = readbyte(addr++);
var offset = scry * 1280 + scrx;
for (var i = 0; i < 8; ++i) {
    fb32[offset + i] = convertPixel(b, i);
}
if (scrx >= curEndPos) {
    scrx = curStartPos;
    scry ++;
    if (scry >= numLines) {
        scry = 0;
        generateIrq();
    }
}
                         

Image processing

• Real BBC usually hooked to a TV
• Blur image on blit to canvas
• Interlace

Misc stuff

Performance

• switch problems
• Dynamic dispatch
• Loop unrolling for video
• Uint32Array for screen

More stuff

• Exact timing
• Undocumented opcodes
• People are more crazy than me...

Worth it!

Also finally hacked Lunar Jetman

Any questions?

• http://bbc.godbolt.org/
• Source on github
• http://visual6502.org/