Codice ASM per esecuzione di operazioni IO in modalità PIO

.386p
ifndef ??version
?debug macro
endm
publicdll macro name
public name
endm
$comm macro name,dist,size,count
comm dist name:BYTE:count*size
endm
else
$comm macro name,dist,size,count
comm dist name[size]:BYTE:count
endm
endif
?debug V 301h
?debug S "ataiopio.c"
?debug C E917BA96320A617461696F70696F2E63
?debug C E980261D1F15433A5C424334355C494E434C5544455C646F732E68
?debug C E980261D1F17433A5C424334355C494E434C5544455C5F64656673+
?debug C 2E68
?debug C E9463E4D3307617461696F2E68
ATAIOPIO_TEXT segment byte public use16 ’ CODE’
ATAIOPIO_TEXT ends
DGROUP group _DATA,_BSS
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_DATA segment word public use16 ’ DATA’
d@ label byte
d@w label word
_DATA ends
_BSS segment word public use16 ’ BSS’
b@ label byte
b@w label word
_BSS ends
_DATA segment word public use16 ’ DATA’
_pio_base_addr1 label word
db 240
db 1
_pio_base_addr2 label word
db 240
db 3
_pio_memory_seg label word
db 0
db 0
_pio_memory_dt_opt label word
db 0
db 0
_pio_bmcr_base_addr label word
db 0
db 0
_pio_xfer_width label word
db 16
db 0
_DATA ends
ATAIOPIO_TEXT segment byte public use16 ’ CODE’
;
; void pio_set_iobase_addr( unsigned int base1,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_set_iobase_addr proc far
push bp
mov bp,sp
;
; unsigned int base2,
; unsigned int base3 )
;
; {
;
; pio_base_addr1 = base1;
;
mov ax,word ptr [bp+6]
mov word ptr DGROUP:_pio_base_addr1,ax
;
; pio_base_addr2 = base2;
;
mov ax,word ptr [bp+8]
mov word ptr DGROUP:_pio_base_addr2,ax
;
; pio_bmcr_base_addr = base3;
;
mov ax,word ptr [bp+10]
mov word ptr DGROUP:_pio_bmcr_base_addr,ax
;
; pio_memory_seg = 0;
;
mov word ptr DGROUP:_pio_memory_seg,0
;
; pio_reg_addrs[ CB_DATA ] = pio_base_addr1 + 0; // 0
;
mov ax,word ptr DGROUP:_pio_base_addr1
mov word ptr DGROUP:_pio_reg_addrs,ax
;
; pio_reg_addrs[ CB_FR ] = pio_base_addr1 + 1; // 1
;
mov ax,word ptr DGROUP:_pio_base_addr1
inc ax
mov word ptr DGROUP:_pio_reg_addrs+2,ax
;
; pio_reg_addrs[ CB_SC ] = pio_base_addr1 + 2; // 2
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,2
mov word ptr DGROUP:_pio_reg_addrs+4,ax
;
; pio_reg_addrs[ CB_SN ] = pio_base_addr1 + 3; // 3
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,3
mov word ptr DGROUP:_pio_reg_addrs+6,ax
;
; pio_reg_addrs[ CB_CL ] = pio_base_addr1 + 4; // 4
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,4
mov word ptr DGROUP:_pio_reg_addrs+8,ax
;
; pio_reg_addrs[ CB_CH ] = pio_base_addr1 + 5; // 5
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,5
mov word ptr DGROUP:_pio_reg_addrs+10,ax
;
; pio_reg_addrs[ CB_DH ] = pio_base_addr1 + 6; // 6
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,6
mov word ptr DGROUP:_pio_reg_addrs+12,ax
;
; pio_reg_addrs[ CB_CMD ] = pio_base_addr1 + 7; // 7
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,7
mov word ptr DGROUP:_pio_reg_addrs+14,ax
;
; pio_reg_addrs[ CB_DC ] = pio_base_addr2 + 6; // 8
;
mov ax,word ptr DGROUP:_pio_base_addr2
add ax,6
mov word ptr DGROUP:_pio_reg_addrs+16,ax
;
; pio_reg_addrs[ CB_DA ] = pio_base_addr2 + 7; // 9
;
mov ax,word ptr DGROUP:_pio_base_addr2
add ax,7
mov word ptr DGROUP:_pio_reg_addrs+18,ax
;
; }
;
pop bp
ret
_pio_set_iobase_addr endp
;
; void pio_set_memory_addr( unsigned int seg )
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_set_memory_addr proc far
push bp
mov bp,sp
;
;
; {
;
; pio_base_addr1 = 0;
;
mov word ptr DGROUP:_pio_base_addr1,0
;
; pio_base_addr2 = 8;
;
mov word ptr DGROUP:_pio_base_addr2,8
;
; pio_bmcr_base_addr = 0;
;
mov word ptr DGROUP:_pio_bmcr_base_addr,0
;
; pio_memory_seg = seg;
;
mov ax,word ptr [bp+6]
mov word ptr DGROUP:_pio_memory_seg,ax
;
; pio_memory_dt_opt = PIO_MEMORY_DT_OPT0;
;
mov word ptr DGROUP:_pio_memory_dt_opt,0
;
; pio_reg_addrs[ CB_DATA ] = pio_base_addr1 + 0; // 0
;
mov ax,word ptr DGROUP:_pio_base_addr1
mov word ptr DGROUP:_pio_reg_addrs,ax
;
; pio_reg_addrs[ CB_FR ] = pio_base_addr1 + 1; // 1
;
mov ax,word ptr DGROUP:_pio_base_addr1
inc ax
mov word ptr DGROUP:_pio_reg_addrs+2,ax
;
; pio_reg_addrs[ CB_SC ] = pio_base_addr1 + 2; // 2
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,2
mov word ptr DGROUP:_pio_reg_addrs+4,ax
;
; pio_reg_addrs[ CB_SN ] = pio_base_addr1 + 3; // 3
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,3
mov word ptr DGROUP:_pio_reg_addrs+6,ax
;
; pio_reg_addrs[ CB_CL ] = pio_base_addr1 + 4; // 4
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,4
mov word ptr DGROUP:_pio_reg_addrs+8,ax
;
; pio_reg_addrs[ CB_CH ] = pio_base_addr1 + 5; // 5
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,5
mov word ptr DGROUP:_pio_reg_addrs+10,ax
;
; pio_reg_addrs[ CB_DH ] = pio_base_addr1 + 6; // 6
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,6
mov word ptr DGROUP:_pio_reg_addrs+12,ax
;
; pio_reg_addrs[ CB_CMD ] = pio_base_addr1 + 7; // 7
;
mov ax,word ptr DGROUP:_pio_base_addr1
add ax,7
mov word ptr DGROUP:_pio_reg_addrs+14,ax
;
; pio_reg_addrs[ CB_DC ] = pio_base_addr2 + 6; // 8
;
mov ax,word ptr DGROUP:_pio_base_addr2
add ax,6
mov word ptr DGROUP:_pio_reg_addrs+16,ax
;
; pio_reg_addrs[ CB_DA ] = pio_base_addr2 + 7; // 9
;
mov ax,word ptr DGROUP:_pio_base_addr2
add ax,7
mov word ptr DGROUP:_pio_reg_addrs+18,ax
;
; }
;
pop bp
ret
_pio_set_memory_addr endp
;
; unsigned char pio_inbyte( unsigned int addr )
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_inbyte proc far
enter 8,0
push si
mov si,word ptr [bp+6]
;
;
; {
; unsigned int regAddr;
; unsigned char uc;
; unsigned char far * ucp;
;
; regAddr = pio_reg_addrs[ addr ];
;
mov bx,si
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; if ( pio_memory_seg )
;
cmp word ptr DGROUP:_pio_memory_seg,0
je short @3@86
;
; {
; ucp = (unsigned char far *) MK_FP( pio_memory_seg, regAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov dx,word ptr [bp-2]
mov word ptr [bp-6],ax
mov word ptr [bp-8],dx
;
; uc = * ucp;
;
les bx,dword ptr [bp-8]
mov al,byte ptr es:[bx]
mov byte ptr [bp-3],al
;
; }
;
jmp short @3@310
@3@86:
;
; else
; {
; // uc = (unsigned char) inportb( regAddr );
;
; // READ THIS: If you get a compile error on the following
; // statement you are trying to use BASM (the assembler
; // built into Borland C). BASM can not assemble 386
; // instructions. You must use Borland TASM as is shown
; // in the EXAMPLE1.MAK or EXAMPLE2.MAK "make files".
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push dx
;
push dx
;
;
; asm mov dx,regAddr
;
mov dx,[bp-2]
;
;
; asm in al,dx
;
in al,dx
;
; asm mov uc,al
;
mov [bp-3],al
;
;
; asm pop dx
;
pop dx
;
; asm pop ax
;
pop ax
@3@310:
;
;
; }
; pio_last_read[ addr ] = uc;
;
mov al,byte ptr [bp-3]
mov byte ptr DGROUP:_pio_last_read[si],al
;
; trc_llt( addr, uc, TRC_LLT_INB );
;
push 1
push word ptr [bp-3]
push si
call far ptr _trc_llt
add sp,6
;
; return uc;
;
mov al,byte ptr [bp-3]
jmp short @3@366
@3@366:
;
; }
;
pop si
leave
ret
_pio_inbyte endp
;
; void pio_outbyte( unsigned int addr, unsigned char data )
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_outbyte proc far
enter 6,0
push si
mov si,word ptr [bp+6]
;
;
; {
; unsigned int regAddr;
; unsigned char far * ucp;
;
; regAddr = pio_reg_addrs[ addr ];
;
mov bx,si
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; if ( pio_memory_seg )
;
cmp word ptr DGROUP:_pio_memory_seg,0
je short @4@86
;
; {
; ucp = (unsigned char far *) MK_FP( pio_memory_seg, regAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov dx,word ptr [bp-2]
mov word ptr [bp-4],ax
mov word ptr [bp-6],dx
;
; * ucp = data;
;
les bx,dword ptr [bp-6]
mov al,byte ptr [bp+8]
mov byte ptr es:[bx],al
;
; }
;
jmp short @4@310
@4@86:
;
; else
; {
; // outportb( regAddr, data );
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push dx
;
push dx
;
;
; asm mov dx,regAddr
;
mov dx,[bp-2]
;
; asm mov al,data
;
mov al,[bp+8]
;
;
; asm out dx,al
;
out dx,al
;
;
; asm pop dx
;
pop dx
;
; asm pop ax
;
pop ax
@4@310:
;
;
; }
; pio_last_write[ addr ] = data;
;
mov al,byte ptr [bp+8]
mov byte ptr DGROUP:_pio_last_write[si],al
;
; trc_llt( addr, data, TRC_LLT_OUTB );
;
push 2
push word ptr [bp+8]
push si
call far ptr _trc_llt
add sp,6
;
; }
;
pop si
leave
ret
_pio_outbyte endp
;
; unsigned int pio_inword( unsigned int addr )
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_inword proc far
enter 8,0
push si
mov si,word ptr [bp+6]
;
;
; {
; unsigned int regAddr;
; unsigned int ui;
; unsigned int far * uip;
;
; regAddr = pio_reg_addrs[ addr ];
;
mov bx,si
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; if ( pio_memory_seg )
;
cmp word ptr DGROUP:_pio_memory_seg,0
je short @5@86
;
; {
; uip = (unsigned int far *) MK_FP( pio_memory_seg, regAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov dx,word ptr [bp-2]
mov word ptr [bp-6],ax
mov word ptr [bp-8],dx
;
; ui = * uip;
;
les bx,dword ptr [bp-8]
mov ax,word ptr es:[bx]
mov word ptr [bp-4],ax
;
; }
;
jmp short @5@310
@5@86:
;
; else
; {
; // ui = inport( regAddr );
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push dx
;
push dx
;
;
; asm mov dx,regAddr
;
mov dx,[bp-2]
;
;
; asm in ax,dx
;
in ax,dx
;
; asm mov ui,ax
;
mov [bp-4],ax
;
;
; asm pop dx
;
pop dx
;
; asm pop ax
;
pop ax
@5@310:
;
;
; }
; trc_llt( addr, 0, TRC_LLT_INW );
;
push 3
push 0
push si
call far ptr _trc_llt
add sp,6
;
; return ui;
;
mov ax,word ptr [bp-4]
jmp short @5@366
@5@366:
;
; }
;
pop si
leave
ret
_pio_inword endp
;
; void pio_outword( unsigned int addr, unsigned int data )
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_outword proc far
enter 6,0
push si
mov si,word ptr [bp+6]
;
;
; {
; unsigned int regAddr;
; unsigned int far * uip;
;
; regAddr = pio_reg_addrs[ addr ];
;
mov bx,si
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; if ( pio_memory_seg )
;
cmp word ptr DGROUP:_pio_memory_seg,0
je short @6@86
;
; {
; uip = (unsigned int far *) MK_FP( pio_memory_seg, regAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov dx,word ptr [bp-2]
mov word ptr [bp-4],ax
mov word ptr [bp-6],dx
;
; * uip = data;
;
les bx,dword ptr [bp-6]
mov ax,word ptr [bp+8]
mov word ptr es:[bx],ax
;
; }
;
jmp short @6@310
@6@86:
;
; else
; {
; // outport( regAddr, data );
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push dx
;
push dx
;
;
; asm mov dx,regAddr
;
mov dx,[bp-2]
;
; asm mov ax,data
;
mov ax,[bp+8]
;
;
; asm out dx,ax
;
out dx,ax
;
;
; asm pop dx
;
pop dx
;
; asm pop ax
;
pop ax
@6@310:
;
;
; }
; trc_llt( addr, 0, TRC_LLT_OUTW );
;
push 4
push 0
push si
call far ptr _trc_llt
add sp,6
;
; }
;
pop si
leave
ret
_pio_outword endp
;
; void pio_drq_block_in( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_drq_block_in proc far
enter 34,0
push si
push di
mov di,word ptr [bp+8]
;
; unsigned int bufSeg, unsigned int bufOff,
; long wordCnt )
;
; {
; long bCnt;
; int memDtOpt;
; unsigned int randVal;
; unsigned int dataRegAddr;
; unsigned int far * uip1;
; unsigned int far * uip2;
; unsigned char far * ucp1;
; unsigned char far * ucp2;
; unsigned long bufAddr;
;
; // NOTE: wordCnt is the size of a DRQ data block/packet
; // in words. The maximum value of wordCnt is normally:
; // a) For ATA, 16384 words or 32768 bytes (64 sectors,
; // only with READ/WRITE MULTIPLE commands),
; // b) For ATAPI, 32768 words or 65536 bytes
; // (actually 65535 bytes plus a pad byte).
;
; // normalize bufSeg:bufOff
;
; bufAddr = bufSeg;
;
movzx eax,di
mov dword ptr [bp-28],eax
;
; bufAddr = bufAddr << 4;
;
mov eax,dword ptr [bp-28]
shl eax,4
mov dword ptr [bp-28],eax
;
; bufAddr = bufAddr + bufOff;
;
movzx eax,word ptr [bp+10]
add eax,dword ptr [bp-28]
mov dword ptr [bp-28],eax
;
;
; if ( pio_memory_seg )
;
cmp word ptr DGROUP:_pio_memory_seg,0
je @7@674
;
; {
;
; // PCMCIA Memory mode data transfer.
;
; // set Data reg address per pio_memory_dt_opt
; dataRegAddr = 0x0000;
;
xor si,si
;
; memDtOpt = pio_memory_dt_opt;
;
mov ax,word ptr DGROUP:_pio_memory_dt_opt
mov word ptr [bp-6],ax
;
; if ( pio_memory_dt_opt == PIO_MEMORY_DT_OPTR )
;
cmp word ptr DGROUP:_pio_memory_dt_opt,3
jne short @7@114
;
; {
; randVal = * (unsigned int *) MK_FP( 0x40, 0x6c );
;
mov ax,64
mov es,ax
mov ax,word ptr es:[108]
mov word ptr [bp-8],ax
;
; memDtOpt = randVal % 3;
;
mov ax,word ptr [bp-8]
mov bx,3
xor dx,dx
div bx
mov word ptr [bp-6],dx
@7@114:
;
; }
; if ( memDtOpt == PIO_MEMORY_DT_OPT8 )
;
cmp word ptr [bp-6],1
jne short @7@170
;
; dataRegAddr = 0x0008;
;
mov si,8
@7@170:
;
; if ( memDtOpt == PIO_MEMORY_DT_OPTB )
;
cmp word ptr [bp-6],2
jne short @7@254
;
; {
; dataRegAddr = 0x0400;
;
mov si,1024
;
; if ( pio_memory_dt_opt == PIO_MEMORY_DT_OPTR )
;
cmp word ptr DGROUP:_pio_memory_dt_opt,3
jne short @7@254
;
; dataRegAddr = dataRegAddr | ( randVal & 0x03fe );
;
mov ax,word ptr [bp-8]
and ax,1022
or ax,si
mov si,ax
@7@254:
;
; }
;
; if ( pio_xfer_width == 8 )
;
cmp word ptr DGROUP:_pio_xfer_width,8
jne short @7@450
;
; {
; // PCMCIA Memory mode 8-bit
; bCnt = wordCnt * 2L;
;
mov eax,dword ptr [bp+12]
shl eax,1
mov dword ptr [bp-4],eax
;
; ucp1 = (unsigned char far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-18],ax
mov word ptr [bp-20],si
jmp short @7@394
@7@310:
;
; for ( ; bCnt > 0; bCnt -- )
; {
; bufSeg = (unsigned int) ( bufAddr >> 4 );
;
mov eax,dword ptr [bp-28]
shr eax,4
mov di,ax
;
; bufOff = (unsigned int) ( bufAddr & 0x0000000fL );
;
mov ax,word ptr [bp-28]
and ax,15
mov word ptr [bp+10],ax
;
; ucp2 = (unsigned char far *) MK_FP( bufSeg, bufOff );
;
mov ax,word ptr [bp+10]
mov word ptr [bp-22],di
mov word ptr [bp-24],ax
;
; * ucp2 = * ucp1;
;
les bx,dword ptr [bp-20]
mov al,byte ptr es:[bx]
les bx,dword ptr [bp-24]
mov byte ptr es:[bx],al
;
; bufAddr += 1;
;
inc dword ptr [bp-28]
;
; if ( memDtOpt == PIO_MEMORY_DT_OPTB )
;
cmp word ptr [bp-6],2
jne short @7@366
;
; {
; dataRegAddr += 1;
;
inc si
;
; dataRegAddr = ( dataRegAddr & 0x03ff ) | 0x0400;
;
mov ax,si
and ax,1023
or ax,1024
mov si,ax
;
; ucp1 = (unsigned char far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-18],ax
mov word ptr [bp-20],si
@7@366:
dec dword ptr [bp-4]
@7@394:
cmp dword ptr [bp-4],large 0
jg short @7@310
;
; }
; }
; trc_llt( addrDataReg, 0, TRC_LLT_INSB );
;
push 5
jmp short @7@618
@7@450:
;
; }
; else
; {
; // PCMCIA Memory mode 16-bit
; uip1 = (unsigned int far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-10],ax
mov word ptr [bp-12],si
jmp short @7@562
@7@478:
;
; for ( ; wordCnt > 0; wordCnt -- )
; {
; bufSeg = (unsigned int) ( bufAddr >> 4 );
;
mov eax,dword ptr [bp-28]
shr eax,4
mov di,ax
;
; bufOff = (unsigned int) ( bufAddr & 0x0000000fL );
;
mov ax,word ptr [bp-28]
and ax,15
mov word ptr [bp+10],ax
;
; uip2 = (unsigned int far *) MK_FP( bufSeg, bufOff );
;
mov ax,word ptr [bp+10]
mov word ptr [bp-14],di
mov word ptr [bp-16],ax
;
; * uip2 = * uip1;
;
les bx,dword ptr [bp-12]
mov ax,word ptr es:[bx]
les bx,dword ptr [bp-16]
mov word ptr es:[bx],ax
;
; bufAddr += 2;
;
add dword ptr [bp-28],large 2
;
; if ( memDtOpt == PIO_MEMORY_DT_OPTB )
;
cmp word ptr [bp-6],2
jne short @7@534
;
; {
; dataRegAddr += 2;
;
add si,2
;
; dataRegAddr = ( dataRegAddr & 0x03fe ) | 0x0400;
;
mov ax,si
and ax,1022
or ax,1024
mov si,ax
;
; uip1 = (unsigned int far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-10],ax
mov word ptr [bp-12],si
@7@534:
dec dword ptr [bp+12]
@7@562:
cmp dword ptr [bp+12],large 0
jg short @7@478
;
; }
; }
; trc_llt( addrDataReg, 0, TRC_LLT_INSW );
;
push 7
@7@618:
push 0
push word ptr [bp+6]
call far ptr _trc_llt
add sp,6
;
; }
; }
;
jmp @7@1094
@7@674:
;
; else
; {
; int pxw;
; long wc;
;
; // adjust pio_xfer_width - don’ t use DWORD if wordCnt is odd.
;
; pxw = pio_xfer_width;
;
mov ax,word ptr DGROUP:_pio_xfer_width
mov word ptr [bp-30],ax
;
; if ( ( pxw == 32 ) && ( wordCnt & 0x00000001L ) )
;
cmp word ptr [bp-30],32
jne short @7@758
test byte ptr [bp+12],1
je short @7@758
;
; pxw = 16;
;
mov word ptr [bp-30],16
@7@758:
jmp @7@1066
@7@786:
;
;
; // Data transfer using INS instruction.
; // Break the transfer into chunks of 32768 or fewer bytes.
;
; while ( wordCnt > 0 )
; {
; bufSeg = (unsigned int) ( bufAddr >> 4 );
;
mov eax,dword ptr [bp-28]
shr eax,4
mov di,ax
;
; bufOff = (unsigned int) ( bufAddr & 0x0000000fL );
;
mov ax,word ptr [bp-28]
and ax,15
mov word ptr [bp+10],ax
;
; if ( wordCnt > 16384L )
;
cmp dword ptr [bp+12],large 16384
jle short @7@842
;
; wc = 16384;
;
mov dword ptr [bp-34],large 16384
jmp short @7@870
@7@842:
;
; else
; wc = wordCnt;
;
mov eax,dword ptr [bp+12]
mov dword ptr [bp-34],eax
@7@870:
;
; if ( pxw == 8 )
;
cmp word ptr [bp-30],8
jne short @7@926
;
; {
; // do REP INS
; pio_rep_inbyte( addrDataReg, bufSeg, bufOff, wc * 2L );
;
mov eax,dword ptr [bp-34]
shl eax,1
push eax
push word ptr [bp+10]
push di
push word ptr [bp+6]
call far ptr _pio_rep_inbyte
add sp,10
;
; }
;
jmp short @7@1038
@7@926:
;
; else
; if ( pxw == 32 )
;
cmp word ptr [bp-30],32
jne short @7@982
;
; {
; // do REP INSD
; pio_rep_indword( addrDataReg, bufSeg, bufOff, wc / 2L );
;
mov eax,dword ptr [bp-34]
mov ebx,large 2
cdq
idiv ebx
push eax
push word ptr [bp+10]
push di
push word ptr [bp+6]
call far ptr _pio_rep_indword
jmp short @7@1010
@7@982:
;
; }
; else
; {
; // do REP INSW
; pio_rep_inword( addrDataReg, bufSeg, bufOff, wc );
;
push dword ptr [bp-34]
push word ptr [bp+10]
push di
push word ptr [bp+6]
call far ptr _pio_rep_inword
@7@1010:
add sp,10
@7@1038:
;
; }
; bufAddr = bufAddr + ( wc * 2 );
;
mov eax,dword ptr [bp-34]
shl eax,1
add eax,dword ptr [bp-28]
mov dword ptr [bp-28],eax
;
; wordCnt = wordCnt - wc;
;
mov eax,dword ptr [bp+12]
sub eax,dword ptr [bp-34]
mov dword ptr [bp+12],eax
@7@1066:
cmp dword ptr [bp+12],large 0
jg @7@786
@7@1094:
;
; }
; }
;
; return;
;
jmp short @7@1122
@7@1122:
;
; }
;
pop di
pop si
leave
ret
_pio_drq_block_in endp
;
; void pio_drq_block_out( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_drq_block_out proc far
enter 34,0
push si
push di
mov di,word ptr [bp+8]
;
; unsigned int bufSeg, unsigned int bufOff,
; long wordCnt )
;
; {
; long bCnt;
; int memDtOpt;
; unsigned int randVal;
; unsigned int dataRegAddr;
; unsigned int far * uip1;
; unsigned int far * uip2;
; unsigned char far * ucp1;
; unsigned char far * ucp2;
; unsigned long bufAddr;
;
; // NOTE: wordCnt is the size of a DRQ data block/packet
; // in words. The maximum value of wordCnt is normally:
; // a) For ATA, 16384 words or 32768 bytes (64 sectors,
; // only with READ/WRITE MULTIPLE commands),
; // b) For ATAPI, 32768 words or 65536 bytes
; // (actually 65535 bytes plus a pad byte).
;
; // normalize bufSeg:bufOff
;
; bufAddr = bufSeg;
;
movzx eax,di
mov dword ptr [bp-28],eax
;
; bufAddr = bufAddr << 4;
;
mov eax,dword ptr [bp-28]
shl eax,4
mov dword ptr [bp-28],eax
;
; bufAddr = bufAddr + bufOff;
;
movzx eax,word ptr [bp+10]
add eax,dword ptr [bp-28]
mov dword ptr [bp-28],eax
;
;
; if ( pio_memory_seg )
;
cmp word ptr DGROUP:_pio_memory_seg,0
je @8@674
;
; {
;
; // PCMCIA Memory mode data transfer.
;
; // set Data reg address per pio_memory_dt_opt
; dataRegAddr = 0x0000;
;
xor si,si
;
; memDtOpt = pio_memory_dt_opt;
;
mov ax,word ptr DGROUP:_pio_memory_dt_opt
mov word ptr [bp-6],ax
;
; if ( pio_memory_dt_opt == PIO_MEMORY_DT_OPTR )
;
cmp word ptr DGROUP:_pio_memory_dt_opt,3
jne short @8@114
;
; {
; randVal = * (unsigned int *) MK_FP( 0x40, 0x6c );
;
mov ax,64
mov es,ax
mov ax,word ptr es:[108]
mov word ptr [bp-8],ax
;
; memDtOpt = randVal % 3;
;
mov ax,word ptr [bp-8]
mov bx,3
xor dx,dx
div bx
mov word ptr [bp-6],dx
@8@114:
;
; }
; if ( memDtOpt == PIO_MEMORY_DT_OPT8 )
;
cmp word ptr [bp-6],1
jne short @8@170
;
; dataRegAddr = 0x0008;
;
mov si,8
@8@170:
;
; if ( memDtOpt == PIO_MEMORY_DT_OPTB )
;
cmp word ptr [bp-6],2
jne short @8@254
;
; {
; dataRegAddr = 0x0400;
;
mov si,1024
;
; if ( pio_memory_dt_opt == PIO_MEMORY_DT_OPTR )
;
cmp word ptr DGROUP:_pio_memory_dt_opt,3
jne short @8@254
;
; dataRegAddr = dataRegAddr | ( randVal & 0x03fe );
;
mov ax,word ptr [bp-8]
and ax,1022
or ax,si
mov si,ax
@8@254:
;
; }
;
; if ( pio_xfer_width == 8 )
;
cmp word ptr DGROUP:_pio_xfer_width,8
jne short @8@450
;
; {
; // PCMCIA Memory mode 8-bit
; bCnt = wordCnt * 2L;
;
mov eax,dword ptr [bp+12]
shl eax,1
mov dword ptr [bp-4],eax
;
; ucp2 = (unsigned char far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-22],ax
mov word ptr [bp-24],si
jmp short @8@394
@8@310:
;
; for ( ; bCnt > 0; bCnt -- )
; {
; bufSeg = (unsigned int) ( bufAddr >> 4 );
;
mov eax,dword ptr [bp-28]
shr eax,4
mov di,ax
;
; bufOff = (unsigned int) ( bufAddr & 0x0000000fL );
;
mov ax,word ptr [bp-28]
and ax,15
mov word ptr [bp+10],ax
;
; ucp1 = (unsigned char far *) MK_FP( bufSeg, bufOff );
;
mov ax,word ptr [bp+10]
mov word ptr [bp-18],di
mov word ptr [bp-20],ax
;
; * ucp2 = * ucp1;
;
les bx,dword ptr [bp-20]
mov al,byte ptr es:[bx]
les bx,dword ptr [bp-24]
mov byte ptr es:[bx],al
;
; bufAddr += 1;
;
inc dword ptr [bp-28]
;
; if ( memDtOpt == PIO_MEMORY_DT_OPTB )
;
cmp word ptr [bp-6],2
jne short @8@366
;
; {
; dataRegAddr += 1;
;
inc si
;
; dataRegAddr = ( dataRegAddr & 0x03ff ) | 0x0400;
;
mov ax,si
and ax,1023
or ax,1024
mov si,ax
;
; ucp2 = (unsigned char far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-22],ax
mov word ptr [bp-24],si
@8@366:
dec dword ptr [bp-4]
@8@394:
cmp dword ptr [bp-4],large 0
jg short @8@310
;
; }
; }
; trc_llt( addrDataReg, 0, TRC_LLT_OUTSB );
;
push 6
jmp short @8@618
@8@450:
;
; }
; else
; {
; // PCMCIA Memory mode 16-bit
; uip2 = (unsigned int far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-14],ax
mov word ptr [bp-16],si
jmp short @8@562
@8@478:
;
; for ( ; wordCnt > 0; wordCnt -- )
; {
; bufSeg = (unsigned int) ( bufAddr >> 4 );
;
mov eax,dword ptr [bp-28]
shr eax,4
mov di,ax
;
; bufOff = (unsigned int) ( bufAddr & 0x0000000fL );
;
mov ax,word ptr [bp-28]
and ax,15
mov word ptr [bp+10],ax
;
; uip1 = (unsigned int far *) MK_FP( bufSeg, bufOff );
;
mov ax,word ptr [bp+10]
mov word ptr [bp-10],di
mov word ptr [bp-12],ax
;
; * uip2 = * uip1;
;
les bx,dword ptr [bp-12]
mov ax,word ptr es:[bx]
les bx,dword ptr [bp-16]
mov word ptr es:[bx],ax
;
; bufAddr += 2;
;
add dword ptr [bp-28],large 2
;
; if ( memDtOpt == PIO_MEMORY_DT_OPTB )
;
cmp word ptr [bp-6],2
jne short @8@534
;
; {
; dataRegAddr = dataRegAddr + 2;
;
lea ax,word ptr [si+2]
mov si,ax
;
; dataRegAddr = ( dataRegAddr & 0x03fe ) | 0x0400;
;
mov ax,si
and ax,1022
or ax,1024
mov si,ax
;
; uip2 = (unsigned int far *) MK_FP( pio_memory_seg, dataRegAddr );
;
mov ax,word ptr DGROUP:_pio_memory_seg
mov word ptr [bp-14],ax
mov word ptr [bp-16],si
@8@534:
dec dword ptr [bp+12]
@8@562:
cmp dword ptr [bp+12],large 0
jg short @8@478
;
; }
; }
; trc_llt( addrDataReg, 0, TRC_LLT_OUTSW );
;
push 8
@8@618:
push 0
push word ptr [bp+6]
call far ptr _trc_llt
add sp,6
;
; }
; }
;
jmp @8@1094
@8@674:
;
; else
; {
; int pxw;
; long wc;
;
; // adjust pio_xfer_width - don’ t use DWORD if wordCnt is odd.
;
; pxw = pio_xfer_width;
;
mov ax,word ptr DGROUP:_pio_xfer_width
mov word ptr [bp-30],ax
;
; if ( ( pxw == 32 ) && ( wordCnt & 0x00000001L ) )
;
cmp word ptr [bp-30],32
jne short @8@758
test byte ptr [bp+12],1
je short @8@758
;
; pxw = 16;
;
mov word ptr [bp-30],16
@8@758:
jmp @8@1066
@8@786:
;
;
; // Data transfer using OUTS instruction.
; // Break the transfer into chunks of 32768 or fewer bytes.
;
; while ( wordCnt > 0 )
; {
; bufOff = (unsigned int) ( bufAddr & 0x0000000fL );
;
mov ax,word ptr [bp-28]
and ax,15
mov word ptr [bp+10],ax
;
; bufSeg = (unsigned int) ( bufAddr >> 4 );
;
mov eax,dword ptr [bp-28]
shr eax,4
mov di,ax
;
; if ( wordCnt > 16384L )
;
cmp dword ptr [bp+12],large 16384
jle short @8@842
;
; wc = 16384;
;
mov dword ptr [bp-34],large 16384
jmp short @8@870
@8@842:
;
; else
; wc = wordCnt;
;
mov eax,dword ptr [bp+12]
mov dword ptr [bp-34],eax
@8@870:
;
; if ( pxw == 8 )
;
cmp word ptr [bp-30],8
jne short @8@926
;
; {
; // do REP OUTS
; pio_rep_outbyte( addrDataReg, bufSeg, bufOff, wc * 2L );
;
mov eax,dword ptr [bp-34]
shl eax,1
push eax
push word ptr [bp+10]
push di
push word ptr [bp+6]
call far ptr _pio_rep_outbyte
add sp,10
;
; }
;
jmp short @8@1038
@8@926:
;
; else
; if ( pxw == 32 )
;
cmp word ptr [bp-30],32
jne short @8@982
;
; {
; // do REP OUTSD
; pio_rep_outdword( addrDataReg, bufSeg, bufOff, wc / 2L );
;
mov eax,dword ptr [bp-34]
mov ebx,large 2
cdq
idiv ebx
push eax
push word ptr [bp+10]
push di
push word ptr [bp+6]
call far ptr _pio_rep_outdword
jmp short @8@1010
@8@982:
;
; }
; else
; {
; // do REP OUTSW
; pio_rep_outword( addrDataReg, bufSeg, bufOff, wc );
;
push dword ptr [bp-34]
push word ptr [bp+10]
push di
push word ptr [bp+6]
call far ptr _pio_rep_outword
@8@1010:
add sp,10
@8@1038:
;
; }
; bufAddr = bufAddr + ( wc * 2 );
;
mov eax,dword ptr [bp-34]
shl eax,1
add eax,dword ptr [bp-28]
mov dword ptr [bp-28],eax
;
; wordCnt = wordCnt - wc;
;
mov eax,dword ptr [bp+12]
sub eax,dword ptr [bp-34]
mov dword ptr [bp+12],eax
@8@1066:
cmp dword ptr [bp+12],large 0
jg @8@786
@8@1094:
;
; }
; }
;
; return;
;
jmp short @8@1122
@8@1122:
;
; }
;
pop di
pop si
leave
ret
_pio_drq_block_out endp
;
; void pio_rep_inbyte( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_rep_inbyte proc far
enter 4,0
push si
push di
mov si,word ptr [bp+6]
;
; unsigned int bufSeg, unsigned int bufOff,
; long byteCnt )
;
; {
; unsigned int dataRegAddr = pio_reg_addrs[ addrDataReg ];
;
mov bx,si
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; unsigned int bCnt = (unsigned int) byteCnt;
;
mov ax,word ptr [bp+12]
mov word ptr [bp-4],ax
;
;
; // Warning: Avoid calling this function with
; // byteCnt > 32768 (transfers 32768 bytes).
; // bufSeg and bufOff should be normalized such
; // that bufOff is a value between 0 and 15 (0xf).
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push cx
;
push cx
;
; asm push dx
;
push dx
;
; asm push di
;
push di
;
; asm push es
;
push es
;
;
; asm mov ax,bufSeg
;
mov ax,[bp+8]
;
; asm mov es,ax
;
mov es,ax
;
; asm mov di,bufOff
;
mov di,[bp+10]
;
;
; asm mov cx,bCnt
;
mov cx,[bp-4]
;
; asm mov dx,dataRegAddr
;
mov dx,[bp-2]
;
;
; asm cld
;
cld
;
;
; asm rep insb
;
rep insb
;
;
; asm pop es
;
pop es
;
; asm pop di
;
pop di
;
; asm pop dx
;
pop dx
;
; asm pop cx
;
pop cx
;
; asm pop ax
;
pop ax
;
;
; trc_llt( addrDataReg, 0, TRC_LLT_INSB );
;
push 5
push 0
push si
call far ptr _trc_llt
add sp,6
;
; }
;
pop di
pop si
leave
ret
_pio_rep_inbyte endp
;
; void pio_rep_outbyte( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_rep_outbyte proc far
enter 4,0
push si
push di
mov di,word ptr [bp+6]
;
; unsigned int bufSeg, unsigned int bufOff,
; long byteCnt )
;
; {
; unsigned int dataRegAddr = pio_reg_addrs[ addrDataReg ];
;
mov bx,di
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; unsigned int bCnt = (unsigned int) byteCnt;
;
mov ax,word ptr [bp+12]
mov word ptr [bp-4],ax
;
;
; // Warning: Avoid calling this function with
; // byteCnt > 32768 (transfers 32768 bytes).
; // bufSeg and bufOff should be normalized such
; // that bufOff is a value between 0 and 15 (0xf).
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push cx
;
push cx
;
; asm push dx
;
push dx
;
; asm push si
;
push si
;
; asm push ds
;
push ds
;
;
; asm mov ax,bufSeg
;
mov ax,[bp+8]
;
; asm mov ds,ax
;
mov ds,ax
;
; asm mov si,bufOff
;
mov si,[bp+10]
;
;
; asm mov cx,bCnt
;
mov cx,[bp-4]
;
; asm mov dx,dataRegAddr
;
mov dx,[bp-2]
;
;
; asm cld
;
cld
;
;
; asm rep outsb
;
rep outsb
;
;
; asm pop ds
;
pop ds
;
; asm pop si
;
pop si
;
; asm pop dx
;
pop dx
;
; asm pop cx
;
pop cx
;
; asm pop ax
;
pop ax
;
;
; trc_llt( addrDataReg, 0, TRC_LLT_OUTSB );
;
push 6
push 0
push di
call far ptr _trc_llt
add sp,6
;
; }
;
pop di
pop si
leave
ret
_pio_rep_outbyte endp
;
; void pio_rep_inword( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_rep_inword proc far
enter 4,0
push si
push di
mov si,word ptr [bp+6]
;
; unsigned int bufSeg, unsigned int bufOff,
; long wordCnt )
;
; {
; unsigned int dataRegAddr = pio_reg_addrs[ addrDataReg ];
;
mov bx,si
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; unsigned int wCnt = (unsigned int) wordCnt;
;
mov ax,word ptr [bp+12]
mov word ptr [bp-4],ax
;
;
; // Warning: Avoid calling this function with
; // wordCnt > 16384 (transfers 32768 bytes).
; // bufSeg and bufOff should be normalized such
; // that bufOff is a value between 0 and 15 (0xf).
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push cx
;
push cx
;
; asm push dx
;
push dx
;
; asm push di
;
push di
;
; asm push es
;
push es
;
;
; asm mov ax,bufSeg
;
mov ax,[bp+8]
;
; asm mov es,ax
;
mov es,ax
;
; asm mov di,bufOff
;
mov di,[bp+10]
;
;
; asm mov cx,wCnt
;
mov cx,[bp-4]
;
; asm mov dx,dataRegAddr
;
mov dx,[bp-2]
;
;
; asm cld
;
cld
;
;
; asm rep insw
;
rep insw
;
;
; asm pop es
;
pop es
;
; asm pop di
;
pop di
;
; asm pop dx
;
pop dx
;
; asm pop cx
;
pop cx
;
; asm pop ax
;
pop ax
;
;
; trc_llt( addrDataReg, 0, TRC_LLT_INSW );
;
push 7
push 0
push si
call far ptr _trc_llt
add sp,6
;
; }
;
pop di
pop si
leave
ret
_pio_rep_inword endp
;
; void pio_rep_outword( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_rep_outword proc far
enter 4,0
push si
push di
mov di,word ptr [bp+6]
;
; unsigned int bufSeg, unsigned int bufOff,
; long wordCnt )
;
; {
; unsigned int dataRegAddr = pio_reg_addrs[ addrDataReg ];
;
mov bx,di
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; unsigned int wCnt = (unsigned int) wordCnt;
;
mov ax,word ptr [bp+12]
mov word ptr [bp-4],ax
;
;
; // Warning: Avoid calling this function with
; // wordCnt > 16384 (transfers 32768 bytes).
; // bufSeg and bufOff should be normalized such
; // that bufOff is a value between 0 and 15 (0xf).
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push cx
;
push cx
;
; asm push dx
;
push dx
;
; asm push si
;
push si
;
; asm push ds
;
push ds
;
;
; asm mov ax,bufSeg
;
mov ax,[bp+8]
;
; asm mov ds,ax
;
mov ds,ax
;
; asm mov si,bufOff
;
mov si,[bp+10]
;
;
; asm mov cx,wCnt
;
mov cx,[bp-4]
;
; asm mov dx,dataRegAddr
;
mov dx,[bp-2]
;
;
; asm cld
;
cld
;
;
; asm rep outsw
;
rep outsw
;
;
; asm pop ds
;
pop ds
;
; asm pop si
;
pop si
;
; asm pop dx
;
pop dx
;
; asm pop cx
;
pop cx
;
; asm pop ax
;
pop ax
;
;
; trc_llt( addrDataReg, 0, TRC_LLT_OUTSW );
;
push 8
push 0
push di
call far ptr _trc_llt
add sp,6
;
; }
;
pop di
pop si
leave
ret
_pio_rep_outword endp
;
; void pio_rep_indword( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_rep_indword proc far
enter 4,0
push si
push di
mov si,word ptr [bp+6]
;
; unsigned int bufSeg, unsigned int bufOff,
; long dwordCnt )
;
; {
; unsigned int dataRegAddr = pio_reg_addrs[ addrDataReg ];
;
mov bx,si
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; unsigned int dwCnt = (unsigned int) dwordCnt;
;
mov ax,word ptr [bp+12]
mov word ptr [bp-4],ax
;
;
; // Warning: Avoid calling this function with
; // dwordCnt > 8192 (transfers 32768 bytes).
; // bufSeg and bufOff should be normalized such
; // that bufOff is a value between 0 and 15 (0xf).
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push cx
;
push cx
;
; asm push dx
;
push dx
;
; asm push di
;
push di
;
; asm push es
;
push es
;
;
; asm mov ax,bufSeg
;
mov ax,[bp+8]
;
; asm mov es,ax
;
mov es,ax
;
; asm mov di,bufOff
;
mov di,[bp+10]
;
;
; asm mov cx,dwCnt
;
mov cx,[bp-4]
;
; asm mov dx,dataRegAddr
;
mov dx,[bp-2]
;
;
; asm cld
;
cld
;
;
; asm rep insd
;
rep insd
;
;
; asm pop es
;
pop es
;
; asm pop di
;
pop di
;
; asm pop dx
;
pop dx
;
; asm pop cx
;
pop cx
;
; asm pop ax
;
pop ax
;
;
; trc_llt( addrDataReg, 0, TRC_LLT_INSD );
;
push 9
push 0
push si
call far ptr _trc_llt
add sp,6
;
; }
;
pop di
pop si
leave
ret
_pio_rep_indword endp
;
; void pio_rep_outdword( unsigned int addrDataReg,
;
assume cs:ATAIOPIO_TEXT,ds:DGROUP
_pio_rep_outdword proc far
enter 4,0
push si
push di
mov di,word ptr [bp+6]
;
; unsigned int bufSeg, unsigned int bufOff,
; long dwordCnt )
;
; {
; unsigned int dataRegAddr = pio_reg_addrs[ addrDataReg ];
;
mov bx,di
add bx,bx
mov ax,word ptr DGROUP:_pio_reg_addrs[bx]
mov word ptr [bp-2],ax
;
; unsigned int dwCnt = (unsigned int) dwordCnt;
;
mov ax,word ptr [bp+12]
mov word ptr [bp-4],ax
;
;
; // Warning: Avoid calling this function with
; // dwordCnt > 8192 (transfers 32768 bytes).
; // bufSeg and bufOff should be normalized such
; // that bufOff is a value between 0 and 15 (0xf).
;
; asm .386
;
.386
;
;
; asm push ax
;
push ax
;
; asm push cx
;
push cx
;
; asm push dx
;
push dx
;
; asm push si
;
push si
;
; asm push ds
;
push ds
;
;
; asm mov ax,bufSeg
;
mov ax,[bp+8]
;
; asm mov ds,ax
;
mov ds,ax
;
; asm mov si,bufOff
;
mov si,[bp+10]
;
;
; asm mov cx,dwCnt
;
mov cx,[bp-4]
;
; asm mov dx,dataRegAddr
;
mov dx,[bp-2]
;
;
; asm cld
;
cld
;
;
; asm rep outsd
;
rep outsd
;
;
; asm pop ds
;
pop ds
;
; asm pop si
;
pop si
;
; asm pop dx
;
pop dx
;
; asm pop cx
;
pop cx
;
; asm pop ax
;
pop ax
;
;
; trc_llt( addrDataReg, 0, TRC_LLT_OUTSD );
;
push 10
push 0
push di
call far ptr _trc_llt
add sp,6
;
; }
;
pop di
pop si
leave
ret
_pio_rep_outdword endp
ATAIOPIO_TEXT ends
_BSS segment word public use16 ’ BSS’
_pio_reg_addrs label word
db 20 dup (?)
_pio_last_write label byte
db 10 dup (?)
_pio_last_read label byte
db 10 dup (?)
?debug C E9
?debug C FA00000000
_BSS ends
_DATA segment word public use16 ’ DATA’
s@ label byte
_DATA ends
ATAIOPIO_TEXT segment byte public use16 ’ CODE’
ATAIOPIO_TEXT ends
_s@ equ s@
public _pio_base_addr1
public _pio_base_addr2
public _pio_memory_seg
public _pio_memory_dt_opt
public _pio_bmcr_base_addr
public _pio_reg_addrs
public _pio_last_write
public _pio_last_read
public _pio_xfer_width
public _pio_set_iobase_addr
public _pio_set_memory_addr
public _pio_inbyte
public _pio_outbyte
public _pio_inword
public _pio_outword
public _pio_drq_block_in
public _pio_drq_block_out
public _pio_rep_inbyte
public _pio_rep_outbyte
public _pio_rep_inword
public _pio_rep_outword
public _pio_rep_indword
public _pio_rep_outdword
extrn _trc_llt:far
end