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 #ifdef EMU_C68K\r
 791 static __inline int PicoMemBaseM68k(u32 pc)\r
 792 {\r
 793   if ((pc&0xe00000)==0xe00000)\r
 794     return (int)Pico.ram-(pc&0xff0000); // Program Counter in Ram\r
 795 \r
 796   if (pc < 0x20000)\r
 797     return (int)Pico_mcd->bios; // Program Counter in BIOS\r
 798 \r
 799   if ((pc&0xfc0000)==0x200000)\r
 800   {\r
 801     if (!(Pico_mcd->s68k_regs[3]&4))\r
 802       return (int)Pico_mcd->word_ram2M - 0x200000; // Program Counter in Word Ram\r
 803     if (pc < 0x220000) {\r
 804       int bank = Pico_mcd->s68k_regs[3]&1;\r
 805       return (int)Pico_mcd->word_ram1M[bank] - 0x200000;\r
 806     }\r
 807   }\r
 808 \r
 809   // Error - Program Counter is invalid\r
 810   elprintf(EL_ANOMALY, "m68k FIXME: unhandled jump to %06x", pc);\r
 811 \r
 812   return (int)Pico_mcd->bios;\r
 813 }\r
 814 \r
 815 \r
 816 static u32 PicoCheckPcM68k(u32 pc)\r
 817 {\r
 818   pc-=PicoCpuCM68k.membase; // Get real pc\r
 819   pc&=0xfffffe;\r
 820 \r
 821   PicoCpuCM68k.membase=PicoMemBaseM68k(pc);\r
 822 \r
 823   return PicoCpuCM68k.membase+pc;\r
 824 }\r
 825 \r
 826 \r
 827 static __inline int PicoMemBaseS68k(u32 pc)\r
 828 {\r
 829   if (pc < 0x80000)                     // PRG RAM\r
 830     return (int)Pico_mcd->prg_ram;\r
 831 \r
 832   if ((pc&0xfc0000)==0x080000)          // WORD RAM 2M area (assume we are in the right mode..)\r
 833     return (int)Pico_mcd->word_ram2M - 0x080000;\r
 834 \r
 835   if ((pc&0xfe0000)==0x0c0000) {        // word RAM 1M area\r
 836     int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
 837     return (int)Pico_mcd->word_ram1M[bank] - 0x0c0000;\r
 838   }\r
 839 \r
 840   // Error - Program Counter is invalid\r
 841   elprintf(EL_ANOMALY, "s68k FIXME: unhandled jump to %06x", pc);\r
 842 \r
 843   return (int)Pico_mcd->prg_ram;\r
 844 }\r
 845 \r
 846 \r
 847 static u32 PicoCheckPcS68k(u32 pc)\r
 848 {\r
 849   pc-=PicoCpuCS68k.membase; // Get real pc\r
 850   pc&=0xfffffe;\r
 851 \r
 852   PicoCpuCS68k.membase=PicoMemBaseS68k(pc);\r
 853 \r
 854   return PicoCpuCS68k.membase+pc;\r
 855 }\r
 856 #endif\r
 857 \r
 858 // TODO: probably split\r
 859 void PicoMemRemapCD(int r3)\r
 860 {\r
 861   void *bank;\r
 862 \r
 863   // PRG RAM\r
 864   if (Pico_mcd->m.busreq & 2) {\r
 865     bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3] >> 6];\r
 866     cpu68k_map_all_ram(0x020000, 0x03ffff, bank, 0);\r
 867   }\r
 868   else {\r
 869     m68k_map_unmap(0x020000, 0x03ffff);\r
 870   }\r
 871 \r
 872   // WORD RAM\r
 873   if (!(r3 & 4)) {\r
 874     // 2M mode. XXX: allowing access in all cases for simplicity\r
 875     bank = Pico_mcd->word_ram2M;\r
 876     cpu68k_map_all_ram(0x200000, 0x23ffff, bank, 0);\r
 877     cpu68k_map_all_ram(0x080000, 0x0bffff, bank, 1);\r
 878     // TODO: handle 0x0c0000\r
 879   }\r
 880   else {\r
 881     bank = Pico_mcd->word_ram1M[r3 & 1];\r
 882     cpu68k_map_all_ram(0x200000, 0x21ffff, bank, 0);\r
 883     bank = Pico_mcd->word_ram1M[(r3 & 1) ^ 1];\r
 884     cpu68k_map_all_ram(0x0c0000, 0x0effff, bank, 1);\r
 885     // "cell arrange" on m68k\r
 886     cpu68k_map_set(m68k_read8_map,   0x220000, 0x23ffff, PicoReadM68k8_cell, 1);\r
 887     cpu68k_map_set(m68k_read16_map,  0x220000, 0x23ffff, PicoReadM68k16_cell, 1);\r
 888     cpu68k_map_set(m68k_write8_map,  0x220000, 0x23ffff, PicoWriteM68k8_cell, 1);\r
 889     cpu68k_map_set(m68k_write16_map, 0x220000, 0x23ffff, PicoWriteM68k16_cell, 1);\r
 890     // "decode format" on s68k\r
 891     cpu68k_map_set(s68k_read8_map,   0x080000, 0x0bffff, PicoReadS68k8_dec, 1);\r
 892     cpu68k_map_set(s68k_read16_map,  0x080000, 0x0bffff, PicoReadS68k16_dec, 1);\r
 893     cpu68k_map_set(s68k_write8_map,  0x080000, 0x0bffff, PicoWriteS68k8_dec, 1);\r
 894     cpu68k_map_set(s68k_write16_map, 0x080000, 0x0bffff, PicoWriteS68k16_dec, 1);\r
 895   }\r
 896 \r
 897 #ifdef EMU_F68K\r
 898   // update fetchmap..\r
 899   int i;\r
 900   if (!(r3 & 4))\r
 901   {\r
 902     for (i = M68K_FETCHBANK1*2/16; (i<<(24-FAMEC_FETCHBITS)) < 0x240000; i++)\r
 903       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram2M - 0x200000;\r
 904   }\r
 905   else\r
 906   {\r
 907     for (i = M68K_FETCHBANK1*2/16; (i<<(24-FAMEC_FETCHBITS)) < 0x220000; i++)\r
 908       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram1M[r3 & 1] - 0x200000;\r
 909     for (i = M68K_FETCHBANK1*0x0c/0x100; (i<<(24-FAMEC_FETCHBITS)) < 0x0e0000; i++)\r
 910       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram1M[(r3&1)^1] - 0x0c0000;\r
 911   }\r
 912 #endif\r
 913 }\r
 914 \r
 915 #ifdef EMU_M68K\r
 916 static void m68k_mem_setup_cd(void);\r
 917 #endif\r
 918 \r
 919 PICO_INTERNAL void PicoMemSetupCD(void)\r
 920 {\r
 921   // setup default main68k map\r
 922   PicoMemSetup();\r
 923 \r
 924   // PicoMemRemapCD() will set up RAMs, so not done here\r
 925 \r
 926   // main68k map (BIOS mapped by PicoMemSetup()):\r
 927   // RAM cart\r
 928   if (PicoOpt & POPT_EN_MCD_RAMCART) {\r
 929     cpu68k_map_set(m68k_read8_map,   0x400000, 0x7fffff, PicoReadM68k8_ramc, 1);\r
 930     cpu68k_map_set(m68k_read16_map,  0x400000, 0x7fffff, PicoReadM68k16_ramc, 1);\r
 931     cpu68k_map_set(m68k_write8_map,  0x400000, 0x7fffff, PicoWriteM68k8_ramc, 1);\r
 932     cpu68k_map_set(m68k_write16_map, 0x400000, 0x7fffff, PicoWriteM68k16_ramc, 1);\r
 933   }\r
 934 \r
 935   // registers/IO:\r
 936   cpu68k_map_set(m68k_read8_map,   0xa10000, 0xa1ffff, PicoReadM68k8_io, 1);\r
 937   cpu68k_map_set(m68k_read16_map,  0xa10000, 0xa1ffff, PicoReadM68k16_io, 1);\r
 938   cpu68k_map_set(m68k_write8_map,  0xa10000, 0xa1ffff, PicoWriteM68k8_io, 1);\r
 939   cpu68k_map_set(m68k_write16_map, 0xa10000, 0xa1ffff, PicoWriteM68k16_io, 1);\r
 940 \r
 941   // sub68k map\r
 942   cpu68k_map_set(s68k_read8_map,   0x000000, 0xffffff, s68k_unmapped_read8, 1);\r
 943   cpu68k_map_set(s68k_read16_map,  0x000000, 0xffffff, s68k_unmapped_read16, 1);\r
 944   cpu68k_map_set(s68k_write8_map,  0x000000, 0xffffff, s68k_unmapped_write8, 1);\r
 945   cpu68k_map_set(s68k_write16_map, 0x000000, 0xffffff, s68k_unmapped_write16, 1);\r
 946 \r
 947   // PRG RAM\r
 948   cpu68k_map_set(s68k_read8_map,   0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 949   cpu68k_map_set(s68k_read16_map,  0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 950   cpu68k_map_set(s68k_write8_map,  0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 951   cpu68k_map_set(s68k_write16_map, 0x000000, 0x07ffff, Pico_mcd->prg_ram, 0);\r
 952 \r
 953   // BRAM\r
 954   cpu68k_map_set(s68k_read8_map,   0xfe0000, 0xfeffff, PicoReadS68k8_bram, 1);\r
 955   cpu68k_map_set(s68k_read16_map,  0xfe0000, 0xfeffff, PicoReadS68k16_bram, 1);\r
 956   cpu68k_map_set(s68k_write8_map,  0xfe0000, 0xfeffff, PicoWriteS68k8_bram, 1);\r
 957   cpu68k_map_set(s68k_write16_map, 0xfe0000, 0xfeffff, PicoWriteS68k16_bram, 1);\r
 958 \r
 959   // PCM, regs\r
 960   cpu68k_map_set(s68k_read8_map,   0xff0000, 0xffffff, PicoReadS68k8_pr, 1);\r
 961   cpu68k_map_set(s68k_read16_map,  0xff0000, 0xffffff, PicoReadS68k16_pr, 1);\r
 962   cpu68k_map_set(s68k_write8_map,  0xff0000, 0xffffff, PicoWriteS68k8_pr, 1);\r
 963   cpu68k_map_set(s68k_write16_map, 0xff0000, 0xffffff, PicoWriteS68k16_pr, 1);\r
 964 \r
 965 #ifdef EMU_C68K\r
 966   PicoCpuCM68k.checkpc = PicoCheckPcM68k;\r
 967   // s68k\r
 968   PicoCpuCS68k.checkpc = PicoCheckPcS68k;\r
 969   PicoCpuCS68k.fetch8  = PicoCpuCS68k.read8  = s68k_read8;\r
 970   PicoCpuCS68k.fetch16 = PicoCpuCS68k.read16 = s68k_read16;\r
 971   PicoCpuCS68k.fetch32 = PicoCpuCS68k.read32 = s68k_read32;\r
 972   PicoCpuCS68k.write8  = s68k_write8;\r
 973   PicoCpuCS68k.write16 = s68k_write16;\r
 974   PicoCpuCS68k.write32 = s68k_write32;\r
 975 #endif\r
 976 #ifdef EMU_F68K\r
 977   // s68k\r
 978   PicoCpuFS68k.read_byte  = s68k_read8;\r
 979   PicoCpuFS68k.read_word  = s68k_read16;\r
 980   PicoCpuFS68k.read_long  = s68k_read32;\r
 981   PicoCpuFS68k.write_byte = s68k_write8;\r
 982   PicoCpuFS68k.write_word = s68k_write16;\r
 983   PicoCpuFS68k.write_long = s68k_write32;\r
 984 \r
 985   // setup FAME fetchmap\r
 986   {\r
 987     int i;\r
 988     // M68k\r
 989     // by default, point everything to fitst 64k of ROM (BIOS)\r
 990     for (i = 0; i < M68K_FETCHBANK1; i++)\r
 991       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.rom - (i<<(24-FAMEC_FETCHBITS));\r
 992     // now real ROM (BIOS)\r
 993     for (i = 0; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < Pico.romsize; i++)\r
 994       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.rom;\r
 995     // .. and RAM\r
 996     for (i = M68K_FETCHBANK1*14/16; i < M68K_FETCHBANK1; i++)\r
 997       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.ram - (i<<(24-FAMEC_FETCHBITS));\r
 998     // S68k\r
 999     // PRG RAM is default\r
1000     for (i = 0; i < M68K_FETCHBANK1; i++)\r
1001       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->prg_ram - (i<<(24-FAMEC_FETCHBITS));\r
1002     // real PRG RAM\r
1003     for (i = 0; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < 0x80000; i++)\r
1004       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->prg_ram;\r
1005     // WORD RAM 2M area\r
1006     for (i = M68K_FETCHBANK1*0x08/0x100; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < 0xc0000; i++)\r
1007       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram2M - 0x80000;\r
1008     // PicoMemRemapCD() will setup word ram for both\r
1009   }\r
1010 #endif\r
1011 #ifdef EMU_M68K\r
1012   m68k_mem_setup_cd();\r
1013 #endif\r
1014 \r
1015   // m68k_poll_addr = m68k_poll_cnt = 0;\r
1016   s68k_poll_adclk = s68k_poll_cnt = 0;\r
1017 }\r
1018 \r
1019 \r
1020 #ifdef EMU_M68K\r
1021 u32  m68k_read8(u32 a);\r
1022 u32  m68k_read16(u32 a);\r
1023 u32  m68k_read32(u32 a);\r
1024 void m68k_write8(u32 a, u8 d);\r
1025 void m68k_write16(u32 a, u16 d);\r
1026 void m68k_write32(u32 a, u32 d);\r
1027 \r
1028 static unsigned int PicoReadCD8w (unsigned int a) {\r
1029         return m68ki_cpu_p == &PicoCpuMS68k ? s68k_read8(a) : m68k_read8(a);\r
1030 }\r
1031 static unsigned int PicoReadCD16w(unsigned int a) {\r
1032         return m68ki_cpu_p == &PicoCpuMS68k ? s68k_read16(a) : m68k_read16(a);\r
1033 }\r
1034 static unsigned int PicoReadCD32w(unsigned int a) {\r
1035         return m68ki_cpu_p == &PicoCpuMS68k ? s68k_read32(a) : m68k_read32(a);\r
1036 }\r
1037 static void PicoWriteCD8w (unsigned int a, unsigned char d) {\r
1038         if (m68ki_cpu_p == &PicoCpuMS68k) s68k_write8(a, d); else m68k_write8(a, d);\r
1039 }\r
1040 static void PicoWriteCD16w(unsigned int a, unsigned short d) {\r
1041         if (m68ki_cpu_p == &PicoCpuMS68k) s68k_write16(a, d); else m68k_write16(a, d);\r
1042 }\r
1043 static void PicoWriteCD32w(unsigned int a, unsigned int d) {\r
1044         if (m68ki_cpu_p == &PicoCpuMS68k) s68k_write32(a, d); else m68k_write32(a, d);\r
1045 }\r
1046 \r
1047 extern unsigned int (*pm68k_read_memory_8) (unsigned int address);\r
1048 extern unsigned int (*pm68k_read_memory_16)(unsigned int address);\r
1049 extern unsigned int (*pm68k_read_memory_32)(unsigned int address);\r
1050 extern void (*pm68k_write_memory_8) (unsigned int address, unsigned char  value);\r
1051 extern void (*pm68k_write_memory_16)(unsigned int address, unsigned short value);\r
1052 extern void (*pm68k_write_memory_32)(unsigned int address, unsigned int   value);\r
1053 \r
1054 static void m68k_mem_setup_cd(void)\r
1055 {\r
1056   pm68k_read_memory_8  = PicoReadCD8w;\r
1057   pm68k_read_memory_16 = PicoReadCD16w;\r
1058   pm68k_read_memory_32 = PicoReadCD32w;\r
1059   pm68k_write_memory_8  = PicoWriteCD8w;\r
1060   pm68k_write_memory_16 = PicoWriteCD16w;\r
1061   pm68k_write_memory_32 = PicoWriteCD32w;\r
1062 }\r
1063 #endif // EMU_M68K\r
1064 \r