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

Diff for /np2/cbus/ideio.c between versions 1.1 and 1.3

version 1.1, 2004/03/19 03:36:52 version 1.3, 2004/03/23 13:32:50
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   
   // winでidentifyまでは取得に行くんだけどな…ってAnex86も同じか
   
 #if defined(SUPPORT_IDEIO)  #if defined(SUPPORT_IDEIO)
   
 #include        "dosio.h"  #include        "dosio.h"
Line 9 Line 11
 #include        "ideio.h"  #include        "ideio.h"
 #include        "atapicmd.h"  #include        "atapicmd.h"
 #include        "sxsi.h"  #include        "sxsi.h"
   #include        "idebios.res"
   
   
         IDEIO   ideio;          IDEIO   ideio;
Line 16 Line 19
   
 static IDEDEV getidedev(void) {  static IDEDEV getidedev(void) {
   
         IDEDEV  ret;          UINT    bank;
   
         ret = ideio.dev + (ideio.bank[1] & 1);          bank = ideio.bank[1] & 0x7f;
         return(ret);          if (bank < 2) {
                   return(ideio.dev + bank);
           }
           else {
                   return(NULL);
           }
 }  }
   
 static IDEDRV getidedrv(void) {  static IDEDRV getidedrv(void) {
   
         IDEDEV  dev;          IDEDEV  dev;
   
         dev = ideio.dev + (ideio.bank[1] & 1);          dev = getidedev();
         return(dev->drv + dev->drivesel);          if (dev) {
                   return(dev->drv + dev->drivesel);
           }
           else {
                   return(NULL);
           }
 }  }
   
   static const char serial[] = "824919341192        ";
   static const char firm[] = "A5U.1200";
   static const char model[] = "QUANTUM FIREBALL CR                     ";
   
 static BOOL setidentify(IDEDRV drv) {  static BOOL setidentify(IDEDRV drv) {
   
         SXSIDEV sxsi;          SXSIDEV sxsi;
         UINT16  tmp[256];          UINT16  tmp[256];
         BYTE    *p;          BYTE    *p;
         UINT    i;          UINT    i;
           UINT32  size;
   
         sxsi = sxsi_getptr(drv->sxsidrv);          sxsi = sxsi_getptr(drv->sxsidrv);
         if ((sxsi == NULL) || (sxsi->fname[0] == '\0')) {          if ((sxsi == NULL) || (sxsi->fname[0] == '\0')) {
Line 44  static BOOL setidentify(IDEDRV drv) { Line 62  static BOOL setidentify(IDEDRV drv) {
   
         ZeroMemory(tmp, sizeof(tmp));          ZeroMemory(tmp, sizeof(tmp));
         // とりあえず使ってる部分だけ          // とりあえず使ってる部分だけ
           tmp[0] = 0x045a;
         tmp[1] = sxsi->cylinders;          tmp[1] = sxsi->cylinders;
         tmp[3] = sxsi->surfaces;          tmp[3] = sxsi->surfaces;
           tmp[4] = sxsi->sectors * 512;
   //      tmp[5] = 0;                                     // ???
         tmp[6] = sxsi->sectors;          tmp[6] = sxsi->sectors;
           for (i=0; i<10; i++) {
                   tmp[10+i] = (serial[i*2] << 8) + serial[i*2+1];
           }
           tmp[20] = 3;
           tmp[21] = 16;
           tmp[22] = 4;
           for (i=0; i<4; i++) {
                   tmp[23+i] = (firm[i*2] << 8) + firm[i*2+1];
           }
           for (i=0; i<20; i++) {
                   tmp[27+i] = (model[i*2] << 8) + model[i*2+1];
           }
   //      tmp[47] = 0;                            // multiple
           tmp[49] = 0x0f00;
           tmp[50] = 0x4000;
           tmp[51] = 0x0200;
           tmp[52] = 0x0200;
           tmp[53] = 0x0007;
           tmp[54] = sxsi->cylinders;
           tmp[55] = sxsi->surfaces;
           tmp[56] = sxsi->sectors;
           size = sxsi->cylinders * sxsi->surfaces * sxsi->sectors;
           tmp[57] = (UINT16)size;
           tmp[58] = (UINT16)(size >> 16);
   //      tmp[59] = 0;
           tmp[60] = (UINT16)size;
           tmp[61] = (UINT16)(size >> 16);
           tmp[63] = 0x0407;
   
           tmp[80] = 0x001e;
           tmp[81] = 0x0011;
   
         p = drv->buf;          p = drv->buf;
         for (i=0; i<256; i++) {          for (i=0; i<256; i++) {
Line 54  static BOOL setidentify(IDEDRV drv) { Line 106  static BOOL setidentify(IDEDRV drv) {
                 p[1] = (BYTE)(tmp[i] >> 8);                  p[1] = (BYTE)(tmp[i] >> 8);
                 p += 2;                  p += 2;
         }          }
           drv->bufdir = IDEDIR_IN;
         drv->bufpos = 0;          drv->bufpos = 0;
         drv->bufsize = 512;          drv->bufsize = 512;
         return(SUCCESS);          return(SUCCESS);
Line 73  static void cmdabort(IDEDRV drv) { Line 126  static void cmdabort(IDEDRV drv) {
         pic_setirq(IDE_IRQ);          pic_setirq(IDE_IRQ);
 }  }
   
   static void panic(const char *str, ...) {
   
           char    buf[2048];
           va_list ap;
   
           va_start(ap, str);
           vsnprintf(buf, sizeof(buf), str, ap);
           va_end(ap);
   
           msgbox("ide_panic", buf);
           exit(1);
   }
   
   
 // ----  // ----
   
 static void incsec(IDEDRV drv) {  static void incsec(IDEDRV drv) {
   
         if (drv->dr & IDEDEV_LBA) {          if (!(drv->dr & IDEDEV_LBA)) {
                 TRACEOUT(("ideio: incsec() LBA mode?"));                  drv->sn++;
                 return;                  if (drv->sn <= drv->sectors) {
         }                          return;
         drv->sn++;                  }
         if (drv->sn <= drv->sectors) {                  drv->sn = 1;
                 return;                  drv->hd++;
                   if (drv->hd < drv->surfaces) {
                           return;
                   }
                   drv->hd = 0;
                   drv->cy++;
         }          }
         drv->sn = 1;          else {
         drv->hd++;                  TRACEOUT(("ideio: incsec() LBA mode?"));
         if (drv->hd < drv->surfaces) {                  drv->sn++;
                 return;                  if (drv->sn) {
                           return;
                   }
                   drv->cy++;
                   if (drv->cy) {
                           return;
                   }
                   drv->hd++;
         }          }
         drv->hd = 0;  
         drv->cy++;  
 }  }
   
 static long getcursec(const _IDEDRV *drv) {  static long getcursec(const _IDEDRV *drv) {
   
         long    ret;          long    ret;
   
         if (drv->dr & IDEDEV_LBA) {          if (!(drv->dr & IDEDEV_LBA)) {
                   ret = drv->cy;
                   ret *= drv->surfaces;
                   ret += drv->hd;
                   ret *= drv->sectors;
                   ret += (drv->sn - 1);
           }
           else {
                 TRACEOUT(("ideio: getcursec() LBA mode?"));                  TRACEOUT(("ideio: getcursec() LBA mode?"));
                 return(-1);                  ret = drv->sn;
                   ret |= (drv->cy << 8);
                   ret |= (drv->hd << 24);
         }          }
         ret = drv->cy;  
         ret *= drv->surfaces;  
         ret += drv->hd;  
         ret *= drv->sectors;  
         ret += (drv->sn - 1);  
         return(ret);          return(ret);
 }  }
   
Line 121  static void readsec(IDEDRV drv) { Line 201  static void readsec(IDEDRV drv) {
         sec = getcursec(drv);          sec = getcursec(drv);
         TRACEOUT(("readsec->drv %d sec %x", drv->sxsidrv, sec));          TRACEOUT(("readsec->drv %d sec %x", drv->sxsidrv, sec));
         if (sxsi_read(drv->sxsidrv, sec, drv->buf, 512)) {          if (sxsi_read(drv->sxsidrv, sec, drv->buf, 512)) {
                 TRACEOUT(("readerror!"));                  TRACEOUT(("read error!"));
                 goto read_err;                  goto read_err;
         }          }
         drv->bufdir = IDEDIR_IN;          drv->bufdir = IDEDIR_IN;
Line 142  read_err: Line 222  read_err:
   
 static void IOOUTCALL ideio_o430(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o430(UINT port, REG8 dat) {
   
         TRACEOUT(("ideio setbank%d %.2x [%.4x:%.4x]",          TRACEOUT(("ideio setbank%d %.2x [%.4x:%.8x]",
                                                                         (port >> 1) & 1, dat, CPU_CS, CPU_IP));                                                                          (port >> 1) & 1, dat, CPU_CS, CPU_EIP));
         if ((dat == 0) || (dat == 1)) {          if (!(dat & 0x80)) {
                 ideio.bank[(port >> 1) & 1] = dat;                  ideio.bank[(port >> 1) & 1] = dat;
         }          }
 }  }
Line 157  static REG8 IOINPCALL ideio_i430(UINT po Line 237  static REG8 IOINPCALL ideio_i430(UINT po
         bank = (port >> 1) & 1;          bank = (port >> 1) & 1;
         ret = ideio.bank[bank];          ret = ideio.bank[bank];
         ideio.bank[bank] = ret & (~0x80);          ideio.bank[bank] = ret & (~0x80);
         TRACEOUT(("ideio getbank%d %.2x [%.4x:%.4x]",          TRACEOUT(("ideio getbank%d %.2x [%.4x:%.8x]",
                                                                         (port >> 1) & 1, ret, CPU_CS, CPU_IP));                                                                          (port >> 1) & 1, ret, CPU_CS, CPU_EIP));
         return(ret);          return(ret & 0x81);
 }  }
   
   
Line 170  static void IOOUTCALL ideio_o642(UINT po Line 250  static void IOOUTCALL ideio_o642(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         drv->wp = dat;          if (drv) {
         TRACEOUT(("ideio set WP %.2x [%.4x:%.4x]", dat, CPU_CS, CPU_IP));                  drv->wp = dat;
                   TRACEOUT(("ideio set WP %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
           }
 }  }
   
 static void IOOUTCALL ideio_o644(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o644(UINT port, REG8 dat) {
Line 179  static void IOOUTCALL ideio_o644(UINT po Line 261  static void IOOUTCALL ideio_o644(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         drv->sc = dat;          if (drv) {
         TRACEOUT(("ideio set SC %.2x [%.4x:%.4x]", dat, CPU_CS, CPU_IP));                  drv->sc = dat;
                   TRACEOUT(("ideio set SC %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
           }
 }  }
   
 static void IOOUTCALL ideio_o646(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o646(UINT port, REG8 dat) {
Line 188  static void IOOUTCALL ideio_o646(UINT po Line 272  static void IOOUTCALL ideio_o646(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         drv->sn = dat;          if (drv) {
         TRACEOUT(("ideio set SN %.2x [%.4x:%.4x]", dat, CPU_CS, CPU_IP));                  drv->sn = dat;
                   TRACEOUT(("ideio set SN %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
           }
 }  }
   
 static void IOOUTCALL ideio_o648(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o648(UINT port, REG8 dat) {
Line 197  static void IOOUTCALL ideio_o648(UINT po Line 283  static void IOOUTCALL ideio_o648(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         drv->cy &= 0xff00;          if (drv) {
         drv->cy |= dat;                  drv->cy &= 0xff00;
         TRACEOUT(("ideio set CYL %.2x [%.4x:%.4x]", dat, CPU_CS, CPU_IP));                  drv->cy |= dat;
                   TRACEOUT(("ideio set CYL %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
           }
 }  }
   
 static void IOOUTCALL ideio_o64a(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o64a(UINT port, REG8 dat) {
Line 207  static void IOOUTCALL ideio_o64a(UINT po Line 295  static void IOOUTCALL ideio_o64a(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         drv->cy &= 0x00ff;          if (drv) {
         drv->cy |= dat << 8;                  drv->cy &= 0x00ff;
         TRACEOUT(("ideio set CYH %.2x [%.4x:%.4x]", dat, CPU_CS, CPU_IP));                  drv->cy |= dat << 8;
                   TRACEOUT(("ideio set CYH %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
           }
 }  }
   
 static void IOOUTCALL ideio_o64c(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o64c(UINT port, REG8 dat) {
Line 217  static void IOOUTCALL ideio_o64c(UINT po Line 307  static void IOOUTCALL ideio_o64c(UINT po
         IDEDEV  dev;          IDEDEV  dev;
         UINT    drvnum;          UINT    drvnum;
   
           dev = getidedev();
           if (dev == NULL) {
                   return;
           }
 #if defined(TRACE)  #if defined(TRACE)
         if ((dat & 0xf0) != 0xa0) {          if ((dat & 0xf0) != 0xa0) {
                 TRACEOUT(("ideio set SDH illegal param? (%.2x)", dat));                  TRACEOUT(("ideio set SDH illegal param? (%.2x)", dat));
         }          }
 #endif  #endif
         drvnum = (dat >> 4) & 1;          drvnum = (dat >> 4) & 1;
         dev = getidedev();  
         dev->drivesel = drvnum;          dev->drivesel = drvnum;
         dev->drv[drvnum].dr = dat & 0xf0;          dev->drv[drvnum].dr = dat & 0xf0;
         dev->drv[drvnum].hd = dat & 0x0f;          dev->drv[drvnum].hd = dat & 0x0f;
         TRACEOUT(("ideio set DRHD %.2x [%.4x:%.4x]", dat, CPU_CS, CPU_IP));          TRACEOUT(("ideio set DRHD %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
 }  }
   
 static void IOOUTCALL ideio_o64e(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o64e(UINT port, REG8 dat) {
Line 235  static void IOOUTCALL ideio_o64e(UINT po Line 328  static void IOOUTCALL ideio_o64e(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
           if (drv == NULL) {
                   return;
           }
         drv->cmd = dat;          drv->cmd = dat;
         TRACEOUT(("ideio set cmd %.2x [%.4x:%.4x]", dat, CPU_CS, CPU_IP));          TRACEOUT(("ideio set cmd %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
         switch(dat) {          switch(dat) {
                 case 0x08:              // atapi reset                  case 0x08:              // atapi reset
                         if (drv->device == IDETYPE_CDROM) {                          if (drv->device == IDETYPE_CDROM) {
Line 298  static void IOOUTCALL ideio_o64e(UINT po Line 394  static void IOOUTCALL ideio_o64e(UINT po
                         }                          }
                         break;                          break;
   
                 case 0xec:              // indentify                  case 0xa1:              // identify
                         TRACEOUT(("ideio: indentify"));                  case 0xec:              // identify
                           TRACEOUT(("ideio: identify"));
                         if (setidentify(drv) == SUCCESS) {                          if (setidentify(drv) == SUCCESS) {
                                 drv->status = IDESTAT_DRDY | IDESTAT_DSC | IDESTAT_DRQ;                                  drv->status = IDESTAT_DRDY | IDESTAT_DSC | IDESTAT_DRQ;
                                 drv->error = 0;                                  drv->error = 0;
Line 311  static void IOOUTCALL ideio_o64e(UINT po Line 408  static void IOOUTCALL ideio_o64e(UINT po
                         break;                          break;
   
                 default:                  default:
                           panic("command:%.2x", dat);
                         break;                          break;
         }          }
 }  }
Line 321  static void IOOUTCALL ideio_o74c(UINT po Line 419  static void IOOUTCALL ideio_o74c(UINT po
         REG8    modify;          REG8    modify;
   
         dev = getidedev();          dev = getidedev();
           if (dev == NULL) {
                   return;
           }
         modify = dev->drv[0].ctrl ^ dat;          modify = dev->drv[0].ctrl ^ dat;
         dev->drv[0].ctrl = dat;          dev->drv[0].ctrl = dat;
         dev->drv[1].ctrl = dat;          dev->drv[1].ctrl = dat;
Line 342  static void IOOUTCALL ideio_o74c(UINT po Line 443  static void IOOUTCALL ideio_o74c(UINT po
                         }                          }
                 }                  }
         }          }
         TRACEOUT(("ideio %.4x,%.2x [%.4x:%.4x]", port, dat, CPU_CS, CPU_IP));          TRACEOUT(("ideio %.4x,%.2x [%.4x:%.8x]", port, dat, CPU_CS, CPU_EIP));
 }  }
   
 static void IOOUTCALL ideio_o74e(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o74e(UINT port, REG8 dat) {
   
         TRACEOUT(("ideio %.4x,%.2x [%.4x:%.4x]", port, dat, CPU_CS, CPU_IP));          TRACEOUT(("ideio %.4x,%.2x [%.4x:%.8x]", port, dat, CPU_CS, CPU_EIP));
 }  }
   
   
Line 358  static REG8 IOINPCALL ideio_i642(UINT po Line 459  static REG8 IOINPCALL ideio_i642(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         drv->status &= ~IDESTAT_ERR;          if (drv) {
         TRACEOUT(("ideio get error %.2x [%.4x:%.4x]", drv->error, CPU_CS, CPU_IP));                  drv->status &= ~IDESTAT_ERR;
         return(drv->error);                  TRACEOUT(("ideio get error %.2x [%.4x:%.8x]",
                                                                                                   drv->error, CPU_CS, CPU_EIP));
                   return(drv->error);
           }
           else {
                   return(0xff);
           }
 }  }
   
 static REG8 IOINPCALL ideio_i644(UINT port) {  static REG8 IOINPCALL ideio_i644(UINT port) {
Line 368  static REG8 IOINPCALL ideio_i644(UINT po Line 475  static REG8 IOINPCALL ideio_i644(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         TRACEOUT(("ideio get SC %.2x [%.4x:%.4x]", drv->sc, CPU_CS, CPU_IP));          if (drv) {
         return(drv->sc);                  TRACEOUT(("ideio get SC %.2x [%.4x:%.8x]", drv->sc, CPU_CS, CPU_EIP));
                   return(drv->sc);
           }
           else {
                   return(0xff);
           }
 }  }
   
 static REG8 IOINPCALL ideio_i646(UINT port) {  static REG8 IOINPCALL ideio_i646(UINT port) {
Line 377  static REG8 IOINPCALL ideio_i646(UINT po Line 489  static REG8 IOINPCALL ideio_i646(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         TRACEOUT(("ideio get SN %.2x [%.4x:%.4x]", drv->sn, CPU_CS, CPU_IP));          if (drv) {
         return(drv->sn);                  TRACEOUT(("ideio get SN %.2x [%.4x:%.8x]", drv->sn, CPU_CS, CPU_EIP));
                   return(drv->sn);
           }
           else {
                   return(0xff);
           }
 }  }
   
 static REG8 IOINPCALL ideio_i648(UINT port) {  static REG8 IOINPCALL ideio_i648(UINT port) {
Line 386  static REG8 IOINPCALL ideio_i648(UINT po Line 503  static REG8 IOINPCALL ideio_i648(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         TRACEOUT(("ideio get CYL %.4x [%.4x:%.4x]", drv->cy, CPU_CS, CPU_IP));          if (drv) {
         return((UINT8)drv->cy);                  TRACEOUT(("ideio get CYL %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));
                   return((UINT8)drv->cy);
           }
           else {
                   return(0xff);
           }
 }  }
   
 static REG8 IOINPCALL ideio_i64a(UINT port) {  static REG8 IOINPCALL ideio_i64a(UINT port) {
Line 395  static REG8 IOINPCALL ideio_i64a(UINT po Line 517  static REG8 IOINPCALL ideio_i64a(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         TRACEOUT(("ideio get CYH %.4x [%.4x:%.4x]", drv->cy, CPU_CS, CPU_IP));          if (drv) {
         return((REG8)(drv->cy >> 8));                  TRACEOUT(("ideio get CYH %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));
                   return((REG8)(drv->cy >> 8));
           }
           else {
                   return(0xff);
           }
 }  }
   
 static REG8 IOINPCALL ideio_i64c(UINT port) {  static REG8 IOINPCALL ideio_i64c(UINT port) {
Line 405  static REG8 IOINPCALL ideio_i64c(UINT po Line 532  static REG8 IOINPCALL ideio_i64c(UINT po
         REG8    ret;          REG8    ret;
   
         drv = getidedrv();          drv = getidedrv();
         ret = drv->dr | drv->hd;          if (drv) {
         TRACEOUT(("ideio get DRHD %.2x [%.4x:%.4x]", ret, CPU_CS, CPU_IP));                  ret = drv->dr | drv->hd;
         return(ret);                  TRACEOUT(("ideio get DRHD %.2x [%.4x:%.8x]", ret, CPU_CS, CPU_EIP));
                   return(ret);
           }
           else {
                   return(0xff);
           }
 }  }
   
 static REG8 IOINPCALL ideio_i64e(UINT port) {  static REG8 IOINPCALL ideio_i64e(UINT port) {
Line 415  static REG8 IOINPCALL ideio_i64e(UINT po Line 547  static REG8 IOINPCALL ideio_i64e(UINT po
         IDEDRV  drv;          IDEDRV  drv;
   
         drv = getidedrv();          drv = getidedrv();
         TRACEOUT(("ideio status %.2x [%.4x:%.4x]", drv->status, CPU_CS, CPU_IP));          if (drv) {
         return(drv->status);                  TRACEOUT(("ideio status %.2x [%.4x:%.8x]",
                                                                                           drv->status, CPU_CS, CPU_EIP));
                   return(drv->status);
           }
           else {
                   return(0xff);
           }
 }  }
   
 static REG8 IOINPCALL ideio_i74c(UINT port) {  static REG8 IOINPCALL ideio_i74c(UINT port) {
   
         TRACEOUT(("ideio %.4x [%.4x:%.4x]", port, CPU_CS, CPU_IP));          TRACEOUT(("ideio %.4x [%.4x:%.8x]", port, CPU_CS, CPU_EIP));
         return(0xff);          return(0xff);
 }  }
   
Line 434  void IOOUTCALL ideio_w16(UINT port, REG1 Line 572  void IOOUTCALL ideio_w16(UINT port, REG1
         BYTE    *p;          BYTE    *p;
   
         drv = getidedrv();          drv = getidedrv();
         if ((drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_OUT)) {          if ((drv != NULL) &&
                   (drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_OUT)) {
                 p = drv->buf + drv->bufpos;                  p = drv->buf + drv->bufpos;
                 p[0] = (BYTE)value;                  p[0] = (BYTE)value;
                 p[1] = (BYTE)(value >> 8);                  p[1] = (BYTE)(value >> 8);
                 TRACEOUT(("ide-data send %4x (%.4x) [%.4x:%.4x]",                  TRACEOUT(("ide-data send %4x (%.4x) [%.4x:%.8x]",
                                                                                 value, drv->bufpos, CPU_CS, CPU_IP));                                                                                  value, drv->bufpos, CPU_CS, CPU_EIP));
                 drv->bufpos += 2;                  drv->bufpos += 2;
                 if (drv->bufpos >= drv->bufsize) {                  if (drv->bufpos >= drv->bufsize) {
                         drv->status &= ~IDESTAT_DRQ;                          drv->status &= ~IDESTAT_DRQ;
Line 454  void IOOUTCALL ideio_w16(UINT port, REG1 Line 593  void IOOUTCALL ideio_w16(UINT port, REG1
   
 REG16 IOOUTCALL ideio_r16(UINT port) {  REG16 IOOUTCALL ideio_r16(UINT port) {
   
         REG16   ret;  
         IDEDRV  drv;          IDEDRV  drv;
           REG16   ret;
         BYTE    *p;          BYTE    *p;
   
         ret = 0;  
         drv = getidedrv();          drv = getidedrv();
           if (drv == NULL) {
                   return(0xff);
           }
           ret = 0;
         if ((drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_IN)) {          if ((drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_IN)) {
                 p = drv->buf + drv->bufpos;                  p = drv->buf + drv->bufpos;
                 ret = p[0] + (p[1] << 8);                  ret = p[0] + (p[1] << 8);
                 TRACEOUT(("ide-data recv %4x (%.4x) [%.4x:%.4x]",                  TRACEOUT(("ide-data recv %4x (%.4x) [%.4x:%.8x]",
                                                                                 ret, drv->bufpos, CPU_CS, CPU_IP));                                                                                  ret, drv->bufpos, CPU_CS, CPU_EIP));
                 drv->bufpos += 2;                  drv->bufpos += 2;
                 if (drv->bufpos >= drv->bufsize) {                  if (drv->bufpos >= drv->bufsize) {
                         drv->status &= ~IDESTAT_DRQ;                          drv->status &= ~IDESTAT_DRQ;
Line 525  void ideio_reset(void) { Line 667  void ideio_reset(void) {
                 devinit(drv, i);                  devinit(drv, i);
         }          }
   
 #if 1           // CD-ROM test  #if 0           // CD-ROM test
         drv = ideio.dev[1].drv;          drv = ideio.dev[1].drv;
         drv->hd = 0;          drv->hd = 0;
         drv->sc = 1;          drv->sc = 1;
Line 547  void ideio_reset(void) { Line 689  void ideio_reset(void) {
         ideio.dev[1].drv[0].sxsidrv = 0x02;          ideio.dev[1].drv[0].sxsidrv = 0x02;
         ideio.dev[1].drv[1].sxsidrv = 0x03;          ideio.dev[1].drv[1].sxsidrv = 0x03;
 #endif  #endif
   
           CopyMemory(mem + 0xd0000, idebios, sizeof(idebios));
           TRACEOUT(("use simulate ide.rom"));
 }  }
   
 void ideio_bind(void) {  void ideio_bind(void) {
Removed from v.1.1  
changed lines
  Added in v.1.3

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