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

Diff for /np2/io/dmac.c between versions 1.1.1.1 and 1.6

version 1.1.1.1, 2003/10/16 17:57:51 version 1.6, 2004/01/13 05:30:58
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "i286.h"  
 #include        "memory.h"  
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "sound.h"  #include        "sound.h"
 #include        "fmboard.h"  #include        "cs4231.h"
   
   
 void DMACCALL dma_dummyout(BYTE data) {  void DMACCALL dma_dummyout(REG8 data) {
   
         (void)data;          (void)data;
 }  }
   
 BYTE DMACCALL dma_dummyin(void) {  REG8 DMACCALL dma_dummyin(void) {
   
         return(0xff);          return(0xff);
 }  }
   
 BYTE DMACCALL dma_dummyproc(BYTE func) {  REG8 DMACCALL dma_dummyproc(REG8 func) {
   
         (void)func;          (void)func;
         return(0);          return(0);
 }  }
   
   static const DMAPROC dmaproc[] = {
                   {dma_dummyout,          dma_dummyin,            dma_dummyproc},         // NONE
                   {fdc_DataRegWrite,      fdc_DataRegRead,        fdc_dmafunc},           // 2HD
                   {fdc_DataRegWrite,      fdc_DataRegRead,        fdc_dmafunc},           // 2DD
                   {dma_dummyout,          dma_dummyin,            dma_dummyproc},         // SASI
                   {dma_dummyout,          dma_dummyin,            dma_dummyproc},         // SCSI
                   {dma_dummyout,          dma_dummyin,            cs4231dmafunc},         // CS4231
   };
   
   
 // ----  // ----
   
Line 30  void dmac_check(void) { Line 37  void dmac_check(void) {
   
         BOOL    workchg;          BOOL    workchg;
         DMACH   ch;          DMACH   ch;
         BYTE    bit;          REG8    bit;
   
         workchg = FALSE;          workchg = FALSE;
         ch = dmac.dmach;          ch = dmac.dmach;
Line 39  void dmac_check(void) { Line 46  void dmac_check(void) {
                 if ((!(dmac.mask & bit)) && (ch->ready)) {                  if ((!(dmac.mask & bit)) && (ch->ready)) {
                         if (!(dmac.work & bit)) {                          if (!(dmac.work & bit)) {
                                 dmac.work |= bit;                                  dmac.work |= bit;
                                 if (ch->extproc(DMAEXT_START)) {                                  if (ch->proc.extproc(DMAEXT_START)) {
                                         dmac.stat &= ~bit;                                              // ver0.27                                          dmac.stat &= ~bit;                                              // ver0.27
                                         dmac.working |= bit;                                          dmac.working |= bit;
                                         workchg = TRUE;                                          workchg = TRUE;
Line 50  void dmac_check(void) { Line 57  void dmac_check(void) {
                         if (dmac.work & bit) {                          if (dmac.work & bit) {
                                 dmac.work &= ~bit;                                  dmac.work &= ~bit;
                                 dmac.working &= ~bit;                                  dmac.working &= ~bit;
                                 ch->extproc(DMAEXT_BREAK);                                  ch->proc.extproc(DMAEXT_BREAK);
                                 workchg = TRUE;                                  workchg = TRUE;
                         }                          }
                 }                  }
Line 65  void dmac_check(void) { Line 72  void dmac_check(void) {
   
 // ---- I/O  // ---- I/O
   
 static void IOOUTCALL dmac_o01(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o01(UINT port, REG8 dat) {
   
         DMACH   dmach;          DMACH   dmach;
         int             lh;          int             lh;
Line 77  static void IOOUTCALL dmac_o01(UINT port Line 84  static void IOOUTCALL dmac_o01(UINT port
         dmach->adrsorg.b[lh] = dat;          dmach->adrsorg.b[lh] = dat;
 }  }
   
 static void IOOUTCALL dmac_o03(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o03(UINT port, REG8 dat) {
   
         int             ch;          int             ch;
         DMACH   dmach;          DMACH   dmach;
Line 92  static void IOOUTCALL dmac_o03(UINT port Line 99  static void IOOUTCALL dmac_o03(UINT port
         dmac.stat &= ~(1 << ch);          dmac.stat &= ~(1 << ch);
 }  }
   
 static void IOOUTCALL dmac_o13(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o13(UINT port, REG8 dat) {
   
         dmac.dmach[dat & 3].sreq = dat;          dmac.dmach[dat & 3].sreq = dat;
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL dmac_o15(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o15(UINT port, REG8 dat) {
   
         if (dat & 4) {          if (dat & 4) {
                 dmac.mask |= (1 << (dat & 3));                  dmac.mask |= (1 << (dat & 3));
Line 110  static void IOOUTCALL dmac_o15(UINT port Line 117  static void IOOUTCALL dmac_o15(UINT port
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL dmac_o17(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o17(UINT port, REG8 dat) {
   
         dmac.dmach[dat & 3].mode = dat;          dmac.dmach[dat & 3].mode = dat;
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL dmac_o19(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o19(UINT port, REG8 dat) {
   
         dmac.lh = DMA16_LOW;          dmac.lh = DMA16_LOW;
         (void)port;          (void)port;
         (void)dat;          (void)dat;
 }  }
   
 static void IOOUTCALL dmac_o1b(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o1b(UINT port, REG8 dat) {
   
         dmac.mask = 0x0f;          dmac.mask = 0x0f;
         (void)port;          (void)port;
         (void)dat;          (void)dat;
 }  }
   
 static void IOOUTCALL dmac_o1f(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o1f(UINT port, REG8 dat) {
   
         dmac.mask = dat;          dmac.mask = dat;
         dmac_check();          dmac_check();
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL dmac_o21(UINT port, BYTE dat) {  static void IOOUTCALL dmac_o21(UINT port, REG8 dat) {
   
         DMACH   dmach;          DMACH   dmach;
   
         dmach = dmac.dmach + (((port >> 1) + 1) & 3);          dmach = dmac.dmach + (((port >> 1) + 1) & 3);
         dmach->adrs.b[DMA32_HIGH + DMA16_LOW] = dat;          dmach->adrs.b[DMA32_HIGH + DMA16_LOW] = dat & 0x0f;
 }  }
   
 static BYTE IOINPCALL dmac_i01(UINT port) {  static REG8 IOINPCALL dmac_i01(UINT port) {
   
         DMACH   dmach;          DMACH   dmach;
         int             lh;          int             lh;
Line 153  static BYTE IOINPCALL dmac_i01(UINT port Line 160  static BYTE IOINPCALL dmac_i01(UINT port
         dmach = dmac.dmach + ((port >> 2) & 3);          dmach = dmac.dmach + ((port >> 2) & 3);
         lh = dmac.lh;          lh = dmac.lh;
         dmac.lh = lh ^ 1;          dmac.lh = lh ^ 1;
         return(dmach->leng.b[lh]);          return(dmach->adrs.b[lh + DMA32_LOW]);
 }  }
   
 static BYTE IOINPCALL dmac_i03(UINT port) {  static REG8 IOINPCALL dmac_i03(UINT port) {
   
         DMACH   dmach;          DMACH   dmach;
         int             lh;          int             lh;
Line 164  static BYTE IOINPCALL dmac_i03(UINT port Line 171  static BYTE IOINPCALL dmac_i03(UINT port
         dmach = dmac.dmach + ((port >> 2) & 3);          dmach = dmac.dmach + ((port >> 2) & 3);
         lh = dmac.lh;          lh = dmac.lh;
         dmac.lh = lh ^ 1;          dmac.lh = lh ^ 1;
         return(dmach->adrs.b[lh + DMA32_LOW]);          return(dmach->leng.b[lh]);
 }  }
   
 static BYTE IOINPCALL dmac_i11(UINT port) {  static REG8 IOINPCALL dmac_i11(UINT port) {
   
         (void)port;          (void)port;
         return(dmac.stat);                                                                                              // ToDo!!          return(dmac.stat);                                                                                              // ToDo!!
Line 193  static const IOOUT dmaco21[4] = { Line 200  static const IOOUT dmaco21[4] = {
   
 void dmac_reset(void) {  void dmac_reset(void) {
   
         int             i;  
   
         ZeroMemory(&dmac, sizeof(dmac));          ZeroMemory(&dmac, sizeof(dmac));
         dmac.lh = DMA16_LOW;          dmac.lh = DMA16_LOW;
         dmac.mask = 0xf;          dmac.mask = 0xf;
         for (i=0; i<4; i++) {          dmac_procset();
                 dmac.dmach[i].outproc = dma_dummyout;  
                 dmac.dmach[i].inproc = dma_dummyin;  
                 dmac.dmach[i].extproc = dma_dummyproc;  
         }  
         dmac.dmach[0].extproc = cs4231dmafunc;  
         dmac.dmach[DMA_2HD].inproc = fdc_DataRegRead;  
         dmac.dmach[DMA_2HD].outproc = fdc_DataRegWrite;  
         dmac.dmach[DMA_2HD].extproc = fdc_dmafunc;  
         dmac.dmach[DMA_2DD].inproc = fdc_DataRegRead;  
         dmac.dmach[DMA_2DD].outproc = fdc_DataRegWrite;  
         dmac.dmach[DMA_2DD].extproc = fdc_dmafunc;  
   
 //      TRACEOUT(("sizeof(_DMACH) = %d", sizeof(_DMACH)));  //      TRACEOUT(("sizeof(_DMACH) = %d", sizeof(_DMACH)));
 }  }
   
Line 221  void dmac_bind(void) { Line 214  void dmac_bind(void) {
         iocore_attachsysoutex(0x0021, 0x0cf1, dmaco21, 4);          iocore_attachsysoutex(0x0021, 0x0cf1, dmaco21, 4);
 }  }
   
   
   // ----
   
   static void dmacset(REG8 channel) {
   
           DMADEV          *dev;
           DMADEV          *devterm;
           UINT            dmadev;
   
           dev = dmac.device;
           devterm = dev + dmac.devices;
           dmadev = DMADEV_NONE;
           while(dev < devterm) {
                   if (dev->channel == channel) {
                           dmadev = dev->device;
                   }
                   dev++;
           }
           if (dmadev >= sizeof(dmaproc) / sizeof(DMAPROC)) {
                   dmadev = 0;
           }
           dmac.dmach[channel].proc = dmaproc[dmadev];
   }
   
   void dmac_procset(void) {
   
           REG8    i;
   
           for (i=0; i<4; i++) {
                   dmacset(i);
           }
   }
   
   void dmac_attach(REG8 device, REG8 channel) {
   
           dmac_detach(device);
   
           if (dmac.devices < (sizeof(dmac.device) / sizeof(DMADEV))) {
                   dmac.device[dmac.devices].device = device;
                   dmac.device[dmac.devices].channel = channel;
                   dmac.devices++;
                   dmacset(channel);
           }
   }
   
   void dmac_detach(REG8 device) {
   
           DMADEV  *dev;
           DMADEV  *devterm;
           REG8    ch;
   
           dev = dmac.device;
           devterm = dev + dmac.devices;
           while(dev < devterm) {
                   if (dev->device == device) {
                           break;
                   }
                   dev++;
           }
           if (dev < devterm) {
                   ch = dev->channel;
                   dev++;
                   while(dev < devterm) {
                           *(dev - 1) = *dev;
                           dev++;
                   }
                   dmac.devices--;
                   dmacset(ch);
           }
   }
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.6

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