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

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

version 1.3, 2004/03/23 13:32:50 version 1.8, 2005/02/07 14:46:08
Line 33  static IDEDEV getidedev(void) { Line 33  static IDEDEV getidedev(void) {
 static IDEDRV getidedrv(void) {  static IDEDRV getidedrv(void) {
   
         IDEDEV  dev;          IDEDEV  dev;
           IDEDRV  drv;
   
         dev = getidedev();          dev = getidedev();
         if (dev) {          if (dev) {
                 return(dev->drv + dev->drivesel);                  drv = dev->drv + dev->drivesel;
         }                  if (drv->device != IDETYPE_NONE) {
         else {                          return(drv);
                 return(NULL);                  }
         }          }
           return(NULL);
 }  }
   
 static const char serial[] = "824919341192        ";  static const char serial[] = "824919341192        ";
Line 51  static BOOL setidentify(IDEDRV drv) { Line 53  static BOOL setidentify(IDEDRV drv) {
   
         SXSIDEV sxsi;          SXSIDEV sxsi;
         UINT16  tmp[256];          UINT16  tmp[256];
         BYTE    *p;          UINT8   *p;
         UINT    i;          UINT    i;
         UINT32  size;          UINT32  size;
   
Line 62  static BOOL setidentify(IDEDRV drv) { Line 64  static BOOL setidentify(IDEDRV drv) {
   
         ZeroMemory(tmp, sizeof(tmp));          ZeroMemory(tmp, sizeof(tmp));
         // とりあえず使ってる部分だけ          // とりあえず使ってる部分だけ
         tmp[0] = 0x045a;          tmp[0] = 0x0040;
         tmp[1] = sxsi->cylinders;          tmp[1] = sxsi->cylinders;
         tmp[3] = sxsi->surfaces;          tmp[3] = sxsi->surfaces;
         tmp[4] = sxsi->sectors * 512;          tmp[4] = sxsi->sectors * 512;
 //      tmp[5] = 0;                                     // ???  
         tmp[6] = sxsi->sectors;          tmp[6] = sxsi->sectors;
         for (i=0; i<10; i++) {          for (i=0; i<10; i++) {
                 tmp[10+i] = (serial[i*2] << 8) + serial[i*2+1];                  tmp[10+i] = (serial[i*2] << 8) + serial[i*2+1];
         }          }
         tmp[20] = 3;  
         tmp[21] = 16;  
         tmp[22] = 4;          tmp[22] = 4;
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 tmp[23+i] = (firm[i*2] << 8) + firm[i*2+1];                  tmp[23+i] = (firm[i*2] << 8) + firm[i*2+1];
Line 80  static BOOL setidentify(IDEDRV drv) { Line 79  static BOOL setidentify(IDEDRV drv) {
         for (i=0; i<20; i++) {          for (i=0; i<20; i++) {
                 tmp[27+i] = (model[i*2] << 8) + model[i*2+1];                  tmp[27+i] = (model[i*2] << 8) + model[i*2+1];
         }          }
 //      tmp[47] = 0;                            // multiple  #if IDEIO_MULTIPLE_MAX > 0
         tmp[49] = 0x0f00;          tmp[47] = 0x8000 | IDEIO_MULTIPLE_MAX;  // multiple
         tmp[50] = 0x4000;  #endif
           tmp[49] = 0x0000;                       // LBA(1 << 9)
         tmp[51] = 0x0200;          tmp[51] = 0x0200;
         tmp[52] = 0x0200;          tmp[53] = 0x0001;
         tmp[53] = 0x0007;  
         tmp[54] = sxsi->cylinders;          tmp[54] = sxsi->cylinders;
         tmp[55] = sxsi->surfaces;          tmp[55] = sxsi->surfaces;
         tmp[56] = sxsi->sectors;          tmp[56] = sxsi->sectors;
         size = sxsi->cylinders * sxsi->surfaces * sxsi->sectors;          size = sxsi->cylinders * sxsi->surfaces * sxsi->sectors;
         tmp[57] = (UINT16)size;          tmp[57] = (UINT16)size;
         tmp[58] = (UINT16)(size >> 16);          tmp[58] = (UINT16)(size >> 16);
 //      tmp[59] = 0;  #if IDEIO_MULTIPLE_MAX > 0
           tmp[59] = 0x0100 | drv->mulmode;        // current multiple mode
   #endif
         tmp[60] = (UINT16)size;          tmp[60] = (UINT16)size;
         tmp[61] = (UINT16)(size >> 16);          tmp[61] = (UINT16)(size >> 16);
         tmp[63] = 0x0407;          tmp[63] = 0x0000;                       // no support multiword DMA
   
         tmp[80] = 0x001e;          tmp[80] = 0x0006;                       // only support ATA-1/2
         tmp[81] = 0x0011;          tmp[81] = 0;
           tmp[82] = 0x0000;                       // DEVICE RESET(1 << 9)
   
         p = drv->buf;          p = drv->buf;
         for (i=0; i<256; i++) {          for (i=0; i<256; i++) {
                 p[0] = (BYTE)tmp[i];                  p[0] = (UINT8)tmp[i];
                 p[1] = (BYTE)(tmp[i] >> 8);                  p[1] = (UINT8)(tmp[i] >> 8);
                 p += 2;                  p += 2;
         }          }
         drv->bufdir = IDEDIR_IN;          drv->bufdir = IDEDIR_IN;
Line 114  static BOOL setidentify(IDEDRV drv) { Line 116  static BOOL setidentify(IDEDRV drv) {
   
 static void setintr(IDEDRV drv) {  static void setintr(IDEDRV drv) {
   
         ideio.bank[0] = ideio.bank[1] | 0x80;                   // ????          if (!(drv->ctrl & IDECTRL_NIEN)) {
         pic_setirq(IDE_IRQ);                  TRACEOUT(("ideio: setintr()"));
                   ideio.bank[0] = ideio.bank[1] | 0x80;                   // ????
                   pic_setirq(IDE_IRQ);
           }
 }  }
   
 static void cmdabort(IDEDRV drv) {  static void cmdabort(IDEDRV drv) {
   
           TRACEOUT(("ideio: cmdabort()"));
         drv->status = IDESTAT_DRDY | IDESTAT_ERR;          drv->status = IDESTAT_DRDY | IDESTAT_ERR;
         drv->error = IDEERR_ABRT;          drv->error = IDEERR_ABRT;
         ideio.bank[0] = ideio.bank[1] | 0x80;                   // ????          setintr(drv);
         pic_setirq(IDE_IRQ);  
 }  }
   
 static void panic(const char *str, ...) {  static void panic(const char *str, ...) {
Line 171  static void incsec(IDEDRV drv) { Line 176  static void incsec(IDEDRV drv) {
         }          }
 }  }
   
 static long getcursec(const _IDEDRV *drv) {  static long getcursec(const IDEDRV drv) {
   
         long    ret;          long    ret;
   
Line 199  static void readsec(IDEDRV drv) { Line 204  static void readsec(IDEDRV drv) {
                 goto read_err;                  goto read_err;
         }          }
         sec = getcursec(drv);          sec = getcursec(drv);
         TRACEOUT(("readsec->drv %d sec %x", drv->sxsidrv, sec));          TRACEOUT(("readsec->drv %d sec %x cnt %d thr %d",
                                                                   drv->sxsidrv, sec, drv->mulcnt, drv->multhr));
         if (sxsi_read(drv->sxsidrv, sec, drv->buf, 512)) {          if (sxsi_read(drv->sxsidrv, sec, drv->buf, 512)) {
                 TRACEOUT(("read error!"));                  TRACEOUT(("read error!"));
                 goto read_err;                  goto read_err;
Line 208  static void readsec(IDEDRV drv) { Line 214  static void readsec(IDEDRV drv) {
         drv->bufpos = 0;          drv->bufpos = 0;
         drv->bufsize = 512;          drv->bufsize = 512;
   
         drv->status = IDESTAT_DRDY | IDESTAT_DSC | IDESTAT_DRQ;          if ((drv->mulcnt & (drv->multhr - 1)) == 0) {
         drv->error = 0;                  drv->status = IDESTAT_DRDY | IDESTAT_DSC | IDESTAT_DRQ;
         setintr(drv);                  drv->error = 0;
                   setintr(drv);
           }
           drv->mulcnt++;
         return;          return;
   
 read_err:  read_err:
Line 254  static void IOOUTCALL ideio_o642(UINT po Line 263  static void IOOUTCALL ideio_o642(UINT po
                 drv->wp = dat;                  drv->wp = dat;
                 TRACEOUT(("ideio set WP %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio set WP %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
         }          }
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o644(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o644(UINT port, REG8 dat) {
   
         IDEDRV  drv;          IDEDRV  drv;
   
           (void)port;
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 drv->sc = dat;                  drv->sc = dat;
                 TRACEOUT(("ideio set SC %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio set SC %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
         }          }
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o646(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o646(UINT port, REG8 dat) {
Line 276  static void IOOUTCALL ideio_o646(UINT po Line 288  static void IOOUTCALL ideio_o646(UINT po
                 drv->sn = dat;                  drv->sn = dat;
                 TRACEOUT(("ideio set SN %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio set SN %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
         }          }
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o648(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o648(UINT port, REG8 dat) {
Line 288  static void IOOUTCALL ideio_o648(UINT po Line 301  static void IOOUTCALL ideio_o648(UINT po
                 drv->cy |= dat;                  drv->cy |= dat;
                 TRACEOUT(("ideio set CYL %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio set CYL %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
         }          }
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o64a(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o64a(UINT port, REG8 dat) {
Line 300  static void IOOUTCALL ideio_o64a(UINT po Line 314  static void IOOUTCALL ideio_o64a(UINT po
                 drv->cy |= dat << 8;                  drv->cy |= dat << 8;
                 TRACEOUT(("ideio set CYH %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio set CYH %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
         }          }
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o64c(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o64c(UINT port, REG8 dat) {
Line 321  static void IOOUTCALL ideio_o64c(UINT po Line 336  static void IOOUTCALL ideio_o64c(UINT po
         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:%.8x]", dat, CPU_CS, CPU_EIP));          TRACEOUT(("ideio set DRHD %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o64e(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o64e(UINT port, REG8 dat) {
   
         IDEDRV  drv;          IDEDRV  drv;
           IDEDEV  dev;
   
           // execute device diagnostic
           if (dat == 0x90) {
                   TRACEOUT(("ideio set cmd %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
                   TRACEOUT(("ideio: execute device diagnostic"));
                   dev = getidedev();
                   if (dev) {
                           IDEDRV d;
                           int i;
   
                           for (i = 0; i < 2; i++) {
                                   d = dev->drv + i;
                                   d->hd = 0x00;
                                   d->sc = 0x01;
                                   d->sn = 0x01;
                                   d->cy = 0x0000;
                                   d->status = IDESTAT_DRDY;
                                   d->error = 0x01;
                                   if (i == 0) {
                                           if (dev->drv[0].device == IDETYPE_NONE) {
                                                   d->error = 0x00;
                                           }
                                           if (dev->drv[1].device == IDETYPE_NONE) {
                                                   d->error |= 0x80;
                                           }
                                   }
                                   else {
                                           if (dev->drv[1].device == IDETYPE_NONE) {
                                                   d->error = 0x00;
                                           }
                                   }
                           }
                   }
                   return;
           }
   
         drv = getidedrv();          drv = getidedrv();
         if (drv == NULL) {          if (drv == NULL) {
Line 334  static void IOOUTCALL ideio_o64e(UINT po Line 386  static void IOOUTCALL ideio_o64e(UINT po
         drv->cmd = dat;          drv->cmd = dat;
         TRACEOUT(("ideio set cmd %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));          TRACEOUT(("ideio set cmd %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
         switch(dat) {          switch(dat) {
                 case 0x08:              // atapi reset                  case 0x08:              // device reset
                         if (drv->device == IDETYPE_CDROM) {                          TRACEOUT(("ideio: device reset"));
                                 drv->hd = 0;                          if (drv->device == IDETYPE_NONE) {
                                 drv->sc = 1;                                  cmdabort(drv);
                                 drv->sn = 1;                                  break;
                           }
                           else if (drv->device == IDETYPE_HDD) {
                                   drv->hd = 0x00;
                                   drv->sc = 0x01;
                                   drv->sn = 0x01;
                                   drv->cy = 0x0000;
                           }
                           else if (drv->device == IDETYPE_CDROM) {
                                   drv->hd = 0x10;
                                   drv->sc = 0x01;
                                   drv->sn = 0x01;
                                 drv->cy = 0xeb14;                                  drv->cy = 0xeb14;
                                 drv->status = 0;  
                                 drv->error = 0;  
                         }                          }
                           drv->status = 0x00;
                           drv->error = 0x01;
                           dev = getidedev();
                           if (dev) {
                                   if (dev->drivesel == 0) {
                                           if (dev->drv[0].device == IDETYPE_NONE) {
                                                   drv->error = 0x00;
                                           }
                                           if (dev->drv[1].device == IDETYPE_NONE) {
                                                   drv->error |= 0x80;
                                           }
                                   }
                                   else {
                                           if (dev->drv[1].device == IDETYPE_NONE) {
                                                   drv->error = 0x00;
                                           }
                                   }
                           }
                           setintr(drv);
                         break;                          break;
   
                 case 0x10:              // calibrate                  case 0x10:              // calibrate
 //              case 0x11: case 0x12: case 0x13: case 0x14: case 0x15:  //              case 0x11: case 0x12: case 0x13: case 0x14: case 0x15:
 //              case 0x16: case 0x17: case 0x18: case 0x19: case 0x1a:  //              case 0x16: case 0x17: case 0x18: case 0x19: case 0x1a:
 //              case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:  //              case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
                           TRACEOUT(("ideio: calibrate"));
                         if (drv->device) {                          if (drv->device) {
                                 drv->status = IDESTAT_DRDY | IDESTAT_DSC;                                  drv->status = IDESTAT_DRDY | IDESTAT_DSC;
                                 drv->error = 0;                                  drv->error = 0;
Line 362  static void IOOUTCALL ideio_o64e(UINT po Line 443  static void IOOUTCALL ideio_o64e(UINT po
   
                 case 0x20:              // read (with retry)                  case 0x20:              // read (with retry)
                 case 0x21:              // read                  case 0x21:              // read
                           TRACEOUT(("ideio: read sector"));
                           drv->mulcnt = 0;
                           drv->multhr = 1;
                         readsec(drv);                          readsec(drv);
                         break;                          break;
   
                 case 0x91:              // set parameters                  case 0x91:              // set parameters
                         TRACEOUT(("ideio: set parameters dh=%x sec=%x",                          TRACEOUT(("ideio: set parameters dh=%x sec=%x",
                                                                                         drv->dr | drv->hd, drv->sc));                                                                                          drv->dr | drv->hd, drv->sc));
                         if (drv->device) {                          if (drv->device != IDETYPE_NONE) {
                                 drv->surfaces = drv->hd + 1;                                  drv->surfaces = drv->hd + 1;
                                 drv->sectors = drv->sc;                                  drv->sectors = drv->sc;
                                 drv->status &= ~(IDESTAT_BSY | IDESTAT_DRQ | IDESTAT_ERR);                                  drv->status &= ~(IDESTAT_BSY | IDESTAT_DRQ | IDESTAT_ERR);
Line 407  static void IOOUTCALL ideio_o64e(UINT po Line 491  static void IOOUTCALL ideio_o64e(UINT po
                         }                          }
                         break;                          break;
   
                   case 0xc4:              // read multiple
   #if IDEIO_MULTIPLE_MAX > 0
                           TRACEOUT(("ideio: read multiple"));
                           drv->mulcnt = 0;
                           drv->multhr = drv->mulmode;
                           readsec(drv);
   #else
                           cmdabort(drv);
   #endif
                           break;
   
                   case 0xc6:              // set multiple mode
                           TRACEOUT(("ideio: set multiple mode"));
                           switch(drv->sc) {
   #if IDEIO_MULTIPLE_MAX > 0
                                   case 2: case 4: case 8: case 16: case 32: case 64: case 128:
                                           if (drv->sc <= IDEIO_MULTIPLE_MAX) {
                                                   drv->mulmode = drv->sc;
                                                   setintr(drv);
                                                   break;
                                           }
                                           /*FALLTHROUGH*/
   #endif
                                   default:
                                           cmdabort(drv);
                                           break;
                           }
                           break;
   
                   case 0xef:              // set features
                           TRACEOUT(("ideio: set features reg = %.2x", drv->wp));
                           cmdabort(drv);
                           break;
   
                 default:                  default:
                         panic("command:%.2x", dat);                          panic("ideio: unknown command %.2x", dat);
                         break;                          break;
         }          }
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o74c(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o74c(UINT port, REG8 dat) {
Line 443  static void IOOUTCALL ideio_o74c(UINT po Line 562  static void IOOUTCALL ideio_o74c(UINT po
                         }                          }
                 }                  }
         }          }
         TRACEOUT(("ideio %.4x,%.2x [%.4x:%.8x]", port, dat, CPU_CS, CPU_EIP));          TRACEOUT(("ideio interrupt %sable", (dat & IDECTRL_NIEN) ? "dis" : "en"));
           TRACEOUT(("ideio devctrl %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
           (void)port;
 }  }
   
 static void IOOUTCALL ideio_o74e(UINT port, REG8 dat) {  static void IOOUTCALL ideio_o74e(UINT port, REG8 dat) {
   
         TRACEOUT(("ideio %.4x,%.2x [%.4x:%.8x]", port, dat, CPU_CS, CPU_EIP));          TRACEOUT(("ideio %.4x,%.2x [%.4x:%.8x]", port, dat, CPU_CS, CPU_EIP));
           (void)port;
           (void)dat;
 }  }
   
   
Line 458  static REG8 IOINPCALL ideio_i642(UINT po Line 581  static REG8 IOINPCALL ideio_i642(UINT po
   
         IDEDRV  drv;          IDEDRV  drv;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 drv->status &= ~IDESTAT_ERR;                  drv->status &= ~IDESTAT_ERR;
Line 474  static REG8 IOINPCALL ideio_i644(UINT po Line 599  static REG8 IOINPCALL ideio_i644(UINT po
   
         IDEDRV  drv;          IDEDRV  drv;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 TRACEOUT(("ideio get SC %.2x [%.4x:%.8x]", drv->sc, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio get SC %.2x [%.4x:%.8x]", drv->sc, CPU_CS, CPU_EIP));
Line 488  static REG8 IOINPCALL ideio_i646(UINT po Line 615  static REG8 IOINPCALL ideio_i646(UINT po
   
         IDEDRV  drv;          IDEDRV  drv;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 TRACEOUT(("ideio get SN %.2x [%.4x:%.8x]", drv->sn, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio get SN %.2x [%.4x:%.8x]", drv->sn, CPU_CS, CPU_EIP));
Line 502  static REG8 IOINPCALL ideio_i648(UINT po Line 631  static REG8 IOINPCALL ideio_i648(UINT po
   
         IDEDRV  drv;          IDEDRV  drv;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 TRACEOUT(("ideio get CYL %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio get CYL %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));
Line 516  static REG8 IOINPCALL ideio_i64a(UINT po Line 647  static REG8 IOINPCALL ideio_i64a(UINT po
   
         IDEDRV  drv;          IDEDRV  drv;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 TRACEOUT(("ideio get CYH %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));                  TRACEOUT(("ideio get CYH %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));
Line 531  static REG8 IOINPCALL ideio_i64c(UINT po Line 664  static REG8 IOINPCALL ideio_i64c(UINT po
         IDEDRV  drv;          IDEDRV  drv;
         REG8    ret;          REG8    ret;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 ret = drv->dr | drv->hd;                  ret = drv->dr | drv->hd;
Line 546  static REG8 IOINPCALL ideio_i64e(UINT po Line 681  static REG8 IOINPCALL ideio_i64e(UINT po
   
         IDEDRV  drv;          IDEDRV  drv;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv) {          if (drv) {
                 TRACEOUT(("ideio status %.2x [%.4x:%.8x]",                  TRACEOUT(("ideio status %.2x [%.4x:%.8x]",
                                                                                         drv->status, CPU_CS, CPU_EIP));                                                                                          drv->status, CPU_CS, CPU_EIP));
                   if (!(drv->ctrl & IDECTRL_NIEN)) {
                           TRACEOUT(("ideio: resetirq"));
                           pic_resetirq(IDE_IRQ);
                   }
                 return(drv->status);                  return(drv->status);
         }          }
         else {          else {
Line 559  static REG8 IOINPCALL ideio_i64e(UINT po Line 700  static REG8 IOINPCALL ideio_i64e(UINT po
   
 static REG8 IOINPCALL ideio_i74c(UINT port) {  static REG8 IOINPCALL ideio_i74c(UINT port) {
   
         TRACEOUT(("ideio %.4x [%.4x:%.8x]", port, CPU_CS, CPU_EIP));          IDEDRV  drv;
         return(0xff);  
           (void)port;
   
           drv = getidedrv();
           if (drv) {
                   TRACEOUT(("ideio alt status %.2x [%.4x:%.8x]",
                                                                                           drv->status, CPU_CS, CPU_EIP));
                   return(drv->status);
           }
           else {
                   return(0xff);
           }
 }  }
   
   
Line 569  static REG8 IOINPCALL ideio_i74c(UINT po Line 721  static REG8 IOINPCALL ideio_i74c(UINT po
 void IOOUTCALL ideio_w16(UINT port, REG16 value) {  void IOOUTCALL ideio_w16(UINT port, REG16 value) {
   
         IDEDRV  drv;          IDEDRV  drv;
         BYTE    *p;          UINT8   *p;
   
         drv = getidedrv();          drv = getidedrv();
         if ((drv != NULL) &&          if ((drv != NULL) &&
                 (drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_OUT)) {                  (drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_OUT)) {
                 p = drv->buf + drv->bufpos;                  p = drv->buf + drv->bufpos;
                 p[0] = (BYTE)value;                  p[0] = (UINT8)value;
                 p[1] = (BYTE)(value >> 8);                  p[1] = (UINT8)(value >> 8);
                 TRACEOUT(("ide-data send %4x (%.4x) [%.4x:%.8x]",                  TRACEOUT(("ide-data send %4x (%.4x) [%.4x:%.8x]",
                                                                                 value, drv->bufpos, CPU_CS, CPU_EIP));                                                                                  value, drv->bufpos, CPU_CS, CPU_EIP));
                 drv->bufpos += 2;                  drv->bufpos += 2;
Line 589  void IOOUTCALL ideio_w16(UINT port, REG1 Line 741  void IOOUTCALL ideio_w16(UINT port, REG1
                         }                          }
                 }                  }
         }          }
           (void)port;
 }  }
   
 REG16 IOOUTCALL ideio_r16(UINT port) {  REG16 IOINPCALL ideio_r16(UINT port) {
   
         IDEDRV  drv;          IDEDRV  drv;
         REG16   ret;          REG16   ret;
         BYTE    *p;          UINT8   *p;
   
           (void)port;
   
         drv = getidedrv();          drv = getidedrv();
         if (drv == NULL) {          if (drv == NULL) {
Line 605  REG16 IOOUTCALL ideio_r16(UINT port) { Line 760  REG16 IOOUTCALL ideio_r16(UINT port) {
         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:%.8x]",                  TRACEOUT(("ide-data recv %.4x (%.4x) [%.4x:%.8x]",
                                                                                 ret, drv->bufpos, CPU_CS, CPU_EIP));                                                                                  ret, drv->bufpos, CPU_CS, CPU_EIP));
                 drv->bufpos += 2;                  drv->bufpos += 2;
                 if (drv->bufpos >= drv->bufsize) {                  if (drv->bufpos >= drv->bufsize) {
Line 613  REG16 IOOUTCALL ideio_r16(UINT port) { Line 768  REG16 IOOUTCALL ideio_r16(UINT port) {
                         switch(drv->cmd) {                          switch(drv->cmd) {
                                 case 0x20:                                  case 0x20:
                                 case 0x21:                                  case 0x21:
                                   case 0xc4:
                                         incsec(drv);                                          incsec(drv);
                                         drv->sc--;                                          drv->sc--;
                                         if (drv->sc) {                                          if (drv->sc) {
Line 649  static void devinit(IDEDRV drv, REG8 sxs Line 805  static void devinit(IDEDRV drv, REG8 sxs
                 drv->device = IDETYPE_HDD;                  drv->device = IDETYPE_HDD;
                 drv->surfaces = sxsi->surfaces;                  drv->surfaces = sxsi->surfaces;
                 drv->sectors = sxsi->sectors;                  drv->sectors = sxsi->sectors;
                   drv->mulmode = 1;
         }          }
         else {          else {
                 drv->status = IDESTAT_ERR;                  drv->status = IDESTAT_ERR;
                 drv->error = IDEERR_TR0;                  drv->error = IDEERR_TR0;
                   drv->device = IDETYPE_NONE;
         }          }
 }  }
   
Line 722  void ideio_bind(void) { Line 880  void ideio_bind(void) {
                 iocore_attachinp(0x074c, ideio_i74c);                  iocore_attachinp(0x074c, ideio_i74c);
         }          }
 }  }
 #endif  
   
   #endif  /* SUPPORT_IDEIO */
Removed from v.1.3  
changed lines
  Added in v.1.8

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