[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.2 and 1.3

version 1.2, 2004/08/02 11:48:13 version 1.3, 2004/08/02 13:38:46
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "x1_io.h"  #include        "iocore.h"
 #include        "x1_fdc.h"  
 #include        "fdd_mtr.h"  
 #include        "fdd_d88.h"  
 #include        "fddfile.h"  #include        "fddfile.h"
   #include        "fdd_d88.h"
   #include        "fdd_mtr.h"
   
   
 static  D88_HEADER      d88head[4];  static  D88_HEADER      d88head[4];
Line 23  static BYTE  *curdata; Line 22  static BYTE  *curdata;
 static  WORD            crcnum = 0;  static  WORD            crcnum = 0;
 static  BYTE            crcerror = FALSE;  static  BYTE            crcerror = FALSE;
   
 extern  BYTE            WRITEPT[];  
 extern  BYTE            DISKNUM[];  
   
 extern  WORD            readdiag;  extern  WORD            readdiag;
   
 #define         TAO_MODE_GAP    0x4e  #define         TAO_MODE_GAP    0x4e
Line 270  crcerror_d88:; Line 266  crcerror_d88:;
   
 BYTE fdd_stat_d88(void) {  BYTE fdd_stat_d88(void) {
   
         BYTE            type, cmnd;          FDDFILE         fdd;
           BYTE            type;
           REG8            cmd;
         BYTE            ans = 0;          BYTE            ans = 0;
         int                     seekable;          int                     seekable;
         WORD            trk;          WORD            trk;
   
         if (DISKNUM[fdc.drv] == DRV_EMPTY) {          fdd = fddfile + fdc.drv;
           if (fdd->type != DISKTYPE_D88) {
                 return(0x80);                                           // NOT READY                  return(0x80);                                           // NOT READY
         }          }
         type = fdc.type;          type = fdc.type;
         cmnd = (BYTE)(fdc.cmnd >> 4);          cmd = (REG8)(fdc.cmd >> 4);
         trk = (fdc.c << 1) + (WORD)fdc.h;          trk = (fdc.c << 1) + (WORD)fdc.h;
         seekable = seeksector(fdc.drv, trk, fdc.r);          seekable = seeksector(fdc.drv, trk, fdc.r);
         if (!fdc.r) {          if (!fdc.r) {
Line 287  BYTE fdd_stat_d88(void) { Line 286  BYTE fdd_stat_d88(void) {
         }          }
   
         if (type == 0 || type == 1 || type == 4 ||          if (type == 0 || type == 1 || type == 4 ||
                 cmnd == 0x0a || cmnd == 0x0b || cmnd == 0x0f) {                  cmd == 0x0a || cmd == 0x0b || cmd == 0x0f) {
                 if (d88head[fdc.drv].protect & 0x10) {  // WRITE PROTECT                  if (fdd->protect) {                                     // WRITE PROTECT
                         ans |= 0x40;                          ans |= 0x40;
                 }                  }
         }          }
         if (type == 2 || cmnd == 0x0f) {          if (type == 2 || cmd == 0x0f) {
                 if (fdc.r && cursec.del_flg) {                  if (fdc.r && cursec.del_flg) {
                         ans |= 0x20;                                    // RECODE TYPE / WRITE FAULT                          ans |= 0x20;                                    // RECODE TYPE / WRITE FAULT
                 }                  }
Line 305  BYTE fdd_stat_d88(void) { Line 304  BYTE fdd_stat_d88(void) {
                         ans |= 0x08;                                    // CRC ERROR                          ans |= 0x08;                                    // CRC ERROR
                 }                  }
         }          }
         if (cmnd == 0x0c) {          if (cmd == 0x0c) {
                 if (curtrkerr) {                  if (curtrkerr) {
                         ans |= 0x10;                          ans |= 0x10;
                 }                  }
Line 331  BYTE fdd_stat_d88(void) { Line 330  BYTE fdd_stat_d88(void) {
                 if ((type == 2) && ((WORD)fdc.off < cursec.size)) {                  if ((type == 2) && ((WORD)fdc.off < cursec.size)) {
                         ans |= 0x03;                                    // DATA REQUEST / BUSY                          ans |= 0x03;                                    // DATA REQUEST / BUSY
                 }                  }
                 else if ((cmnd == 0x0e) && (readdiag < 0x1a00)) {                  else if ((cmd == 0x0e) && (readdiag < 0x1a00)) {
                         ans |= 0x03;                          ans |= 0x03;
                 }                  }
                 else if ((cmnd == 0x0c) && (fdc.crc_off < 6)) {         // ver0.25                  else if ((cmd == 0x0c) && (fdc.crc_off < 6)) {          // ver0.25
                         ans |= 0x03;                          ans |= 0x03;
                 }                  }
                 else if (cmnd == 0x0f) {                  else if (cmd == 0x0f) {
                         if (tao.flag == 3) {                          if (tao.flag == 3) {
                                 if (++tao.lostdatacnt > LOSTDATA_COUNT) {                                  if (++tao.lostdatacnt > LOSTDATA_COUNT) {
                                         tao.flag = 4;                                          tao.flag = 4;
Line 372  void fdd_write_d88(void) { Line 371  void fdd_write_d88(void) {
   
 BYTE fdd_incoff_d88(void) {  BYTE fdd_incoff_d88(void) {
   
         BYTE    cmnd;          REG8    cmd;
         WORD    trk;          WORD    trk;
   
         cmnd = (BYTE)(fdc.cmnd >> 4);          cmd = (REG8)(fdc.cmd >> 4);
         trk = (fdc.c << 1) + (WORD)fdc.h;          trk = (fdc.c << 1) + (WORD)fdc.h;
         seeksector(fdc.drv, trk, fdc.r);          seeksector(fdc.drv, trk, fdc.r);
         if ((WORD)(++fdc.off) < cursec.size) {          if ((WORD)(++fdc.off) < cursec.size) {
                 return(0);                  return(0);
         }          }
         fdc.off = cursec.size;          fdc.off = cursec.size;
         if (cmnd == 0x09 || cmnd == 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)) {
                         fdc.r++;                          fdc.r++;
Line 625  void fdd_wtao_d88(BYTE data) { Line 624  void fdd_wtao_d88(BYTE data) {
   
 // ----  // ----
   
 BRESULT fddd88_eject(REG8 drv) {  BRESULT fddd88_eject(FDDFILE fdd, REG8 drv) {
   
         FDDFILE fdd;  
   
         drvflush(drv);          drvflush(drv);
         fdd = fddfile + drv;  
         ZeroMemory(&d88head[drv], sizeof(D88_HEADER));          ZeroMemory(&d88head[drv], sizeof(D88_HEADER));
         fdd->fname[0] = '\0';          fdd->fname[0] = '\0';
         DISKNUM[drv] = 0;          fdd->type = DISKTYPE_NOTREADY;
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 BRESULT fddd88_set(REG8 drv, const OEMCHAR *fname) {  BRESULT fddd88_set(FDDFILE fdd, REG8 drv, const OEMCHAR *fname) {
   
         FDDFILE fdd;  
         short   attr;          short   attr;
         FILEH   fh;          FILEH   fh;
         UINT    rsize;          UINT    rsize;
   
         fdd = fddfile + drv;  
         attr = file_attr(fname);          attr = file_attr(fname);
         if (attr & 0x18) {          if (attr & 0x18) {
                 goto fdst_err;                  goto fdst_err;
Line 658  BRESULT fddd88_set(REG8 drv, const OEMCH Line 652  BRESULT fddd88_set(REG8 drv, const OEMCH
         if (rsize != sizeof(D88_HEADER)) {          if (rsize != sizeof(D88_HEADER)) {
                 goto fdst_err;                  goto fdst_err;
         }          }
         if (attr & 1) {          if (d88head[drv].protect & 0x10) {
                 d88head[drv].protect |= (WORD)0x10;                  attr |= 1;
         }          }
         milstr_ncpy(fdd->fname, fname, NELEMENTS(fdd->fname));          milstr_ncpy(fdd->fname, fname, NELEMENTS(fdd->fname));
         DISKNUM[drv] = 1;          fdd->type = DISKTYPE_D88;
           fdd->protect = (UINT8)(attr & 1);
         return(SUCCESS);          return(SUCCESS);
   
 fdst_err:  fdst_err:
Removed from v.1.2  
changed lines
  Added in v.1.3

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