Chipset.cpp

//
//  Chipset.cpp
//  SDL3Test
//
//  Created by Matt Parsons on 06/03/2026.
//
#include "Chipset.hpp"
#include "Gayle.hpp"
#include "m68k.h"

static Chipset* _this;

static uint16_t Unimplmented(bool isWrite, uint16_t value){
    
    if(isWrite){
        printf("Unimplmented Write\n");
        return 0;
    }
    printf("Unimplmented read\n");
    return 0; //Fake a value that pretends the serial is good to go
    
}

static uint16_t DummyReadWrite(bool isWrite, uint16_t value){
    
    if(isWrite){
        printf("Dummy Write\n");
        return 0;
    }
    printf("Dummy read\n");
    return 0;
    
}

void Chipset::CIAAInterrupt(bool set){
    
    if(set){
        INTREQ(true, 0x8008);
        return;
    }
    INTREQ(true, 0x0008);
    
}

void Chipset::CIABInterrupt(bool set){
    
    if(set){
        INTREQ(true, 0xA000);
        return;
    }
    INTREQ(true, 0x2000);
}




void Chipset::Init(void* bus){
    busPtr = bus;
    copper.Init(bus);
    blitter.Init(bus);
    paula.Init(((Gayle*)bus)->chipram, &dmacon);
    _this = this;

    // Paula fires this when a DMA buffer reloads
    paula.InterruptCallback = [](uint16_t bits){ _this->INTREQ(true, bits); };
    paula.OpenAudio();

    //CIAs
    CIAA.SetInterruptCallBack([](bool set){_this->CIAAInterrupt(set);});
    CIAA.isA = true;
    CIAB.SetInterruptCallBack([](bool set){_this->CIABInterrupt(set);});
    
    
    
    //Setup Chipset Registers
    
    //Just fill register space with dummy acessors
     for(int i = 0; i<257; ++i){
         Registers[i]  = [](bool isWrite, uint16_t value) -> uint16_t {return Unimplmented(isWrite,value);};
     }
     
   //Read only registers
    Registers[1] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DMACON(false,value);};
    Registers[2] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.VPOSR(false,value);};
    Registers[3] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.VHPOSR(false,value);};
    Registers[4] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DSKDATR(false,value);};
    Registers[5] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->JOY0DAT(false,value);};
    Registers[6] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->JOY1DAT(false,value);};
    Registers[7] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->CLXDAT(false,value);};
    Registers[8] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->ADKCONR(false,value);};
    Registers[9] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->POT0DAT(false,value);};
    Registers[10] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->POT1DAT(false,value);};
    
    Registers[11] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->POTGOR(false,value);};
    Registers[12] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->SERDATR(false,value);};
    Registers[13] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DSKBYTR(false,value);};
    
    Registers[14] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->INTENA(false,value);};
    Registers[15] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->INTREQ(false,value);};

    
    
    
    //Write Only registers
    Registers[16] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DSKPTH(isWrite,value);};
    Registers[17] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DSKPTL(isWrite,value);};
    Registers[18] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DSKLEN(isWrite,value);};
    Registers[19] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DSKDAT(isWrite,value);};
    
    Registers[20] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->REFPTR(isWrite,value);};
    
    Registers[21] = [](bool isWrite, uint16_t value) -> uint16_t {
        return _this->denise.VPOSR(isWrite,value);};
    Registers[22] = [](bool isWrite, uint16_t value) -> uint16_t {
        return _this->denise.VHPOSR(isWrite,value);};
    Registers[23] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->copper.COPCON(isWrite,value);};
    
    Registers[24] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->SERDAT(isWrite,value);};
    Registers[25] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->SERPER(isWrite,value);};
    Registers[26] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->POTGO(isWrite,value);};
    Registers[27] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->JOYTEST(isWrite,value);};
    
    Registers[28] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.STREQU(isWrite,value);};
    Registers[29] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.STRVBL(isWrite,value);};
    Registers[30] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.STRHOR(isWrite,value);};
    Registers[31] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.STRLONG(isWrite,value);};
    
    //Blitter Section
    Registers[32]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTCON0(isWrite,value);};
    Registers[33]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTCON1(isWrite,value);};
    Registers[34]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTAFWM(isWrite,value);};
    Registers[35]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTALWM(isWrite,value);};
       
    Registers[36] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTCPTH(isWrite,value);};
    Registers[37] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTCPTL(isWrite,value);};
    Registers[38] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTBPTH(isWrite,value);};
    Registers[39] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTBPTL(isWrite,value);};
    Registers[40] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTAPTH(isWrite,value);};
    Registers[41] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTAPTL(isWrite,value);};
    Registers[42] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTDPTH(isWrite,value);};
    Registers[43] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTDPTL(isWrite,value);};
       
    Registers[44]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTSIZE(isWrite,value);}; //Writing to this will complete blit immidiatelly
       //There should be a BLTCONL register here... but I dn't support ECS right now
    Registers[46]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTSIZV(isWrite,value);};
    Registers[47]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTSIZH(isWrite,value);}; //Writing to this will complete blit immidiatelly 
       
    Registers[48] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTCMOD(isWrite,value);};
    Registers[49] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTBMOD(isWrite,value);};
    Registers[50] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTAMOD(isWrite,value);};
    Registers[51] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTDMOD(isWrite,value);};
       
    Registers[56] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTCDAT(isWrite,value);};
    Registers[57] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTBDAT(isWrite,value);};
    Registers[58] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTADAT(isWrite,value);};
    Registers[0]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->blitter.BLTDDAT(isWrite,value);};
    
    
    Registers[62] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.DENISEID(false,value);};
    Registers[63] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DSKSYNC(isWrite,value);};
    
    //Copper Section

    Registers[64] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->copper.COP1LCH(isWrite,value);};
    Registers[65] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->copper.COP1LCL(isWrite,value);};
    Registers[66] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->copper.COP2LCH(isWrite,value);};
    Registers[67] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->copper.COP2LCL(isWrite,value);};
    Registers[68] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->copper.COPJMP1(isWrite,value);};
    Registers[69] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->copper.COPJMP2(isWrite,value);};
    
    Registers[71] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.DIWSTRT(isWrite,value);};
    Registers[72] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.DIWSTOP(isWrite,value);};
    Registers[73] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.DFFSTRT(isWrite,value);};
    Registers[74] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.DFFSTOP(isWrite,value);};
    
    Registers[75] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->DMACON(isWrite,value);};
    Registers[77] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->INTENA(isWrite,value);};
    Registers[78] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->INTREQ(isWrite,value);};
    
    Registers[79] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->ADKCON(isWrite,value);};
    
    
    Registers[112] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL1PTH(isWrite,value);};
    Registers[113] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL1PTL(isWrite,value);};
    Registers[114] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL2PTH(isWrite,value);};
    Registers[115] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL2PTL(isWrite,value);};
    Registers[116] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL3PTH(isWrite,value);};
    Registers[117] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL3PTL(isWrite,value);};
    Registers[118] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL4PTH(isWrite,value);};
    Registers[119] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL4PTL(isWrite,value);};
    Registers[120] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL5PTH(isWrite,value);};
    Registers[121] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL5PTL(isWrite,value);};
    Registers[122] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL6PTH(isWrite,value);};
    Registers[123] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL6PTL(isWrite,value);};
    
    Registers[124] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL7PTH(isWrite,value);};
    Registers[125] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL7PTL(isWrite,value);};
    Registers[126] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL8PTH(isWrite,value);};
    Registers[127] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL8PTL(isWrite,value);};
    
    
    Registers[128] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPLCON0(isWrite,value);};
    Registers[129] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPLCON1(isWrite,value);};
    Registers[130] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPLCON2(isWrite,value);};
    Registers[131] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPLCON3(isWrite,value);};
    
    Registers[132] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL1MOD(isWrite,value);};
    Registers[133] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL2MOD(isWrite,value);};
    Registers[134] = [](bool isWrite, uint16_t value) -> uint16_t {return DummyReadWrite(isWrite,value);};          //Undefined Register?
    Registers[135] = [](bool isWrite, uint16_t value) -> uint16_t {return DummyReadWrite(isWrite,value);};          //Undefined Register?
    
    Registers[136] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL1DAT(isWrite,value);};
    Registers[137] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL2DAT(isWrite,value);};
    Registers[138] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL3DAT(isWrite,value);};
    Registers[139] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL4DAT(isWrite,value);};
    Registers[140] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL5DAT(isWrite,value);};
    Registers[141] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL6DAT(isWrite,value);};
    //Registers[142] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL7DAT(isWrite,value);};
    //Registers[143] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.BPL8DAT(isWrite,value);};
    
    // Sprite registers
    Registers[144] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(0,isWrite,value);};
    Registers[145] = [](bool isWrite, uint16_t value) -> uint16_t {
        if(isWrite){
            _this->denise.SPRxPTL(0,true,value);
        }
        return _this->denise.SPRxPTL(0,false,0);
    };
    Registers[146] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(1,isWrite,value);};
    Registers[147] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTL(1,isWrite,value);};
    Registers[148] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(2,isWrite,value);};
    Registers[149] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTL(2,isWrite,value);};
    Registers[150] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(3,isWrite,value);};
    Registers[151] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTL(3,isWrite,value);};
    Registers[152] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(4,isWrite,value);};
    Registers[153] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTL(4,isWrite,value);};
    Registers[154] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(5,isWrite,value);};
    Registers[155] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTL(5,isWrite,value);};
    Registers[156] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(6,isWrite,value);};
    Registers[157] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTL(6,isWrite,value);};
    Registers[158] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTH(7,isWrite,value);};
    Registers[159] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPTL(7,isWrite,value);};
    
    
    
    Registers[160] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(0,isWrite,value);};
    Registers[161] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(0,isWrite,value);};
    Registers[162] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(0,isWrite,value);};
    Registers[163] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(0,isWrite,value);};
    
    Registers[164] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(1,isWrite,value);};
    Registers[165] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(1,isWrite,value);};
    Registers[166] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(1,isWrite,value);};
    Registers[167] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(1,isWrite,value);};
    
    Registers[168] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(2,isWrite,value);};
    Registers[169] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(2,isWrite,value);};
    Registers[170] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(2,isWrite,value);};
    Registers[171] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(2,isWrite,value);};
    
    Registers[172] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(3,isWrite,value);};
    Registers[173] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(3,isWrite,value);};
    Registers[174] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(3,isWrite,value);};
    Registers[175] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(3,isWrite,value);};
    
    Registers[176] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(4,isWrite,value);};
    Registers[177] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(4,isWrite,value);};
    Registers[178] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(4,isWrite,value);};
    Registers[179] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(4,isWrite,value);};
    
    Registers[180] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(5,isWrite,value);};
    Registers[181] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(5,isWrite,value);};
    Registers[182] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(5,isWrite,value);};
    Registers[183] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(5,isWrite,value);};
    
    Registers[184] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(6,isWrite,value);};
    Registers[185] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(6,isWrite,value);};
    Registers[186] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(6,isWrite,value);};
    Registers[187] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(6,isWrite,value);};
    
    Registers[188] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxPOS(7,isWrite,value);};
    Registers[189] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxCTL(7,isWrite,value);};
    Registers[190] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATA(7,isWrite,value);};
    Registers[191] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.SPRxDATB(7,isWrite,value);};
    
    Registers[192] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(0,isWrite,value);};
    Registers[193] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(1,isWrite,value);};
    Registers[194] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(2,isWrite,value);};
    Registers[195] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(3,isWrite,value);};
    Registers[196] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(4,isWrite,value);};
    Registers[197] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(5,isWrite,value);};
    Registers[198] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(6,isWrite,value);};
    Registers[199] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(7,isWrite,value);};
    Registers[200] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(8,isWrite,value);};
    Registers[201] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(9,isWrite,value);};
    Registers[202] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(10,isWrite,value);};
    Registers[203] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(11,isWrite,value);};
    Registers[204] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(12,isWrite,value);};
    Registers[205] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(13,isWrite,value);};
    Registers[206] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(14,isWrite,value);};
    Registers[207] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(15,isWrite,value);};
    
    Registers[208] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(16,isWrite,value);};
    Registers[209] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(17,isWrite,value);};
    Registers[210] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(18,isWrite,value);};
    Registers[211] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(19,isWrite,value);};
    Registers[212] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(20,isWrite,value);};
    Registers[213] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(21,isWrite,value);};
    Registers[214] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(22,isWrite,value);};
    Registers[215] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(23,isWrite,value);};
    Registers[216] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(24,isWrite,value);};
    Registers[217] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(25,isWrite,value);};
    Registers[218] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(26,isWrite,value);};
    Registers[219] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(27,isWrite,value);};
    Registers[220] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(28,isWrite,value);};
    Registers[221] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(29,isWrite,value);};
    Registers[222] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(30,isWrite,value);};
    Registers[223] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.COLOR(31,isWrite,value);};

    //ECS Registers
    Registers[228] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.VTOTAL(isWrite,value);};
    
    Registers[229] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.VSSTOP(isWrite,value);};
    Registers[230] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.VBSTRT(isWrite,value);};
    Registers[231] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->denise.VBSTOP(isWrite,value);};
    
    Registers[238] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->NOOP(isWrite,value);};
    Registers[255] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->NOOP(isWrite,value);};

    // Paula Audio registers
    // AUD0: 0xA0-0xAA → indices 80-85
    Registers[80] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCH(0,isWrite,value);};
    Registers[81] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCL(0,isWrite,value);};
    Registers[82] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLEN(0,isWrite,value);};
    Registers[83] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxPER(0,isWrite,value);};
    Registers[84] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxVOL(0,isWrite,value);};
    Registers[85] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxDAT(0,isWrite,value);};

    // AUD1: 0xB0-0xBA → indices 88-93
    Registers[88] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCH(1,isWrite,value);};
    Registers[89] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCL(1,isWrite,value);};
    Registers[90] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLEN(1,isWrite,value);};
    Registers[91] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxPER(1,isWrite,value);};
    Registers[92] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxVOL(1,isWrite,value);};
    Registers[93] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxDAT(1,isWrite,value);};

    // AUD2: 0xC0-0xCA → indices 96-101
    Registers[96]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCH(2,isWrite,value);};
    Registers[97]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCL(2,isWrite,value);};
    Registers[98]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLEN(2,isWrite,value);};
    Registers[99]  = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxPER(2,isWrite,value);};
    Registers[100] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxVOL(2,isWrite,value);};
    Registers[101] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxDAT(2,isWrite,value);};

    // AUD3: 0xD0-0xDA → indices 104-109
    Registers[104] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCH(3,isWrite,value);};
    Registers[105] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLCL(3,isWrite,value);};
    Registers[106] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxLEN(3,isWrite,value);};
    Registers[107] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxPER(3,isWrite,value);};
    Registers[108] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxVOL(3,isWrite,value);};
    Registers[109] = [](bool isWrite, uint16_t value) -> uint16_t {return _this->paula.AUDxDAT(3,isWrite,value);};
}



uint16_t Chipset::REFPTR(bool isWrite, uint16_t value){
    return 0;
}

uint16_t Chipset::JOYTEST(bool isWrite, uint16_t value){
    return 0;
}

uint16_t Chipset::JOY0DAT(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("JOY0DAT\n");
        joy0dat = value;
        return 0;
    }
    return joy0dat;
}
uint16_t Chipset::JOY1DAT(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("JOY1DAT\n");
        joy1dat = value;
        return 0;
    }
    return joy1dat;
}

uint16_t Chipset::CLXDAT(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("CLXDAT\n");
        clxdat = value;
        return 0;
    }
    return clxdat;
}

uint16_t Chipset::ADKCONR(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("ADKCONR\n");
        adkcon = value;
        return 0;
    }
    return adkcon;
}

uint16_t Chipset::POT0DAT(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("POT0DAT\n");
        pot0dat = value;
        return 0;
    }
    return pot0dat;
}
uint16_t Chipset::POT1DAT(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("POT1DAT\n");
        pot1dat = value;
        return 0;
    }
    return pot1dat;
}


uint16_t Chipset::DSKBYTR(bool isWrite, uint16_t value){
    // Read-only register — returns disk byte status
    if(!isWrite){
        uint16_t result = 0;
        // Bit 15: DSKBYT — always set (byte ready, disk is streaming)
        result |= 0x8000;
        // Bit 14: DMAON — disk DMA enabled in DMACON
        if((dmacon & 0x0210) == 0x0210){
            result |= 0x4000;
        }
        // Bit 12: WORDEQUAL — sync word found (always true when disk present)
        Floppy* floppy = drives ? drives->getSelectedDisk() : nullptr;
        if(floppy && floppy->DiskPresent()){
            result |= 0x1000;
        }
        return result;
    }
    return 0;
}

uint16_t Chipset::DSKPTH(bool isWrite, uint16_t value){
    if(isWrite){
        dskpt = (dskpt & 0x0000FFFF) | ((uint32_t)value << 16);
        return 0;
    }
    return (uint16_t)(dskpt >> 16);
}
uint16_t Chipset::DSKPTL(bool isWrite, uint16_t value){
    if(isWrite){
        dskpt = (dskpt & 0xFFFF0000) | (value & 0xFFFE);
        return 0;
    }
    return (uint16_t)(dskpt & 0xFFFF);
}

uint16_t Chipset::DSKLEN(bool isWrite, uint16_t value){
    if(isWrite){
        if((value & 0x8000) && (dsklenPrev & 0x8000)){
            // Double-write with bit 15 set — activate disk DMA
            bool writeMode = (value & 0x4000) != 0;
            int wordCount = value & 0x3FFF;

            // Check disk DMA is enabled in DMACON (bit 4 = DSKEN, bit 9 = DMAEN)
            if((dmacon & 0x0210) != 0x0210){
                dsklenPrev = value;
                return 0;
            }

            Floppy* floppy = drives ? drives->getSelectedDisk() : nullptr;
            if(!floppy || !floppy->DiskPresent() || floppy->mfmTrackLength == 0){
                dsklenPrev = value;
                return 0;
            }

            if(!writeMode){
                // Read: find sync word in MFM buffer, then bulk copy into chip RAM
                // Find sync word — on real hardware, the sync word itself is
                // the first word written to RAM by DMA
                int syncPos = -1;
                for(int i = 0; i < floppy->mfmTrackLength - 1; i++){
                    if(floppy->mfmTrack[i] == dsksync){
                        syncPos = i;
                        break;
                    }
                }

                if(syncPos < 0){
                    //printf("Disk: DSKSYNC $%04X not found in MFM track\n", dsksync);
                    dsklenPrev = value;
                    return 0;
                }

                //printf("Disk: DSKLEN=$%04X sync=$%04X syncPos=%d dskpt=$%06X words=%d trk=%d side=%d\n",
                //       value, dsksync, syncPos, dskpt, wordCount,
                //       floppy->getTrack(), floppy->side);

                Gayle* bus = (Gayle*)busPtr;
                int mfmPos = syncPos;
                for(int i = 0; i < wordCount; i++){
                    if(mfmPos >= floppy->mfmTrackLength){
                        mfmPos = 0; // Wrap around track
                    }
                    bus->chipram->Write16(dskpt, floppy->mfmTrack[mfmPos]);
                    dskpt += 2;
                    mfmPos++;
                }

                //printf("Disk: First 8 words at $%06X:", startAddr);
                //for(int i = 0; i < 8 && i < wordCount; i++){
                //    printf(" %04X", bus->chipram->Read16(startAddr + i * 2));
                //}
                //printf("\n");

                // Fire DSKBLK interrupt (bit 1)
                INTREQ(true, 0x8002);
            }
            // Write mode not yet implemented
        } else if(!(value & 0x8000)){
            // Bit 15 clear — stop any active DMA (nothing to stop in instant mode)
        }
        dsklenPrev = value;
        return 0;
    }
    return 0;
}

uint16_t Chipset::DSKDAT(bool isWrite, uint16_t value){
    return 0;
}

uint16_t Chipset::DSKSYNC(bool isWrite, uint16_t value){
    if(isWrite){
        dsksync = value;
        return 0;
    }
    return dsksync;
}

uint16_t Chipset::SERDATR(bool isWrite, uint16_t value){
    return 0x3000;
}

uint16_t Chipset::SERDAT(bool isWrite, uint16_t value){
    //printf("%c",value &0xFF);
    return 0;
}

uint16_t Chipset::SERPER(bool isWrite, uint16_t value){
    //printf("%c",value &0xFF);
    return 0;
}


uint16_t Chipset::POTGOR(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("POTGO\n");
        potgo = (potgo & 0xFF) | value;
        return 0;
    }
    return potgo;
}



uint16_t Chipset::POTGO(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("POTGO\n");
        potgo = (potgo & 0xFF) | value;
        return 0;
    }
    return potgo;
}



uint16_t Chipset::DSKDATR(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("DSKDATR\n");
        dskdatr = value;
        return 0;
    }
    return dskdatr;
}




//***********************************************

uint16_t Chipset::DMACON(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("DMACON\n");
        if(value & 0x8000){
           dmacon = dmacon | (value & 0x7FFF) ; // Set requested bits, only lower 15 bits
        }else{
            dmacon = dmacon ^ (value & dmacon ); // clear requested bits
        }
        return 0;
    }
    return dmacon;
}





void Chipset::RequestInterrupt(uint16_t intLevel){
        
    if(intLevel & 0x2000){  m68k_set_irq(6); return;}  // EXTER (CIA-B)
    if(intLevel & 0x1800){  m68k_set_irq(5); return;}  // RBF, DSKSYN
    if(intLevel & 0x0780){  m68k_set_irq(4); return;}  // AUD0-3
    if(intLevel & 0x0070){  m68k_set_irq(3); return;}  // COPPER, VERTB, BLIT
    if(intLevel & 0x0008){  m68k_set_irq(2); return;}  // PORTS (CIA)
    if(intLevel & 0x0007){  m68k_set_irq(1); return;}  // TBE, DSKBLK, SOFT

    m68k_set_irq(0);
    return;

    /*
    if(intLevel !=0){
        
        if(intLevel & 1){    // Serial Transmit buffer empty
            m68k_set_irq(1);
        }
        
        if(intLevel & 2){    // Disk block finished
            m68k_set_irq(1);
        }
        
        if(intLevel & 4){    // Software int
            m68k_set_irq(1);
        }
        
        if(intLevel & 8){    // Ports, IO and timers
            m68k_set_irq(2);
        }
        
        if(intLevel & 16){   // Copper
            m68k_set_irq(3);
        }
        
        if(intLevel & 32){   // VBL
            m68k_set_irq(3);
        }
        
        if(intLevel & 64){   // Blitter finished
            m68k_set_irq(3);
        }
        
        if(intLevel & 128){  // Audio 0
            m68k_set_irq(4);
        }
        
        if(intLevel & 256){  // Audio 1
            m68k_set_irq(4);
        }
        
        if(intLevel & 512){  // Audio 2
            m68k_set_irq(4);
        }
        
        if(intLevel & 1024){ // Audio 3
            m68k_set_irq(4);
        }
        
        if(intLevel & 2048){ // Serial receive buffer full
            m68k_set_irq(5);
        }
        
        if(intLevel & 4096){ // Disk sync
            m68k_set_irq(5);
        }
        
        if(intLevel & 8192){  // External int
            m68k_set_irq(6);
        }
        
        
    }else{
        //m68k_set_irq(0);
    }
    */
}


void Chipset::CheckInterrupt(){
    //RequestInterrupt(IRQMask);
    
    if(IRQMask & 0x2000){  m68k_set_irq(6); return;}  // EXTER (CIA-B)
    if(IRQMask & 0x1800){  m68k_set_irq(5); return;}  // RBF, DSKSYN
    if(IRQMask & 0x0780){  m68k_set_irq(4); return;}  // AUD0-3
    if(IRQMask & 0x0070){  m68k_set_irq(3); return;}  // COPPER, VERTB, BLIT
    if(IRQMask & 0x0008){  m68k_set_irq(2); return;}  // PORTS (CIA)
    if(IRQMask & 0x0007){  m68k_set_irq(1); return;}  // TBE, DSKBLK, SOFT

    m68k_set_irq(0);
    return;
    
}

uint16_t Chipset::INTENA(bool isWrite, uint16_t value){
    if(isWrite){
        //printf("INTENA\n");
    
        if(value & 0x8000){
            intena = intena | (value & 0x7FFF) ; // Set requested bits, only lower 15 bits
        }else{
            intena = intena ^ (value & intena ); // clear requested bits
        }
    
        //Generate interrupt only if INTENA Master bit is set
        if( !(intena & 0x4000) ){
            return 0;
        }
        
        IRQMask = intena & intreq;
        //RequestInterrupt(intena & intreq);
        return 0;
    }
    return intena;
}
uint16_t Chipset::INTREQ(bool isWrite, uint16_t value){
    if(isWrite){
        
        //printf("INTREQ\n");
    
        if(value & 0x8000){
            intreq.fetch_or(static_cast<uint16_t>(value & 0x7FFF));   // atomic set
            //intreq = intreq | (value & 0x7FFF);
        }else{
            intreq.fetch_and(static_cast<uint16_t>(~(value & 0x7FFF))); // atomic clear
            //intreq = intreq ^ (value & intreq ); // clear requested bits
        }
    
        //Generate interrupt only if INTENA Master bit is set
        if( !(intena & 0x4000) ){
            return 0;
        }
        
        IRQMask = intena & intreq;
        //RequestInterrupt(intena & intreq);
        
        return 0;
    }
    return intreq;
}


uint16_t Chipset::ADKCON(bool isWrite, uint16_t value){
    if(isWrite){
        if(value & 0x8000){
            adkcon = adkcon | (value & 0x7FFF) ; // Set requested bits, only lower 15 bits
        }else{
            adkcon = adkcon ^ (value & adkcon ); // clear requested bits
        }
        return 0;
    }
    return adkcon;
}


uint16_t Chipset::NOOP(bool isWrite, uint16_t value){
    return 0;
}