pico/cd/cdc.c

   1 /***************************************************************************************
   2  *  Genesis Plus
   3  *  CD data controller (LC89510 compatible)
   4  *
   5  *  Copyright (C) 2012  Eke-Eke (Genesis Plus GX)
   6  *
   7  *  Redistribution and use of this code or any derivative works are permitted
   8  *  provided that the following conditions are met:
   9  *
  10  *   - Redistributions may not be sold, nor may they be used in a commercial
  11  *     product or activity.
  12  *
  13  *   - Redistributions that are modified from the original source must include the
  14  *     complete source code, including the source code for all components used by a
  15  *     binary built from the modified sources. However, as a special exception, the
  16  *     source code distributed need not include anything that is normally distributed
  17  *     (in either source or binary form) with the major components (compiler, kernel,
  18  *     and so on) of the operating system on which the executable runs, unless that
  19  *     component itself accompanies the executable.
  20  *
  21  *   - Redistributions must reproduce the above copyright notice, this list of
  22  *     conditions and the following disclaimer in the documentation and/or other
  23  *     materials provided with the distribution.
  24  *
  25  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  26  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  29  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  *  POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  ****************************************************************************************/
  38
  39 #include "../pico_int.h"
  40 #include "genplus_macros.h"
  41
  42 /* IFSTAT register bitmasks */
  43 #define BIT_DTEI  0x40
  44 #define BIT_DECI  0x20
  45 #define BIT_DTBSY 0x08
  46 #define BIT_DTEN  0x02
  47
  48 /* IFCTRL register bitmasks */
  49 #define BIT_DTEIEN  0x40
  50 #define BIT_DECIEN  0x20
  51 #define BIT_DOUTEN  0x02
  52
  53 /* CTRL0 register bitmasks */
  54 #define BIT_DECEN   0x80
  55 #define BIT_E01RQ   0x20
  56 #define BIT_AUTORQ  0x10
  57 #define BIT_WRRQ    0x04
  58
  59 /* CTRL1 register bitmasks */
  60 #define BIT_MODRQ   0x08
  61 #define BIT_FORMRQ  0x04
  62 #define BIT_SHDREN  0x01
  63
  64 /* CTRL2 register bitmask */
  65 #define BIT_VALST   0x80
  66
  67 /* PicoDrive: doing DMA at once, not using callbacks */
  68 //#define DMA_BYTES_PER_LINE 512
  69
  70 enum dma_type {
  71   word_ram_0_dma_w = 1,
  72   word_ram_1_dma_w = 2,
  73   word_ram_2M_dma_w = 3,
  74   pcm_ram_dma_w = 4,
  75   prg_ram_dma_w = 5,
  76 };
  77
  78 /* CDC hardware */
  79 typedef struct
  80 {
  81   uint8 ifstat;
  82   uint8 ifctrl;
  83   uint16 dbc;
  84   uint16 dac;
  85   uint16 pt;
  86   uint16 wa;
  87   uint8 ctrl[2];
  88   uint8 head[2][4];
  89   uint8 stat[4];
  90   int cycles;
  91   //void (*dma_w)(unsigned int words);
  92   int dma_w;
  93   uint8 ram[0x4000 + 2352]; /* 16K external RAM (with one block overhead to handle buffer overrun) */
  94 } cdc_t;
  95
  96 static cdc_t cdc;
  97
  98 void cdc_init(void)
  99 {
 100   memset(&cdc, 0, sizeof(cdc_t));
 101 }
 102
 103 void cdc_reset(void)
 104 {
 105   /* reset CDC register index */
 106   Pico_mcd->s68k_regs[0x04+1] = 0x00;
 107
 108   /* reset CDC registers */
 109   cdc.ifstat  = 0xff;
 110   cdc.ifctrl  = 0x00;
 111   cdc.ctrl[0] = 0x00;
 112   cdc.ctrl[1] = 0x00;
 113   cdc.stat[0] = 0x00;
 114   cdc.stat[1] = 0x00;
 115   cdc.stat[2] = 0x00;
 116   cdc.stat[3] = 0x80;
 117   cdc.head[0][0] = 0x00;
 118   cdc.head[0][1] = 0x00;
 119   cdc.head[0][2] = 0x00;
 120   cdc.head[0][3] = 0x01;
 121   cdc.head[1][0] = 0x00;
 122   cdc.head[1][1] = 0x00;
 123   cdc.head[1][2] = 0x00;
 124   cdc.head[1][3] = 0x00;
 125
 126   /* reset CDC cycle counter */
 127   cdc.cycles = 0;
 128
 129   /* DMA transfer disabled */
 130   cdc.dma_w = 0;
 131 }
 132
 133 int cdc_context_save(uint8 *state)
 134 {
 135   uint8 tmp8;
 136   int bufferptr = 0;
 137
 138   if (cdc.dma_w == pcm_ram_dma_w)
 139   {
 140     tmp8 = 1;
 141   }
 142   else if (cdc.dma_w == prg_ram_dma_w)
 143   {
 144     tmp8 = 2;
 145   }
 146   else if (cdc.dma_w == word_ram_0_dma_w)
 147   {
 148     tmp8 = 3;
 149   }
 150   else if (cdc.dma_w == word_ram_1_dma_w)
 151   {
 152     tmp8 = 4;
 153   }
 154   else if (cdc.dma_w == word_ram_2M_dma_w)
 155   {
 156     tmp8 = 5;
 157   }
 158   else
 159   {
 160     tmp8 = 0;
 161   }
 162
 163   save_param(&cdc, sizeof(cdc));
 164   save_param(&tmp8, 1);
 165
 166   return bufferptr;
 167 }
 168
 169 int cdc_context_load(uint8 *state)
 170 {
 171   uint8 tmp8;
 172   int bufferptr = 0;
 173
 174   load_param(&cdc, sizeof(cdc));
 175   load_param(&tmp8, 1);
 176
 177   switch (tmp8)
 178   {
 179     case 1:
 180       cdc.dma_w = pcm_ram_dma_w;
 181       break;
 182     case 2:
 183       cdc.dma_w = prg_ram_dma_w;
 184       break;
 185     case 3:
 186       cdc.dma_w = word_ram_0_dma_w;
 187       break;
 188     case 4:
 189       cdc.dma_w = word_ram_1_dma_w;
 190       break;
 191     case 5:
 192       cdc.dma_w = word_ram_2M_dma_w;
 193       break;
 194     default:
 195       cdc.dma_w = 0;
 196       break;
 197   }
 198
 199   return bufferptr;
 200 }
 201
 202 int cdc_context_load_old(uint8 *state)
 203 {
 204 #define old_load(v, ofs) \
 205   memcpy(&cdc.v, state + ofs, sizeof(cdc.v))
 206
 207   memcpy(cdc.ram, state, 0x4000);
 208   old_load(ifstat, 67892);
 209   old_load(ifctrl, 67924);
 210   old_load(dbc, 67896);
 211   old_load(dac, 67900);
 212   old_load(pt, 67908);
 213   old_load(wa, 67912);
 214   old_load(ctrl, 67928);
 215   old_load(head[0], 67904);
 216   old_load(stat, 67916);
 217
 218   cdc.dma_w = 0;
 219   switch (Pico_mcd->s68k_regs[0x04+0] & 0x07)
 220   {
 221     case 4: /* PCM RAM DMA */
 222       cdc.dma_w = pcm_ram_dma_w;
 223       break;
 224     case 5: /* PRG-RAM DMA */
 225       cdc.dma_w = prg_ram_dma_w;
 226       break;
 227     case 7: /* WORD-RAM DMA */
 228       if (Pico_mcd->s68k_regs[0x02+1] & 0x04)
 229       {
 230         if (Pico_mcd->s68k_regs[0x02+1] & 0x01)
 231           cdc.dma_w = word_ram_0_dma_w;
 232         else
 233           cdc.dma_w = word_ram_1_dma_w;
 234       }
 235       else
 236       {
 237         if (Pico_mcd->s68k_regs[0x02+1] & 0x02)
 238           cdc.dma_w = word_ram_2M_dma_w;
 239       }
 240       break;
 241   }
 242
 243   return 0x10960; // sizeof(old_cdc)
 244 #undef old_load
 245 }
 246
 247 static void do_dma(enum dma_type type, int words_in)
 248 {
 249         int dma_addr = (Pico_mcd->s68k_regs[0x0a] << 8) | Pico_mcd->s68k_regs[0x0b];
 250   int src_addr = cdc.dac & 0x3ffe;
 251   int dst_addr = dma_addr;
 252   int words = words_in;
 253   int dst_limit = 0;
 254   uint8 *dst;
 255   int len;
 256
 257   elprintf(EL_CD, "dma %d %04x->%04x %x",
 258     type, cdc.dac, dst_addr, words_in);
 259
 260   switch (type)
 261   {
 262     case pcm_ram_dma_w:
 263       dst_addr = (dst_addr << 2) & 0xffc;
 264       if (dst_addr + words * 2 > 0x1000) {
 265         elprintf(EL_ANOMALY, "pcm dma oflow: %x %x", dst_addr, words);
 266         words = (0x1000 - dst_addr) / 2;
 267       }
 268       dst = Pico_mcd->pcm_ram_b[Pico_mcd->pcm.bank];
 269       dst = dst + dst_addr;
 270       while (words > 0)
 271       {
 272         if (src_addr + words * 2 > 0x4000) {
 273           len = 0x4000 - src_addr;
 274           memcpy(dst, cdc.ram + src_addr, len);
 275           dst += len;
 276           src_addr = 0;
 277           words -= len / 2;
 278           continue;
 279         }
 280         memcpy(dst, cdc.ram + src_addr, words * 2);
 281         break;
 282       }
 283       goto update_dma;
 284
 285     case prg_ram_dma_w:
 286       dst_addr <<= 3;
 287                   dst = Pico_mcd->prg_ram + dst_addr;
 288       dst_limit = 0x80000;
 289       break;
 290
 291     case word_ram_0_dma_w:
 292       dst_addr = (dst_addr << 3) & 0x1fffe;
 293                         dst = Pico_mcd->word_ram1M[0] + dst_addr;
 294       dst_limit = 0x20000;
 295       break;
 296
 297     case word_ram_1_dma_w:
 298       dst_addr = (dst_addr << 3) & 0x1fffe;
 299                         dst = Pico_mcd->word_ram1M[1] + dst_addr;
 300       dst_limit = 0x20000;
 301       break;
 302
 303     case word_ram_2M_dma_w:
 304       dst_addr = (dst_addr << 3) & 0x3fffe;
 305                         dst = Pico_mcd->word_ram2M + dst_addr;
 306       dst_limit = 0x40000;
 307       break;
 308
 309     default:
 310       elprintf(EL_ANOMALY, "invalid dma: %d", type);
 311       goto update_dma;
 312   }
 313
 314   if (dst_addr + words * 2 > dst_limit) {
 315     elprintf(EL_ANOMALY, "cd dma %d oflow: %x %x", type, dst_addr, words);
 316     words = (dst_limit - dst_addr) / 2;
 317   }
 318   while (words > 0)
 319   {
 320     if (src_addr + words * 2 > 0x4000) {
 321       len = 0x4000 - src_addr;
 322       memcpy16bswap((void *)dst, cdc.ram + src_addr, len / 2);
 323       dst += len;
 324       src_addr = 0;
 325       words -= len / 2;
 326       continue;
 327     }
 328     memcpy16bswap((void *)dst, cdc.ram + src_addr, words);
 329     break;
 330   }
 331
 332 update_dma:
 333   /* update DMA addresses */
 334   cdc.dac += words_in * 2;
 335   if (type == pcm_ram_dma_w)
 336     dma_addr += words_in >> 1;
 337   else
 338     dma_addr += words_in >> 2;
 339
 340   Pico_mcd->s68k_regs[0x0a] = dma_addr >> 8;
 341   Pico_mcd->s68k_regs[0x0b] = dma_addr;
 342 }
 343
 344 void cdc_dma_update(void)
 345 {
 346   /* end of DMA transfer ? */
 347   //if (cdc.dbc < DMA_BYTES_PER_LINE)
 348   {
 349     /* transfer remaining words using 16-bit DMA */
 350     //cdc.dma_w((cdc.dbc + 1) >> 1);
 351     do_dma(cdc.dma_w, (cdc.dbc + 1) >> 1);
 352
 353     /* reset data byte counter (DBCH bits 4-7 should be set to 1) */
 354     cdc.dbc = 0xf000;
 355
 356     /* clear !DTEN and !DTBSY */
 357     cdc.ifstat |= (BIT_DTBSY | BIT_DTEN);
 358
 359     /* pending Data Transfer End interrupt */
 360     cdc.ifstat &= ~BIT_DTEI;
 361
 362     /* Data Transfer End interrupt enabled ? */
 363     if (cdc.ifctrl & BIT_DTEIEN)
 364     {
 365       /* level 5 interrupt enabled ? */
 366       if (Pico_mcd->s68k_regs[0x32+1] & PCDS_IEN5)
 367       {
 368         /* update IRQ level */
 369         elprintf(EL_INTS, "cdc DTE irq 5");
 370         SekInterruptS68k(5);
 371       }
 372     }
 373
 374     /* clear DSR bit & set EDT bit (SCD register $04) */
 375     Pico_mcd->s68k_regs[0x04+0] = (Pico_mcd->s68k_regs[0x04+0] & 0x07) | 0x80;
 376
 377     /* disable DMA transfer */
 378     cdc.dma_w = 0;
 379   }
 380 #if 0
 381   else
 382   {
 383     /* transfer all words using 16-bit DMA */
 384     cdc.dma_w(DMA_BYTES_PER_LINE >> 1);
 385
 386     /* decrement data byte counter */
 387     cdc.dbc -= length;
 388   }
 389 #endif
 390 }
 391
 392 int cdc_decoder_update(uint8 header[4])
 393 {
 394   /* data decoding enabled ? */
 395   if (cdc.ctrl[0] & BIT_DECEN)
 396   {
 397     /* update HEAD registers */
 398     memcpy(cdc.head[0], header, sizeof(cdc.head[0]));
 399
 400     /* set !VALST */
 401     cdc.stat[3] = 0x00;
 402
 403     /* pending decoder interrupt */
 404     cdc.ifstat &= ~BIT_DECI;
 405
 406     /* decoder interrupt enabled ? */
 407     if (cdc.ifctrl & BIT_DECIEN)
 408     {
 409       /* level 5 interrupt enabled ? */
 410       if (Pico_mcd->s68k_regs[0x32+1] & PCDS_IEN5)
 411       {
 412         /* update IRQ level */
 413         elprintf(EL_INTS, "cdc DEC irq 5");
 414         SekInterruptS68k(5);
 415       }
 416     }
 417
 418     /* buffer RAM write enabled ? */
 419     if (cdc.ctrl[0] & BIT_WRRQ)
 420     {
 421       uint16 offset;
 422
 423       /* increment block pointer  */
 424       cdc.pt += 2352;
 425
 426       /* increment write address */
 427       cdc.wa += 2352;
 428
 429       /* CDC buffer address */
 430       offset = cdc.pt & 0x3fff;
 431
 432       /* write CDD block header (4 bytes) */
 433       memcpy(cdc.ram + offset, header, 4);
 434
 435       /* write CDD block data (2048 bytes) */
 436       cdd_read_data(cdc.ram + 4 + offset);
 437
 438       /* take care of buffer overrun */
 439       if (offset > (0x4000 - 2048 - 4))
 440       {
 441         /* data should be written at the start of buffer */
 442         memcpy(cdc.ram, cdc.ram + 0x4000, offset + 2048 + 4 - 0x4000);
 443       }
 444
 445       /* read next data block */
 446       return 1;
 447     }
 448   }
 449
 450   /* keep decoding same data block if Buffer Write is disabled */
 451   return 0;
 452 }
 453
 454 void cdc_reg_w(unsigned char data)
 455 {
 456 #ifdef LOG_CDC
 457   elprintf(EL_STATUS, "CDC register %X write 0x%04x", Pico_mcd->s68k_regs[0x04+1] & 0x0F, data);
 458 #endif
 459   switch (Pico_mcd->s68k_regs[0x04+1] & 0x0F)
 460   {
 461     case 0x01:  /* IFCTRL */
 462     {
 463       /* pending interrupts ? */
 464       if (((data & BIT_DTEIEN) && !(cdc.ifstat & BIT_DTEI)) ||
 465           ((data & BIT_DECIEN) && !(cdc.ifstat & BIT_DECI)))
 466       {
 467         /* level 5 interrupt enabled ? */
 468         if (Pico_mcd->s68k_regs[0x32+1] & PCDS_IEN5)
 469         {
 470           /* update IRQ level */
 471           elprintf(EL_INTS, "cdc pending irq 5");
 472           SekInterruptS68k(5);
 473         }
 474       }
 475       else // if (scd.pending & (1 << 5))
 476       {
 477         /* clear pending level 5 interrupts */
 478         SekInterruptClearS68k(5);
 479       }
 480
 481       /* abort any data transfer if data output is disabled */
 482       if (!(data & BIT_DOUTEN))
 483       {
 484         /* clear !DTBSY and !DTEN */
 485         cdc.ifstat |= (BIT_DTBSY | BIT_DTEN);
 486       }
 487
 488       cdc.ifctrl = data;
 489       Pico_mcd->s68k_regs[0x04+1] = 0x02;
 490       break;
 491     }
 492
 493     case 0x02:  /* DBCL */
 494       cdc.dbc &= 0xff00;
 495       cdc.dbc |= data;
 496       Pico_mcd->s68k_regs[0x04+1] = 0x03;
 497       break;
 498
 499     case 0x03:  /* DBCH */
 500       cdc.dbc &= 0x00ff;
 501       cdc.dbc |= data << 8;
 502       Pico_mcd->s68k_regs[0x04+1] = 0x04;
 503       break;
 504
 505     case 0x04:  /* DACL */
 506       cdc.dac &= 0xff00;
 507       cdc.dac |= data;
 508       Pico_mcd->s68k_regs[0x04+1] = 0x05;
 509       break;
 510
 511     case 0x05:  /* DACH */
 512       cdc.dac &= 0x00ff;
 513       cdc.dac |= data << 8;
 514       Pico_mcd->s68k_regs[0x04+1] = 0x06;
 515       break;
 516
 517     case 0x06:  /* DTRG */
 518     {
 519       /* start data transfer if data output is enabled */
 520       if (cdc.ifctrl & BIT_DOUTEN)
 521       {
 522         /* set !DTBSY */
 523         cdc.ifstat &= ~BIT_DTBSY;
 524
 525         /* clear DBCH bits 4-7 */
 526         cdc.dbc &= 0x0fff;
 527
 528         /* clear EDT & DSR bits (SCD register $04) */
 529         Pico_mcd->s68k_regs[0x04+0] &= 0x07;
 530
 531         cdc.dma_w = 0;
 532
 533         /* setup data transfer destination */
 534         switch (Pico_mcd->s68k_regs[0x04+0] & 0x07)
 535         {
 536           case 2: /* MAIN-CPU host read */
 537           case 3: /* SUB-CPU host read */
 538           {
 539             /* set !DTEN */
 540             cdc.ifstat &= ~BIT_DTEN;
 541
 542             /* set DSR bit (register $04) */
 543             Pico_mcd->s68k_regs[0x04+0] |= 0x40;
 544             break;
 545           }
 546
 547           case 4: /* PCM RAM DMA */
 548           {
 549             cdc.dma_w = pcm_ram_dma_w;
 550             break;
 551           }
 552
 553           case 5: /* PRG-RAM DMA */
 554           {
 555             cdc.dma_w = prg_ram_dma_w;
 556             break;
 557           }
 558
 559           case 7: /* WORD-RAM DMA */
 560           {
 561             /* check memory mode */
 562             if (Pico_mcd->s68k_regs[0x02+1] & 0x04)
 563             {
 564               /* 1M mode */
 565               if (Pico_mcd->s68k_regs[0x02+1] & 0x01)
 566               {
 567                 /* Word-RAM bank 0 is assigned to SUB-CPU */
 568                 cdc.dma_w = word_ram_0_dma_w;
 569               }
 570               else
 571               {
 572                 /* Word-RAM bank 1 is assigned to SUB-CPU */
 573                 cdc.dma_w = word_ram_1_dma_w;
 574               }
 575             }
 576             else
 577             {
 578               /* 2M mode */
 579               if (Pico_mcd->s68k_regs[0x02+1] & 0x02)
 580               {
 581                 /* only process DMA if Word-RAM is assigned to SUB-CPU */
 582                 cdc.dma_w = word_ram_2M_dma_w;
 583               }
 584             }
 585             break;
 586           }
 587
 588           default: /* invalid */
 589           {
 590             elprintf(EL_ANOMALY, "invalid CDC tranfer destination (%d)",
 591               Pico_mcd->s68k_regs[0x04+0] & 0x07);
 592             break;
 593           }
 594         }
 595
 596         if (cdc.dma_w)
 597           pcd_event_schedule_s68k(PCD_EVENT_DMA, cdc.dbc / 2);
 598       }
 599
 600       Pico_mcd->s68k_regs[0x04+1] = 0x07;
 601       break;
 602     }
 603
 604     case 0x07:  /* DTACK */
 605     {
 606       /* clear pending data transfer end interrupt */
 607       cdc.ifstat |= BIT_DTEI;
 608
 609       /* clear DBCH bits 4-7 */
 610       cdc.dbc &= 0x0fff;
 611
 612 #if 0
 613       /* no pending decoder interrupt ? */
 614       if ((cdc.ifstat | BIT_DECI) || !(cdc.ifctrl & BIT_DECIEN))
 615       {
 616         /* clear pending level 5 interrupt */
 617         SekInterruptClearS68k(5);
 618       }
 619 #endif
 620       Pico_mcd->s68k_regs[0x04+1] = 0x08;
 621       break;
 622     }
 623
 624     case 0x08:  /* WAL */
 625       cdc.wa &= 0xff00;
 626       cdc.wa |= data;
 627       Pico_mcd->s68k_regs[0x04+1] = 0x09;
 628       break;
 629
 630     case 0x09:  /* WAH */
 631       cdc.wa &= 0x00ff;
 632       cdc.wa |= data << 8;
 633       Pico_mcd->s68k_regs[0x04+1] = 0x0a;
 634       break;
 635
 636     case 0x0a:  /* CTRL0 */
 637     {
 638       /* set CRCOK bit only if decoding is enabled */
 639       cdc.stat[0] = data & BIT_DECEN;
 640
 641       /* update decoding mode */
 642       if (data & BIT_AUTORQ)
 643       {
 644         /* set MODE bit according to CTRL1 register & clear FORM bit */
 645         cdc.stat[2] = cdc.ctrl[1] & BIT_MODRQ;
 646       }
 647       else
 648       {
 649         /* set MODE & FORM bits according to CTRL1 register */
 650         cdc.stat[2] = cdc.ctrl[1] & (BIT_MODRQ | BIT_FORMRQ);
 651       }
 652
 653       cdc.ctrl[0] = data;
 654       Pico_mcd->s68k_regs[0x04+1] = 0x0b;
 655       break;
 656     }
 657
 658     case 0x0b:  /* CTRL1 */
 659     {
 660       /* update decoding mode */
 661       if (cdc.ctrl[0] & BIT_AUTORQ)
 662       {
 663         /* set MODE bit according to CTRL1 register & clear FORM bit */
 664         cdc.stat[2] = data & BIT_MODRQ;
 665       }
 666       else
 667       {
 668         /* set MODE & FORM bits according to CTRL1 register */
 669         cdc.stat[2] = data & (BIT_MODRQ | BIT_FORMRQ);
 670       }
 671
 672       cdc.ctrl[1] = data;
 673       Pico_mcd->s68k_regs[0x04+1] = 0x0c;
 674       break;
 675     }
 676
 677     case 0x0c:  /* PTL */
 678       cdc.pt &= 0xff00;
 679       cdc.pt |= data;
 680       Pico_mcd->s68k_regs[0x04+1] = 0x0d;
 681       break;
 682
 683     case 0x0d:  /* PTH */
 684       cdc.pt &= 0x00ff;
 685       cdc.pt |= data << 8;
 686       Pico_mcd->s68k_regs[0x04+1] = 0x0e;
 687       break;
 688
 689     case 0x0e:  /* CTRL2 (unused) */
 690       Pico_mcd->s68k_regs[0x04+1] = 0x0f;
 691       break;
 692
 693     case 0x0f:  /* RESET */
 694       cdc_reset();
 695       break;
 696
 697     default:  /* by default, SBOUT is not used */
 698       break;
 699   }
 700 }
 701
 702 unsigned char cdc_reg_r(void)
 703 {
 704   switch (Pico_mcd->s68k_regs[0x04+1] & 0x0F)
 705   {
 706     case 0x01:  /* IFSTAT */
 707       Pico_mcd->s68k_regs[0x04+1] = 0x02;
 708       return cdc.ifstat;
 709
 710     case 0x02:  /* DBCL */
 711       Pico_mcd->s68k_regs[0x04+1] = 0x03;
 712       return cdc.dbc & 0xff;
 713
 714     case 0x03:  /* DBCH */
 715       Pico_mcd->s68k_regs[0x04+1] = 0x04;
 716       return (cdc.dbc >> 8) & 0xff;
 717
 718     case 0x04:  /* HEAD0 */
 719       Pico_mcd->s68k_regs[0x04+1] = 0x05;
 720       return cdc.head[cdc.ctrl[1] & BIT_SHDREN][0];
 721
 722     case 0x05:  /* HEAD1 */
 723       Pico_mcd->s68k_regs[0x04+1] = 0x06;
 724       return cdc.head[cdc.ctrl[1] & BIT_SHDREN][1];
 725
 726     case 0x06:  /* HEAD2 */
 727       Pico_mcd->s68k_regs[0x04+1] = 0x07;
 728       return cdc.head[cdc.ctrl[1] & BIT_SHDREN][2];
 729
 730     case 0x07:  /* HEAD3 */
 731       Pico_mcd->s68k_regs[0x04+1] = 0x08;
 732       return cdc.head[cdc.ctrl[1] & BIT_SHDREN][3];
 733
 734     case 0x08:  /* PTL */
 735       Pico_mcd->s68k_regs[0x04+1] = 0x09;
 736       return cdc.pt & 0xff;
 737
 738     case 0x09:  /* PTH */
 739       Pico_mcd->s68k_regs[0x04+1] = 0x0a;
 740       return (cdc.pt >> 8) & 0xff;
 741
 742     case 0x0a:  /* WAL */
 743       Pico_mcd->s68k_regs[0x04+1] = 0x0b;
 744       return cdc.wa & 0xff;
 745
 746     case 0x0b:  /* WAH */
 747       Pico_mcd->s68k_regs[0x04+1] = 0x0c;
 748       return (cdc.wa >> 8) & 0xff;
 749
 750     case 0x0c: /* STAT0 */
 751       Pico_mcd->s68k_regs[0x04+1] = 0x0d;
 752       return cdc.stat[0];
 753
 754     case 0x0d: /* STAT1 (always return 0) */
 755       Pico_mcd->s68k_regs[0x04+1] = 0x0e;
 756       return 0x00;
 757
 758     case 0x0e:  /* STAT2 */
 759       Pico_mcd->s68k_regs[0x04+1] = 0x0f;
 760       return cdc.stat[2];
 761
 762     case 0x0f:  /* STAT3 */
 763     {
 764       uint8 data = cdc.stat[3];
 765
 766       /* clear !VALST (note: this is not 100% correct but BIOS do not seem to care) */
 767       cdc.stat[3] = BIT_VALST;
 768
 769       /* clear pending decoder interrupt */
 770       cdc.ifstat |= BIT_DECI;
 771
 772 #if 0
 773       /* no pending data transfer end interrupt */
 774       if ((cdc.ifstat | BIT_DTEI) || !(cdc.ifctrl & BIT_DTEIEN))
 775       {
 776         /* clear pending level 5 interrupt */
 777         SekInterruptClearS68k(5);
 778       }
 779 #endif
 780
 781       Pico_mcd->s68k_regs[0x04+1] = 0x00;
 782       return data;
 783     }
 784
 785     default:  /* by default, COMIN is always empty */
 786       return 0xff;
 787   }
 788 }
 789
 790 unsigned short cdc_host_r(void)
 791 {
 792   /* check if data is available */
 793   if (!(cdc.ifstat & BIT_DTEN))
 794   {
 795     /* read data word from CDC RAM buffer */
 796     uint8 *datap = cdc.ram + (cdc.dac & 0x3ffe);
 797     uint16 data = (datap[0] << 8) | datap[1];
 798
 799 #ifdef LOG_CDC
 800     error("CDC host read 0x%04x -> 0x%04x (dbc=0x%x) (%X)\n", cdc.dac, data, cdc.dbc, s68k.pc);
 801 #endif
 802
 803     /* increment data address counter */
 804     cdc.dac += 2;
 805
 806     /* decrement data byte counter */
 807     cdc.dbc -= 2;
 808
 809     /* end of transfer ? */
 810     if ((int16)cdc.dbc <= 0)
 811     {
 812       /* reset data byte counter (DBCH bits 4-7 should be set to 1) */
 813       cdc.dbc = 0xf000;
 814
 815       /* clear !DTEN and !DTBSY */
 816       cdc.ifstat |= (BIT_DTBSY | BIT_DTEN);
 817
 818       /* pending Data Transfer End interrupt */
 819       cdc.ifstat &= ~BIT_DTEI;
 820
 821       /* Data Transfer End interrupt enabled ? */
 822       if (cdc.ifctrl & BIT_DTEIEN)
 823       {
 824         /* level 5 interrupt enabled ? */
 825         if (Pico_mcd->s68k_regs[0x32+1] & PCDS_IEN5)
 826         {
 827           /* update IRQ level */
 828           elprintf(EL_INTS, "cdc DTE irq 5");
 829           SekInterruptS68k(5);
 830         }
 831       }
 832
 833       /* clear DSR bit & set EDT bit (SCD register $04) */
 834       Pico_mcd->s68k_regs[0x04+0] = (Pico_mcd->s68k_regs[0x04+0] & 0x07) | 0x80;
 835     }
 836
 837     return data;
 838   }
 839
 840 #ifdef LOG_CDC
 841   error("error reading CDC host (data transfer disabled)\n");
 842 #endif
 843   return 0xffff;
 844 }
 845
 846 // vim:shiftwidth=2:ts=2:expandtab