pico/cd/memory.c

   1 // Memory I/O handlers for Sega/Mega CD.\r
   2 // (c) Copyright 2007-2009, Grazvydas "notaz" Ignotas\r
   3 \r
   4 #include "../pico_int.h"\r
   5 #include "../memory.h"\r
   6 \r
   7 #include "gfx_cd.h"\r
   8 #include "pcm.h"\r
   9 \r
  10 unsigned long s68k_read8_map  [0x1000000 >> M68K_MEM_SHIFT];\r
  11 unsigned long s68k_read16_map [0x1000000 >> M68K_MEM_SHIFT];\r
  12 unsigned long s68k_write8_map [0x1000000 >> M68K_MEM_SHIFT];\r
  13 unsigned long s68k_write16_map[0x1000000 >> M68K_MEM_SHIFT];\r
  14 \r
  15 MAKE_68K_READ8(s68k_read8, s68k_read8_map)\r
  16 MAKE_68K_READ16(s68k_read16, s68k_read16_map)\r
  17 MAKE_68K_READ32(s68k_read32, s68k_read16_map)\r
  18 MAKE_68K_WRITE8(s68k_write8, s68k_write8_map)\r
  19 MAKE_68K_WRITE16(s68k_write16, s68k_write16_map)\r
  20 MAKE_68K_WRITE32(s68k_write32, s68k_write16_map)\r
  21 \r
  22 // -----------------------------------------------------------------\r
  23 \r
  24 // poller detection\r
  25 #define POLL_LIMIT 16\r
  26 #define POLL_CYCLES 124\r
  27 unsigned int s68k_poll_adclk, s68k_poll_cnt;\r
  28 \r
  29 #ifndef _ASM_CD_MEMORY_C\r
  30 static u32 m68k_reg_read16(u32 a)\r
  31 {\r
  32   u32 d=0;\r
  33   a &= 0x3e;\r
  34 \r
  35   switch (a) {\r
  36     case 0:\r
  37       d = ((Pico_mcd->s68k_regs[0x33]<<13)&0x8000) | Pico_mcd->m.busreq; // here IFL2 is always 0, just like in Gens\r
  38       goto end;\r
  39     case 2:\r
  40       d = (Pico_mcd->s68k_regs[a]<<8) | (Pico_mcd->s68k_regs[a+1]&0xc7);\r
  41       elprintf(EL_CDREG3, "m68k_regs r3: %02x @%06x", (u8)d, SekPc);\r
  42       goto end;\r
  43     case 4:\r
  44       d = Pico_mcd->s68k_regs[4]<<8;\r
  45       goto end;\r
  46     case 6:\r
  47       d = *(u16 *)(Pico_mcd->bios + 0x72);\r
  48       goto end;\r
  49     case 8:\r
  50       d = Read_CDC_Host(0);\r
  51       goto end;\r
  52     case 0xA:\r
  53       elprintf(EL_UIO, "m68k FIXME: reserved read");\r
  54       goto end;\r
  55     case 0xC:\r
  56       d = Pico_mcd->m.timer_stopwatch >> 16;\r
  57       elprintf(EL_CDREGS, "m68k stopwatch timer read (%04x)", d);\r
  58       goto end;\r
  59   }\r
  60 \r
  61   if (a < 0x30) {\r
  62     // comm flag/cmd/status (0xE-0x2F)\r
  63     d = (Pico_mcd->s68k_regs[a]<<8) | Pico_mcd->s68k_regs[a+1];\r
  64     goto end;\r
  65   }\r
  66 \r
  67   elprintf(EL_UIO, "m68k_regs FIXME invalid read @ %02x", a);\r
  68 \r
  69 end:\r
  70 \r
  71   return d;\r
  72 }\r
  73 #endif\r
  74 \r
  75 #ifndef _ASM_CD_MEMORY_C\r
  76 static\r
  77 #endif\r
  78 void m68k_reg_write8(u32 a, u32 d)\r
  79 {\r
  80   u32 dold;\r
  81   a &= 0x3f;\r
  82 \r
  83   switch (a) {\r
  84     case 0:\r
  85       d &= 1;\r
  86       if ((d&1) && (Pico_mcd->s68k_regs[0x33]&(1<<2))) { elprintf(EL_INTS, "m68k: s68k irq 2"); SekInterruptS68k(2); }\r
  87       return;\r
  88     case 1:\r
  89       d &= 3;\r
  90       if (!(d&1)) Pico_mcd->m.state_flags |= 1; // reset pending, needed to be sure we fetch the right vectors on reset\r
  91       if ( (Pico_mcd->m.busreq&1) != (d&1)) elprintf(EL_INTSW, "m68k: s68k reset %i", !(d&1));\r
  92       if ( (Pico_mcd->m.busreq&2) != (d&2)) elprintf(EL_INTSW, "m68k: s68k brq %i", (d&2)>>1);\r
  93       if ((Pico_mcd->m.state_flags&1) && (d&3)==1) {\r
  94         SekResetS68k(); // S68k comes out of RESET or BRQ state\r
  95         Pico_mcd->m.state_flags&=~1;\r
  96         elprintf(EL_CDREGS, "m68k: resetting s68k, cycles=%i", SekCyclesLeft);\r
  97       }\r
  98       if (!(d & 1))\r
  99         d |= 2; // verified: reset also gives bus\r
 100       if ((d ^ Pico_mcd->m.busreq) & 2)\r
 101         PicoMemRemapCD(Pico_mcd->s68k_regs[3]);\r
 102       Pico_mcd->m.busreq = d;\r
 103       return;\r
 104     case 2:\r
 105       elprintf(EL_CDREGS, "m68k: prg wp=%02x", d);\r
 106       Pico_mcd->s68k_regs[2] = d; // really use s68k side register\r
 107       return;\r
 108     case 3:\r
 109       dold = Pico_mcd->s68k_regs[3];\r
 110       elprintf(EL_CDREG3, "m68k_regs w3: %02x @%06x", (u8)d, SekPc);\r
 111       //if ((Pico_mcd->s68k_regs[3]&4) != (d&4)) dprintf("m68k: ram mode %i mbit", (d&4) ? 1 : 2);\r
 112       //if ((Pico_mcd->s68k_regs[3]&2) != (d&2)) dprintf("m68k: %s", (d&4) ? ((d&2) ? "word swap req" : "noop?") :\r
 113       //                                             ((d&2) ? "word ram to s68k" : "word ram to m68k"));\r
 114       if (dold & 4) {   // 1M mode\r
 115         d ^= 2;         // writing 0 to DMNA actually sets it, 1 does nothing\r
 116       } else {\r
 117         if ((d ^ dold) & d & 2) { // DMNA is being set\r
 118           dold &= ~1;   // return word RAM to s68k\r
 119           /* Silpheed hack: bset(w3), r3, btst, bne, r3 */\r
 120           SekEndRun(20+16+10+12+16);\r
 121         }\r
 122       }\r
 123       Pico_mcd->s68k_regs[3] = (d & 0xc2) | (dold & 0x1f);\r
 124       if ((d ^ dold) & 0xc0) {\r
 125         elprintf(EL_CDREGS, "m68k: prg bank: %i -> %i", (Pico_mcd->s68k_regs[a]>>6), ((d>>6)&3));\r
 126         PicoMemRemapCD(Pico_mcd->s68k_regs[3]);\r
 127       }\r
 128 #ifdef USE_POLL_DETECT\r
 129       if ((s68k_poll_adclk&0xfe) == 2 && s68k_poll_cnt > POLL_LIMIT) {\r
 130         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 131         elprintf(EL_CDPOLL, "s68k poll release, a=%02x", a);\r
 132       }\r
 133 #endif\r
 134       return;\r
 135     case 6:\r
 136       Pico_mcd->bios[0x72 + 1] = d; // simple hint vector changer\r
 137       return;\r
 138     case 7:\r
 139       Pico_mcd->bios[0x72] = d;\r
 140       elprintf(EL_CDREGS, "hint vector set to %04x%04x",\r
 141         ((u16 *)Pico_mcd->bios)[0x70/2], ((u16 *)Pico_mcd->bios)[0x72/2]);\r
 142       return;\r
 143     case 0xf:\r
 144       d = (d << 1) | ((d >> 7) & 1); // rol8 1 (special case)\r
 145     case 0xe:\r
 146       //dprintf("m68k: comm flag: %02x", d);\r
 147       Pico_mcd->s68k_regs[0xe] = d;\r
 148 #ifdef USE_POLL_DETECT\r
 149       if ((s68k_poll_adclk&0xfe) == 0xe && s68k_poll_cnt > POLL_LIMIT) {\r
 150         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 151         elprintf(EL_CDPOLL, "s68k poll release, a=%02x", a);\r
 152       }\r
 153 #endif\r
 154       return;\r
 155   }\r
 156 \r
 157   if ((a&0xf0) == 0x10) {\r
 158       Pico_mcd->s68k_regs[a] = d;\r
 159 #ifdef USE_POLL_DETECT\r
 160       if ((a&0xfe) == (s68k_poll_adclk&0xfe) && s68k_poll_cnt > POLL_LIMIT) {\r
 161         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 162         elprintf(EL_CDPOLL, "s68k poll release, a=%02x", a);\r
 163       }\r
 164 #endif\r
 165       return;\r
 166   }\r
 167 \r
 168   elprintf(EL_UIO, "m68k FIXME: invalid write? [%02x] %02x", a, d);\r
 169 }\r
 170 \r
 171 #ifndef _ASM_CD_MEMORY_C\r
 172 static\r
 173 #endif\r
 174 u32 s68k_poll_detect(u32 a, u32 d)\r
 175 {\r
 176 #ifdef USE_POLL_DETECT\r
 177   // needed mostly for Cyclone, which doesn't always check it's cycle counter\r
 178   if (SekIsStoppedS68k()) return d;\r
 179   // polling detection\r
 180   if (a == (s68k_poll_adclk&0xff)) {\r
 181     unsigned int clkdiff = SekCyclesDoneS68k() - (s68k_poll_adclk>>8);\r
 182     if (clkdiff <= POLL_CYCLES) {\r
 183       s68k_poll_cnt++;\r
 184       //printf("-- diff: %u, cnt = %i\n", clkdiff, s68k_poll_cnt);\r
 185       if (s68k_poll_cnt > POLL_LIMIT) {\r
 186         SekSetStopS68k(1);\r
 187         elprintf(EL_CDPOLL, "s68k poll detected @ %06x, a=%02x", SekPcS68k, a);\r
 188       }\r
 189       s68k_poll_adclk = (SekCyclesDoneS68k() << 8) | a;\r
 190       return d;\r
 191     }\r
 192   }\r
 193   s68k_poll_adclk = (SekCyclesDoneS68k() << 8) | a;\r
 194   s68k_poll_cnt = 0;\r
 195 #endif\r
 196   return d;\r
 197 }\r
 198 \r
 199 #define READ_FONT_DATA(basemask) \\r
 200 { \\r
 201       unsigned int fnt = *(unsigned int *)(Pico_mcd->s68k_regs + 0x4c); \\r
 202       unsigned int col0 = (fnt >> 8) & 0x0f, col1 = (fnt >> 12) & 0x0f;   \\r
 203       if (fnt & (basemask << 0)) d  = col1      ; else d  = col0;       \\r
 204       if (fnt & (basemask << 1)) d |= col1 <<  4; else d |= col0 <<  4; \\r
 205       if (fnt & (basemask << 2)) d |= col1 <<  8; else d |= col0 <<  8; \\r
 206       if (fnt & (basemask << 3)) d |= col1 << 12; else d |= col0 << 12; \\r
 207 }\r
 208 \r
 209 \r
 210 #ifndef _ASM_CD_MEMORY_C\r
 211 static\r
 212 #endif\r
 213 u32 s68k_reg_read16(u32 a)\r
 214 {\r
 215   u32 d=0;\r
 216 \r
 217   switch (a) {\r
 218     case 0:\r
 219       return ((Pico_mcd->s68k_regs[0]&3)<<8) | 1; // ver = 0, not in reset state\r
 220     case 2:\r
 221       d = (Pico_mcd->s68k_regs[2]<<8) | (Pico_mcd->s68k_regs[3]&0x1f);\r
 222       elprintf(EL_CDREG3, "s68k_regs r3: %02x @%06x", (u8)d, SekPcS68k);\r
 223       return s68k_poll_detect(a, d);\r
 224     case 6:\r
 225       return CDC_Read_Reg();\r
 226     case 8:\r
 227       return Read_CDC_Host(1); // Gens returns 0 here on byte reads\r
 228     case 0xC:\r
 229       d = Pico_mcd->m.timer_stopwatch >> 16;\r
 230       elprintf(EL_CDREGS, "s68k stopwatch timer read (%04x)", d);\r
 231       return d;\r
 232     case 0x30:\r
 233       elprintf(EL_CDREGS, "s68k int3 timer read (%02x)", Pico_mcd->s68k_regs[31]);\r
 234       return Pico_mcd->s68k_regs[31];\r
 235     case 0x34: // fader\r
 236       return 0; // no busy bit\r
 237     case 0x50: // font data (check: Lunar 2, Silpheed)\r
 238       READ_FONT_DATA(0x00100000);\r
 239       return d;\r
 240     case 0x52:\r
 241       READ_FONT_DATA(0x00010000);\r
 242       return d;\r
 243     case 0x54:\r
 244       READ_FONT_DATA(0x10000000);\r
 245       return d;\r
 246     case 0x56:\r
 247       READ_FONT_DATA(0x01000000);\r
 248       return d;\r
 249   }\r
 250 \r
 251   d = (Pico_mcd->s68k_regs[a]<<8) | Pico_mcd->s68k_regs[a+1];\r
 252 \r
 253   if (a >= 0x0e && a < 0x30)\r
 254     return s68k_poll_detect(a, d);\r
 255 \r
 256   return d;\r
 257 }\r
 258 \r
 259 #ifndef _ASM_CD_MEMORY_C\r
 260 static\r
 261 #endif\r
 262 void s68k_reg_write8(u32 a, u32 d)\r
 263 {\r
 264   // Warning: d might have upper bits set\r
 265   switch (a) {\r
 266     case 2:\r
 267       return; // only m68k can change WP\r
 268     case 3: {\r
 269       int dold = Pico_mcd->s68k_regs[3];\r
 270       elprintf(EL_CDREG3, "s68k_regs w3: %02x @%06x", (u8)d, SekPcS68k);\r
 271       d &= 0x1d;\r
 272       d |= dold & 0xc2;\r
 273       if (d & 4)\r
 274       {\r
 275         if ((d ^ dold) & 5) {\r
 276           d &= ~2; // in case of mode or bank change we clear DMNA (m68k req) bit\r
 277           PicoMemRemapCD(d);\r
 278         }\r
 279 #ifdef _ASM_CD_MEMORY_C\r
 280         if ((d ^ dold) & 0x1d)\r
 281           PicoMemResetCDdecode(d);\r
 282 #endif\r
 283         if (!(dold & 4)) {\r
 284           elprintf(EL_CDREG3, "wram mode 2M->1M");\r
 285           wram_2M_to_1M(Pico_mcd->word_ram2M);\r
 286         }\r
 287       }\r
 288       else\r
 289       {\r
 290         if (dold & 4) {\r
 291           elprintf(EL_CDREG3, "wram mode 1M->2M");\r
 292           if (!(d&1)) { // it didn't set the ret bit, which means it doesn't want to give WRAM to m68k\r
 293             d &= ~3;\r
 294             d |= (dold&1) ? 2 : 1; // then give it to the one which had bank0 in 1M mode\r
 295           }\r
 296           wram_1M_to_2M(Pico_mcd->word_ram2M);\r
 297           PicoMemRemapCD(d);\r
 298         }\r
 299         // s68k can only set RET, writing 0 has no effect\r
 300         else if ((dold ^ d) & d & 1) {   // RET being set\r
 301           SekEndRunS68k(20+16+10+12+16); // see DMNA case\r
 302         } else\r
 303           d |= dold & 1;\r
 304         if (d & 1)\r
 305           d &= ~2;                       // DMNA clears\r
 306       }\r
 307       break;\r
 308     }\r
 309     case 4:\r
 310       elprintf(EL_CDREGS, "s68k CDC dest: %x", d&7);\r
 311       Pico_mcd->s68k_regs[4] = (Pico_mcd->s68k_regs[4]&0xC0) | (d&7); // CDC mode\r
 312       return;\r
 313     case 5:\r
 314       //dprintf("s68k CDC reg addr: %x", d&0xf);\r
 315       break;\r
 316     case 7:\r
 317       CDC_Write_Reg(d);\r
 318       return;\r
 319     case 0xa:\r
 320       elprintf(EL_CDREGS, "s68k set CDC dma addr");\r
 321       break;\r
 322     case 0xc:\r
 323     case 0xd:\r
 324       elprintf(EL_CDREGS, "s68k set stopwatch timer");\r
 325       Pico_mcd->m.timer_stopwatch = 0;\r
 326       return;\r
 327     case 0xe:\r
 328       Pico_mcd->s68k_regs[0xf] = (d>>1) | (d<<7); // ror8 1, Gens note: Dragons lair\r
 329       return;\r
 330     case 0x31:\r
 331       elprintf(EL_CDREGS, "s68k set int3 timer: %02x", d);\r
 332       Pico_mcd->m.timer_int3 = (d & 0xff) << 16;\r
 333       break;\r
 334     case 0x33: // IRQ mask\r
 335       elprintf(EL_CDREGS, "s68k irq mask: %02x", d);\r
 336       if ((d&(1<<4)) && (Pico_mcd->s68k_regs[0x37]&4) && !(Pico_mcd->s68k_regs[0x33]&(1<<4))) {\r
 337         CDD_Export_Status();\r
 338       }\r
 339       break;\r
 340     case 0x34: // fader\r
 341       Pico_mcd->s68k_regs[a] = (u8) d & 0x7f;\r
 342       return;\r
 343     case 0x36:\r
 344       return; // d/m bit is unsetable\r
 345     case 0x37: {\r
 346       u32 d_old = Pico_mcd->s68k_regs[0x37];\r
 347       Pico_mcd->s68k_regs[0x37] = d&7;\r
 348       if ((d&4) && !(d_old&4)) {\r
 349         CDD_Export_Status();\r
 350       }\r
 351       return;\r
 352     }\r
 353     case 0x4b:\r
 354       Pico_mcd->s68k_regs[a] = (u8) d;\r
 355       CDD_Import_Command();\r
 356       return;\r
 357   }\r
 358 \r
 359   if ((a&0x1f0) == 0x10 || (a >= 0x38 && a < 0x42))\r
 360   {\r
 361     elprintf(EL_UIO, "s68k FIXME: invalid write @ %02x?", a);\r
 362     return;\r
 363   }\r
 364 \r
 365   Pico_mcd->s68k_regs[a] = (u8) d;\r
 366 }\r
 367 \r
 368 // -----------------------------------------------------------------\r
 369 //                          Main 68k\r
 370 // -----------------------------------------------------------------\r
 371 \r
 372 #ifndef _ASM_CD_MEMORY_C\r
 373 #include "cell_map.c"\r
 374 #endif\r
 375 \r
 376 // WORD RAM, cell aranged area (220000 - 23ffff)\r
 377 static u32 PicoReadM68k8_cell(u32 a)\r
 378 {\r
 379   int bank = Pico_mcd->s68k_regs[3] & 1;\r
 380   a = (a&3) | (cell_map(a >> 2) << 2); // cell arranged\r
 381   return Pico_mcd->word_ram1M[bank][a ^ 1];\r
 382 }\r
 383 \r
 384 static u32 PicoReadM68k16_cell(u32 a)\r
 385 {\r
 386   int bank = Pico_mcd->s68k_regs[3] & 1;\r
 387   a = (a&2) | (cell_map(a >> 2) << 2);\r
 388   return *(u16 *)(Pico_mcd->word_ram1M[bank] + a);\r
 389 }\r
 390 \r
 391 static void PicoWriteM68k8_cell(u32 a, u32 d)\r
 392 {\r
 393   int bank = Pico_mcd->s68k_regs[3] & 1;\r
 394   a = (a&3) | (cell_map(a >> 2) << 2);\r
 395   Pico_mcd->word_ram1M[bank][a ^ 1] = d;\r
 396 }\r
 397 \r
 398 static void PicoWriteM68k16_cell(u32 a, u32 d)\r
 399 {\r
 400   int bank = Pico_mcd->s68k_regs[3] & 1;\r
 401   a = (a&3) | (cell_map(a >> 2) << 2);\r
 402   *(u16 *)(Pico_mcd->word_ram1M[bank] + a) = d;\r
 403 }\r
 404 \r
 405 // RAM cart (40000 - 7fffff, optional)\r
 406 static u32 PicoReadM68k8_ramc(u32 a)\r
 407 {\r
 408   u32 d = 0;\r
 409   if (a == 0x400001) {\r
 410     if (SRam.data != NULL)\r
 411       d = 3; // 64k cart\r
 412     return d;\r
 413   }\r
 414 \r
 415   if ((a & 0xfe0000) == 0x600000) {\r
 416     if (SRam.data != NULL)\r
 417       d = SRam.data[((a >> 1) & 0xffff) + 0x2000];\r
 418     return d;\r
 419   }\r
 420 \r
 421   if (a == 0x7fffff)\r
 422     return Pico_mcd->m.bcram_reg;\r
 423 \r
 424   elprintf(EL_UIO, "m68k unmapped r8  [%06x] @%06x", a, SekPc);\r
 425   return d;\r
 426 }\r
 427 \r
 428 static u32 PicoReadM68k16_ramc(u32 a)\r
 429 {\r
 430   elprintf(EL_ANOMALY, "ramcart r16: [%06x] @%06x", a, SekPcS68k);\r
 431   return PicoReadM68k8_ramc(a + 1);\r
 432 }\r
 433 \r
 434 static void PicoWriteM68k8_ramc(u32 a, u32 d)\r
 435 {\r
 436   if ((a & 0xfe0000) == 0x600000) {\r
 437     if (SRam.data != NULL && (Pico_mcd->m.bcram_reg & 1)) {\r
 438       SRam.data[((a>>1) & 0xffff) + 0x2000] = d;\r
 439       SRam.changed = 1;\r
 440     }\r
 441     return;\r
 442   }\r
 443 \r
 444   if (a == 0x7fffff) {\r
 445     Pico_mcd->m.bcram_reg = d;\r
 446     return;\r
 447   }\r
 448 \r
 449   elprintf(EL_UIO, "m68k unmapped w8  [%06x]   %02x @%06x", a, d & 0xff, SekPc);\r
 450 }\r
 451 \r
 452 static void PicoWriteM68k16_ramc(u32 a, u32 d)\r
 453 {\r
 454   elprintf(EL_ANOMALY, "ramcart w16: [%06x] %04x @%06x", a, d, SekPcS68k);\r
 455   PicoWriteM68k8_ramc(a + 1, d);\r
 456 }\r
 457 \r
 458 // IO/control/cd registers (a10000 - ...)\r
 459 static u32 PicoReadM68k8_io(u32 a)\r
 460 {\r
 461   u32 d;\r
 462   if ((a & 0xff00) == 0x2000) { // a12000 - a120ff\r
 463     d = m68k_reg_read16(a); // TODO: m68k_reg_read8\r
 464     if (!(a & 1))\r
 465       d >>= 8;\r
 466     d &= 0xff;\r
 467     elprintf(EL_CDREGS, "m68k_regs r8:  [%02x]   %02x @%06x", a & 0x3f, d, SekPc);\r
 468     return d;\r
 469   }\r
 470 \r
 471   // fallback to default MD handler\r
 472   return PicoRead8_io(a);\r
 473 }\r
 474 \r
 475 static u32 PicoReadM68k16_io(u32 a)\r
 476 {\r
 477   u32 d;\r
 478   if ((a & 0xff00) == 0x2000) {\r
 479     d = m68k_reg_read16(a);\r
 480     elprintf(EL_CDREGS, "m68k_regs r16: [%02x] %04x @%06x", a & 0x3f, d, SekPc);\r
 481     return d;\r
 482   }\r
 483 \r
 484   return PicoRead16_io(a);\r
 485 }\r
 486 \r
 487 static void PicoWriteM68k8_io(u32 a, u32 d)\r
 488 {\r
 489   if ((a & 0xff00) == 0x2000) { // a12000 - a120ff\r
 490     elprintf(EL_CDREGS, "m68k_regs w8:  [%02x]   %02x @%06x", a&0x3f, d, SekPc);\r
 491     m68k_reg_write8(a, d);\r
 492     return;\r
 493   }\r
 494 \r
 495   PicoWrite16_io(a, d);\r
 496 }\r
 497 \r
 498 static void PicoWriteM68k16_io(u32 a, u32 d)\r
 499 {\r
 500   if ((a & 0xff00) == 0x2000) { // a12000 - a120ff\r
 501     elprintf(EL_CDREGS, "m68k_regs w16: [%02x] %04x @%06x", a&0x3f, d, SekPc);\r
 502 /* TODO FIXME?\r
 503     if (a == 0xe) { // special case, 2 byte writes would be handled differently\r
 504       Pico_mcd->s68k_regs[0xe] = d >> 8;\r
 505 #ifdef USE_POLL_DETECT\r
 506       if ((s68k_poll_adclk&0xfe) == 0xe && s68k_poll_cnt > POLL_LIMIT) {\r
 507         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 508         elprintf(EL_CDPOLL, "s68k poll release, a=%02x", a);\r
 509       }\r
 510 #endif\r
 511       return;\r
 512     }\r
 513 */\r
 514     m68k_reg_write8(a,     d >> 8);\r
 515     m68k_reg_write8(a + 1, d & 0xff);\r
 516     return;\r
 517   }\r
 518 \r
 519   PicoWrite16_io(a, d);\r
 520 }\r
 521 \r
 522 // -----------------------------------------------------------------\r
 523 //                           Sub 68k\r
 524 // -----------------------------------------------------------------\r
 525 \r
 526 static u32 s68k_unmapped_read8(u32 a)\r
 527 {\r
 528   elprintf(EL_UIO, "s68k unmapped r8  [%06x] @%06x", a, SekPc);\r
 529   return 0;\r
 530 }\r
 531 \r
 532 static u32 s68k_unmapped_read16(u32 a)\r
 533 {\r
 534   elprintf(EL_UIO, "s68k unmapped r16 [%06x] @%06x", a, SekPc);\r
 535   return 0;\r
 536 }\r
 537 \r
 538 static void s68k_unmapped_write8(u32 a, u32 d)\r
 539 {\r
 540   elprintf(EL_UIO, "s68k unmapped w8  [%06x]   %02x @%06x", a, d & 0xff, SekPc);\r
 541 }\r
 542 \r
 543 static void s68k_unmapped_write16(u32 a, u32 d)\r
 544 {\r
 545   elprintf(EL_UIO, "s68k unmapped w16 [%06x] %04x @%06x", a, d & 0xffff, SekPc);\r
 546 }\r
 547 \r
 548 // decode (080000 - 0bffff, in 1M mode)\r
 549 static u32 PicoReadS68k8_dec(u32 a)\r
 550 {\r
 551   u32 d, bank;\r
 552   bank = (Pico_mcd->s68k_regs[3] & 1) ^ 1;\r
 553   d = Pico_mcd->word_ram1M[bank][((a >> 1) ^ 1) & 0x1ffff];\r
 554   if (a & 1)\r
 555     d &= 0x0f;\r
 556   else\r
 557     d >>= 4;\r
 558   return d;\r
 559 }\r
 560 \r
 561 static u32 PicoReadS68k16_dec(u32 a)\r
 562 {\r
 563   u32 d, bank;\r
 564   bank = (Pico_mcd->s68k_regs[3] & 1) ^ 1;\r
 565   d = Pico_mcd->word_ram1M[bank][((a >> 1) ^ 1) & 0x1ffff];\r
 566   d |= d << 4;\r
 567   d &= ~0xf0;\r
 568   return d;\r
 569 }\r
 570 \r
 571 /* check: jaguar xj 220 (draws entire world using decode) */\r
 572 static void PicoWriteS68k8_dec(u32 a, u32 d)\r
 573 {\r
 574   u8 r3 = Pico_mcd->s68k_regs[3];\r
 575   u8 *pd = &Pico_mcd->word_ram1M[(r3 & 1) ^ 1][((a >> 1) ^ 1) & 0x1ffff];\r
 576   u8 oldmask = (a & 1) ? 0xf0 : 0x0f;\r
 577 \r
 578   r3 &= 0x18;\r
 579   d  &= 0x0f;\r
 580   if (!(a & 1))\r
 581     d <<= 4;\r
 582 \r
 583   if (r3 == 8) {\r
 584     if ((!(*pd & (~oldmask))) && d)\r
 585       goto do_it;\r
 586   } else if (r3 > 8) {\r
 587     if (d)\r
 588       goto do_it;\r
 589   } else\r
 590     goto do_it;\r
 591 \r
 592   return;\r
 593 \r
 594 do_it:\r
 595   *pd = d | (*pd & oldmask);\r
 596 }\r
 597 \r
 598 static void PicoWriteS68k16_dec(u32 a, u32 d)\r
 599 {\r
 600   u8 r3 = Pico_mcd->s68k_regs[3];\r
 601   u8 *pd = &Pico_mcd->word_ram1M[(r3 & 1) ^ 1][((a >> 1) ^ 1) & 0x1ffff];\r
 602 \r
 603   //if ((a & 0x3ffff) < 0x28000) return;\r
 604 \r
 605   r3 &= 0x18;\r
 606   d  &= 0x0f0f;\r
 607   d  |= d >> 4;\r
 608 \r
 609   if (r3 == 8) {\r
 610     u8 dold = *pd;\r
 611     if (!(dold & 0xf0)) dold |= d & 0xf0;\r
 612     if (!(dold & 0x0f)) dold |= d & 0x0f;\r
 613     *pd = dold;\r
 614   } else if (r3 > 8) {\r
 615     u8 dold = *pd;\r
 616     if (!(d & 0xf0)) d |= dold & 0xf0;\r
 617     if (!(d & 0x0f)) d |= dold & 0x0f;\r
 618     *pd = d;\r
 619   } else {\r
 620     *pd = d;\r
 621   }\r
 622 }\r
 623 \r
 624 // backup RAM (fe0000 - feffff)\r
 625 static u32 PicoReadS68k8_bram(u32 a)\r
 626 {\r
 627   return Pico_mcd->bram[(a>>1)&0x1fff];\r
 628 }\r
 629 \r
 630 static u32 PicoReadS68k16_bram(u32 a)\r
 631 {\r
 632   u32 d;\r
 633   elprintf(EL_ANOMALY, "FIXME: s68k_bram r16: [%06x] @%06x", a, SekPcS68k);\r
 634   a = (a >> 1) & 0x1fff;\r
 635   d = Pico_mcd->bram[a++];\r
 636   d|= Pico_mcd->bram[a++] << 8; // probably wrong, TODO: verify\r
 637   return d;\r
 638 }\r
 639 \r
 640 static void PicoWriteS68k8_bram(u32 a, u32 d)\r
 641 {\r
 642   Pico_mcd->bram[(a >> 1) & 0x1fff] = d;\r
 643   SRam.changed = 1;\r
 644 }\r
 645 \r
 646 static void PicoWriteS68k16_bram(u32 a, u32 d)\r
 647 {\r
 648   elprintf(EL_ANOMALY, "s68k_bram w16: [%06x] %04x @%06x", a, d, SekPcS68k);\r
 649   a = (a >> 1) & 0x1fff;\r
 650   Pico_mcd->bram[a++] = d;\r
 651   Pico_mcd->bram[a++] = d >> 8; // TODO: verify..\r
 652   SRam.changed = 1;\r
 653 }\r
 654 \r
 655 // PCM and registers (ff0000 - ffffff)\r
 656 static u32 PicoReadS68k8_pr(u32 a)\r
 657 {\r
 658   u32 d = 0;\r
 659 \r
 660   // regs\r
 661   if ((a & 0xfe00) == 0x8000) {\r
 662     a &= 0x1ff;\r
 663     elprintf(EL_CDREGS, "s68k_regs r8: [%02x] @ %06x", a, SekPcS68k);\r
 664     if (a >= 0x0e && a < 0x30) {\r
 665       d = Pico_mcd->s68k_regs[a];\r
 666       s68k_poll_detect(a, d);\r
 667       elprintf(EL_CDREGS, "ret = %02x", (u8)d);\r
 668       return d;\r
 669     }\r
 670     else if (a >= 0x58 && a < 0x68)\r
 671          d = gfx_cd_read(a & ~1);\r
 672     else d = s68k_reg_read16(a & ~1);\r
 673     if (!(a & 1))\r
 674       d >>= 8;\r
 675     elprintf(EL_CDREGS, "ret = %02x", (u8)d);\r
 676     return d & 0xff;\r
 677   }\r
 678 \r
 679   // PCM\r
 680   if ((a & 0x8000) == 0x0000) {\r
 681     a &= 0x7fff;\r
 682     if (a >= 0x2000)\r
 683       d = Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a >> 1) & 0xfff];\r
 684     else if (a >= 0x20) {\r
 685       a &= 0x1e;\r
 686       d = Pico_mcd->pcm.ch[a>>2].addr >> PCM_STEP_SHIFT;\r
 687       if (a & 2)\r
 688         d >>= 8;\r
 689     }\r
 690     return d & 0xff;\r
 691   }\r
 692 \r
 693   return s68k_unmapped_read8(a);\r
 694 }\r
 695 \r
 696 static u32 PicoReadS68k16_pr(u32 a)\r
 697 {\r
 698   u32 d = 0;\r
 699 \r
 700   // regs\r
 701   if ((a & 0xfe00) == 0x8000) {\r
 702     a &= 0x1fe;\r
 703     elprintf(EL_CDREGS, "s68k_regs r16: [%02x] @ %06x", a, SekPcS68k);\r
 704     if (0x58 <= a && a < 0x68)\r
 705          d = gfx_cd_read(a);\r
 706     else d = s68k_reg_read16(a);\r
 707     elprintf(EL_CDREGS, "ret = %04x", d);\r
 708     return d;\r
 709   }\r
 710 \r
 711   // PCM\r
 712   if ((a & 0x8000) == 0x0000) {\r
 713     //elprintf(EL_ANOMALY, "FIXME: s68k_pcm r16: [%06x] @%06x", a, SekPcS68k);\r
 714     a &= 0x7fff;\r
 715     if (a >= 0x2000)\r
 716       d = Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a>>1)&0xfff];\r
 717     else if (a >= 0x20) {\r
 718       a &= 0x1e;\r
 719       d = Pico_mcd->pcm.ch[a>>2].addr >> PCM_STEP_SHIFT;\r
 720       if (a & 2) d >>= 8;\r
 721     }\r
 722     elprintf(EL_CDREGS, "ret = %04x", d);\r
 723     return d;\r
 724   }\r
 725 \r
 726   return s68k_unmapped_read16(a);\r
 727 }\r
 728 \r
 729 static void PicoWriteS68k8_pr(u32 a, u32 d)\r
 730 {\r
 731   // regs\r
 732   if ((a & 0xfe00) == 0x8000) {\r
 733     a &= 0x1ff;\r
 734     elprintf(EL_CDREGS, "s68k_regs w8: [%02x] %02x @ %06x", a, d, SekPcS68k);\r
 735     if (0x58 <= a && a < 0x68)\r
 736          gfx_cd_write16(a&~1, (d<<8)|d);\r
 737     else s68k_reg_write8(a,d);\r
 738     return;\r
 739   }\r
 740 \r
 741   // PCM\r
 742   if ((a & 0x8000) == 0x0000) {\r
 743     a &= 0x7fff;\r
 744     if (a >= 0x2000)\r
 745       Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a>>1)&0xfff] = d;\r
 746     else if (a < 0x12)\r
 747       pcm_write(a>>1, d);\r
 748     return;\r
 749   }\r
 750 \r
 751   s68k_unmapped_write8(a, d);\r
 752 }\r
 753 \r
 754 static void PicoWriteS68k16_pr(u32 a, u32 d)\r
 755 {\r
 756   // regs\r
 757   if ((a & 0xfe00) == 0x8000) {\r
 758     a &= 0x1fe;\r
 759     elprintf(EL_CDREGS, "s68k_regs w16: [%02x] %04x @ %06x", a, d, SekPcS68k);\r
 760     if (a >= 0x58 && a < 0x68)\r
 761       gfx_cd_write16(a, d);\r
 762     else {\r
 763       if (a == 0xe) {\r
 764         // special case, 2 byte writes would be handled differently\r
 765         // TODO: verify\r
 766         Pico_mcd->s68k_regs[0xf] = d;\r
 767         return;\r
 768       }\r
 769       s68k_reg_write8(a,     d >> 8);\r
 770       s68k_reg_write8(a + 1, d & 0xff);\r
 771     }\r
 772     return;\r
 773   }\r
 774 \r
 775   // PCM\r
 776   if ((a & 0x8000) == 0x0000) {\r
 777     a &= 0x7fff;\r
 778     if (a >= 0x2000)\r
 779       Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a>>1)&0xfff] = d;\r
 780     else if (a < 0x12)\r
 781       pcm_write(a>>1, d & 0xff);\r
 782     return;\r
 783   }\r
 784 \r
 785   s68k_unmapped_write16(a, d);\r
 786 }\r
 787 \r
 788 // -----------------------------------------------------------------\r
 789 \r
 790 // TODO: probably split\r
 791 void PicoMemRemapCD(int r3)\r
 792 {\r
 793   void *bank;\r
 794 \r
 795   // PRG RAM\r
 796   if (Pico_mcd->m.busreq & 2) {\r
 797     bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3] >> 6];\r
 798     cpu68k_map_all_ram(0x020000, 0x03ffff, bank, 0);\r
 799   }\r
 800   else {\r
 801     m68k_map_unmap(0x020000, 0x03ffff);\r
 802   }\r
 803 \r
 804   // WORD RAM\r
 805   if (!(r3 & 4)) {\r
 806     // 2M mode. XXX: allowing access in all cases for simplicity\r
 807     bank = Pico_mcd->word_ram2M;\r
 808     cpu68k_map_all_ram(0x200000, 0x23ffff, bank, 0);\r
 809     cpu68k_map_all_ram(0x080000, 0x0bffff, bank, 1);\r
 810     // TODO: handle 0x0c0000\r
 811   }\r
 812   else {\r
 813     bank = Pico_mcd->word_ram1M[r3 & 1];\r
 814     cpu68k_map_all_ram(0x200000, 0x21ffff, bank, 0);\r
 815     bank = Pico_mcd->word_ram1M[(r3 & 1) ^ 1];\r
 816     cpu68k_map_all_ram(0x0c0000, 0x0effff, bank, 1);\r
 817     // "cell arrange" on m68k\r
 818     cpu68k_map_set(m68k_read8_map,   0x220000, 0x23ffff, PicoReadM68k8_cell, 1);\r
 819     cpu68k_map_set(m68k_read16_map,  0x220000, 0x23ffff, PicoReadM68k16_cell, 1);\r
 820     cpu68k_map_set(m68k_write8_map,  0x220000, 0x23ffff, PicoWriteM68k8_cell, 1);\r
 821     cpu68k_map_set(m68k_write16_map, 0x220000, 0x23ffff, PicoWriteM68k16_cell, 1);\r
 822     // "decode format" on s68k\r
 823     cpu68k_map_set(s68k_read8_map,   0x080000, 0x0bffff, PicoReadS68k8_dec, 1);\r
 824     cpu68k_map_set(s68k_read16_map,  0x080000, 0x0bffff, PicoReadS68k16_dec, 1);\r
 825     cpu68k_map_set(s68k_write8_map,  0x080000, 0x0bffff, PicoWriteS68k8_dec, 1);\r
 826     cpu68k_map_set(s68k_write16_map, 0x080000, 0x0bffff, PicoWriteS68k16_dec, 1);\r
 827   }\r
 828 \r
 829 #ifdef EMU_F68K\r
 830   // update fetchmap..\r
 831   int i;\r
 832   if (!(r3 & 4))\r
 833   {\r
 834     for (i = M68K_FETCHBANK1*2/16; (i<<(24-FAMEC_FETCHBITS)) < 0x240000; i++)\r
 835       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram2M - 0x200000;\r
 836   }\r
 837   else\r
 838   {\r
 839     for (i = M68K_FETCHBANK1*2/16; (i<<(24-FAMEC_FETCHBITS)) < 0x220000; i++)\r
 840       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram1M[r3 & 1] - 0x200000;\r
 841     for (i = M68K_FETCHBANK1*0x0c/0x100; (i<<(24-FAMEC_FETCHBITS)) < 0x0e0000; i++)\r
 842       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram1M[(r3&1)^1] - 0x0c0000;\r
 843   }\r
 844 #endif\r
 845 }\r
 846 \r
 847 #ifdef EMU_M68K\r
 848 static void m68k_mem_setup_cd(void);\r
 849 #endif\r
 850 \r
 851 PICO_INTERNAL void PicoMemSetupCD(void)\r
 852 {\r
 853   // setup default main68k map\r
 854   PicoMemSetup();\r
 855 \r
 856   // PicoMemRemapCD() will set up RAMs, so not done here\r
 857 \r
 858   // main68k map (BIOS mapped by PicoMemSetup()):\r
 859   // RAM cart\r
 860   if (PicoOpt & POPT_EN_MCD_RAMCART) {\r
 861     cpu68k_map_set(m68k_read8_map,   0x400000, 0x7fffff, PicoReadM68k8_ramc, 1);\r
 862     cpu68k_map_set(m68k_read16_map,  0x400000, 0x7fffff, PicoReadM68k16_ramc, 1);\r
 863     cpu68k_map_set(m68k_write8_map,  0x400000, 0x7fffff, PicoWriteM68k8_ramc, 1);\r
 864     cpu68k_map_set(m68k_write16_map, 0x400000, 0x7fffff, PicoWriteM68k16_ramc, 1);\r
 865   }\r
 866 \r
 867   // registers/IO:\r
 868   cpu68k_map_set(m68k_read8_map,   0xa10000, 0xa1ffff, PicoReadM68k8_io, 1);\r
 869   cpu68k_map_set(m68k_read16_map,  0xa10000, 0xa1ffff, PicoReadM68k16_io, 1);\r
 870   cpu68k_map_set(m68k_write8_map,  0xa10000, 0xa1ffff, PicoWriteM68k8_io, 1);\r
 871   cpu68k_map_set(m68k_write16_map, 0xa10000, 0xa1ffff, PicoWriteM68k16_io, 1);\r
 872 \r
 873   // sub68k map\r
 874   cpu68k_map_set(s68k_read8_map,   0x000000, 0xffffff, s68k_unmapped_read8, 1);\r
 875   cpu68k_map_set(s68k_read16_map,  0x000000, 0xffffff, s68k_unmapped_read16, 1);\r
 876   cpu68k_map_set(s68k_write8_map,  0x000000, 0xffffff, s68k_unmapped_write8, 1);\r
 877   cpu68k_map_set(s68k_write16_map, 0x000000, 0xffffff, s68k_unmapped_write16, 1);\r
 878 \r
 879   // PRG RAM\r
 880   cpu68k_map_set(s68k_read8_map,   0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 881   cpu68k_map_set(s68k_read16_map,  0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 882   cpu68k_map_set(s68k_write8_map,  0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 883   cpu68k_map_set(s68k_write16_map, 0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 884 \r
 885   // BRAM\r
 886   cpu68k_map_set(s68k_read8_map,   0xfe0000, 0xfeffff, PicoReadS68k8_bram, 1);\r
 887   cpu68k_map_set(s68k_read16_map,  0xfe0000, 0xfeffff, PicoReadS68k16_bram, 1);\r
 888   cpu68k_map_set(s68k_write8_map,  0xfe0000, 0xfeffff, PicoWriteS68k8_bram, 1);\r
 889   cpu68k_map_set(s68k_write16_map, 0xfe0000, 0xfeffff, PicoWriteS68k16_bram, 1);\r
 890 \r
 891   // PCM, regs\r
 892   cpu68k_map_set(s68k_read8_map,   0xff0000, 0xffffff, PicoReadS68k8_pr, 1);\r
 893   cpu68k_map_set(s68k_read16_map,  0xff0000, 0xffffff, PicoReadS68k16_pr, 1);\r
 894   cpu68k_map_set(s68k_write8_map,  0xff0000, 0xffffff, PicoWriteS68k8_pr, 1);\r
 895   cpu68k_map_set(s68k_write16_map, 0xff0000, 0xffffff, PicoWriteS68k16_pr, 1);\r
 896 \r
 897 #ifdef EMU_C68K\r
 898   // s68k\r
 899   PicoCpuCS68k.read8  = (void *)s68k_read8_map;\r
 900   PicoCpuCS68k.read16 = (void *)s68k_read16_map;\r
 901   PicoCpuCS68k.read32 = (void *)s68k_read16_map;\r
 902   PicoCpuCS68k.write8  = (void *)s68k_write8_map;\r
 903   PicoCpuCS68k.write16 = (void *)s68k_write16_map;\r
 904   PicoCpuCS68k.write32 = (void *)s68k_write16_map;\r
 905   PicoCpuCS68k.checkpc = NULL; /* unused */\r
 906   PicoCpuCS68k.fetch8  = NULL;\r
 907   PicoCpuCS68k.fetch16 = NULL;\r
 908   PicoCpuCS68k.fetch32 = NULL;\r
 909 #endif\r
 910 #ifdef EMU_F68K\r
 911   // s68k\r
 912   PicoCpuFS68k.read_byte  = s68k_read8;\r
 913   PicoCpuFS68k.read_word  = s68k_read16;\r
 914   PicoCpuFS68k.read_long  = s68k_read32;\r
 915   PicoCpuFS68k.write_byte = s68k_write8;\r
 916   PicoCpuFS68k.write_word = s68k_write16;\r
 917   PicoCpuFS68k.write_long = s68k_write32;\r
 918 \r
 919   // setup FAME fetchmap\r
 920   {\r
 921     int i;\r
 922     // M68k\r
 923     // by default, point everything to fitst 64k of ROM (BIOS)\r
 924     for (i = 0; i < M68K_FETCHBANK1; i++)\r
 925       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.rom - (i<<(24-FAMEC_FETCHBITS));\r
 926     // now real ROM (BIOS)\r
 927     for (i = 0; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < Pico.romsize; i++)\r
 928       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.rom;\r
 929     // .. and RAM\r
 930     for (i = M68K_FETCHBANK1*14/16; i < M68K_FETCHBANK1; i++)\r
 931       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.ram - (i<<(24-FAMEC_FETCHBITS));\r
 932     // S68k\r
 933     // PRG RAM is default\r
 934     for (i = 0; i < M68K_FETCHBANK1; i++)\r
 935       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->prg_ram - (i<<(24-FAMEC_FETCHBITS));\r
 936     // real PRG RAM\r
 937     for (i = 0; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < 0x80000; i++)\r
 938       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->prg_ram;\r
 939     // WORD RAM 2M area\r
 940     for (i = M68K_FETCHBANK1*0x08/0x100; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < 0xc0000; i++)\r
 941       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram2M - 0x80000;\r
 942     // PicoMemRemapCD() will setup word ram for both\r
 943   }\r
 944 #endif\r
 945 #ifdef EMU_M68K\r
 946   m68k_mem_setup_cd();\r
 947 #endif\r
 948 \r
 949   // m68k_poll_addr = m68k_poll_cnt = 0;\r
 950   s68k_poll_adclk = s68k_poll_cnt = 0;\r
 951 }\r
 952 \r
 953 \r
 954 #ifdef EMU_M68K\r
 955 u32  m68k_read8(u32 a);\r
 956 u32  m68k_read16(u32 a);\r
 957 u32  m68k_read32(u32 a);\r
 958 void m68k_write8(u32 a, u8 d);\r
 959 void m68k_write16(u32 a, u16 d);\r
 960 void m68k_write32(u32 a, u32 d);\r
 961 \r
 962 static unsigned int PicoReadCD8w (unsigned int a) {\r
 963         return m68ki_cpu_p == &PicoCpuMS68k ? s68k_read8(a) : m68k_read8(a);\r
 964 }\r
 965 static unsigned int PicoReadCD16w(unsigned int a) {\r
 966         return m68ki_cpu_p == &PicoCpuMS68k ? s68k_read16(a) : m68k_read16(a);\r
 967 }\r
 968 static unsigned int PicoReadCD32w(unsigned int a) {\r
 969         return m68ki_cpu_p == &PicoCpuMS68k ? s68k_read32(a) : m68k_read32(a);\r
 970 }\r
 971 static void PicoWriteCD8w (unsigned int a, unsigned char d) {\r
 972         if (m68ki_cpu_p == &PicoCpuMS68k) s68k_write8(a, d); else m68k_write8(a, d);\r
 973 }\r
 974 static void PicoWriteCD16w(unsigned int a, unsigned short d) {\r
 975         if (m68ki_cpu_p == &PicoCpuMS68k) s68k_write16(a, d); else m68k_write16(a, d);\r
 976 }\r
 977 static void PicoWriteCD32w(unsigned int a, unsigned int d) {\r
 978         if (m68ki_cpu_p == &PicoCpuMS68k) s68k_write32(a, d); else m68k_write32(a, d);\r
 979 }\r
 980 \r
 981 extern unsigned int (*pm68k_read_memory_8) (unsigned int address);\r
 982 extern unsigned int (*pm68k_read_memory_16)(unsigned int address);\r
 983 extern unsigned int (*pm68k_read_memory_32)(unsigned int address);\r
 984 extern void (*pm68k_write_memory_8) (unsigned int address, unsigned char  value);\r
 985 extern void (*pm68k_write_memory_16)(unsigned int address, unsigned short value);\r
 986 extern void (*pm68k_write_memory_32)(unsigned int address, unsigned int   value);\r
 987 \r
 988 static void m68k_mem_setup_cd(void)\r
 989 {\r
 990   pm68k_read_memory_8  = PicoReadCD8w;\r
 991   pm68k_read_memory_16 = PicoReadCD16w;\r
 992   pm68k_read_memory_32 = PicoReadCD32w;\r
 993   pm68k_write_memory_8  = PicoWriteCD8w;\r
 994   pm68k_write_memory_16 = PicoWriteCD16w;\r
 995   pm68k_write_memory_32 = PicoWriteCD32w;\r
 996 }\r
 997 #endif // EMU_M68K\r
 998 \r