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

Diff for /xmil/z80c/z80dmap.c between versions 1.1 and 1.4

version 1.1, 2004/08/01 05:31:32 version 1.4, 2004/08/08 14:00:56
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "z80core.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "x1_io.h"  
 #include        "x1_fdc.h"  
   
   
 void z80dmap(void) {  void z80dmap(void) {
 #if 0  
         UINT8   al;  
   
         al = dma.DMA_CMND;          REG8    r;
         if ((al & 3) == 0) return;          UINT16  *off1;
           UINT16  *off2;
           REG8    flag1;
           REG8    flag2;
           UINT    addr;
           REG8    dat;
           REG8    vect;
   
           r = dma.DMA_CMND;
           if ((r & 3) == 0) return;
         if (dma.DMA_ENBL == 0) return;          if (dma.DMA_ENBL == 0) return;
         if (dma.ENDB_FLG != 0) return;          if (dma.ENDB_FLG != 0) return;
         if (al & 2) {          if (r & 2) {
                 if (dma.MACH_FLG != 0) return;                  if (dma.MACH_FLG != 0) return;
         }          }
         if (dma.DMA_MODE != 1) {          if (dma.DMA_MODE != 1) {
                 al = dma.WR[5] ^ dma.DMA_REDY                  if ((dma.WR[5] ^ dma.DMA_REDY) & 8) return;
                 if (al & 8) return;  
         }          }
   
           if (dma.WR[0] & 4) {
                   off1 = &dma.CNT_A.w;
                   flag1 = dma.WR[1];
                   off2 = &dma.CNT_B.w;
                   flag2 = dma.WR[2];
           }
           else {
                   off2 = &dma.CNT_A.w;
                   flag2 = dma.WR[1];
                   off1 = &dma.CNT_B.w;
                   flag1 = dma.WR[2];
           }
   
           do {            // dma_lp
 #if 0                  if (dma.ENDB_FLG) {
 dmaintmain:             push    ebx                          break;
                                 mov             ebx, offset dma.CNT_A                  }
                                 mov             ecx, offset dma.CNT_B                  if ((dma.DMA_CMND & 2) && (dma.MACH_FLG)) {
                           break;
                                 mov             dx, word ptr (dma.WR[1])                  }
                                 test    dma.WR[0], 4                  addr = *off1;
                                 jne             dma_lp                  if (flag1 & 8) {
                                 xchg    ebx, ecx                          if (addr == 0x0ffb) {
                                 xchg    dl, dh                                  fdcdummyread = 0;
                           }
 dma_lp:                 cmp             dma.ENDB_FLG, 0                          dat = iocore_inp(addr);
                                 jne             dmalpend                  }
                                 test    dma.DMA_CMND, 2                  else {
                                 je              dma_lpst                          dat = mem_read8(addr);
                                 cmp             dma.MACH_FLG, 0                  }
                                 jne             dmalpend                  if (dma.DMA_CMND & 1) {
 dma_lpst:                          addr = *off2;
                                 push    ecx                          if (flag2 & 8) {
                                 movzx   ecx, word ptr [ebx]                                  if ((addr == 0x0ffb) && (!ppi.IO_MODE)) {
                                 test    dl, 8                                          fdcdummyread = 0;
                                 jne             dma_inport                                  }
                                 call    fast_RDMEM                                  iocore_out(addr, dat);
 dmasrcend:              pop             ecx                          }
                           else {
                                 test    dma.DMA_CMND, 1                                  mem_write8(addr, dat);
                                 je              dmadstend                          }
                   }
                                 push    eax                  if (dma.DMA_CMND & 2) {
                                 push    ecx                          if (!((dat ^ dma.MACH_BYT) & (~dma.MASK_BYT))) {
                                 push    edx                                  dma.MACH_FLG = 1;
                                 movzx   ecx, word ptr [ecx]                          }
                                 mov             dl, al                  }
                                 test    dh, 8                  if (dma.DMA_MODE != 1) {
                                 jne             dma_outport                          dma.DMA_STOP = (dma.WR[5] ^ dma.DMA_REDY) & 8;
                                 call    fast_WRMEM                          if (dma.DMA_STOP) {
 dmadstend:              pop             edx                                  goto dma_stop;
                                 pop             ecx                          }
                                 pop             eax                  }
                   if (!(flag1 & 0x20)) {
                                 test    dma.DMA_CMND, 2                          *off1 += (flag1 & 0x10)?1:-1;
                                 je              dmamachcend                  }
                                 xor             al, dma.MACH_BYT                  if (!(flag2 & 0x20)) {
                                 mov             ah,     dma.MASK_BYT                          *off2 += (flag2 & 0x10)?1:-1;
                                 not             ah                  }
                                 and             al, ah  
                                 jne             short dmamachcend  dma_stop:
                                 mov             dma.MACH_FLG, 1                  dma.BYT_N.w++;
 dmamachcend:                  if (dma.BYT_N.w == 0) {
                                 cmp             dma.DMA_MODE, 1                          dma.ENDB_FLG = 1;
                                 je              forcesrcaddr                          break;
                                 mov             al, dma.WR[5]                  }
                                 xor             al, dma.DMA_REDY                  if ((dma.BYT_L.w) && (dma.BYT_L.w != 0xffff) && (dma.BYT_N.w >= (dma.BYT_L.w + 1))) {
                                 and             al, 8                          dma.ENDB_FLG = 1;
                                 mov             dma.DMA_STOP, al                          break;
                                 jne             dmadststpend                  }
           } while(dma.DMA_MODE);
 forcesrcaddr:   test    dl, 20h  
                                 jne             dmasrcstpend          if (dma.INT_ENBL) {
                                 test    dl, 10h                  vect = 0;
                                 je              dmasrcdec                  if ((dma.INT_FLG & 1) && (dma.MACH_FLG)) {
                                         inc             word ptr [ebx]                          vect = 2;
                                 jmp             dmasrcstpend                  }
 dmasrcdec:                      dec             word ptr [ebx]                  else if ((dma.INT_FLG & 2) && (dma.ENDB_FLG)) {
 dmasrcstpend:                          vect = 4;
                                 test    dh, 20h                  }
                                 jne             dmadststpend                  if (vect) {
                                 test    dh, 10h                          if (dma.INT_FLG & 0x20) {
                                 je              dmadstdec                                  vect += (dma.INT_VCT & 0xf9);
                                         inc             word ptr [ecx]                          }
                                 jmp             dmadststpend                          else {
 dmadstdec:                      dec             word ptr [ecx]                                  vect = dma.INT_VCT;
 dmadststpend:                          }
                                 inc             dma.BYT_N.w                          z80c_interrupt(vect);
                                 je              dmaforceend                  }
                                 mov             ax, dma.BYT_L.w          }
                                 or              ax, ax  
                                 je              dmplpedch                               // BYT_L == 0なら無制限?  
                                 inc             ax  
                                 je              dmplpedch                               // ver0.25  
                                 cmp             ax, dma.BYT_N.w  
                                 ja              dmplpedch  
 dmaforceend:    mov             dma.ENDB_FLG, 1  
                                 jmp             dmalpend  
   
 dmplpedch:              cmp             dma.DMA_MODE, 0  
                                 jne             dma_lp  
 dmalpend:  
                                 pop             ebx  
                                 cmp             dma.INT_ENBL, 0  
                                 je              dmaintrptend  
                                 mov             dl, 2  
                                 mov             al, dma.INT_FLG  
                                 test    al, 1  
                                 je              dmaintrpt2ck  
                                 cmp             dma.MACH_FLG, 0  
                                 jne             dmaintrptcall  
 dmaintrpt2ck:   mov             dl, 4  
                                 test    al, 2  
                                 je              dmaintrptend  
                                 cmp             dma.ENDB_FLG, 0  
                                 je              dmaintrptend  
 dmaintrptcall:  movzx   ecx, dma.INT_VCT  
                                 test    al, 20h  
                                 je              dma_intrpt  
                                 and             cl, 0f9h  
                                 or              cl, dl  
 dma_intrpt:             jmp             z80x_interrupt  
 dmaintrptend:   ret  
   
   
 dma_inport:             push    edx  
                                 push    ebx  
                                 cmp             cx, 0ffbh  
                                 jne             Z80inport  
 //                              cmp             s8255.IO_MODE, 0  
 //                              jne             Z80inport  
                                 mov             fdcdummyread, 0  
 Z80inport:              call    Z80_In  
                                 pop             ebx  
                                 pop             edx  
                                 jmp             dmasrcend  
   
 dma_outport:    push    ebx  
                                 cmp             cx, 0ffbh  
                                 jne             Z80outport  
                                 cmp             s8255.IO_MODE, 0  
                                 jne             Z80outport  
                                 mov             fdcdummyread, 0  
 Z80outport:             call    Z80_Out  
                                 pop             ebx  
                                 jmp             dmadstend  
 #endif  
 #endif  
 }  }
   
Removed from v.1.1  
changed lines
  Added in v.1.4

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