// SPDX-License-Identifier: GPL-3.0-or-later #include typedef unsigned char byte; #define WINDOW 0x8000u #define TASK0 ((byte *)0xFFA0) #define CHUNK 32 static byte active; static byte marker; static asm byte lowProgramAndStack(void) { asm { program_end import program_start import s_rodata import l_rodata import s_rwdata import ldx #s_rodata cmpx #program_start blo @no ldx #s_rwdata cmpx #s_rodata+l_rodata blo @no ldx #program_end cmpx #s_rwdata blo @no cmpx #$8000 bhi @no cmps #$8000 bhi @no ldb #1 rts @no clrb } } static asm byte irqEnabled(void) { asm { tfr cc,b bitb #$10 bne @no ldb #1 rts @no clrb } } static asm unsigned programStart(void) { asm { program_start import ldd #program_start } } static asm unsigned writableStart(void) { asm { s_rwdata import ldd #s_rwdata } } // Read back the real MMU register. A NOP ($12) supplies zero high bus bits // on a 128/512 KiB machine, whose register drives only the bottom six bits. static asm byte readPage(const byte *entry) { asm { ldx 2,s ldb ,x nop } } // Prove that task 0 bank 4 can actually select the requested banks. First // read our own low-memory marker through a second address, twice. Then map // the candidate bank and check if changing the marker is visible there. // On 128 KiB, $28 aliases $38 (and $29 aliases $39, etc.). All writes in // this probe go to our own byte, never through the borrowed window. static byte independent(byte ordinary, byte candidate, byte *window, byte *local) { byte ok; asm { pshs cc,y orcc #$50 lda >$ffa4 nop pshs a ldx :local ldy :window lda :ordinary sta >$ffa4 lda #$5a sta ,x cmpa ,y bne @reject coma sta ,x cmpa ,y bne @reject lda :candidate sta >$ffa4 lda ,y coma sta ,x cmpa ,y beq @reject ldb #1 bra @restore @reject clrb @restore clr ,x puls a sta >$ffa4 puls cc,y stb :ok } return ok; } static byte usableMap(void) { unsigned address = (unsigned)▮ byte slot = (byte)(address >> 13); byte i, page; if (!lowProgramAndStack() || slot >= 4 || *(unsigned *)0xfff8 != 0xfef7) return 0; for (i = 0; i < 16; ++i) { page = readPage(TASK0 + i); if (i < 8 && page != 0x38 + i) return 0; if (page >= BANK_FIRST_PAGE && page < BANK_FIRST_PAGE + 4) return 0; } return independent(0x38 + slot, BANK_FIRST_PAGE + slot, (byte *)(WINDOW + (address & (BANK_PAGE_SIZE - 1))), &marker); } byte bank_open(void) { if (active || !irqEnabled() || !usableMap()) return 0; active = 1; return 1; } void bank_close(void) { active = 0; } // All addresses and the byte count are prepared before remapping. Keep a // 32-byte bound on the masked interval so BASIC can service interrupts even // when the caller transfers a full asset in one request. static void copyChunk(byte page, const byte *source, byte *destination, byte count) { asm { pshs cc,y orcc #$50 lda >$ffa4 nop pshs a ldx :source ldy :destination ldb :count lda :page sta >$ffa4 @copy lda ,x+ sta ,y+ decb bne @copy puls a sta >$ffa4 puls cc,y } } static byte transfer(unsigned offset, byte *buffer, unsigned length, byte writing) { unsigned address = (unsigned)buffer; if (!active || offset > BANK_CAPACITY || length > BANK_CAPACITY - offset) return 0; if (!length) return 1; if (address < (writing ? programStart() : writableStart()) || address >= WINDOW || length > WINDOW - address || !usableMap()) return 0; while (length) { unsigned inPage = offset & (BANK_PAGE_SIZE - 1); unsigned count = BANK_PAGE_SIZE - inPage; byte page = (byte)(BANK_FIRST_PAGE + (offset >> 13)); byte *window = (byte *)(WINDOW + inPage); if (count > CHUNK) count = CHUNK; if (count > length) count = length; if (writing) copyChunk(page, buffer, window, (byte) count); else copyChunk(page, window, buffer, (byte) count); buffer += count; offset += count; length -= count; } return 1; } byte bank_read(unsigned offset, void *destination, unsigned length) { return transfer(offset, (byte *)destination, length, 0); } byte bank_write(unsigned offset, const void *source, unsigned length) { return transfer(offset, (byte *)source, length, 1); }