Pico/cd/Memory.c

   1 // Memory I/O handlers for Sega/Mega CD.\r
   2 // Loosely based on Gens code.\r
   3 // (c) Copyright 2007, Grazvydas "notaz" Ignotas\r
   4 \r
   5 \r
   6 //#define __debug_io\r
   7 \r
   8 #include "../PicoInt.h"\r
   9 \r
  10 #include "../sound/ym2612.h"\r
  11 #include "../sound/sn76496.h"\r
  12 \r
  13 #include "gfx_cd.h"\r
  14 #include "pcm.h"\r
  15 \r
  16 #ifndef UTYPES_DEFINED\r
  17 typedef unsigned char  u8;\r
  18 typedef unsigned short u16;\r
  19 typedef unsigned int   u32;\r
  20 #define UTYPES_DEFINED\r
  21 #endif\r
  22 \r
  23 //#define __debug_io\r
  24 //#define __debug_io2\r
  25 \r
  26 //#define rdprintf dprintf\r
  27 #define rdprintf(...)\r
  28 //#define wrdprintf dprintf\r
  29 #define wrdprintf(...)\r
  30 #define plprintf dprintf\r
  31 //#define plprintf(...)\r
  32 \r
  33 #ifdef EMU_CORE_DEBUG\r
  34 extern u32 lastread_a, lastread_d[16], lastwrite_cyc_d[16];\r
  35 extern int lrp_cyc, lwp_cyc;\r
  36 #undef USE_POLL_DETECT\r
  37 #endif\r
  38 \r
  39 // -----------------------------------------------------------------\r
  40 \r
  41 // poller detection\r
  42 #define POLL_LIMIT 16\r
  43 #define POLL_CYCLES 124\r
  44 // int m68k_poll_addr, m68k_poll_cnt;\r
  45 unsigned int s68k_poll_adclk, s68k_poll_cnt;\r
  46 \r
  47 #ifndef _ASM_CD_MEMORY_C\r
  48 static u32 m68k_reg_read16(u32 a)\r
  49 {\r
  50   u32 d=0;\r
  51   a &= 0x3e;\r
  52   // dprintf("m68k_regs r%2i: [%02x] @%06x", realsize&~1, a+(realsize&1), SekPc);\r
  53 \r
  54   switch (a) {\r
  55     case 0:\r
  56       d = ((Pico_mcd->s68k_regs[0x33]<<13)&0x8000) | Pico_mcd->m.busreq; // here IFL2 is always 0, just like in Gens\r
  57       goto end;\r
  58     case 2:\r
  59       d = (Pico_mcd->s68k_regs[a]<<8) | (Pico_mcd->s68k_regs[a+1]&0xc7);\r
  60       // the DMNA delay must only be visible on s68k side (Lunar2, Silpheed)\r
  61       if (Pico_mcd->m.state_flags&2) { d &= ~1; d |= 2; }\r
  62       //printf("m68k_regs r3: %02x @%06x\n", (u8)d, SekPc);\r
  63       goto end;\r
  64     case 4:\r
  65       d = Pico_mcd->s68k_regs[4]<<8;\r
  66       goto end;\r
  67     case 6:\r
  68       d = *(u16 *)(Pico_mcd->bios + 0x72);\r
  69       goto end;\r
  70     case 8:\r
  71       d = Read_CDC_Host(0);\r
  72       goto end;\r
  73     case 0xA:\r
  74       dprintf("m68k FIXME: reserved read");\r
  75       goto end;\r
  76     case 0xC:\r
  77       d = Pico_mcd->m.timer_stopwatch >> 16;\r
  78       dprintf("m68k stopwatch timer read (%04x)", d);\r
  79       goto end;\r
  80   }\r
  81 \r
  82   if (a < 0x30) {\r
  83     // comm flag/cmd/status (0xE-0x2F)\r
  84     d = (Pico_mcd->s68k_regs[a]<<8) | Pico_mcd->s68k_regs[a+1];\r
  85     goto end;\r
  86   }\r
  87 \r
  88   dprintf("m68k_regs FIXME invalid read @ %02x", a);\r
  89 \r
  90 end:\r
  91 \r
  92   // dprintf("ret = %04x", d);\r
  93   return d;\r
  94 }\r
  95 #endif\r
  96 \r
  97 #ifndef _ASM_CD_MEMORY_C\r
  98 static\r
  99 #endif\r
 100 void m68k_reg_write8(u32 a, u32 d)\r
 101 {\r
 102   a &= 0x3f;\r
 103   // dprintf("m68k_regs w%2i: [%02x] %02x @%06x", realsize, a, d, SekPc);\r
 104 \r
 105   switch (a) {\r
 106     case 0:\r
 107       d &= 1;\r
 108       if ((d&1) && (Pico_mcd->s68k_regs[0x33]&(1<<2))) { dprintf("m68k: s68k irq 2"); SekInterruptS68k(2); }\r
 109       return;\r
 110     case 1:\r
 111       d &= 3;\r
 112       if (!(d&1)) Pico_mcd->m.state_flags |= 1; // reset pending, needed to be sure we fetch the right vectors on reset\r
 113       if ( (Pico_mcd->m.busreq&1) != (d&1)) dprintf("m68k: s68k reset %i", !(d&1));\r
 114       if ( (Pico_mcd->m.busreq&2) != (d&2)) dprintf("m68k: s68k brq %i", (d&2)>>1);\r
 115       if ((Pico_mcd->m.state_flags&1) && (d&3)==1) {\r
 116         SekResetS68k(); // S68k comes out of RESET or BRQ state\r
 117         Pico_mcd->m.state_flags&=~1;\r
 118         dprintf("m68k: resetting s68k, cycles=%i", SekCyclesLeft);\r
 119       }\r
 120       Pico_mcd->m.busreq = d;\r
 121       return;\r
 122     case 2:\r
 123       dprintf("m68k: prg wp=%02x", d);\r
 124       Pico_mcd->s68k_regs[2] = d; // really use s68k side register\r
 125       return;\r
 126     case 3: {\r
 127       u32 dold = Pico_mcd->s68k_regs[3]&0x1f;\r
 128       //printf("m68k_regs w3: %02x @%06x\n", (u8)d, SekPc);\r
 129       d &= 0xc2;\r
 130       if ((dold>>6) != ((d>>6)&3))\r
 131         dprintf("m68k: prg bank: %i -> %i", (Pico_mcd->s68k_regs[a]>>6), ((d>>6)&3));\r
 132       //if ((Pico_mcd->s68k_regs[3]&4) != (d&4)) dprintf("m68k: ram mode %i mbit", (d&4) ? 1 : 2);\r
 133       //if ((Pico_mcd->s68k_regs[3]&2) != (d&2)) dprintf("m68k: %s", (d&4) ? ((d&2) ? "word swap req" : "noop?") :\r
 134       //                                             ((d&2) ? "word ram to s68k" : "word ram to m68k"));\r
 135       if (dold & 4) {\r
 136         d ^= 2;                // writing 0 to DMNA actually sets it, 1 does nothing\r
 137       } else {\r
 138         //dold &= ~2; // ??\r
 139 #if 1\r
 140         if ((d & 2) && !(dold & 2)) {\r
 141           Pico_mcd->m.state_flags |= 2; // we must delay setting DMNA bit (needed for Silpheed)\r
 142           d &= ~2;\r
 143         }\r
 144 #else\r
 145         if (d & 2) dold &= ~1; // return word RAM to s68k in 2M mode\r
 146 #endif\r
 147       }\r
 148       Pico_mcd->s68k_regs[3] = d | dold; // really use s68k side register\r
 149 #ifdef USE_POLL_DETECT\r
 150       if ((s68k_poll_adclk&0xfe) == 2 && s68k_poll_cnt > POLL_LIMIT) {\r
 151         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 152         plprintf("s68k poll release, a=%02x\n", a);\r
 153       }\r
 154 #endif\r
 155       return;\r
 156     }\r
 157     case 6:\r
 158       Pico_mcd->bios[0x72 + 1] = d; // simple hint vector changer\r
 159       return;\r
 160     case 7:\r
 161       Pico_mcd->bios[0x72] = d;\r
 162       dprintf("hint vector set to %08x", PicoRead32(0x70));\r
 163       return;\r
 164     case 0xf:\r
 165       d = (d << 1) | ((d >> 7) & 1); // rol8 1 (special case)\r
 166     case 0xe:\r
 167       //dprintf("m68k: comm flag: %02x", d);\r
 168       Pico_mcd->s68k_regs[0xe] = d;\r
 169 #ifdef USE_POLL_DETECT\r
 170       if ((s68k_poll_adclk&0xfe) == 0xe && s68k_poll_cnt > POLL_LIMIT) {\r
 171         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 172         plprintf("s68k poll release, a=%02x\n", a);\r
 173       }\r
 174 #endif\r
 175       return;\r
 176   }\r
 177 \r
 178   if ((a&0xf0) == 0x10) {\r
 179       Pico_mcd->s68k_regs[a] = d;\r
 180 #ifdef USE_POLL_DETECT\r
 181       if ((a&0xfe) == (s68k_poll_adclk&0xfe) && s68k_poll_cnt > POLL_LIMIT) {\r
 182         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 183         plprintf("s68k poll release, a=%02x\n", a);\r
 184       }\r
 185 #endif\r
 186       return;\r
 187   }\r
 188 \r
 189   dprintf("m68k FIXME: invalid write? [%02x] %02x", a, d);\r
 190 }\r
 191 \r
 192 #ifndef _ASM_CD_MEMORY_C\r
 193 static\r
 194 #endif\r
 195 u32 s68k_poll_detect(u32 a, u32 d)\r
 196 {\r
 197 #ifdef USE_POLL_DETECT\r
 198   // polling detection\r
 199   if (a == (s68k_poll_adclk&0xff)) {\r
 200     unsigned int clkdiff = SekCyclesDoneS68k() - (s68k_poll_adclk>>8);\r
 201     if (clkdiff <= POLL_CYCLES) {\r
 202       s68k_poll_cnt++;\r
 203       //printf("-- diff: %u, cnt = %i\n", clkdiff, s68k_poll_cnt);\r
 204       if (s68k_poll_cnt > POLL_LIMIT) {\r
 205         SekSetStopS68k(1);\r
 206         plprintf("s68k poll detected @ %06x, a=%02x\n", SekPcS68k, a);\r
 207       }\r
 208       s68k_poll_adclk = (SekCyclesDoneS68k() << 8) | a;\r
 209       return d;\r
 210     }\r
 211   }\r
 212   s68k_poll_adclk = (SekCyclesDoneS68k() << 8) | a;\r
 213   s68k_poll_cnt = 0;\r
 214 #endif\r
 215   return d;\r
 216 }\r
 217 \r
 218 #define READ_FONT_DATA(basemask) \\r
 219 { \\r
 220       unsigned int fnt = *(unsigned int *)(Pico_mcd->s68k_regs + 0x4c); \\r
 221       unsigned int col0 = (fnt >> 8) & 0x0f, col1 = (fnt >> 12) & 0x0f;   \\r
 222       if (fnt & (basemask << 0)) d  = col1      ; else d  = col0;       \\r
 223       if (fnt & (basemask << 1)) d |= col1 <<  4; else d |= col0 <<  4; \\r
 224       if (fnt & (basemask << 2)) d |= col1 <<  8; else d |= col0 <<  8; \\r
 225       if (fnt & (basemask << 3)) d |= col1 << 12; else d |= col0 << 12; \\r
 226 }\r
 227 \r
 228 \r
 229 #ifndef _ASM_CD_MEMORY_C\r
 230 static\r
 231 #endif\r
 232 u32 s68k_reg_read16(u32 a)\r
 233 {\r
 234   u32 d=0;\r
 235 \r
 236   // dprintf("s68k_regs r%2i: [%02x] @ %06x", realsize&~1, a+(realsize&1), SekPcS68k);\r
 237 \r
 238   switch (a) {\r
 239     case 0:\r
 240       return ((Pico_mcd->s68k_regs[0]&3)<<8) | 1; // ver = 0, not in reset state\r
 241     case 2:\r
 242       d = (Pico_mcd->s68k_regs[2]<<8) | (Pico_mcd->s68k_regs[3]&0x1f);\r
 243       //printf("s68k_regs r3: %02x @%06x\n", (u8)d, SekPcS68k);\r
 244       return s68k_poll_detect(a, d);\r
 245     case 6:\r
 246       return CDC_Read_Reg();\r
 247     case 8:\r
 248       return Read_CDC_Host(1); // Gens returns 0 here on byte reads\r
 249     case 0xC:\r
 250       d = Pico_mcd->m.timer_stopwatch >> 16;\r
 251       dprintf("s68k stopwatch timer read (%04x)", d);\r
 252       return d;\r
 253     case 0x30:\r
 254       dprintf("s68k int3 timer read (%02x)", Pico_mcd->s68k_regs[31]);\r
 255       return Pico_mcd->s68k_regs[31];\r
 256     case 0x34: // fader\r
 257       return 0; // no busy bit\r
 258     case 0x50: // font data (check: Lunar 2, Silpheed)\r
 259       READ_FONT_DATA(0x00100000);\r
 260       return d;\r
 261     case 0x52:\r
 262       READ_FONT_DATA(0x00010000);\r
 263       return d;\r
 264     case 0x54:\r
 265       READ_FONT_DATA(0x10000000);\r
 266       return d;\r
 267     case 0x56:\r
 268       READ_FONT_DATA(0x01000000);\r
 269       return d;\r
 270   }\r
 271 \r
 272   d = (Pico_mcd->s68k_regs[a]<<8) | Pico_mcd->s68k_regs[a+1];\r
 273 \r
 274   if (a >= 0x0e && a < 0x30)\r
 275     return s68k_poll_detect(a, d);\r
 276 \r
 277   return d;\r
 278 }\r
 279 \r
 280 #ifndef _ASM_CD_MEMORY_C\r
 281 static\r
 282 #endif\r
 283 void s68k_reg_write8(u32 a, u32 d)\r
 284 {\r
 285   //dprintf("s68k_regs w%2i: [%02x] %02x @ %06x", realsize, a, d, SekPcS68k);\r
 286 \r
 287   // Warning: d might have upper bits set\r
 288   switch (a) {\r
 289     case 2:\r
 290       return; // only m68k can change WP\r
 291     case 3: {\r
 292       int dold = Pico_mcd->s68k_regs[3];\r
 293       //printf("s68k_regs w3: %02x @%06x\n", (u8)d, SekPcS68k);\r
 294       d &= 0x1d;\r
 295       d |= dold&0xc2;\r
 296       if (d&4) {\r
 297         if ((d ^ dold) & 5) {\r
 298           d &= ~2; // in case of mode or bank change we clear DMNA (m68k req) bit\r
 299           PicoMemResetCD(d);\r
 300         }\r
 301 #ifdef _ASM_CD_MEMORY_C\r
 302         if ((d ^ dold) & 0x1d)\r
 303           PicoMemResetCDdecode(d);\r
 304 #endif\r
 305         if (!(dold & 4)) {\r
 306           dprintf("wram mode 2M->1M");\r
 307           wram_2M_to_1M(Pico_mcd->word_ram2M);\r
 308         }\r
 309       } else {\r
 310         if (dold & 4) {\r
 311           dprintf("wram mode 1M->2M");\r
 312           if (!(d&1)) { // it didn't set the ret bit, which means it doesn't want to give WRAM to m68k\r
 313             d &= ~3;\r
 314             d |= (dold&1) ? 2 : 1; // then give it to the one which had bank0 in 1M mode\r
 315           }\r
 316           wram_1M_to_2M(Pico_mcd->word_ram2M);\r
 317           PicoMemResetCD(d);\r
 318         }\r
 319         else\r
 320           d |= dold&1;\r
 321         if (d&1) d &= ~2; // return word RAM to m68k in 2M mode\r
 322       }\r
 323       break;\r
 324     }\r
 325     case 4:\r
 326       dprintf("s68k CDC dest: %x", d&7);\r
 327       Pico_mcd->s68k_regs[4] = (Pico_mcd->s68k_regs[4]&0xC0) | (d&7); // CDC mode\r
 328       return;\r
 329     case 5:\r
 330       //dprintf("s68k CDC reg addr: %x", d&0xf);\r
 331       break;\r
 332     case 7:\r
 333       CDC_Write_Reg(d);\r
 334       return;\r
 335     case 0xa:\r
 336       dprintf("s68k set CDC dma addr");\r
 337       break;\r
 338     case 0xc:\r
 339     case 0xd:\r
 340       dprintf("s68k set stopwatch timer");\r
 341       Pico_mcd->m.timer_stopwatch = 0;\r
 342       return;\r
 343     case 0xe:\r
 344       Pico_mcd->s68k_regs[0xf] = (d>>1) | (d<<7); // ror8 1, Gens note: Dragons lair\r
 345       return;\r
 346     case 0x31:\r
 347       dprintf("s68k set int3 timer: %02x", d);\r
 348       Pico_mcd->m.timer_int3 = (d & 0xff) << 16;\r
 349       break;\r
 350     case 0x33: // IRQ mask\r
 351       dprintf("s68k irq mask: %02x", d);\r
 352       if ((d&(1<<4)) && (Pico_mcd->s68k_regs[0x37]&4) && !(Pico_mcd->s68k_regs[0x33]&(1<<4))) {\r
 353         CDD_Export_Status();\r
 354       }\r
 355       break;\r
 356     case 0x34: // fader\r
 357       Pico_mcd->s68k_regs[a] = (u8) d & 0x7f;\r
 358       return;\r
 359     case 0x36:\r
 360       return; // d/m bit is unsetable\r
 361     case 0x37: {\r
 362       u32 d_old = Pico_mcd->s68k_regs[0x37];\r
 363       Pico_mcd->s68k_regs[0x37] = d&7;\r
 364       if ((d&4) && !(d_old&4)) {\r
 365         CDD_Export_Status();\r
 366       }\r
 367       return;\r
 368     }\r
 369     case 0x4b:\r
 370       Pico_mcd->s68k_regs[a] = (u8) d;\r
 371       CDD_Import_Command();\r
 372       return;\r
 373   }\r
 374 \r
 375   if ((a&0x1f0) == 0x10 || (a >= 0x38 && a < 0x42))\r
 376   {\r
 377     dprintf("s68k FIXME: invalid write @ %02x?", a);\r
 378     return;\r
 379   }\r
 380 \r
 381   Pico_mcd->s68k_regs[a] = (u8) d;\r
 382 }\r
 383 \r
 384 \r
 385 #ifndef _ASM_CD_MEMORY_C\r
 386 static u32 OtherRead16End(u32 a, int realsize)\r
 387 {\r
 388   u32 d=0;\r
 389 \r
 390   if ((a&0xffffc0)==0xa12000) {\r
 391     d=m68k_reg_read16(a);\r
 392     goto end;\r
 393   }\r
 394 \r
 395   if (a==0x400000) {\r
 396     if (SRam.data != NULL) d=3; // 64k cart\r
 397     goto end;\r
 398   }\r
 399 \r
 400   if ((a&0xfe0000)==0x600000) {\r
 401     if (SRam.data != NULL) {\r
 402       d=SRam.data[((a>>1)&0xffff)+0x2000];\r
 403       if (realsize == 8) d|=d<<8;\r
 404     }\r
 405     goto end;\r
 406   }\r
 407 \r
 408   if (a==0x7ffffe) {\r
 409     d=Pico_mcd->m.bcram_reg;\r
 410     goto end;\r
 411   }\r
 412 \r
 413   dprintf("m68k FIXME: unusual r%i: %06x @%06x", realsize&~1, (a&0xfffffe)+(realsize&1), SekPc);\r
 414 \r
 415 end:\r
 416   return d;\r
 417 }\r
 418 \r
 419 \r
 420 static void OtherWrite8End(u32 a, u32 d, int realsize)\r
 421 {\r
 422   if ((a&0xffffc0)==0xa12000) { m68k_reg_write8(a, d); return; }\r
 423 \r
 424   if ((a&0xfe0000)==0x600000) {\r
 425     if (SRam.data != NULL && (Pico_mcd->m.bcram_reg&1)) {\r
 426       SRam.data[((a>>1)&0xffff)+0x2000]=d;\r
 427       SRam.changed = 1;\r
 428     }\r
 429     return;\r
 430   }\r
 431 \r
 432   if (a==0x7fffff) {\r
 433     Pico_mcd->m.bcram_reg=d;\r
 434     return;\r
 435   }\r
 436 \r
 437   dprintf("m68k FIXME: strange w%i: [%06x], %08x @%06x", realsize, a&0xffffff, d, SekPc);\r
 438 }\r
 439 \r
 440 #define _CD_MEMORY_C\r
 441 #undef _ASM_MEMORY_C\r
 442 #include "../MemoryCmn.c"\r
 443 #include "cell_map.c"\r
 444 #endif // !def _ASM_CD_MEMORY_C\r
 445 \r
 446 \r
 447 // -----------------------------------------------------------------\r
 448 //                     Read Rom and read Ram\r
 449 \r
 450 #ifdef _ASM_CD_MEMORY_C\r
 451 u32 PicoReadM68k8(u32 a);\r
 452 #else\r
 453 static u32 PicoReadM68k8(u32 a)\r
 454 {\r
 455   u32 d=0;\r
 456 \r
 457   a&=0xffffff;\r
 458 \r
 459   switch (a >> 17)\r
 460   {\r
 461     case 0x00>>1: // BIOS: 000000 - 020000\r
 462       d = *(u8 *)(Pico_mcd->bios+(a^1));\r
 463       break;\r
 464     case 0x02>>1: // prg RAM\r
 465       if ((Pico_mcd->m.busreq&3)!=1) {\r
 466         u8 *prg_bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3]>>6];\r
 467         d = *(prg_bank+((a^1)&0x1ffff));\r
 468       }\r
 469       break;\r
 470     case 0x20>>1: // word RAM: 200000 - 220000\r
 471       wrdprintf("m68k_wram r8: [%06x] @%06x", a, SekPc);\r
 472       a &= 0x1ffff;\r
 473       if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 474         int bank = Pico_mcd->s68k_regs[3]&1;\r
 475         d = Pico_mcd->word_ram1M[bank][a^1];\r
 476       } else {\r
 477         // allow access in any mode, like Gens does\r
 478         d = Pico_mcd->word_ram2M[a^1];\r
 479       }\r
 480       wrdprintf("ret = %02x", (u8)d);\r
 481       break;\r
 482     case 0x22>>1: // word RAM: 220000 - 240000\r
 483       wrdprintf("m68k_wram r8: [%06x] @%06x", a, SekPc);\r
 484       if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 485         int bank = Pico_mcd->s68k_regs[3]&1;\r
 486         a = (a&3) | (cell_map(a >> 2) << 2); // cell arranged\r
 487         d = Pico_mcd->word_ram1M[bank][a^1];\r
 488       } else {\r
 489         // allow access in any mode, like Gens does\r
 490         d = Pico_mcd->word_ram2M[(a^1)&0x3ffff];\r
 491       }\r
 492       wrdprintf("ret = %02x", (u8)d);\r
 493       break;\r
 494     case 0xc0>>1: case 0xc2>>1: case 0xc4>>1: case 0xc6>>1:\r
 495     case 0xc8>>1: case 0xca>>1: case 0xcc>>1: case 0xce>>1:\r
 496     case 0xd0>>1: case 0xd2>>1: case 0xd4>>1: case 0xd6>>1:\r
 497     case 0xd8>>1: case 0xda>>1: case 0xdc>>1: case 0xde>>1:\r
 498       // VDP\r
 499       if ((a&0xe700e0)==0xc00000) {\r
 500         d=PicoVideoRead(a);\r
 501         if ((a&1)==0) d>>=8;\r
 502       }\r
 503       break;\r
 504     case 0xe0>>1: case 0xe2>>1: case 0xe4>>1: case 0xe6>>1:\r
 505     case 0xe8>>1: case 0xea>>1: case 0xec>>1: case 0xee>>1:\r
 506     case 0xf0>>1: case 0xf2>>1: case 0xf4>>1: case 0xf6>>1:\r
 507     case 0xf8>>1: case 0xfa>>1: case 0xfc>>1: case 0xfe>>1:\r
 508       // RAM:\r
 509       d = *(u8 *)(Pico.ram+((a^1)&0xffff));\r
 510       break;\r
 511     default:\r
 512       if ((a&0xff4000)==0xa00000) { d=z80Read8(a); break; } // Z80 Ram\r
 513       if ((a&0xffffc0)==0xa12000)\r
 514         rdprintf("m68k_regs r8: [%02x] @%06x", a&0x3f, SekPc);\r
 515 \r
 516       d=OtherRead16(a&~1, 8|(a&1)); if ((a&1)==0) d>>=8;\r
 517 \r
 518       if ((a&0xffffc0)==0xa12000)\r
 519         rdprintf("ret = %02x", (u8)d);\r
 520       break;\r
 521   }\r
 522 \r
 523 \r
 524 #ifdef __debug_io\r
 525   dprintf("r8 : %06x,   %02x @%06x", a&0xffffff, (u8)d, SekPc);\r
 526 #endif\r
 527 #ifdef EMU_CORE_DEBUG\r
 528   if (a>=Pico.romsize) {\r
 529     lastread_a = a;\r
 530     lastread_d[lrp_cyc++&15] = d;\r
 531   }\r
 532 #endif\r
 533   return d;\r
 534 }\r
 535 #endif\r
 536 \r
 537 \r
 538 #ifdef _ASM_CD_MEMORY_C\r
 539 u32 PicoReadM68k16(u32 a);\r
 540 #else\r
 541 static u32 PicoReadM68k16(u32 a)\r
 542 {\r
 543   u32 d=0;\r
 544 \r
 545   a&=0xfffffe;\r
 546 \r
 547   switch (a >> 17)\r
 548   {\r
 549     case 0x00>>1: // BIOS: 000000 - 020000\r
 550       d = *(u16 *)(Pico_mcd->bios+a);\r
 551       break;\r
 552     case 0x02>>1: // prg RAM\r
 553       if ((Pico_mcd->m.busreq&3)!=1) {\r
 554         u8 *prg_bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3]>>6];\r
 555         wrdprintf("m68k_prgram r16: [%i,%06x] @%06x", Pico_mcd->s68k_regs[3]>>6, a, SekPc);\r
 556         d = *(u16 *)(prg_bank+(a&0x1fffe));\r
 557         wrdprintf("ret = %04x", d);\r
 558       }\r
 559       break;\r
 560     case 0x20>>1: // word RAM: 200000 - 220000\r
 561       wrdprintf("m68k_wram r16: [%06x] @%06x", a, SekPc);\r
 562       a &= 0x1fffe;\r
 563       if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 564         int bank = Pico_mcd->s68k_regs[3]&1;\r
 565         d = *(u16 *)(Pico_mcd->word_ram1M[bank]+a);\r
 566       } else {\r
 567         // allow access in any mode, like Gens does\r
 568         d = *(u16 *)(Pico_mcd->word_ram2M+a);\r
 569       }\r
 570       wrdprintf("ret = %04x", d);\r
 571       break;\r
 572     case 0x22>>1: // word RAM: 220000 - 240000\r
 573       wrdprintf("m68k_wram r16: [%06x] @%06x", a, SekPc);\r
 574       if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 575         int bank = Pico_mcd->s68k_regs[3]&1;\r
 576         a = (a&2) | (cell_map(a >> 2) << 2); // cell arranged\r
 577         d = *(u16 *)(Pico_mcd->word_ram1M[bank]+a);\r
 578       } else {\r
 579         // allow access in any mode, like Gens does\r
 580         d = *(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe));\r
 581       }\r
 582       wrdprintf("ret = %04x", d);\r
 583       break;\r
 584     case 0xc0>>1: case 0xc2>>1: case 0xc4>>1: case 0xc6>>1:\r
 585     case 0xc8>>1: case 0xca>>1: case 0xcc>>1: case 0xce>>1:\r
 586     case 0xd0>>1: case 0xd2>>1: case 0xd4>>1: case 0xd6>>1:\r
 587     case 0xd8>>1: case 0xda>>1: case 0xdc>>1: case 0xde>>1:\r
 588       // VDP\r
 589       if ((a&0xe700e0)==0xc00000)\r
 590         d=PicoVideoRead(a);\r
 591       break;\r
 592     case 0xe0>>1: case 0xe2>>1: case 0xe4>>1: case 0xe6>>1:\r
 593     case 0xe8>>1: case 0xea>>1: case 0xec>>1: case 0xee>>1:\r
 594     case 0xf0>>1: case 0xf2>>1: case 0xf4>>1: case 0xf6>>1:\r
 595     case 0xf8>>1: case 0xfa>>1: case 0xfc>>1: case 0xfe>>1:\r
 596       // RAM:\r
 597       d=*(u16 *)(Pico.ram+(a&0xfffe));\r
 598       break;\r
 599     default:\r
 600       if ((a&0xffffc0)==0xa12000)\r
 601         rdprintf("m68k_regs r16: [%02x] @%06x", a&0x3f, SekPc);\r
 602 \r
 603       d = OtherRead16(a, 16);\r
 604 \r
 605       if ((a&0xffffc0)==0xa12000)\r
 606         rdprintf("ret = %04x", d);\r
 607       break;\r
 608   }\r
 609 \r
 610 \r
 611 #ifdef __debug_io\r
 612   dprintf("r16: %06x, %04x  @%06x", a&0xffffff, d, SekPc);\r
 613 #endif\r
 614 #ifdef EMU_CORE_DEBUG\r
 615   if (a>=Pico.romsize) {\r
 616     lastread_a = a;\r
 617     lastread_d[lrp_cyc++&15] = d;\r
 618   }\r
 619 #endif\r
 620   return d;\r
 621 }\r
 622 #endif\r
 623 \r
 624 \r
 625 #ifdef _ASM_CD_MEMORY_C\r
 626 u32 PicoReadM68k32(u32 a);\r
 627 #else\r
 628 static u32 PicoReadM68k32(u32 a)\r
 629 {\r
 630   u32 d=0;\r
 631 \r
 632   a&=0xfffffe;\r
 633 \r
 634   switch (a >> 17)\r
 635   {\r
 636     case 0x00>>1: { // BIOS: 000000 - 020000\r
 637       u16 *pm=(u16 *)(Pico_mcd->bios+a);\r
 638       d = (pm[0]<<16)|pm[1];\r
 639       break;\r
 640     }\r
 641     case 0x02>>1: // prg RAM\r
 642       if ((Pico_mcd->m.busreq&3)!=1) {\r
 643         u8 *prg_bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3]>>6];\r
 644         u16 *pm=(u16 *)(prg_bank+(a&0x1fffe));\r
 645         d = (pm[0]<<16)|pm[1];\r
 646       }\r
 647       break;\r
 648     case 0x20>>1: // word RAM: 200000 - 220000\r
 649       wrdprintf("m68k_wram r32: [%06x] @%06x", a, SekPc);\r
 650       a&=0x1fffe;\r
 651       if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 652         int bank = Pico_mcd->s68k_regs[3]&1;\r
 653         u16 *pm=(u16 *)(Pico_mcd->word_ram1M[bank]+a);\r
 654         d = (pm[0]<<16)|pm[1];\r
 655       } else {\r
 656         // allow access in any mode, like Gens does\r
 657         u16 *pm=(u16 *)(Pico_mcd->word_ram2M+a);\r
 658         d = (pm[0]<<16)|pm[1];\r
 659       }\r
 660       wrdprintf("ret = %08x", d);\r
 661       break;\r
 662     case 0x22>>1: // word RAM: 220000 - 240000\r
 663       wrdprintf("m68k_wram r32: [%06x] @%06x", a, SekPc);\r
 664       if (Pico_mcd->s68k_regs[3]&4) { // 1M mode, cell arranged?\r
 665         u32 a1, a2;\r
 666         int bank = Pico_mcd->s68k_regs[3]&1;\r
 667         a1 = (a&2) | (cell_map(a >> 2) << 2);\r
 668         if (a&2) a2 = cell_map((a+2) >> 2) << 2;\r
 669         else     a2 = a1 + 2;\r
 670         d  = *(u16 *)(Pico_mcd->word_ram1M[bank]+a1) << 16;\r
 671         d |= *(u16 *)(Pico_mcd->word_ram1M[bank]+a2);\r
 672       } else {\r
 673         // allow access in any mode, like Gens does\r
 674         u16 *pm=(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe));\r
 675         d = (pm[0]<<16)|pm[1];\r
 676       }\r
 677       wrdprintf("ret = %08x", d);\r
 678       break;\r
 679     case 0xc0>>1: case 0xc2>>1: case 0xc4>>1: case 0xc6>>1:\r
 680     case 0xc8>>1: case 0xca>>1: case 0xcc>>1: case 0xce>>1:\r
 681     case 0xd0>>1: case 0xd2>>1: case 0xd4>>1: case 0xd6>>1:\r
 682     case 0xd8>>1: case 0xda>>1: case 0xdc>>1: case 0xde>>1:\r
 683       // VDP\r
 684       d = (PicoVideoRead(a)<<16)|PicoVideoRead(a+2);\r
 685       break;\r
 686     case 0xe0>>1: case 0xe2>>1: case 0xe4>>1: case 0xe6>>1:\r
 687     case 0xe8>>1: case 0xea>>1: case 0xec>>1: case 0xee>>1:\r
 688     case 0xf0>>1: case 0xf2>>1: case 0xf4>>1: case 0xf6>>1:\r
 689     case 0xf8>>1: case 0xfa>>1: case 0xfc>>1: case 0xfe>>1: {\r
 690       // RAM:\r
 691       u16 *pm=(u16 *)(Pico.ram+(a&0xfffe));\r
 692       d = (pm[0]<<16)|pm[1];\r
 693       break;\r
 694     }\r
 695     default:\r
 696       if ((a&0xffffc0)==0xa12000)\r
 697         rdprintf("m68k_regs r32: [%02x] @%06x", a&0x3f, SekPc);\r
 698 \r
 699       d = (OtherRead16(a, 32)<<16)|OtherRead16(a+2, 32);\r
 700 \r
 701       if ((a&0xffffc0)==0xa12000)\r
 702         rdprintf("ret = %08x", d);\r
 703       break;\r
 704   }\r
 705 \r
 706 \r
 707 #ifdef __debug_io\r
 708   dprintf("r32: %06x, %08x @%06x", a&0xffffff, d, SekPc);\r
 709 #endif\r
 710 #ifdef EMU_CORE_DEBUG\r
 711   if (a>=Pico.romsize) {\r
 712     lastread_a = a;\r
 713     lastread_d[lrp_cyc++&15] = d;\r
 714   }\r
 715 #endif\r
 716   return d;\r
 717 }\r
 718 #endif\r
 719 \r
 720 \r
 721 // -----------------------------------------------------------------\r
 722 \r
 723 #ifdef _ASM_CD_MEMORY_C\r
 724 void PicoWriteM68k8(u32 a,u8 d);\r
 725 #else\r
 726 static void PicoWriteM68k8(u32 a,u8 d)\r
 727 {\r
 728 #ifdef __debug_io\r
 729   dprintf("w8 : %06x,   %02x @%06x", a&0xffffff, d, SekPc);\r
 730 #endif\r
 731 #ifdef EMU_CORE_DEBUG\r
 732   lastwrite_cyc_d[lwp_cyc++&15] = d;\r
 733 #endif\r
 734 \r
 735   if ((a&0xe00000)==0xe00000) { // Ram\r
 736     *(u8 *)(Pico.ram+((a^1)&0xffff)) = d;\r
 737     return;\r
 738   }\r
 739 \r
 740   // prg RAM\r
 741   if ((a&0xfe0000)==0x020000 && (Pico_mcd->m.busreq&3)!=1) {\r
 742     u8 *prg_bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3]>>6];\r
 743     *(u8 *)(prg_bank+((a^1)&0x1ffff))=d;\r
 744     return;\r
 745   }\r
 746 \r
 747   a&=0xffffff;\r
 748 \r
 749   // word RAM\r
 750   if ((a&0xfc0000)==0x200000) {\r
 751     wrdprintf("m68k_wram w8: [%06x] %02x @%06x", a, d, SekPc);\r
 752     if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 753       int bank = Pico_mcd->s68k_regs[3]&1;\r
 754       if (a >= 0x220000)\r
 755            a = (a&3) | (cell_map(a >> 2) << 2); // cell arranged\r
 756       else a &= 0x1ffff;\r
 757       *(u8 *)(Pico_mcd->word_ram1M[bank]+(a^1))=d;\r
 758     } else {\r
 759       // allow access in any mode, like Gens does\r
 760       *(u8 *)(Pico_mcd->word_ram2M+((a^1)&0x3ffff))=d;\r
 761     }\r
 762     return;\r
 763   }\r
 764 \r
 765   if ((a&0xffffc0)==0xa12000) {\r
 766     rdprintf("m68k_regs w8: [%02x] %02x @%06x", a&0x3f, d, SekPc);\r
 767     m68k_reg_write8(a, d);\r
 768     return;\r
 769   }\r
 770 \r
 771   OtherWrite8(a,d);\r
 772 }\r
 773 #endif\r
 774 \r
 775 \r
 776 #ifdef _ASM_CD_MEMORY_C\r
 777 void PicoWriteM68k16(u32 a,u16 d);\r
 778 #else\r
 779 static void PicoWriteM68k16(u32 a,u16 d)\r
 780 {\r
 781 #ifdef __debug_io\r
 782   dprintf("w16: %06x, %04x", a&0xffffff, d);\r
 783 #endif\r
 784 #ifdef EMU_CORE_DEBUG\r
 785   lastwrite_cyc_d[lwp_cyc++&15] = d;\r
 786 #endif\r
 787 \r
 788   if ((a&0xe00000)==0xe00000) { // Ram\r
 789     *(u16 *)(Pico.ram+(a&0xfffe))=d;\r
 790     return;\r
 791   }\r
 792 \r
 793   // prg RAM\r
 794   if ((a&0xfe0000)==0x020000 && (Pico_mcd->m.busreq&3)!=1) {\r
 795     u8 *prg_bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3]>>6];\r
 796     wrdprintf("m68k_prgram w16: [%i,%06x] %04x @%06x", Pico_mcd->s68k_regs[3]>>6, a, d, SekPc);\r
 797     *(u16 *)(prg_bank+(a&0x1fffe))=d;\r
 798     return;\r
 799   }\r
 800 \r
 801   a&=0xfffffe;\r
 802 \r
 803   // word RAM\r
 804   if ((a&0xfc0000)==0x200000) {\r
 805     wrdprintf("m68k_wram w16: [%06x] %04x @%06x", a, d, SekPc);\r
 806     if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 807       int bank = Pico_mcd->s68k_regs[3]&1;\r
 808       if (a >= 0x220000)\r
 809            a = (a&2) | (cell_map(a >> 2) << 2); // cell arranged\r
 810       else a &= 0x1fffe;\r
 811       *(u16 *)(Pico_mcd->word_ram1M[bank]+a)=d;\r
 812     } else {\r
 813       // allow access in any mode, like Gens does\r
 814       *(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe))=d;\r
 815     }\r
 816     return;\r
 817   }\r
 818 \r
 819   // regs\r
 820   if ((a&0xffffc0)==0xa12000) {\r
 821     rdprintf("m68k_regs w16: [%02x] %04x @%06x", a&0x3f, d, SekPc);\r
 822     if (a == 0xe) { // special case, 2 byte writes would be handled differently\r
 823       Pico_mcd->s68k_regs[0xe] = d >> 8;\r
 824 #ifdef USE_POLL_DETECT\r
 825       if ((s68k_poll_adclk&0xfe) == 0xe && s68k_poll_cnt > POLL_LIMIT) {\r
 826         SekSetStopS68k(0); s68k_poll_adclk = 0;\r
 827         plprintf("s68k poll release, a=%02x\n", a);\r
 828       }\r
 829 #endif\r
 830       return;\r
 831     }\r
 832     m68k_reg_write8(a,  d>>8);\r
 833     m68k_reg_write8(a+1,d&0xff);\r
 834     return;\r
 835   }\r
 836 \r
 837   // VDP\r
 838   if ((a&0xe700e0)==0xc00000) {\r
 839     PicoVideoWrite(a,(u16)d);\r
 840     return;\r
 841   }\r
 842 \r
 843   OtherWrite16(a,d);\r
 844 }\r
 845 #endif\r
 846 \r
 847 \r
 848 #ifdef _ASM_CD_MEMORY_C\r
 849 void PicoWriteM68k32(u32 a,u32 d);\r
 850 #else\r
 851 static void PicoWriteM68k32(u32 a,u32 d)\r
 852 {\r
 853 #ifdef __debug_io\r
 854   dprintf("w32: %06x, %08x", a&0xffffff, d);\r
 855 #endif\r
 856 #ifdef EMU_CORE_DEBUG\r
 857   lastwrite_cyc_d[lwp_cyc++&15] = d;\r
 858 #endif\r
 859 \r
 860   if ((a&0xe00000)==0xe00000)\r
 861   {\r
 862     // Ram:\r
 863     u16 *pm=(u16 *)(Pico.ram+(a&0xfffe));\r
 864     pm[0]=(u16)(d>>16); pm[1]=(u16)d;\r
 865     return;\r
 866   }\r
 867 \r
 868   // prg RAM\r
 869   if ((a&0xfe0000)==0x020000 && (Pico_mcd->m.busreq&3)!=1) {\r
 870     u8 *prg_bank = Pico_mcd->prg_ram_b[Pico_mcd->s68k_regs[3]>>6];\r
 871     u16 *pm=(u16 *)(prg_bank+(a&0x1fffe));\r
 872     pm[0]=(u16)(d>>16); pm[1]=(u16)d;\r
 873     return;\r
 874   }\r
 875 \r
 876   a&=0xfffffe;\r
 877 \r
 878   // word RAM\r
 879   if ((a&0xfc0000)==0x200000) {\r
 880     if (d != 0) // don't log clears\r
 881       wrdprintf("m68k_wram w32: [%06x] %08x @%06x", a, d, SekPc);\r
 882     if (Pico_mcd->s68k_regs[3]&4) { // 1M mode?\r
 883       int bank = Pico_mcd->s68k_regs[3]&1;\r
 884       if (a >= 0x220000) { // cell arranged\r
 885         u32 a1, a2;\r
 886         a1 = (a&2) | (cell_map(a >> 2) << 2);\r
 887         if (a&2) a2 = cell_map((a+2) >> 2) << 2;\r
 888         else     a2 = a1 + 2;\r
 889         *(u16 *)(Pico_mcd->word_ram1M[bank]+a1) = d >> 16;\r
 890         *(u16 *)(Pico_mcd->word_ram1M[bank]+a2) = d;\r
 891       } else {\r
 892         u16 *pm=(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe));\r
 893         pm[0]=(u16)(d>>16); pm[1]=(u16)d;\r
 894       }\r
 895     } else {\r
 896       // allow access in any mode, like Gens does\r
 897       u16 *pm=(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe));\r
 898       pm[0]=(u16)(d>>16); pm[1]=(u16)d;\r
 899     }\r
 900     return;\r
 901   }\r
 902 \r
 903   if ((a&0xffffc0)==0xa12000) {\r
 904     rdprintf("m68k_regs w32: [%02x] %08x @%06x", a&0x3f, d, SekPc);\r
 905     if ((a&0x3e) == 0xe) dprintf("m68k FIXME: w32 [%02x]", a&0x3f);\r
 906   }\r
 907 \r
 908   // VDP\r
 909   if ((a&0xe700e0)==0xc00000)\r
 910   {\r
 911     PicoVideoWrite(a,  (u16)(d>>16));\r
 912     PicoVideoWrite(a+2,(u16)d);\r
 913     return;\r
 914   }\r
 915 \r
 916   OtherWrite16(a,  (u16)(d>>16));\r
 917   OtherWrite16(a+2,(u16)d);\r
 918 }\r
 919 #endif\r
 920 \r
 921 \r
 922 // -----------------------------------------------------------------\r
 923 //                            S68k\r
 924 // -----------------------------------------------------------------\r
 925 \r
 926 #ifdef _ASM_CD_MEMORY_C\r
 927 u32 PicoReadS68k8(u32 a);\r
 928 #else\r
 929 static u32 PicoReadS68k8(u32 a)\r
 930 {\r
 931   u32 d=0;\r
 932 \r
 933 #ifdef EMU_CORE_DEBUG\r
 934   u32 ab=a&0xfffffe;\r
 935 #endif\r
 936   a&=0xffffff;\r
 937 \r
 938   // prg RAM\r
 939   if (a < 0x80000) {\r
 940     d = *(Pico_mcd->prg_ram+(a^1));\r
 941     goto end;\r
 942   }\r
 943 \r
 944   // regs\r
 945   if ((a&0xfffe00) == 0xff8000) {\r
 946     a &= 0x1ff;\r
 947     rdprintf("s68k_regs r8: [%02x] @ %06x", a, SekPcS68k);\r
 948     if (a >= 0x0e && a < 0x30) {\r
 949       d = Pico_mcd->s68k_regs[a];\r
 950       s68k_poll_detect(a, d);\r
 951       rdprintf("ret = %02x", (u8)d);\r
 952       goto end;\r
 953     }\r
 954     else if (a >= 0x58 && a < 0x68)\r
 955          d = gfx_cd_read(a&~1);\r
 956     else d = s68k_reg_read16(a&~1);\r
 957     if ((a&1)==0) d>>=8;\r
 958     rdprintf("ret = %02x", (u8)d);\r
 959     goto end;\r
 960   }\r
 961 \r
 962   // word RAM (2M area)\r
 963   if ((a&0xfc0000)==0x080000) { // 080000-0bffff\r
 964     // test: batman returns\r
 965     wrdprintf("s68k_wram2M r8: [%06x] @%06x", a, SekPcS68k);\r
 966     if (Pico_mcd->s68k_regs[3]&4) { // 1M decode mode?\r
 967       int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
 968       d = Pico_mcd->word_ram1M[bank][((a>>1)^1)&0x1ffff];\r
 969       if (a&1) d &= 0x0f;\r
 970       else d >>= 4;\r
 971       dprintf("FIXME: decode");\r
 972     } else {\r
 973       // allow access in any mode, like Gens does\r
 974       d = Pico_mcd->word_ram2M[(a^1)&0x3ffff];\r
 975     }\r
 976     wrdprintf("ret = %02x", (u8)d);\r
 977     goto end;\r
 978   }\r
 979 \r
 980   // word RAM (1M area)\r
 981   if ((a&0xfe0000)==0x0c0000 && (Pico_mcd->s68k_regs[3]&4)) { // 0c0000-0dffff\r
 982     int bank;\r
 983     wrdprintf("s68k_wram1M r8: [%06x] @%06x", a, SekPcS68k);\r
 984 //    if (!(Pico_mcd->s68k_regs[3]&4))\r
 985 //      dprintf("s68k_wram1M FIXME: wrong mode");\r
 986     bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
 987     d = Pico_mcd->word_ram1M[bank][(a^1)&0x1ffff];\r
 988     wrdprintf("ret = %02x", (u8)d);\r
 989     goto end;\r
 990   }\r
 991 \r
 992   // PCM\r
 993   if ((a&0xff8000)==0xff0000) {\r
 994     dprintf("s68k_pcm r8: [%06x] @%06x", a, SekPcS68k);\r
 995     a &= 0x7fff;\r
 996     if (a >= 0x2000)\r
 997       d = Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a>>1)&0xfff];\r
 998     else if (a >= 0x20) {\r
 999       a &= 0x1e;\r
1000       d = Pico_mcd->pcm.ch[a>>2].addr >> PCM_STEP_SHIFT;\r
1001       if (a & 2) d >>= 8;\r
1002     }\r
1003     dprintf("ret = %02x", (u8)d);\r
1004     goto end;\r
1005   }\r
1006 \r
1007   // bram\r
1008   if ((a&0xff0000)==0xfe0000) {\r
1009     d = Pico_mcd->bram[(a>>1)&0x1fff];\r
1010     goto end;\r
1011   }\r
1012 \r
1013   dprintf("s68k r8 : %06x,   %02x @%06x", a&0xffffff, (u8)d, SekPcS68k);\r
1014 \r
1015   end:\r
1016 \r
1017 #ifdef __debug_io2\r
1018   dprintf("s68k r8 : %06x,   %02x @%06x", a&0xffffff, (u8)d, SekPcS68k);\r
1019 #endif\r
1020 #ifdef EMU_CORE_DEBUG\r
1021   lastread_a = ab;\r
1022   lastread_d[lrp_cyc++&15] = d;\r
1023 #endif\r
1024   return d;\r
1025 }\r
1026 #endif\r
1027 \r
1028 \r
1029 #ifdef _ASM_CD_MEMORY_C\r
1030 u32 PicoReadS68k16(u32 a);\r
1031 #else\r
1032 static u32 PicoReadS68k16(u32 a)\r
1033 {\r
1034   u32 d=0;\r
1035 \r
1036 #ifdef EMU_CORE_DEBUG\r
1037   u32 ab=a&0xfffffe;\r
1038 #endif\r
1039   a&=0xfffffe;\r
1040 \r
1041   // prg RAM\r
1042   if (a < 0x80000) {\r
1043     wrdprintf("s68k_prgram r16: [%06x] @%06x", a, SekPcS68k);\r
1044     d = *(u16 *)(Pico_mcd->prg_ram+a);\r
1045     wrdprintf("ret = %04x", d);\r
1046     goto end;\r
1047   }\r
1048 \r
1049   // regs\r
1050   if ((a&0xfffe00) == 0xff8000) {\r
1051     a &= 0x1fe;\r
1052     rdprintf("s68k_regs r16: [%02x] @ %06x", a, SekPcS68k);\r
1053     if (a >= 0x58 && a < 0x68)\r
1054          d = gfx_cd_read(a);\r
1055     else d = s68k_reg_read16(a);\r
1056     rdprintf("ret = %04x", d);\r
1057     goto end;\r
1058   }\r
1059 \r
1060   // word RAM (2M area)\r
1061   if ((a&0xfc0000)==0x080000) { // 080000-0bffff\r
1062     wrdprintf("s68k_wram2M r16: [%06x] @%06x", a, SekPcS68k);\r
1063     if (Pico_mcd->s68k_regs[3]&4) { // 1M decode mode?\r
1064       int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1065       d = Pico_mcd->word_ram1M[bank][((a>>1)^1)&0x1ffff];\r
1066       d |= d << 4; d &= ~0xf0;\r
1067       dprintf("FIXME: decode");\r
1068     } else {\r
1069       // allow access in any mode, like Gens does\r
1070       d = *(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe));\r
1071     }\r
1072     wrdprintf("ret = %04x", d);\r
1073     goto end;\r
1074   }\r
1075 \r
1076   // word RAM (1M area)\r
1077   if ((a&0xfe0000)==0x0c0000 && (Pico_mcd->s68k_regs[3]&4)) { // 0c0000-0dffff\r
1078     int bank;\r
1079     wrdprintf("s68k_wram1M r16: [%06x] @%06x", a, SekPcS68k);\r
1080 //    if (!(Pico_mcd->s68k_regs[3]&4))\r
1081 //      dprintf("s68k_wram1M FIXME: wrong mode");\r
1082     bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1083     d = *(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe));\r
1084     wrdprintf("ret = %04x", d);\r
1085     goto end;\r
1086   }\r
1087 \r
1088   // bram\r
1089   if ((a&0xff0000)==0xfe0000) {\r
1090     dprintf("FIXME: s68k_bram r16: [%06x] @%06x", a, SekPcS68k);\r
1091     a = (a>>1)&0x1fff;\r
1092     d = Pico_mcd->bram[a++];            // Gens does little endian here, and so do we..\r
1093     d|= Pico_mcd->bram[a++] << 8;       // This is most likely wrong\r
1094     dprintf("ret = %04x", d);\r
1095     goto end;\r
1096   }\r
1097 \r
1098   // PCM\r
1099   if ((a&0xff8000)==0xff0000) {\r
1100     dprintf("FIXME: s68k_pcm r16: [%06x] @%06x", a, SekPcS68k);\r
1101     a &= 0x7fff;\r
1102     if (a >= 0x2000)\r
1103       d = Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a>>1)&0xfff];\r
1104     else if (a >= 0x20) {\r
1105       a &= 0x1e;\r
1106       d = Pico_mcd->pcm.ch[a>>2].addr >> PCM_STEP_SHIFT;\r
1107       if (a & 2) d >>= 8;\r
1108     }\r
1109     dprintf("ret = %04x", d);\r
1110     goto end;\r
1111   }\r
1112 \r
1113   dprintf("s68k r16: %06x, %04x  @%06x", a&0xffffff, d, SekPcS68k);\r
1114 \r
1115   end:\r
1116 \r
1117 #ifdef __debug_io2\r
1118   dprintf("s68k r16: %06x, %04x  @%06x", a&0xffffff, d, SekPcS68k);\r
1119 #endif\r
1120 #ifdef EMU_CORE_DEBUG\r
1121   lastread_a = ab;\r
1122   lastread_d[lrp_cyc++&15] = d;\r
1123 #endif\r
1124   return d;\r
1125 }\r
1126 #endif\r
1127 \r
1128 \r
1129 #ifdef _ASM_CD_MEMORY_C\r
1130 u32 PicoReadS68k32(u32 a);\r
1131 #else\r
1132 static u32 PicoReadS68k32(u32 a)\r
1133 {\r
1134   u32 d=0;\r
1135 \r
1136 #ifdef EMU_CORE_DEBUG\r
1137   u32 ab=a&0xfffffe;\r
1138 #endif\r
1139   a&=0xfffffe;\r
1140 \r
1141   // prg RAM\r
1142   if (a < 0x80000) {\r
1143     u16 *pm=(u16 *)(Pico_mcd->prg_ram+a);\r
1144     d = (pm[0]<<16)|pm[1];\r
1145     goto end;\r
1146   }\r
1147 \r
1148   // regs\r
1149   if ((a&0xfffe00) == 0xff8000) {\r
1150     a &= 0x1fe;\r
1151     rdprintf("s68k_regs r32: [%02x] @ %06x", a, SekPcS68k);\r
1152     if (a >= 0x58 && a < 0x68)\r
1153          d = (gfx_cd_read(a)<<16)|gfx_cd_read(a+2);\r
1154     else d = (s68k_reg_read16(a)<<16)|s68k_reg_read16(a+2);\r
1155     rdprintf("ret = %08x", d);\r
1156     goto end;\r
1157   }\r
1158 \r
1159   // word RAM (2M area)\r
1160   if ((a&0xfc0000)==0x080000) { // 080000-0bffff\r
1161     wrdprintf("s68k_wram2M r32: [%06x] @%06x", a, SekPcS68k);\r
1162     if (Pico_mcd->s68k_regs[3]&4) { // 1M decode mode?\r
1163       int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1164       a >>= 1;\r
1165       d  = Pico_mcd->word_ram1M[bank][((a+0)^1)&0x1ffff] << 16;\r
1166       d |= Pico_mcd->word_ram1M[bank][((a+1)^1)&0x1ffff];\r
1167       d |= d << 4; d &= 0x0f0f0f0f;\r
1168     } else {\r
1169       // allow access in any mode, like Gens does\r
1170       u16 *pm=(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe)); d = (pm[0]<<16)|pm[1];\r
1171     }\r
1172     wrdprintf("ret = %08x", d);\r
1173     goto end;\r
1174   }\r
1175 \r
1176   // word RAM (1M area)\r
1177   if ((a&0xfe0000)==0x0c0000 && (Pico_mcd->s68k_regs[3]&4)) { // 0c0000-0dffff\r
1178     int bank;\r
1179     wrdprintf("s68k_wram1M r32: [%06x] @%06x", a, SekPcS68k);\r
1180 //    if (!(Pico_mcd->s68k_regs[3]&4))\r
1181 //      dprintf("s68k_wram1M FIXME: wrong mode");\r
1182     bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1183     u16 *pm=(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe)); d = (pm[0]<<16)|pm[1];\r
1184     wrdprintf("ret = %08x", d);\r
1185     goto end;\r
1186   }\r
1187 \r
1188   // PCM\r
1189   if ((a&0xff8000)==0xff0000) {\r
1190     dprintf("s68k_pcm r32: [%06x] @%06x", a, SekPcS68k);\r
1191     a &= 0x7fff;\r
1192     if (a >= 0x2000) {\r
1193       a >>= 1;\r
1194       d  = Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][a&0xfff] << 16;\r
1195       d |= Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a+1)&0xfff];\r
1196     } else if (a >= 0x20) {\r
1197       a &= 0x1e;\r
1198       if (a & 2) {\r
1199         a >>= 2;\r
1200         d  = (Pico_mcd->pcm.ch[a].addr >> (PCM_STEP_SHIFT-8)) & 0xff0000;\r
1201         d |= (Pico_mcd->pcm.ch[(a+1)&7].addr >> PCM_STEP_SHIFT)   & 0xff;\r
1202       } else {\r
1203         d = Pico_mcd->pcm.ch[a>>2].addr >> PCM_STEP_SHIFT;\r
1204         d = ((d<<16)&0xff0000) | ((d>>8)&0xff); // PCM chip is LE\r
1205       }\r
1206     }\r
1207     dprintf("ret = %08x", d);\r
1208     goto end;\r
1209   }\r
1210 \r
1211   // bram\r
1212   if ((a&0xff0000)==0xfe0000) {\r
1213     dprintf("FIXME: s68k_bram r32: [%06x] @%06x", a, SekPcS68k);\r
1214     a = (a>>1)&0x1fff;\r
1215     d = Pico_mcd->bram[a++] << 16;              // middle endian? TODO: verify against Fusion..\r
1216     d|= Pico_mcd->bram[a++] << 24;\r
1217     d|= Pico_mcd->bram[a++];\r
1218     d|= Pico_mcd->bram[a++] << 8;\r
1219     dprintf("ret = %08x", d);\r
1220     goto end;\r
1221   }\r
1222 \r
1223   dprintf("s68k r32: %06x, %08x @%06x", a&0xffffff, d, SekPcS68k);\r
1224 \r
1225   end:\r
1226 \r
1227 #ifdef __debug_io2\r
1228   dprintf("s68k r32: %06x, %08x @%06x", a&0xffffff, d, SekPcS68k);\r
1229 #endif\r
1230 #ifdef EMU_CORE_DEBUG\r
1231   if (ab > 0x78) { // not vectors and stuff\r
1232     lastread_a = ab;\r
1233     lastread_d[lrp_cyc++&15] = d;\r
1234   }\r
1235 #endif\r
1236   return d;\r
1237 }\r
1238 #endif\r
1239 \r
1240 \r
1241 #ifndef _ASM_CD_MEMORY_C\r
1242 /* check: jaguar xj 220 (draws entire world using decode) */\r
1243 static void decode_write8(u32 a, u8 d, int r3)\r
1244 {\r
1245   u8 *pd = Pico_mcd->word_ram1M[(r3 & 1)^1] + (((a>>1)^1)&0x1ffff);\r
1246   u8 oldmask = (a&1) ? 0xf0 : 0x0f;\r
1247 \r
1248   r3 &= 0x18;\r
1249   d  &= 0x0f;\r
1250   if (!(a&1)) d <<= 4;\r
1251 \r
1252   if (r3 == 8) {\r
1253     if ((!(*pd & (~oldmask))) && d) goto do_it;\r
1254   } else if (r3 > 8) {\r
1255     if (d) goto do_it;\r
1256   } else {\r
1257     goto do_it;\r
1258   }\r
1259 \r
1260   return;\r
1261 do_it:\r
1262   *pd = d | (*pd & oldmask);\r
1263 }\r
1264 \r
1265 \r
1266 static void decode_write16(u32 a, u16 d, int r3)\r
1267 {\r
1268   u8 *pd = Pico_mcd->word_ram1M[(r3 & 1)^1] + (((a>>1)^1)&0x1ffff);\r
1269 \r
1270   //if ((a & 0x3ffff) < 0x28000) return;\r
1271 \r
1272   r3 &= 0x18;\r
1273   d  &= 0x0f0f;\r
1274   d  |= d >> 4;\r
1275 \r
1276   if (r3 == 8) {\r
1277     u8 dold = *pd;\r
1278     if (!(dold & 0xf0)) dold |= d & 0xf0;\r
1279     if (!(dold & 0x0f)) dold |= d & 0x0f;\r
1280     *pd = dold;\r
1281   } else if (r3 > 8) {\r
1282     u8 dold = *pd;\r
1283     if (!(d & 0xf0)) d |= dold & 0xf0;\r
1284     if (!(d & 0x0f)) d |= dold & 0x0f;\r
1285     *pd = d;\r
1286   } else {\r
1287     *pd = d;\r
1288   }\r
1289 }\r
1290 #endif\r
1291 \r
1292 // -----------------------------------------------------------------\r
1293 \r
1294 #ifdef _ASM_CD_MEMORY_C\r
1295 void PicoWriteS68k8(u32 a,u8 d);\r
1296 #else\r
1297 static void PicoWriteS68k8(u32 a,u8 d)\r
1298 {\r
1299 #ifdef __debug_io2\r
1300   dprintf("s68k w8 : %06x,   %02x @%06x", a&0xffffff, d, SekPcS68k);\r
1301 #endif\r
1302 \r
1303   a&=0xffffff;\r
1304 \r
1305 #ifdef EMU_CORE_DEBUG\r
1306   lastwrite_cyc_d[lwp_cyc++&15] = d;\r
1307 #endif\r
1308 \r
1309   // prg RAM\r
1310   if (a < 0x80000) {\r
1311     u8 *pm=(u8 *)(Pico_mcd->prg_ram+(a^1));\r
1312     if (a >= (Pico_mcd->s68k_regs[2]<<8)) *pm=d;\r
1313     return;\r
1314   }\r
1315 \r
1316   // regs\r
1317   if ((a&0xfffe00) == 0xff8000) {\r
1318     a &= 0x1ff;\r
1319     rdprintf("s68k_regs w8: [%02x] %02x @ %06x", a, d, SekPcS68k);\r
1320     if (a >= 0x58 && a < 0x68)\r
1321          gfx_cd_write16(a&~1, (d<<8)|d);\r
1322     else s68k_reg_write8(a,d);\r
1323     return;\r
1324   }\r
1325 \r
1326   // word RAM (2M area)\r
1327   if ((a&0xfc0000)==0x080000) { // 080000-0bffff\r
1328     int r3 = Pico_mcd->s68k_regs[3];\r
1329     wrdprintf("s68k_wram2M w8: [%06x] %02x @%06x", a, d, SekPcS68k);\r
1330     if (r3 & 4) { // 1M decode mode?\r
1331       decode_write8(a, d, r3);\r
1332     } else {\r
1333       // allow access in any mode, like Gens does\r
1334       *(u8 *)(Pico_mcd->word_ram2M+((a^1)&0x3ffff))=d;\r
1335     }\r
1336     return;\r
1337   }\r
1338 \r
1339   // word RAM (1M area)\r
1340   if ((a&0xfe0000)==0x0c0000 && (Pico_mcd->s68k_regs[3]&4)) { // 0c0000-0dffff\r
1341     // Wing Commander tries to write here in wrong mode\r
1342     int bank;\r
1343     if (d)\r
1344       wrdprintf("s68k_wram1M w8: [%06x] %02x @%06x", a, d, SekPcS68k);\r
1345 //    if (!(Pico_mcd->s68k_regs[3]&4))\r
1346 //      dprintf("s68k_wram1M FIXME: wrong mode");\r
1347     bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1348     *(u8 *)(Pico_mcd->word_ram1M[bank]+((a^1)&0x1ffff))=d;\r
1349     return;\r
1350   }\r
1351 \r
1352   // PCM\r
1353   if ((a&0xff8000)==0xff0000) {\r
1354     a &= 0x7fff;\r
1355     if (a >= 0x2000)\r
1356       Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a>>1)&0xfff] = d;\r
1357     else if (a < 0x12)\r
1358       pcm_write(a>>1, d);\r
1359     return;\r
1360   }\r
1361 \r
1362   // bram\r
1363   if ((a&0xff0000)==0xfe0000) {\r
1364     Pico_mcd->bram[(a>>1)&0x1fff] = d;\r
1365     SRam.changed = 1;\r
1366     return;\r
1367   }\r
1368 \r
1369   dprintf("s68k w8 : %06x,   %02x @%06x", a&0xffffff, d, SekPcS68k);\r
1370 }\r
1371 #endif\r
1372 \r
1373 \r
1374 #ifdef _ASM_CD_MEMORY_C\r
1375 void PicoWriteS68k16(u32 a,u16 d);\r
1376 #else\r
1377 static void PicoWriteS68k16(u32 a,u16 d)\r
1378 {\r
1379 #ifdef __debug_io2\r
1380   dprintf("s68k w16: %06x, %04x @%06x", a&0xffffff, d, SekPcS68k);\r
1381 #endif\r
1382 \r
1383   a&=0xfffffe;\r
1384 \r
1385 #ifdef EMU_CORE_DEBUG\r
1386   lastwrite_cyc_d[lwp_cyc++&15] = d;\r
1387 #endif\r
1388 \r
1389   // prg RAM\r
1390   if (a < 0x80000) {\r
1391     wrdprintf("s68k_prgram w16: [%06x] %04x @%06x", a, d, SekPcS68k);\r
1392     if (a >= (Pico_mcd->s68k_regs[2]<<8)) // needed for Dungeon Explorer\r
1393       *(u16 *)(Pico_mcd->prg_ram+a)=d;\r
1394     return;\r
1395   }\r
1396 \r
1397   // regs\r
1398   if ((a&0xfffe00) == 0xff8000) {\r
1399     a &= 0x1fe;\r
1400     rdprintf("s68k_regs w16: [%02x] %04x @ %06x", a, d, SekPcS68k);\r
1401     if (a >= 0x58 && a < 0x68)\r
1402       gfx_cd_write16(a, d);\r
1403     else {\r
1404       if (a == 0xe) { // special case, 2 byte writes would be handled differently\r
1405         Pico_mcd->s68k_regs[0xf] = d;\r
1406         return;\r
1407       }\r
1408       s68k_reg_write8(a,  d>>8);\r
1409       s68k_reg_write8(a+1,d&0xff);\r
1410     }\r
1411     return;\r
1412   }\r
1413 \r
1414   // word RAM (2M area)\r
1415   if ((a&0xfc0000)==0x080000) { // 080000-0bffff\r
1416     int r3 = Pico_mcd->s68k_regs[3];\r
1417     wrdprintf("s68k_wram2M w16: [%06x] %04x @%06x", a, d, SekPcS68k);\r
1418     if (r3 & 4) { // 1M decode mode?\r
1419       decode_write16(a, d, r3);\r
1420     } else {\r
1421       // allow access in any mode, like Gens does\r
1422       *(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe))=d;\r
1423     }\r
1424     return;\r
1425   }\r
1426 \r
1427   // word RAM (1M area)\r
1428   if ((a&0xfe0000)==0x0c0000 && (Pico_mcd->s68k_regs[3]&4)) { // 0c0000-0dffff\r
1429     int bank;\r
1430     if (d)\r
1431       wrdprintf("s68k_wram1M w16: [%06x] %04x @%06x", a, d, SekPcS68k);\r
1432 //    if (!(Pico_mcd->s68k_regs[3]&4))\r
1433 //      dprintf("s68k_wram1M FIXME: wrong mode");\r
1434     bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1435     *(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe))=d;\r
1436     return;\r
1437   }\r
1438 \r
1439   // PCM\r
1440   if ((a&0xff8000)==0xff0000) {\r
1441     a &= 0x7fff;\r
1442     if (a >= 0x2000)\r
1443       Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a>>1)&0xfff] = d;\r
1444     else if (a < 0x12)\r
1445       pcm_write(a>>1, d & 0xff);\r
1446     return;\r
1447   }\r
1448 \r
1449   // bram\r
1450   if ((a&0xff0000)==0xfe0000) {\r
1451     dprintf("s68k_bram w16: [%06x] %04x @%06x", a, d, SekPcS68k);\r
1452     a = (a>>1)&0x1fff;\r
1453     Pico_mcd->bram[a++] = d;            // Gens does little endian here, an so do we..\r
1454     Pico_mcd->bram[a++] = d >> 8;\r
1455     SRam.changed = 1;\r
1456     return;\r
1457   }\r
1458 \r
1459   dprintf("s68k w16: %06x, %04x @%06x", a&0xffffff, d, SekPcS68k);\r
1460 }\r
1461 #endif\r
1462 \r
1463 \r
1464 #ifdef _ASM_CD_MEMORY_C\r
1465 void PicoWriteS68k32(u32 a,u32 d);\r
1466 #else\r
1467 static void PicoWriteS68k32(u32 a,u32 d)\r
1468 {\r
1469 #ifdef __debug_io2\r
1470   dprintf("s68k w32: %06x, %08x @%06x", a&0xffffff, d, SekPcS68k);\r
1471 #endif\r
1472 \r
1473   a&=0xfffffe;\r
1474 \r
1475 #ifdef EMU_CORE_DEBUG\r
1476   lastwrite_cyc_d[lwp_cyc++&15] = d;\r
1477 #endif\r
1478 \r
1479   // prg RAM\r
1480   if (a < 0x80000) {\r
1481     if (a >= (Pico_mcd->s68k_regs[2]<<8)) {\r
1482       u16 *pm=(u16 *)(Pico_mcd->prg_ram+a);\r
1483       pm[0]=(u16)(d>>16); pm[1]=(u16)d;\r
1484     }\r
1485     return;\r
1486   }\r
1487 \r
1488   // regs\r
1489   if ((a&0xfffe00) == 0xff8000) {\r
1490     a &= 0x1fe;\r
1491     rdprintf("s68k_regs w32: [%02x] %08x @ %06x", a, d, SekPcS68k);\r
1492     if (a >= 0x58 && a < 0x68) {\r
1493       gfx_cd_write16(a,   d>>16);\r
1494       gfx_cd_write16(a+2, d&0xffff);\r
1495     } else {\r
1496       if ((a&0x1fe) == 0xe) dprintf("s68k FIXME: w32 [%02x]", a&0x3f);\r
1497       s68k_reg_write8(a,   d>>24);\r
1498       s68k_reg_write8(a+1,(d>>16)&0xff);\r
1499       s68k_reg_write8(a+2,(d>>8) &0xff);\r
1500       s68k_reg_write8(a+3, d     &0xff);\r
1501     }\r
1502     return;\r
1503   }\r
1504 \r
1505   // word RAM (2M area)\r
1506   if ((a&0xfc0000)==0x080000) { // 080000-0bffff\r
1507     int r3 = Pico_mcd->s68k_regs[3];\r
1508     wrdprintf("s68k_wram2M w32: [%06x] %08x @%06x", a, d, SekPcS68k);\r
1509     if (r3 & 4) { // 1M decode mode?\r
1510       decode_write16(a  , d >> 16, r3);\r
1511       decode_write16(a+2, d      , r3);\r
1512     } else {\r
1513       // allow access in any mode, like Gens does\r
1514       u16 *pm=(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe));\r
1515       pm[0]=(u16)(d>>16); pm[1]=(u16)d;\r
1516     }\r
1517     return;\r
1518   }\r
1519 \r
1520   // word RAM (1M area)\r
1521   if ((a&0xfe0000)==0x0c0000 && (Pico_mcd->s68k_regs[3]&4)) { // 0c0000-0dffff\r
1522     int bank;\r
1523     u16 *pm;\r
1524     if (d)\r
1525       wrdprintf("s68k_wram1M w32: [%06x] %08x @%06x", a, d, SekPcS68k);\r
1526 //    if (!(Pico_mcd->s68k_regs[3]&4))\r
1527 //      dprintf("s68k_wram1M FIXME: wrong mode");\r
1528     bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1529     pm=(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe));\r
1530     pm[0]=(u16)(d>>16); pm[1]=(u16)d;\r
1531     return;\r
1532   }\r
1533 \r
1534   // PCM\r
1535   if ((a&0xff8000)==0xff0000) {\r
1536     a &= 0x7fff;\r
1537     if (a >= 0x2000) {\r
1538       a >>= 1;\r
1539       Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][a&0xfff] = (d >> 16);\r
1540       Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank][(a+1)&0xfff] = d;\r
1541     } else if (a < 0x12) {\r
1542       a >>= 1;\r
1543       pcm_write(a,  (d>>16) & 0xff);\r
1544       pcm_write(a+1, d & 0xff);\r
1545     }\r
1546     return;\r
1547   }\r
1548 \r
1549   // bram\r
1550   if ((a&0xff0000)==0xfe0000) {\r
1551     dprintf("s68k_bram w32: [%06x] %08x @%06x", a, d, SekPcS68k);\r
1552     a = (a>>1)&0x1fff;\r
1553     Pico_mcd->bram[a++] = d >> 16;              // middle endian? verify?\r
1554     Pico_mcd->bram[a++] = d >> 24;\r
1555     Pico_mcd->bram[a++] = d;\r
1556     Pico_mcd->bram[a++] = d >> 8;\r
1557     SRam.changed = 1;\r
1558     return;\r
1559   }\r
1560 \r
1561   dprintf("s68k w32: %06x, %08x @%06x", a&0xffffff, d, SekPcS68k);\r
1562 }\r
1563 #endif\r
1564 \r
1565 \r
1566 // -----------------------------------------------------------------\r
1567 \r
1568 \r
1569 #ifdef EMU_C68K\r
1570 static __inline int PicoMemBaseM68k(u32 pc)\r
1571 {\r
1572   if ((pc&0xe00000)==0xe00000)\r
1573     return (int)Pico.ram-(pc&0xff0000); // Program Counter in Ram\r
1574 \r
1575   if (pc < 0x20000)\r
1576     return (int)Pico_mcd->bios; // Program Counter in BIOS\r
1577 \r
1578   if ((pc&0xfc0000)==0x200000)\r
1579   {\r
1580     if (!(Pico_mcd->s68k_regs[3]&4))\r
1581       return (int)Pico_mcd->word_ram2M - 0x200000; // Program Counter in Word Ram\r
1582     if (pc < 0x220000) {\r
1583       int bank = Pico_mcd->s68k_regs[3]&1;\r
1584       return (int)Pico_mcd->word_ram1M[bank] - 0x200000;\r
1585     }\r
1586   }\r
1587 \r
1588   // Error - Program Counter is invalid\r
1589   dprintf("m68k FIXME: unhandled jump to %06x", pc);\r
1590 \r
1591   return (int)Pico_mcd->bios;\r
1592 }\r
1593 \r
1594 \r
1595 static u32 PicoCheckPcM68k(u32 pc)\r
1596 {\r
1597   pc-=PicoCpuCM68k.membase; // Get real pc\r
1598   pc&=0xfffffe;\r
1599 \r
1600   PicoCpuCM68k.membase=PicoMemBaseM68k(pc);\r
1601 \r
1602   return PicoCpuCM68k.membase+pc;\r
1603 }\r
1604 \r
1605 \r
1606 static __inline int PicoMemBaseS68k(u32 pc)\r
1607 {\r
1608   if (pc < 0x80000)                     // PRG RAM\r
1609     return (int)Pico_mcd->prg_ram;\r
1610 \r
1611   if ((pc&0xfc0000)==0x080000)          // WORD RAM 2M area (assume we are in the right mode..)\r
1612     return (int)Pico_mcd->word_ram2M - 0x080000;\r
1613 \r
1614   if ((pc&0xfe0000)==0x0c0000) {        // word RAM 1M area\r
1615     int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1616     return (int)Pico_mcd->word_ram1M[bank] - 0x0c0000;\r
1617   }\r
1618 \r
1619   // Error - Program Counter is invalid\r
1620   dprintf("s68k FIXME: unhandled jump to %06x", pc);\r
1621 \r
1622   return (int)Pico_mcd->prg_ram;\r
1623 }\r
1624 \r
1625 \r
1626 static u32 PicoCheckPcS68k(u32 pc)\r
1627 {\r
1628   pc-=PicoCpuCS68k.membase; // Get real pc\r
1629   pc&=0xfffffe;\r
1630 \r
1631   PicoCpuCS68k.membase=PicoMemBaseS68k(pc);\r
1632 \r
1633   return PicoCpuCS68k.membase+pc;\r
1634 }\r
1635 #endif\r
1636 \r
1637 #ifndef _ASM_CD_MEMORY_C\r
1638 void PicoMemResetCD(int r3)\r
1639 {\r
1640 #ifdef EMU_F68K\r
1641   // update fetchmap..\r
1642   int i;\r
1643   if (!(r3 & 4))\r
1644   {\r
1645     for (i = M68K_FETCHBANK1*2/16; (i<<(24-FAMEC_FETCHBITS)) < 0x240000; i++)\r
1646       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram2M - 0x200000;\r
1647   }\r
1648   else\r
1649   {\r
1650     for (i = M68K_FETCHBANK1*2/16; (i<<(24-FAMEC_FETCHBITS)) < 0x220000; i++)\r
1651       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram1M[r3 & 1] - 0x200000;\r
1652     for (i = M68K_FETCHBANK1*0x0c/0x100; (i<<(24-FAMEC_FETCHBITS)) < 0x0e0000; i++)\r
1653       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram1M[(r3&1)^1] - 0x0c0000;\r
1654   }\r
1655 #endif\r
1656 }\r
1657 #endif\r
1658 \r
1659 PICO_INTERNAL void PicoMemSetupCD(void)\r
1660 {\r
1661   dprintf("PicoMemSetupCD()");\r
1662 #ifdef EMU_C68K\r
1663   // Setup m68k memory callbacks:\r
1664   PicoCpuCM68k.checkpc=PicoCheckPcM68k;\r
1665   PicoCpuCM68k.fetch8 =PicoCpuCM68k.read8 =PicoReadM68k8;\r
1666   PicoCpuCM68k.fetch16=PicoCpuCM68k.read16=PicoReadM68k16;\r
1667   PicoCpuCM68k.fetch32=PicoCpuCM68k.read32=PicoReadM68k32;\r
1668   PicoCpuCM68k.write8 =PicoWriteM68k8;\r
1669   PicoCpuCM68k.write16=PicoWriteM68k16;\r
1670   PicoCpuCM68k.write32=PicoWriteM68k32;\r
1671   // s68k\r
1672   PicoCpuCS68k.checkpc=PicoCheckPcS68k;\r
1673   PicoCpuCS68k.fetch8 =PicoCpuCS68k.read8 =PicoReadS68k8;\r
1674   PicoCpuCS68k.fetch16=PicoCpuCS68k.read16=PicoReadS68k16;\r
1675   PicoCpuCS68k.fetch32=PicoCpuCS68k.read32=PicoReadS68k32;\r
1676   PicoCpuCS68k.write8 =PicoWriteS68k8;\r
1677   PicoCpuCS68k.write16=PicoWriteS68k16;\r
1678   PicoCpuCS68k.write32=PicoWriteS68k32;\r
1679 #endif\r
1680 #ifdef EMU_F68K\r
1681   // m68k\r
1682   PicoCpuFM68k.read_byte =PicoReadM68k8;\r
1683   PicoCpuFM68k.read_word =PicoReadM68k16;\r
1684   PicoCpuFM68k.read_long =PicoReadM68k32;\r
1685   PicoCpuFM68k.write_byte=PicoWriteM68k8;\r
1686   PicoCpuFM68k.write_word=PicoWriteM68k16;\r
1687   PicoCpuFM68k.write_long=PicoWriteM68k32;\r
1688   // s68k\r
1689   PicoCpuFS68k.read_byte =PicoReadS68k8;\r
1690   PicoCpuFS68k.read_word =PicoReadS68k16;\r
1691   PicoCpuFS68k.read_long =PicoReadS68k32;\r
1692   PicoCpuFS68k.write_byte=PicoWriteS68k8;\r
1693   PicoCpuFS68k.write_word=PicoWriteS68k16;\r
1694   PicoCpuFS68k.write_long=PicoWriteS68k32;\r
1695 \r
1696   // setup FAME fetchmap\r
1697   {\r
1698     int i;\r
1699     // M68k\r
1700     // by default, point everything to fitst 64k of ROM (BIOS)\r
1701     for (i = 0; i < M68K_FETCHBANK1; i++)\r
1702       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.rom - (i<<(24-FAMEC_FETCHBITS));\r
1703     // now real ROM (BIOS)\r
1704     for (i = 0; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < Pico.romsize; i++)\r
1705       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.rom;\r
1706     // .. and RAM\r
1707     for (i = M68K_FETCHBANK1*14/16; i < M68K_FETCHBANK1; i++)\r
1708       PicoCpuFM68k.Fetch[i] = (unsigned int)Pico.ram - (i<<(24-FAMEC_FETCHBITS));\r
1709     // S68k\r
1710     // PRG RAM is default\r
1711     for (i = 0; i < M68K_FETCHBANK1; i++)\r
1712       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->prg_ram - (i<<(24-FAMEC_FETCHBITS));\r
1713     // real PRG RAM\r
1714     for (i = 0; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < 0x80000; i++)\r
1715       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->prg_ram;\r
1716     // WORD RAM 2M area\r
1717     for (i = M68K_FETCHBANK1*0x08/0x100; i < M68K_FETCHBANK1 && (i<<(24-FAMEC_FETCHBITS)) < 0xc0000; i++)\r
1718       PicoCpuFS68k.Fetch[i] = (unsigned int)Pico_mcd->word_ram2M - 0x80000;\r
1719     // PicoMemResetCD() will setup word ram for both\r
1720   }\r
1721 #endif\r
1722 \r
1723   // m68k_poll_addr = m68k_poll_cnt = 0;\r
1724   s68k_poll_adclk = s68k_poll_cnt = 0;\r
1725 }\r
1726 \r
1727 \r
1728 #ifdef EMU_M68K\r
1729 unsigned char  PicoReadCD8w (unsigned int a) {\r
1730         return m68ki_cpu_p == &PicoCpuMS68k ? PicoReadS68k8(a) : PicoReadM68k8(a);\r
1731 }\r
1732 unsigned short PicoReadCD16w(unsigned int a) {\r
1733         return m68ki_cpu_p == &PicoCpuMS68k ? PicoReadS68k16(a) : PicoReadM68k16(a);\r
1734 }\r
1735 unsigned int   PicoReadCD32w(unsigned int a) {\r
1736         return m68ki_cpu_p == &PicoCpuMS68k ? PicoReadS68k32(a) : PicoReadM68k32(a);\r
1737 }\r
1738 void PicoWriteCD8w (unsigned int a, unsigned char d) {\r
1739         if (m68ki_cpu_p == &PicoCpuMS68k) PicoWriteS68k8(a, d); else PicoWriteM68k8(a, d);\r
1740 }\r
1741 void PicoWriteCD16w(unsigned int a, unsigned short d) {\r
1742         if (m68ki_cpu_p == &PicoCpuMS68k) PicoWriteS68k16(a, d); else PicoWriteM68k16(a, d);\r
1743 }\r
1744 void PicoWriteCD32w(unsigned int a, unsigned int d) {\r
1745         if (m68ki_cpu_p == &PicoCpuMS68k) PicoWriteS68k32(a, d); else PicoWriteM68k32(a, d);\r
1746 }\r
1747 \r
1748 // these are allowed to access RAM\r
1749 unsigned int  m68k_read_pcrelative_CD8 (unsigned int a)\r
1750 {\r
1751   a&=0xffffff;\r
1752   if(m68ki_cpu_p == &PicoCpuMS68k) {\r
1753     if (a < 0x80000) return *(u8 *)(Pico_mcd->prg_ram+(a^1)); // PRG Ram\r
1754     if ((a&0xfc0000)==0x080000 && !(Pico_mcd->s68k_regs[3]&4)) // word RAM (2M area: 080000-0bffff)\r
1755       return *(u8 *)(Pico_mcd->word_ram2M+((a^1)&0x3ffff));\r
1756     if ((a&0xfe0000)==0x0c0000 &&  (Pico_mcd->s68k_regs[3]&4)) { // word RAM (1M area: 0c0000-0dffff)\r
1757       int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1758       return *(u8 *)(Pico_mcd->word_ram1M[bank]+((a^1)&0x1ffff));\r
1759     }\r
1760     dprintf("s68k_read_pcrelative_CD8 FIXME: can't handle %06x", a);\r
1761   } else {\r
1762     if((a&0xe00000)==0xe00000) return *(u8 *)(Pico.ram+((a^1)&0xffff)); // Ram\r
1763     if(a<0x20000)              return *(u8 *)(Pico.rom+(a^1)); // Bios\r
1764     if((a&0xfc0000)==0x200000) { // word RAM\r
1765       if(!(Pico_mcd->s68k_regs[3]&4)) // 2M?\r
1766         return *(u8 *)(Pico_mcd->word_ram2M+((a^1)&0x3ffff));\r
1767       else if (a < 0x220000) {\r
1768         int bank = Pico_mcd->s68k_regs[3]&1;\r
1769         return *(u8 *)(Pico_mcd->word_ram1M[bank]+((a^1)&0x1ffff));\r
1770       }\r
1771     }\r
1772     dprintf("m68k_read_pcrelative_CD8 FIXME: can't handle %06x", a);\r
1773   }\r
1774   return 0;//(u8)  lastread_d;\r
1775 }\r
1776 unsigned int  m68k_read_pcrelative_CD16(unsigned int a)\r
1777 {\r
1778   a&=0xffffff;\r
1779   if(m68ki_cpu_p == &PicoCpuMS68k) {\r
1780     if (a < 0x80000) return *(u16 *)(Pico_mcd->prg_ram+(a&~1)); // PRG Ram\r
1781     if ((a&0xfc0000)==0x080000 && !(Pico_mcd->s68k_regs[3]&4)) // word RAM (2M area: 080000-0bffff)\r
1782       return *(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe));\r
1783     if ((a&0xfe0000)==0x0c0000 &&  (Pico_mcd->s68k_regs[3]&4)) { // word RAM (1M area: 0c0000-0dffff)\r
1784       int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1785       return *(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe));\r
1786     }\r
1787     dprintf("s68k_read_pcrelative_CD16 FIXME: can't handle %06x", a);\r
1788   } else {\r
1789     if((a&0xe00000)==0xe00000) return *(u16 *)(Pico.ram+(a&0xfffe)); // Ram\r
1790     if(a<0x20000)              return *(u16 *)(Pico.rom+(a&~1)); // Bios\r
1791     if((a&0xfc0000)==0x200000) { // word RAM\r
1792       if(!(Pico_mcd->s68k_regs[3]&4)) // 2M?\r
1793         return *(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe));\r
1794       else if (a < 0x220000) {\r
1795         int bank = Pico_mcd->s68k_regs[3]&1;\r
1796         return *(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe));\r
1797       }\r
1798     }\r
1799     dprintf("m68k_read_pcrelative_CD16 FIXME: can't handle %06x", a);\r
1800   }\r
1801   return 0;\r
1802 }\r
1803 unsigned int  m68k_read_pcrelative_CD32(unsigned int a)\r
1804 {\r
1805   u16 *pm;\r
1806   a&=0xffffff;\r
1807   if(m68ki_cpu_p == &PicoCpuMS68k) {\r
1808     if (a < 0x80000) { u16 *pm=(u16 *)(Pico_mcd->prg_ram+(a&~1)); return (pm[0]<<16)|pm[1]; } // PRG Ram\r
1809     if ((a&0xfc0000)==0x080000 && !(Pico_mcd->s68k_regs[3]&4)) // word RAM (2M area: 080000-0bffff)\r
1810       { pm=(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe)); return (pm[0]<<16)|pm[1]; }\r
1811     if ((a&0xfe0000)==0x0c0000 &&  (Pico_mcd->s68k_regs[3]&4)) { // word RAM (1M area: 0c0000-0dffff)\r
1812       int bank = (Pico_mcd->s68k_regs[3]&1)^1;\r
1813       pm=(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe));\r
1814       return (pm[0]<<16)|pm[1];\r
1815     }\r
1816     dprintf("s68k_read_pcrelative_CD32 FIXME: can't handle %06x", a);\r
1817   } else {\r
1818     if((a&0xe00000)==0xe00000) { u16 *pm=(u16 *)(Pico.ram+(a&0xfffe)); return (pm[0]<<16)|pm[1]; } // Ram\r
1819     if(a<0x20000)              { u16 *pm=(u16 *)(Pico.rom+(a&~1));     return (pm[0]<<16)|pm[1]; }\r
1820     if((a&0xfc0000)==0x200000) { // word RAM\r
1821       if(!(Pico_mcd->s68k_regs[3]&4)) // 2M?\r
1822         { pm=(u16 *)(Pico_mcd->word_ram2M+(a&0x3fffe)); return (pm[0]<<16)|pm[1]; }\r
1823       else if (a < 0x220000) {\r
1824         int bank = Pico_mcd->s68k_regs[3]&1;\r
1825         pm=(u16 *)(Pico_mcd->word_ram1M[bank]+(a&0x1fffe));\r
1826         return (pm[0]<<16)|pm[1];\r
1827       }\r
1828     }\r
1829     dprintf("m68k_read_pcrelative_CD32 FIXME: can't handle %06x", a);\r
1830   }\r
1831   return 0;\r
1832 }\r
1833 #endif // EMU_M68K\r
1834 \r