[BACK]Return to atapicmd.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / cbus

Diff for /np2/cbus/atapicmd.c between versions 1.6 and 1.10

version 1.6, 2005/04/04 11:50:59 version 1.10, 2005/04/06 17:44:09
Line 17 Line 17
 #include        "atapicmd.h"  #include        "atapicmd.h"
 #include        "sxsi.h"  #include        "sxsi.h"
   
 // #define      YUIDEBUG  #define YUIDEBUG
   
   
 // INQUIRY  // INQUIRY
Line 115  static void atapi_cmd_read_capacity(IDED Line 115  static void atapi_cmd_read_capacity(IDED
 static void atapi_cmd_read(IDEDRV drv, UINT32 lba, UINT32 leng);  static void atapi_cmd_read(IDEDRV drv, UINT32 lba, UINT32 leng);
 static void atapi_cmd_mode_select(IDEDRV drv);  static void atapi_cmd_mode_select(IDEDRV drv);
 static void atapi_cmd_mode_sense(IDEDRV drv);  static void atapi_cmd_mode_sense(IDEDRV drv);
   static void atapi_cmd_readsubch(IDEDRV drv);
 static void atapi_cmd_readtoc(IDEDRV drv);  static void atapi_cmd_readtoc(IDEDRV drv);
   static void atapi_cmd_playaudiomsf(IDEDRV drv);
   static void atapi_cmd_pauseresume(IDEDRV drv);
   
 void atapicmd_a0(IDEDRV drv) {  void atapicmd_a0(IDEDRV drv) {
   
Line 194  void atapicmd_a0(IDEDRV drv) { Line 197  void atapicmd_a0(IDEDRV drv) {
                 atapi_cmd_mode_sense(drv);                  atapi_cmd_mode_sense(drv);
                 break;                  break;
   
           case 0x42:
                   TRACEOUT(("atapicmd: read sub channel"));
                   atapi_cmd_readsubch(drv);
                   break;
   
         case 0x43:              // read TOC          case 0x43:              // read TOC
                 TRACEOUT(("atapicmd: read TOC"));                  TRACEOUT(("atapicmd: read TOC"));
                 atapi_cmd_readtoc(drv);                  atapi_cmd_readtoc(drv);
                 break;                  break;
   
           case 0x47:              // Play Audio MSF
                   TRACEOUT(("atapicmd: Play Audio MSF"));
                   atapi_cmd_playaudiomsf(drv);
                   break;
   
           case 0x4b:
                   TRACEOUT(("atapicmd: pause resume"));
                   atapi_cmd_pauseresume(drv);
                   break;
   
         default:          default:
                 TRACEOUT(("atapicmd: unknown command = %.2x", cmd));                  TRACEOUT(("atapicmd: unknown command = %.2x", cmd));
                 sendabort(drv);                  sendabort(drv);
Line 502  length_exceeded: Line 520  length_exceeded:
         senddata(drv, cnt, leng);          senddata(drv, cnt, leng);
 }  }
   
   
   // ---- Audio
   
   static void storemsf(UINT8 *ptr, UINT32 pos) {
   
           UINT    f;
           UINT    m;
   
           f = pos % 75;
           pos = pos / 75;
           m = pos % 60;
           pos = pos / 60;
           ptr[0] = 0;
           ptr[1] = (UINT8)pos;
           ptr[2] = (UINT8)m;
           ptr[3] = (UINT8)f;
   }
   
   
   // 0x42: READ SUB CHANNEL
   static void atapi_cmd_readsubch(IDEDRV drv) {
   
           SXSIDEV sxsi;
           UINT    subq;
           UINT    cmd;
           UINT    leng;
           CDTRK   trk;
           UINT    tracks;
           UINT    r;
           UINT32  pos;
   
           sxsi = sxsi_getptr(drv->sxsidrv);
           if ((sxsi == NULL) || (sxsi->devtype != SXSIDEV_CDROM) ||
                   (!(sxsi->flag & SXSIFLAG_READY))) {
                   senderror(drv);
                   return;
           }
           trk = sxsicd_gettrk(sxsi, &tracks);
           leng = (drv->buf[7] << 8) + drv->buf[8];
           subq = drv->buf[2] & 0x40;
           cmd = drv->buf[3];
   
           drv->buf[0] = 0;
           drv->buf[1] = (UINT8)drv->daflag;
           drv->buf[2] = 0;
           drv->buf[3] = 0;
           if (!subq) {
                   senddata(drv, 4, leng);
                   return;
           }
           switch(cmd) {
                   case 0x01:                      // CD-ROM current pos
                           ZeroMemory(drv->buf + 4, 12);
                           drv->buf[3] = 0x12;
                           drv->buf[4] = 0x01;
                           if (drv->daflag != 0x15) {
                                   pos = drv->dacurpos;
                                   if ((drv->daflag == 0x12) || (drv->daflag == 0x13)) {
                                           pos += (rand() & 7);
                                   }
                                   r = tracks;
                                   while(r) {
                                           r--;
                                           if (trk[r].pos <= pos) {
                                                   break;
                                           }
                                   }
                                   drv->buf[5] = trk[r].type;
                                   drv->buf[6] = trk[r].track;
                                   drv->buf[7] = 1;
                                   storemsf(drv->buf + 8, pos + 150);
                                   storemsf(drv->buf + 12, pos - trk[r].pos);
                           }
                           senddata(drv, 16, leng);
                           break;
   
                   default:
                           senderror(drv);
                           break;
           }
   }
   
   // 0x43: READ TOC
 static void atapi_cmd_readtoc(IDEDRV drv) {  static void atapi_cmd_readtoc(IDEDRV drv) {
   
           SXSIDEV sxsi;
         UINT    leng;          UINT    leng;
         UINT    format;          UINT    format;
           CDTRK   trk;
           UINT    tracks;
           UINT    datasize;
           UINT8   *ptr;
           UINT    i;
   
           sxsi = sxsi_getptr(drv->sxsidrv);
           if ((sxsi == NULL) || (sxsi->devtype != SXSIDEV_CDROM) ||
                   (!(sxsi->flag & SXSIFLAG_READY))) {
                   senderror(drv);
                   return;
           }
           trk = sxsicd_gettrk(sxsi, &tracks);
   
         leng = (drv->buf[7] << 8) + drv->buf[8];          leng = (drv->buf[7] << 8) + drv->buf[8];
         format = (drv->buf[9] >> 6);          format = (drv->buf[9] >> 6);
         TRACEOUT(("atapi_cmd_readtoc fmt=%d leng=%d", format, leng));          TRACEOUT(("atapi_cmd_readtoc fmt=%d leng=%d", format, leng));
   
         switch (format) {          switch (format) {
 #ifdef YUIDEBUG  
         case 0: // track info          case 0: // track info
                 // これ、PN専用。                  datasize = (tracks * 8) + 10;
                 // 後で ccd等からデータを作ろう                  drv->buf[0] = (UINT8)(datasize >> 8);
                 drv->buf[0x00] = 0x00;  drv->buf[0x01] = 0x3a;                  drv->buf[1] = (UINT8)(datasize >> 0);
                 drv->buf[0x02] = 0x01;                  drv->buf[2] = 1;
                 drv->buf[0x03] = 0x06;                  drv->buf[3] = (UINT8)tracks;
                   ptr = drv->buf + 4;
                 drv->buf[0x04] = 0x00;  drv->buf[0x05] = 0x14;                  for (i=0; i<=tracks; i++) {
                 drv->buf[0x06] = 0x01;                          ptr[0] = 0;
                 drv->buf[0x07] = 0x00;                          ptr[1] = trk[i].type;
                 drv->buf[0x08] = 0x00;                          ptr[2] = trk[i].track;
                 drv->buf[0x09] = 0x00;                          ptr[3] = 0;
                 drv->buf[0x0a] = 0x02;                          storemsf(ptr + 4, trk[i].pos + 150);
                 drv->buf[0x0b] = 0x00;                          ptr += 8;
                   }
                 drv->buf[0x0c] = 0x00;  drv->buf[0x0d] = 0x10;                  senddata(drv, (tracks * 8) + 12, leng);
                 drv->buf[0x0e] = 0x02;  
                 drv->buf[0x0f] = 0x00;  
                 drv->buf[0x10] = 0x00;  
                 drv->buf[0x11] = 0x29;  
                 drv->buf[0x12] = 0x1c;  
                 drv->buf[0x13] = 0x34;  
   
                 drv->buf[0x14] = 0x00;  drv->buf[0x15] = 0x10;  
                 drv->buf[0x16] = 0x03;  
                 drv->buf[0x17] = 0x00;  
                 drv->buf[0x18] = 0x00;  
                 drv->buf[0x19] = 0x29;  
                 drv->buf[0x1a] = 0x20;  
                 drv->buf[0x1b] = 0x43;  
   
                 drv->buf[0x1c] = 0x00;  drv->buf[0x1d] = 0x10;  
                 drv->buf[0x1e] = 0x04;  
                 drv->buf[0x1f] = 0x00;  
                 drv->buf[0x20] = 0x00;  
                 drv->buf[0x21] = 0x2b;  
                 drv->buf[0x22] = 0x07;  
                 drv->buf[0x23] = 0x19;  
   
                 drv->buf[0x24] = 0x00;  drv->buf[0x25] = 0x10;  
                 drv->buf[0x26] = 0x05;  
                 drv->buf[0x27] = 0x00;  
                 drv->buf[0x28] = 0x00;  
                 drv->buf[0x29] = 0x2e;  
                 drv->buf[0x2a] = 0x39;  
                 drv->buf[0x2b] = 0x1d;  
   
                 drv->buf[0x2c] = 0x00;  drv->buf[0x2d] = 0x10;  
                 drv->buf[0x2e] = 0x06;  
                 drv->buf[0x2f] = 0x00;  
                 drv->buf[0x30] = 0x00;  
                 drv->buf[0x31] = 0x34;  
                 drv->buf[0x32] = 0x0b;  
                 drv->buf[0x33] = 0x13;  
   
                 drv->buf[0x34] = 0x00;  drv->buf[0x35] = 0x10;  
                 drv->buf[0x36] = 0xaa;  
                 drv->buf[0x37] = 0x00;  
                 drv->buf[0x38] = 0x00;  
                 drv->buf[0x39] = 0x3b;  
                 drv->buf[0x3a] = 0x1e;  
                 drv->buf[0x3b] = 0x0b;  
                 senddata(drv, 0x3c, leng);  
                 break;                  break;
 #endif  
   
         case 1: // multi session          case 1: // multi session
                 ZeroMemory(drv->buf, 12);                  ZeroMemory(drv->buf, 12);
Line 596  static void atapi_cmd_readtoc(IDEDRV drv Line 662  static void atapi_cmd_readtoc(IDEDRV drv
         }          }
 }  }
   
   // 0x47: Play Audio MSF
   static void atapi_cmd_playaudiomsf(IDEDRV drv) {
   
           UINT32  pos;
           UINT32  leng;
   
           pos = (((drv->buf[3] * 60) + drv->buf[4]) * 75) + drv->buf[5];
           leng = (((drv->buf[6] * 60) + drv->buf[7]) * 75) + drv->buf[8];
           if (leng > pos) {
                   leng -= pos;
           }
           else {
                   leng = 0;
           }
           if (pos >= 150) {
                   pos -= 150;
           }
           else {
                   pos = 0;
           }
           ideio.daplaying |= 1 << (drv->sxsidrv & 3);
           drv->daflag = 0x11;
           drv->dacurpos = pos;
           drv->dalength = leng;
           drv->dabufrem = 0;
           cmddone(drv);
   }
   
   // 0x4B: PAUSE RESUME
   static void atapi_cmd_pauseresume(IDEDRV drv) {
   
           if (drv->buf[8] & 1) {
                   // resume
                   if (drv->daflag == 0x12) {
                           ideio.daplaying |= 1 << (drv->sxsidrv & 3);
                           drv->daflag = 0x11;
                   }
           }
           else {
                   // pause
                   if (drv->daflag == 0x11) {
                           ideio.daplaying &= ~(1 << (drv->sxsidrv & 3));
                           drv->daflag = 0x12;
                   }
           }
           cmddone(drv);
   }
   
 #endif  /* SUPPORT_IDEIO */  #endif  /* SUPPORT_IDEIO */
   
Removed from v.1.6  
changed lines
  Added in v.1.10

RetroPC.NET-CVS <cvs@retropc.net>