[BACK]Return to fdd_d88.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / xmil / fdd

Diff for /xmil/fdd/fdd_d88.c between versions 1.3 and 1.4

version 1.3, 2004/08/02 13:38:46 version 1.4, 2004/08/04 15:18:26
Line 8 Line 8
   
   
 static  D88_HEADER      d88head[4];  static  D88_HEADER      d88head[4];
 static  D88_SECTOR      cursec;  static  _D88SEC         cursec;
 static  short           curdrv = -1;  static  REG8            curdrv = (REG8)-1;
 static  WORD            curtrk = -1;  static  UINT            curtrk = (UINT)-1;
 static  BYTE            curtype = 0;  static  BYTE            curtype = 0;
 static  WORD            cursct = -1;  static  UINT            cursct = (UINT)-1;
 static  long            curfp = 0;  static  long            curfp = 0;
 static  DWORD           cursize = 0;  static  UINT            cursize = 0;
 static  BYTE            curwrite = 0;  static  BYTE            curwrite = 0;
 static  BYTE            curtrkerr = 0;  static  BYTE            curtrkerr = 0;
 static  BYTE            hole = 0;  static  BYTE            hole = 0;
 static  BYTE            *curdata;  static  BYTE            *curdata;
 static  WORD            crcnum = 0;  static  UINT            crcnum = 0;
 static  BYTE            crcerror = FALSE;  static  BYTE            crcerror = FALSE;
   
 extern  WORD            readdiag;  extern  WORD            readdiag;
Line 115  int curdataflush(void) { Line 115  int curdataflush(void) {
 }  }
   
   
 DWORD read_d88track(short drv, WORD track, BYTE type) {  static DWORD read_d88track(REG8 drv, UINT track, BYTE type) {
   
         FDDFILE fdd;          FDDFILE fdd;
         FILEH   hdr;          FILEH   hdr;
Line 124  DWORD read_d88track(short drv, WORD trac Line 124  DWORD read_d88track(short drv, WORD trac
         curdrv = drv;          curdrv = drv;
         curtrk = track;          curtrk = track;
         curtype = type;          curtype = type;
         cursct = -1;          cursct = (UINT)-1;
         curwrite = 0;          curwrite = 0;
         curtrkerr = 0;          curtrkerr = 0;
         crcnum = 0;          crcnum = 0;
Line 147  DWORD read_d88track(short drv, WORD trac Line 147  DWORD read_d88track(short drv, WORD trac
                 file_close(hdr);                  file_close(hdr);
                 goto readd88_err;                  goto readd88_err;
         }          }
         if (file_read(hdr, D88_BUF, (WORD)cursize) != (WORD)cursize) {          if (file_read(hdr, D88_BUF, cursize) != cursize) {
                 file_close(hdr);                  file_close(hdr);
                 goto readd88_err;                  goto readd88_err;
         }          }
Line 166  readd88_err: Line 166  readd88_err:
   
   
   
 static int seeksector(short drv, WORD track, WORD sector) {  static int seeksector(REG8 drv, UINT track, UINT r) {
   
 static  int             lastflag = FALSE;  static  int             lastflag = FALSE;
   
         BYTE            *p;  const _D88SEC   *p;
         WORD            sec;          UINT            sec;
           UINT            sectors;
           UINT            secsize;
   
         if ((curdrv != drv) || (curtrk != track) || (curtype != fdc.media)) {          if ((curdrv != drv) || (curtrk != track) || (curtype != fdc.media)) {
                 read_d88track(drv, track, fdc.media);                  read_d88track(drv, track, fdc.media);
         }          }
         if (curtrkerr) {          if (curtrkerr) {
                 cursct = sector;                  cursct = r;
                 goto seekerror;                  goto seekerror;
         }          }
         if (cursct != sector) {          if (cursct != r) {
                 cursct = sector;                  cursct = r;
                 p = D88_BUF;                  p = (D88SEC)D88_BUF;
                 for (sec=0; sec<40;) {                  for (sec=0; sec<40; ) {
                         if ((WORD)((D88_SECTOR *)p)->r == sector) {                          sectors = LOADINTELWORD(p->sectors);
                                 memcpy(&cursec, p, sizeof(D88_SECTOR));                          secsize = LOADINTELWORD(p->size);
                                 curdata = p + sizeof(D88_SECTOR);                          if (p->r == r) {
                                   CopyMemory(&cursec, p, sizeof(_D88SEC));
                                   curdata = (UINT8 *)(p + 1);
                                 lastflag = TRUE;                                  lastflag = TRUE;
                                 break;                                  break;
                         }                          }
                         if (++sec >= ((D88_SECTOR *)p)->sectors) {                          sec++;
                           if (sec >= sectors) {
                                 goto seekerror;                                  goto seekerror;
                         }                          }
                         p += ((D88_SECTOR *)p)->size;                          p = (D88SEC)(((UINT8 *)(p + 1)) + secsize);
                         p += sizeof(D88_SECTOR);  
                 }                  }
                 if (sec >= 40) {                  if (sec >= 40) {
                         goto seekerror;                          goto seekerror;
Line 203  static int  lastflag = FALSE; Line 207  static int  lastflag = FALSE;
         return(lastflag);          return(lastflag);
   
 seekerror:;  seekerror:;
         ZeroMemory(&cursec, sizeof(D88_SECTOR));          ZeroMemory(&cursec, sizeof(_D88SEC));
         curdata = &D88_BUF[16];          curdata = &D88_BUF[16];
         lastflag = FALSE;          lastflag = FALSE;
         return(FALSE);          return(FALSE);
 }  }
   
   static void drvflush(REG8 drv) {
 void drvflush(short drv) {  
   
         if (curdrv == drv) {          if (curdrv == drv) {
                 curdataflush();                  curdataflush();
                 curdrv = -1;                  curdrv = (REG8)-1;
                 curtrk = -1;                  curtrk = (UINT)-1;
                 cursct = -1;                  cursct = (UINT)-1;
         }          }
 }  }
   
Line 227  void drvflush(short drv) { Line 230  void drvflush(short drv) {
   
 short fdd_crc_d88(void) {  short fdd_crc_d88(void) {
   
         WORD            track;          UINT            track;
         BYTE            *p;  const _D88SEC   *p;
         WORD            sec;          UINT            sec;
           UINT            sectors;
           UINT            secsize;
   
         ZeroMemory(fdc.crc_dat, 6);          ZeroMemory(fdc.crc_dat, 6);
         if ((track = (WORD)(fdc.c << 1) + (WORD)fdc.h) > 163) {          track = (fdc.c << 1) + fdc.h;
           if (track >= 164) {
                 goto crcerror_d88;                  goto crcerror_d88;
         }          }
         seeksector(fdc.drv, track, fdc.r);          seeksector(fdc.drv, track, fdc.r);
         if (curtrkerr) {          if (curtrkerr) {
                 goto crcerror_d88;                  goto crcerror_d88;
         }          }
         p = D88_BUF;          p = (D88SEC)D88_BUF;
         for (sec=0; sec<crcnum;) {          for (sec=0; sec<crcnum;) {
                 if (++sec >= ((D88_SECTOR *)p)->sectors) {                  sectors = LOADINTELWORD(p->sectors);
                   secsize = LOADINTELWORD(p->size);
                   sec++;
                   if (sec >= sectors) {
                         goto crcerror_d88;                          goto crcerror_d88;
                 }                  }
                 p += ((D88_SECTOR *)p)->size;                  p = (D88SEC)(((UINT8 *)(p + 1)) + secsize);
                 p += sizeof(D88_SECTOR);  
         }          }
         *(long *)fdc.crc_dat = *(long *)p;          fdc.rreg = p->c;                                                                // メルヘンヴェール
         fdc.rreg = ((D88_SECTOR *)p)->c;                                // ??? メルヘンヴェール          fdc.crc_dat[0] = p->c;
           fdc.crc_dat[1] = p->h;
           fdc.crc_dat[2] = p->r;
           fdc.crc_dat[3] = p->n;
         crcnum++;          crcnum++;
         if (((D88_SECTOR *)p)->stat) {          if (p->stat) {
                 crcerror = TRUE;                  crcerror = TRUE;
         }          }
         else {          else {
Line 269  BYTE fdd_stat_d88(void) { Line 280  BYTE fdd_stat_d88(void) {
         FDDFILE         fdd;          FDDFILE         fdd;
         BYTE            type;          BYTE            type;
         REG8            cmd;          REG8            cmd;
           UINT            trk;
         BYTE            ans = 0;          BYTE            ans = 0;
         int                     seekable;          int                     seekable;
         WORD            trk;  
   
         fdd = fddfile + fdc.drv;          fdd = fddfile + fdc.drv;
         if (fdd->type != DISKTYPE_D88) {          if (fdd->type != DISKTYPE_D88) {
Line 279  BYTE fdd_stat_d88(void) { Line 290  BYTE fdd_stat_d88(void) {
         }          }
         type = fdc.type;          type = fdc.type;
         cmd = (REG8)(fdc.cmd >> 4);          cmd = (REG8)(fdc.cmd >> 4);
         trk = (fdc.c << 1) + (WORD)fdc.h;          trk = (fdc.c << 1) + fdc.h;
         seekable = seeksector(fdc.drv, trk, fdc.r);          seekable = seeksector(fdc.drv, trk, fdc.r);
         if (!fdc.r) {          if (!fdc.r) {
                 seekable = TRUE;                  seekable = TRUE;
Line 327  BYTE fdd_stat_d88(void) { Line 338  BYTE fdd_stat_d88(void) {
                 if ((type != 4) && (FDDMTR_BUSY)) {                  if ((type != 4) && (FDDMTR_BUSY)) {
                         ans |= 0x01;                          ans |= 0x01;
                 }                  }
                 if ((type == 2) && ((WORD)fdc.off < cursec.size)) {                  if (type == 2) {
                         ans |= 0x03;                                    // DATA REQUEST / BUSY                          UINT secsize = LOADINTELWORD(cursec.size);
                           if ((UINT)fdc.off < secsize) {
                                   ans |= 0x03;                                    // DATA REQUEST / BUSY
                           }
                 }                  }
                 else if ((cmd == 0x0e) && (readdiag < 0x1a00)) {                  else if ((cmd == 0x0e) && (readdiag < 0x1a00)) {
                         ans |= 0x03;                          ans |= 0x03;
Line 349  BYTE fdd_stat_d88(void) { Line 363  BYTE fdd_stat_d88(void) {
 }  }
   
   
   
 //**********************************************************************  //**********************************************************************
   
 void fdd_read_d88(void) {  void fdd_read_d88(void) {
Line 359  void fdd_read_d88(void) { Line 372  void fdd_read_d88(void) {
         }          }
 }  }
   
   
 void fdd_write_d88(void) {  void fdd_write_d88(void) {
   
         if ((fdd_stat_d88() & 0xf3) == 3) {          if ((fdd_stat_d88() & 0xf3) == 3) {
Line 368  void fdd_write_d88(void) { Line 380  void fdd_write_d88(void) {
         }          }
 }  }
   
   
 BYTE fdd_incoff_d88(void) {  BYTE fdd_incoff_d88(void) {
   
         REG8    cmd;          REG8    cmd;
         WORD    trk;          UINT    trk;
           UINT    secsize;
   
         cmd = (REG8)(fdc.cmd >> 4);          cmd = (REG8)(fdc.cmd >> 4);
         trk = (fdc.c << 1) + (WORD)fdc.h;          trk = (fdc.c << 1) + fdc.h;
         seeksector(fdc.drv, trk, fdc.r);          seeksector(fdc.drv, trk, fdc.r);
         if ((WORD)(++fdc.off) < cursec.size) {          fdc.off++;
           secsize = LOADINTELWORD(cursec.size);
           if ((UINT)fdc.off < secsize) {
                 return(0);                  return(0);
         }          }
         fdc.off = cursec.size;          fdc.off = secsize;
         if ((cmd == 0x09) || (cmd == 0x0b)) {          if ((cmd == 0x09) || (cmd == 0x0b)) {
                 fdc.rreg = fdc.r + 1;                                           // ver0.25                  fdc.rreg = fdc.r + 1;                                           // ver0.25
                 if (seeksector(fdc.drv, trk, fdc.rreg)) {                  if (seeksector(fdc.drv, trk, fdc.rreg)) {
Line 392  BYTE fdd_incoff_d88(void) { Line 406  BYTE fdd_incoff_d88(void) {
         return(1);          return(1);
 }  }
   
   
 // ---------------------------------------------------------------------------  // ---------------------------------------------------------------------------
   
 void init_tao_d88(void) {  void init_tao_d88(void) {
Line 455  void endoftrack(void) { Line 470  void endoftrack(void) {
         long            endpointer;          long            endpointer;
         long            lastpointer;          long            lastpointer;
         long            trksize;          long            trksize;
         int                     ptr;  
         long            apsize;          long            apsize;
           D88SEC          p;
           UINT            secsize;
   
         if (!tao.sector) {          if (!tao.sector) {
                 tao.flag = 4;                  tao.flag = 4;
Line 465  void endoftrack(void) { Line 481  void endoftrack(void) {
         tao.flag = 0;          tao.flag = 0;
   
         curdataflush();                                         // write cache flush &          curdataflush();                                         // write cache flush &
         curdrv = -1;                                            // use D88_BUF[] for temp          curdrv = (REG8)-1;                                      // use D88_BUF[] for temp
   
         head = &d88head[fdc.drv];          head = &d88head[fdc.drv];
         trk = (fdc.c << 1) + (WORD)fdc.h;          trk = (fdc.c << 1) + fdc.h;
   
         ptr = 0;          p = (D88SEC)TAO_BUF;
         for (i=0; i<(int)tao.sector; i++) {          for (i=0; i<(int)tao.sector; i++) {
                 ((D88_SECTOR *)&TAO_BUF[ptr])->sectors = tao.sector;                  STOREINTELWORD(p->sectors, tao.sector);
                 ptr += ((D88_SECTOR *)&TAO_BUF[ptr])->size + 16;                  secsize = LOADINTELWORD(p->size);
                   p = (D88SEC)(((UINT8 *)(p + 1)) + secsize);
         }          }
   
         fdd = fddfile + fdc.drv;          fdd = fddfile + fdc.drv;
Line 517  void endoftrack(void) { Line 534  void endoftrack(void) {
   
 void fdd_wtao_d88(BYTE data) {  void fdd_wtao_d88(BYTE data) {
   
           D88SEC  p;
   
         if (tao.flag != 3) {          if (tao.flag != 3) {
                 return;                  return;
         }          }
Line 533  void fdd_wtao_d88(BYTE data) { Line 552  void fdd_wtao_d88(BYTE data) {
                                 tao.gap = 0;                                  tao.gap = 0;
                         }                          }
                         break;                          break;
   
                 case TAO_MODE_GAP:                  case TAO_MODE_GAP:
                         if (data == TAO_MODE_GAP) {                          if (data == TAO_MODE_GAP) {
                                 if (tao.gap++ > 256) {                                  if (tao.gap++ > 256) {
Line 551  void fdd_wtao_d88(BYTE data) { Line 571  void fdd_wtao_d88(BYTE data) {
                                 tao.flag = 4;                                  tao.flag = 4;
                         }                          }
                         break;                          break;
   
                 case TAO_MODE_SYNC:                  case TAO_MODE_SYNC:
 //                      tao.cnt--;                                                              // ver0.26 Zeliard  //                      tao.cnt--;                                                              // ver0.26 Zeliard
                         if (data == TAO_CMD_AM_IN) {                          if (data == TAO_CMD_AM_IN) {
Line 563  void fdd_wtao_d88(BYTE data) { Line 584  void fdd_wtao_d88(BYTE data) {
                                 tao.flag = 4;                                  tao.flag = 4;
                         }                          }
                         break;                          break;
   
                 case TAO_MODE_IM:                  case TAO_MODE_IM:
                         if (data == TAO_CMD_IM) {                          if (data == TAO_CMD_IM) {
                                 tao.mode = TAO_ENDOFDATA;                                  tao.mode = TAO_ENDOFDATA;
Line 571  void fdd_wtao_d88(BYTE data) { Line 593  void fdd_wtao_d88(BYTE data) {
                                 tao.flag = 4;                                  tao.flag = 4;
                         }                          }
                         break;                          break;
   
                 case TAO_MODE_AM:                  case TAO_MODE_AM:
                         if (data == TAO_CMD_IAM) {                          if (data == TAO_CMD_IAM) {
                                 tao.mode = TAO_MODE_ID;                                  tao.mode = TAO_MODE_ID;
Line 584  void fdd_wtao_d88(BYTE data) { Line 607  void fdd_wtao_d88(BYTE data) {
                         else if (data == TAO_CMD_DDAM) {                          else if (data == TAO_CMD_DDAM) {
                                 tao.mode = TAO_MODE_DATA;                                  tao.mode = TAO_MODE_DATA;
                                 tao.ptr = 0;                                  tao.ptr = 0;
                                 ((D88_SECTOR *)&TAO_BUF[tao.top])->del_flg = 1;                                  p = (D88SEC)(TAO_BUF + tao.top);
                                   p->del_flg = 1;
                         }                          }
                         break;                          break;
   
                 case TAO_MODE_ID:                  case TAO_MODE_ID:
                         if ((data == TAO_CMD_IAM) && (!tao.ptr)) {                          if ((data == TAO_CMD_IAM) && (!tao.ptr)) {
                                 break;                                  break;
Line 597  void fdd_wtao_d88(BYTE data) { Line 622  void fdd_wtao_d88(BYTE data) {
                         }                          }
                         else if (data == TAO_CMD_CRC) {                          else if (data == TAO_CMD_CRC) {
                                 tao.mode = TAO_ENDOFDATA;                                  tao.mode = TAO_ENDOFDATA;
                                 ZeroMemory(&TAO_BUF[tao.size], 12);                                  ZeroMemory(TAO_BUF + tao.size, 12);
                                 tao.size += 12;                                  tao.size += 12;
                         }                          }
                         break;                          break;
   
                 case TAO_MODE_DATA:                                             // DATA WRITE                  case TAO_MODE_DATA:                                             // DATA WRITE
                         if ((!tao.ptr) &&                          if ((!tao.ptr) &&
                                 ((data == TAO_CMD_DAM) || (data == TAO_CMD_DDAM))) {                                  ((data == TAO_CMD_DAM) || (data == TAO_CMD_DDAM))) {
Line 608  void fdd_wtao_d88(BYTE data) { Line 634  void fdd_wtao_d88(BYTE data) {
                         }                          }
                         else if (data == TAO_CMD_CRC) {                 // nで判定した方が無難か？                          else if (data == TAO_CMD_CRC) {                 // nで判定した方が無難か？
                                 tao.mode = TAO_ENDOFDATA;                                  tao.mode = TAO_ENDOFDATA;
                                 ((D88_SECTOR *)&TAO_BUF[tao.top])->size = tao.ptr;                                  p = (D88SEC)(TAO_BUF + tao.top);
                                   STOREINTELWORD(p->size, tao.ptr);
                                 if (tao.sector++ > tao.maxsector) {                                  if (tao.sector++ > tao.maxsector) {
                                         tao.flag = 4;                                          tao.flag = 4;
                                 }                                  }
Removed from v.1.3  
changed lines
  Added in v.1.4

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