windows-xp/Source/XPSP1/NT/base/mvdm/wow16/drivers/comm/ibmsetup.asm

page,132
;---------------------------Module-Header-------------------------------;
; Module Name: IBMSETUP.ASM
;
; Copyright (c) Microsoft Corporation 1985-1990.  All Rights Reserved.
;
; General Description:
;
; History:
;   sudeepb 10-Jan-1993 changed the costly cli/sti with non-trapping
;           FCLI/FSTI macros
;
;-----------------------------------------------------------------------;

title   IBMSetup - IBM PC, PC-XT, PC-AT, PS/2 Communications Interface

.xlist
include cmacros.inc
include comdev.inc
include ins8250.inc
include ibmcom.inc
include BIMODINT.INC
include vint.inc
.list


EBIS_Sel1   equ SIZE Bimodal_Int_Struc
EBIS_Sel2   equ EBIS_Sel1 + (SIZE EBIS_Sel_Struc)

externA  __WinFlags

externFP GetSystemMsecCount
externFP CreateSystemTimer
externFP AllocCStoDSAlias
externFP LockSegment
externFP UnlockSegment
externFP FreeSelector
externFP GetSelectorBase
externFP GetModuleHandle
externFP GetProcAddress
externFP GetPrivateProfileInt
externFP GetPrivateProfileString
externFP GetAppCompatFlags
externFP WowCloseComPort

externNP $RECCOM

externA  __0040H
externA  __F000h

externB  IRQhooks

IF 0
externD  OldIntVecIntB
externD  OldIntVecIntC
externD  OurIntVecIntB
externD  OurIntVecIntC
ENDIF

externB  szMessage
externB  pLPTByte
externB  szCOMMessage
externB  pCOMByte
externB  _szTitle


MULTIPLEX   equ       2Fh       ; multiplex interrupt number
GET386API   equ     1684h       ; Get API entry point from VxD
VPD     equ     000Fh       ; device ID of VPD device
VPD_GETPORT equ     0004h       ; function: assign port to current VM
VPD_RELPORT equ     0005h       ; function: release port
VCD     equ     000Eh       ; device ID of VCD device
VCD_GETVER  equ     0000h       ; get version API
VCD_GETPORT equ     0004h       ; function: assign port to current VM
VCD_RELPORT equ     0005h       ; function: release port
VCD_STEALPORT equ   0006h
VPICD       equ     0003h       ; device ID of VPICD device

POSTMESSAGE equ     110         ; export ordinal of PostMessage()
MESSAGEBOX  equ     1           ; export ordinal of MessageBox()
MB_TASKMODAL equ    2000h
MB_YESNO    equ     0004h       ; messagebox flags
MB_ICONEXCLAMATION equ 0030h
IDYES       equ     6


createSeg _INTERRUPT,IntCode,word,public,CODE
sBegin IntCode
assumes cs,IntCode

    externFP FakeCOMIntFar
    externFP TimerProc
    externFP Control
    externFP COMHandler
    externFP APIHandler
IFDEF No_DOSX_Bimodal_Services
    externW  RM_IntDataSeg
    externFP RM_APIHandler
    externFP Entry_From_RM
    externD  RM_CallBack
ENDIF

sEnd IntCode

page
sBegin   Data

externB lpCommBase
externB CommBaseX
externB lpCommIrq
externB CommIrqX
externB lpCommFifo
externB CommFifoX
externB lpCommDSR
externB CommDSRx

externB lpCommSection
externB lpSYSTEMINI


;------------------------------------------------------------------------------
;
; Reserve data space for COM ports
;
DefineCommX MACRO num
    public  Comm&num
Comm&num label byte
    db  num-1
.errnz  DCB_Id
    db  ((DCBSize+1) AND 0FFFEh)-1 DUP (0)  ; ComDCB
    dw  0                   ; ComErr
    dw  0                   ; Port
    dw  0                   ; NotifyHandle
    dw  0                   ; NotifyFlags
    dw  -1                  ; RecvTrigger
    dw  0                   ; SendTrigger
.errnz IRQhook - SendTrigger - 2
    db  (SIZE ComDEB) - IRQhook DUP(0)
.errnz $ - Comm&num - (SIZE ComDEB)
    Declare_PM_BIS 0,Control,COMHandler,APIHandler,_INTERRUPT,_DATA
    db     (SIZE EBIS_Sel_Struc) * 2 DUP(0)    ; res space for 2 selectors
ENDM
DW_OFFSET_CommX MACRO num
    dw  DataOFFSET Comm&num
ENDM


??portnum = 1
REPT MAXCOM+1
    DefineCommX %??portnum
??portnum = ??portnum+1
ENDM

PUBLIC  COMptrs         ; table of offsets to CommX's declared above
COMptrs label   word
??portnum = 1
REPT MAXCOM+1
    DW_OFFSET_CommX %??portnum
??portnum = ??portnum+1
ENDM

PURGE   DefineCommX
PURGE   DW_OFFSET_CommX

;------------------------------------------------------------------------------
;
; Reserve data space for LPT ports
;
DefineLPTx MACRO num
    public  LPT&num
LPT&num label byte
    db  num-1+LPTx
.errnz  DCB_Id
    db  ((DCBSize+1) AND 0FFFEh)-1 DUP (0)  ; xComDCB
    dw  0                   ; xComErr
    dw  0                   ; xPort
    dw  0                   ; xNotifyHandle
    dw  0                   ; xNotifyFlags
    dw  -1                  ; xRecvTrigger
    dw  0                   ; xSendTrigger
IF num LE 3
    dw  LPTB + (num-1)*2
ELSE
    dw  0                   ; BIOSPortLoc
ENDIF
    .errnz $-LPT&num - SIZE LptDEB
ENDM

??portnum = 1
REPT MAXLPT+1
    DefineLPTx %??portnum
??portnum = ??portnum+1
ENDM

PURGE   DefineLPTx

page

PUBLIC  $MachineID, Using_DPMI
$MachineID    db 0      ;IBM Machine ID
Using_DPMI    db 0      ; 0FFh, if TRUE

    ALIGN 2

PUBLIC  activeCOMs
activeCOMs    dw 0

PUBLIC  lpPostMessage, lpfnMessageBox, lpfnVPD, fVPD

lpPostMessage     dd 0
lpfnMessageBox    dd 0

lpfnVPD       dd 0      ; far pointer to win 386 VPD entry point
lpfnVCD       dd 0      ; far pointer to win 386 VCD entry point
lpfnVPICD     dd 0      ; far pointer to win 386 VPICD entry point
PUBLIC VCD_int_callback
VCD_int_callback  df 0      ; VCD returns the address for this callback
                ;   on every call to acquire a COM port, but
                ;   it is always the same address, so we will
                ;   just maintain it globally.
fVPD          db 0      ; 0-not checked, 1 vpd present, -1 no vpd
fVCD          db 0      ; 0-not checked, 1 vcd present, -1 no vcd
fVPICD        db 0      ; 0-not checked, 1 vpicd present, -1 no vpicd

szUser      db 'USER',0


default_table db  4, 3, 4, 3, 0 ; Default IRQ's (COM3 default is changed to
                ;   3 for PS/2's during LoadLib)


IFDEF No_DOSX_Bimodal_Services
RM_Call_Struc   Real_Mode_Call_Struc <>
ENDIF

IFDEF DEBUG_TimeOut
%OUT including code to display MsgBox, if closing comm with data in buffer
szSendTO    db 'TimedOut CloseComm with data in buffer.  Retry?', 0
ENDIF


sEnd Data

ROMBios           segment  at 0F000h
                  org         0FFFEh

MachineID label byte
RomBios Ends


sBegin Code
assumes cs,Code
assumes ds,Data

page

IFDEF No_DOSX_Bimodal_Services
;----------------------------Private-Routine----------------------------;
; SegmentFromSelector
;
;   Converts a selector to a segment...note that this routine assumes
;   the memory pointed to by the selector is below the 1Meg line!
;
; Params:
;   AX = selector to convert to segment
;
; Returns:
;   AX = segment of selector given
;
; Error Returns:
;   None
;
; Registers Destroyed:
;   CX
;
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public SegmentFromSelector
SegmentFromSelector proc far

.286
    push    dx
    cCall   GetSelectorBase,<ax>    ;DX:AX = segment of selector
    shr ax, 4
    shl dl, 4
    or  ah, dl          ;AX now points to interrupt *segment*
    pop dx
    ret
.8086

SegmentFromSelector endp
ENDIF
page

;------------------------------------------------------------------------------
;
;   Get_API_Entry
;
;   entry - BX = device id
;       DS:DI -> DWORD for proc address
;   exit - Z flag set, if failed
;
Get_API_Entry proc near

    push    di
    xor di, di
    mov es, di
    mov ax, GET386API
    int MULTIPLEX
    mov ax, di
    pop di
    mov [di], ax
    mov [di+2], es
    or  ax, [di+2]
    ret

Get_API_Entry endp

;----------------------------Private-Routine----------------------------;
;
;   Contention_Dlg
;
;   If running under Win386, this routine can be called to ask the user to
;   resolve contention for a COM or LPT port.
;
;   entry - CX is offset of message string for dialog box
;
;   exit  - Z flag set, if user specified that Windows should steal the port

Contention_Dlg proc near
PUBLIC Contention_Dlg

    xor ax,ax
    push    ax          ; hwndOwner
    push    ds
    push    cx          ; message ptr

    cmp wo lpfnMessageBox[2], 0 ;Q: ptr to MessageBox proc valid?
    jne short gmbp_done     ;   Y: we can call it
    push    ds          ;   N: get module handle of USER
    lea ax, szUser
    push    ax
    cCall   GetModuleHandle

    push    ax          ; module handle
    mov ax, MESSAGEBOX
    cwd
    push    dx
    push    ax
    cCall   GetProcAddress
    mov wo lpfnMessageBox[0], ax  ; save received proc address
    mov wo lpfnMessageBox[2], dx
gmbp_done:

    push    ds
    lea ax, _szTitle
    push    ax
    mov ax, MB_ICONEXCLAMATION or MB_YESNO or MB_TASKMODAL
    push    ax
    cCall   lpfnMessageBox
    cmp ax, IDYES       ; user allows us to take the port?
    ret
Contention_Dlg endp


;----------------------------Private-Routine----------------------------;
;
;   GetPort386
;
;   If running under Win386, tell the VPD to assign an LPT port to us.
;   The comm driver will handle contention.
;
;   entry - DI contains offset in ROM area of port...
;       8 - LPT1, A - LPT2, etc
;
;   exit  - registers saved, carry = clear if OK to proceed, set if
;       user won't allow assignment of port or Win386 error
;

GetPort386  proc near
public GetPort386

    cmp fVPD, 0
    jl  getport_VPDNotInstalled
    jnz short getport_CallVPD

    push    di
    mov bx, VPD
    mov di, DataOFFSET lpfnVPD
    call    Get_API_Entry
    pop di
    jnz short getport_CallVPD
    mov fVPD, -1

getport_VPDNotInstalled:
    clc
    jmp short getport_exit

getport_CallVPD:
    mov fVPD, 1
    push    di
    sub di, LPTB
    shr di, 1           ; turn DI into port number

    xor ax, ax
    mov dx, VPD_GETPORT
    mov cx, di
    call    [lpfnVPD]
    jnc getport_gotit

;   port owned by another VM... ask the user for it

    add cl, '1'         ; fix up the port name...
    mov pLPTByte, cl        ; HACK HACK HACK
    lea cx, szMessage
    call    Contention_Dlg
    jnz getport_userwontallow

    mov ax, 1           ; tell win386 we really do want it
    mov cx, di          ;
    mov dx, VPD_GETPORT     ;
    call    [lpfnVPD]       ; return with C set or clear...
    jmp short getport_gotit

getport_userwontallow:
    stc

getport_gotit:
    pop di

getport_exit:
    ret

GetPort386  endp

;----------------------------Private-Routine----------------------------;
;
;   ReleasePort386
;
;   If running under Win386, tell the VPD to deassign an LPT port.
;
;   entry - DS:SI -> COMDEB
;

ReleasePort386  proc near

    cmp fVPD, 1
    jne release_noVPD

    xor cx, cx
    mov cl, [si.DCB_id]
    and cl, NOT LPTx        ; clear high bit
    mov dx, VPD_RELPORT
    call    [lpfnVPD]

release_noVPD:
    ret

ReleasePort386  endp


;----------------------------Private-Routine----------------------------;
;
;   GetCOMport386
;
;   If running under Win386, tell the VCD to assign a COM port to us.
;   The comm driver will handle contention.
;
;   entry - DS:SI -> COMDEB
;
;   exit  - registers saved, carry = clear if OK to proceed, set if
;       user won't allow assignment of port or Win386 error
;
.386
GetCOMport386 proc near
public GetCOMport386

    push    es
    pushad
    cmp fVCD, 0
    jl  short getcomport_VCDNotInstalled
    jnz short getcomport_CallVCD

    mov bx, VCD
    mov di, DataOFFSET lpfnVCD
    call    Get_API_Entry
    jz  short getcomport_checknoVCD

    mov dx, VCD_GETVER
    call    [lpfnVCD]
    cmp ax, 30Ah            ;Q: 3.1 or greater?
    jae short getcomport_CallVCD    ;   Y:

getcomport_checknoVCD:
    mov fVCD, -1

getcomport_VCDNotInstalled:
    clc
    jmp short getcomport_exit

getcomport_CallVCD:
    mov fVCD, 1

    mov ax, 10b         ; flag ring0 int handler
    call    VCD_GetPort_API
    jnc short getcomport_success  ; jump if acquire worked
    jnz short getcomport_noport   ; jump if port doesn't exist

;   port owned by another VM... ask the user for it

    mov cl, [si.DCB_id]
    add cl, '1'         ; fix up the port name...
    mov pCOMByte, cl
    lea cx, szCOMMessage
    call    Contention_Dlg
    stc
    jnz short getcomport_exit

    mov ax, 11b         ; tell win386 we really do want it
    call    VCD_GetPort_API
    jc  short getcomport_exit

getcomport_success:
    mov dword ptr [VCD_int_callback], edi
    mov word ptr [VCD_int_callback+4], cx
    mov [si.VCD_data], ebx
    xchg    ax, [si.Port]
    or  ax, ax          ;Q: already had port base?
    jnz short getcomport_exit ; Y: don't update vector #, or FIFO
    mov [si.IntVecNum], dl
    call    GetPortFlags
    clc

getcomport_exit:
    popad
    pop es
    ret

getcomport_noport:
    mov [si.Port], -1
    jmp getcomport_exit

GetCOMport386 endp

VCD_GetPort_API proc near
    mov dx, VCD_GETPORT
    xor cx, cx
    mov cl, [si.DCB_Id]     ; cx = port #
    mov di, VCDflags        ; offset from start of DEB
    call    [lpfnVCD]
    ret
VCD_GetPort_API endp
.8086

;----------------------------Private-Routine----------------------------;
;
;   ReleaseCOMport386
;
;   If running under Win386, tell the VCD to deassign a COM port.
;
;   entry - DS:SI -> COMDEB
;

ReleaseCOMport386  proc near

ifndef WOW
    cmp fVCD, 1
    jne release_noVCD

    xor cx, cx
    mov cl, [si.DCB_id]
    mov dx, VCD_RELPORT
    call    [lpfnVCD]
else
    xor cx, cx
    mov cl, [si.DCB_id]
    push cx
    call WowCloseComPort
endif

release_noVCD:
    ret

ReleaseCOMport386  endp

PUBLIC StealPort
StealPort proc near

    cmp fVCD, 1
    jne sp_yes
    mov dx, VCD_STEALPORT
    xor cx, cx
    mov cl, [si.DCB_id]
    call    [lpfnVCD]
    or  al, al
    jnz sp_yes

sp_no:
    stc
    ret

sp_yes:
    clc
    mov [si.VCDflags], 0
    ret

StealPort endp

page

;------------------------------------------------------------------------------
;
;   ENTER:  DS:SI -> ComDEB
;   EXIT:   AL = 0, if IRQ was unmasked, else -1, if IRQ was already masked
;
MaskIRQ proc near
    push    es
    push    di
    mov di, ds
    mov es, di
    lea di, [si+SIZE ComDEB]
    mov ax, BIH_API_Get_Mask
    call    APIHandler      ; returns Carry Set, if masked
    jc  short already_masked
    pushf
    mov ax, BIH_API_Mask
    call    APIHandler      ; mask IRQ
    xor ax, ax
    popf
    jnc short mask_exit
already_masked:
    or  al, -1
mask_exit:
    pop di
    pop es
    ret
MaskIRQ endp

;------------------------------------------------------------------------------
;
;   ENTER:  DS:SI -> ComDEB
;
UnmaskIRQ proc near
    push    es
    push    di
    mov di, ds
    mov es, di
    lea di, [si+SIZE ComDEB]
    mov ax, BIH_API_Unmask
    call    APIHandler
    pop di
    pop es
    ret
UnmaskIRQ endp
page

;----------------------------Public Routine-----------------------------;
;
; $INICOM - Initialize A Port
;
; Initalizes the requested port if present, and sets
; up the port with the given attributes when they are valid.
; This routine also initializes communications buffer control
; variables.  This routine is passed the address of a device
; control block.
;
; The RLSD, CTS, and DSR signals should be ignored by all COM
; routines if the corresponding timeout values are 0.
;
; For the LPT ports, a check is performed to see if the hardware
; is present (via the LPT port addresses based at 40:8h.  If the
; port is unavailable, an error is returned.  If the port is
; available, then the DEB is set up for the port.  $SETCOM will
; be called to set up the DEB so that there will be something
; valid to pass back to the caller when he inquires the DEB.
;
; No hardware initialization will be performed to prevent the
; RESET line from being asserted and resetting the printer every
; time this routine is called.
;
; Entry:
;   EX:BX --> Device Control Block with all fields set.
; Returns:
;   AX = 0 if no errors occured
; Error Returns:
;   AX = initialization error code otherwise
; Registers Preserved:
;   None
; Registers Destroyed:
;   AX,BX,CX,DX,ES,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public  $INICOM
$INICOM  proc  near
    push    si          ;As usual, save register variables
    push    di
    mov ah,es:[bx.DCB_Id]   ;Get device i.d.
    call    GetDEB          ;--> DEB for this device
    mov ax, IE_BADID        ; call it a bad id (spooler uses DOS)
    jc  InitCom15       ;Invalid device
    jns InitCom20       ; jmp if COM port

    push    ds

    mov di, [si.BIOSPortLoc]
    cmp di, LPTB
    jb  short InitLPT_Installed

    mov cx,__0040H      ;[rkh] ...
    mov ds,cx           ;Point DS: at ROM Save Area.
    assumes ds,nothing

    mov ax, IE_HARDWARE
    mov cx, wo [di]
    jcxz    InitCom10       ; if zero, no hardware

    mov ax,IE_BadID     ;Show bad device
    cmp ch, 0           ; zero hibyte -> not valid (redir)
    jz  InitCom10       ;   call it a bad id (spooler uses DOS)

    cmp di, LPTB        ; LPT1?
    jz  InitLPT_Installed   ; yes, must be installed

    cmp cx, wo [di-2]       ;Q: duplicate of previous port
    je  InitCom10       ;   Y: (redirected port)

InitLPT_Installed:
    pop ds
    mov [si.Port], cx
    call    $SETCOM
    call    GetPort386      ; tell win386 we're using the port
    mov ax, IE_OPEN     ; port already open (by another VM)
    jc  InitCom15       ;   error
    jmp InitCom90       ;That's all

InitCom10:
    pop ds          ; get DS back
InitCom15:
    jmp InitCom100


    assumes ds,Data
InitCom17:
    mov ax, IE_OPEN
    cmp [si.Port], -1       ;Q: determined that port didn't exist?
    jne InitCom15       ;   N: return IE_OPEN
    jmp short InitCom27     ;   Y: return IE_HARDWARE

; ***  Set up serial port ***
;
InitCom20:
    cmp [si.Port], -1       ;Q: port exists?
    je  InitCom27       ;   N: report not found

    mov ax, __WinFlags
    test    ax, WF_ENHANCED
    jz  short @F
    call    GetCOMport386
    jc  InitCom17

@@:
    cmp [si.Port], 0        ;Q: already got info?
    jnz @F
    call    FindCOMPort
    jc  InitCom27       ; report not found, if error
    mov [si.Port], ax
    mov [si.IntVecNum], dl
@@:

    push    es          ;Save these registers
    push    di
    push    cx          ;needed later for $SETCOM etc
    push    bx

    mov al, [si.IntVecNum]
    xor ah, ah
    lea di, [si+SIZE ComDEB]
    mov [di.BIS_IRQ_Number], ax

    mov di, DataOFFSET IRQhooks
    mov cx, MAXCOM+1
InitCom25:
    cmp al, [di.IRQn]       ;Q: hooked IRQ matches ours?
    je  short InitCom30     ;   Y:
    cmp [di.IRQn], 0        ;Q: end of hooked IRQ list?
    je  short InitCom35     ;   Y:
    add di, SIZE IRQ_Hook_Struc ;   N: check next hook
    loop    InitCom25
    int 3               ; data structures corrupt if we
                    ; get here, because no hook table
                    ; entries exist and there is suppose
                    ; to be at least 1 for each DEB
InitCom26:
    call    ReleaseCOMport386   ; give port back to 386...
    pop bx
    pop cx
    pop di
    pop es

InitCom27:
    mov ax, IE_HARDWARE     ; jump if port not available
    jmp InitCom100

InitCom30:
    cmp [di.HookCnt], 0     ;Q: IRQ still hooked?
    je  short InitCom35     ;   N: rehook
    inc [di.HookCnt]        ;   Y: inc hook count
    mov [si.IRQhook], di    ;   & link DEB into list
    mov ax, [di.First_DEB]
    mov [si.NextDEB], ax
    mov [di.First_DEB], si
    jmp short InitCom40

InitCom35:
    mov [di.IRQn], al       ; hook IRQ for first time, or rehook
    mov [si.IRQhook], di
    mov [di.First_DEB], si
    mov [di.HookCnt], 1
    call    MaskIRQ
    mov [di.OldMask], al

InitCom40:              ; di -> IRQ_Hook_Struc

    cmp [fVPICD], 0     ;Q: VPICD bimodel services available?
    jl  short InitCom415    ;   N:
    mov ax, ds          ;   Y: use them
    mov es, ax
    lea di, [si+SIZE ComDEB]

    mov [di.BIS_Descriptor_Count], 2
    mov ax, word ptr [si.QInAddr+2]  ; get selector of in queue
    mov [di.EBIS_Sel1.EBIS_User_Mode_Sel], ax
    mov ax, word ptr [si.QOutAddr+2] ; get selector of out queue
    mov [di.EBIS_Sel2.EBIS_User_Mode_Sel], ax

    mov ax, VPICD_Install_Handler
    call    [lpfnVPICD]
    jnc InitCom42
    cmp [di.OldMask], 0
    jne InitCom26
    call    UnmaskIRQ
    jmp InitCom26

InitCom42:
;
; save newly allocated selectors/segments into "Alt" queue pointers
;
    mov ax, [di.EBIS_Sel1.EBIS_Super_Mode_Sel]
    mov word ptr [si.AltQInAddr+2], ax
    mov ax, [di.EBIS_Sel2.EBIS_Super_Mode_Sel]
    mov word ptr [si.AltQOutAddr+2], ax

InitCom414:
    jmp InitCom59

InitCom415:
    cmp [di.VecN], 0FFh     ;Q: int already hooked?
IFDEF No_DOSX_Bimodal_Services
    jnz short InitCom52     ;   Y: init RMode ptrs in BIS
ELSE
    jnz InitCom414      ;   Y:
ENDIF
    mov al, [si.IntVecNum]
    add al, 8           ; 1st PIC starts at vector 8h
    cmp al, 16          ;Q: 2nd PIC?
    jb  short InitCom418    ;   N:
    add al, 70h-16      ;   Y: 2nd PIC starts at vector 70h
InitCom418:
    mov [di.VecN], al

; *** Set interrupt vectors ***
;
    mov ah,35h          ;Get the DOS vector
    int 21h         ;DOS Get Vector Function
    mov wo [di.OldIntVec][0], bx
    mov wo [di.OldIntVec][2], es

InitCom50:
    push    ds          ;Save original DS
    mov dx, [di.HandlerOff]
    mov bx, _INTERRUPT
    mov ds, bx          ;Interrupt handler address in ds:dx
    assumes ds,nothing
    mov ah, 25h         ;DOS Set Vector Function
    int 21h         ;Set the DOS vector
    pop ds          ;Original DS
    assumes ds,Data

IFDEF No_DOSX_Bimodal_Services
InitCom52:
    cmp [Using_DPMI], 0
    jz  short InitCom57

    mov ax, Int31_Get_Version SHL 8
    int 31h
    mov bl, [si.IntVecNum]
    mov bh, bl
    add bl, dh          ; assume master PIC
    sub bh, 8           ;Q: IRQ in master?
    jb  @f          ;   Y: add master's base vec
    add bh, dl          ;   N: add slave's base vec
    mov bl, bh
@@:
    mov ax, Get_RM_IntVector
    int 31h
    mov wo [di.RM_OldIntVec][0], dx
    mov wo [di.RM_OldIntVec][2], cx

    mov dx, [di.RM_HandlerOff]
    mov ax, _INTERRUPT
    call    SegmentFromSelector
    mov cx, ax
    push    cx
    mov ax, Set_RM_IntVector
    int 31h

    lea di, [si+SIZE ComDEB]
    mov wo [di.BIS_Super_Mode_API], IntCodeOFFSET RM_APIHandler
    pop cx
    mov wo [di.BIS_Super_Mode_API+2], cx

;
; Get segment addresses for the Q's and set AltQInAddr and AltQOutAddr
;
    mov ax, wo [si.AltQInAddr+2]
    call    SegmentFromSelector
    mov wo [si.AltQInAddr+2], ax
    mov ax, wo [si.AltQOutAddr+2]
    call    SegmentFromSelector
    mov wo [si.AltQOutAddr+2], ax
InitCom57:
ENDIF
    mov ax, __WinFlags      ;In Standard mode, the PIC IRQ
    test    al, WF_STANDARD     ;  priorities get rotated to favor
    jz  InitCom59       ;  the comm ports.

    call    Rotate_PIC

; *** Interrupt handler set : jump here if handler is already installed ***
;
InitCom59:
    pop bx
    pop cx
    pop di
    pop es

InitCom60:
    mov dx,[si.Port]        ;Set comm card address
    xor ax,ax           ;Need a zero
    inc dx          ;--> Interrupt Enable Register
    .errnz ACE_IER-ACE_RBR-1
    out dx,al           ;Turn off interrupts
    call    FlagNotActive
    add dl,ACE_MCR-ACE_IER  ;--> Modem Control Register
    in  al,dx
    and al,ACE_DTR+ACE_RTS  ;Leave DTR, RTS high if already so
    iodelay             ;  but tri-state IRQ line
    out dx,al

InitCom70:
    push    es          ;Zero queue counts and indexes

    push    ds
    pop es
    assumes es,Data

    lea di,QInCount[si]
    mov cx,(EFlags-QInCount)/2
    .errnz (EFlags-QInCount) AND 1
    xor ax,ax
    cld
    rep stosw

    .errnz  QInGet-QInCount-2
    .errnz  QInPut-QInGet-2
    .errnz  QOutCount-QInPut-2
    .errnz  QOutGet-QOutCount-2
    .errnz  QOutPut-QOutGet-2
    .errnz  EFlags-QOutPut-2    ;First non-queue item

    pop es
    assumes es,nothing

    mov HSFlag[si],al       ;Show no handshakes yet
    mov MiscFlags[si],al    ;Show not discarding
    mov EvtWord[si],ax      ;Show no events
    mov [si.VCDflags], al

    mov [si.SendTrigger], ax
    dec ax
    mov [si.RecvTrigger], ax

;Call $SETCOM to perform further hardware initialization.

InitCom80:
    sub dl,ACE_MCR-ACE_FCR  ; dx -> FCR
    in  al, dx
    iodelay
    test    al, ACE_FIFO_E2         ;Q: FIFO already on?
    jz  short @F            ;   N:
    or  EFlags[si], fFIFOpre        ;   Y: flag it
@@:

    ; needs si, di, and es to be saved from the beginning of inicom
    call    $SETCOM         ;Set up Comm Device
    jnz short InitCom110    ;jump if failed

    call    UnmaskIRQ
    and EFlags[si], fEFlagsMask ;Clear internal state

InitCom90:
    xor ax,ax           ;Return AX = 0 to show success
    mov ComErr[si],ax       ;Get rid of any bogus init error

InitCom100:
    pop di
    pop si
    ret

;
; jump to here, if call to $SETCOM failed
;
; DANGER! *** Call into middle of Terminate to clean things up *** DANGER!
;
InitCom110:
    push    ax          ;Failure, save error code
    call    Terminate45     ;Restore port address, int vec
    pop ax          ;Restore error code and exit
    jmp InitCom100

$INICOM endp
page

;----------------------------Public Routine-----------------------------;
;
; $TRMCOM - Terminate Communications Channel
;
; Wait for any outbound data to be transmitted, drop the hardware
; handshaking lines, and disable interrupts.  If the output queue
; contained data when it was closed, an error will be returned
;
; LPT devices have it easy.  They just need to restore the I/O port
; address.
;
; Entry:
;   AH = Device ID
; Returns:
;   AX = 0
; Error Returns:
;   AX = 8000h if invalid device ID
;   AX = -2 if output queue timeout occured
; Registers Destroyed:
;   AX,BX,CX,DX,ES,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public   $TRMCOM
$TRMCOM  proc   near

    push    si
    push    di
    xor cx,cx           ;Show no error if LPT port
    call    GetDEB
    jc  TermCom60       ;ID is invalid, return error
    js  TermCom30       ;Port is a LPT port

    push    ax          ;Save port id
    or  MiscFlags[si],Discard   ;Show discarding serial data
    mov ComErr[si],cx       ;Clear error flags
    mov QInCount[si],cx     ;Show no chars in input queue
    call    $RECCOM         ;Send XON if needed

;-----------------------------------------------------------------------;
;   We have to wait for the output queue to empty.   To do this,
;   a timer will be created.  If no character has been transmitted
;   when the timeout occurs, then an error will be indicated and
;   the port closed anyway.  If the timer cannot be created, then
;   just loop until the queue empties, which will be better than
;   discarding charatcers if there are any
;-----------------------------------------------------------------------;

    test    [si.HSFlag], HHSAlwaysDown ; Q: handshaking ever up?
    jnz TermCom17       ;   N: skip wait loop

TermCom10:
    mov cx,QOutCount[si]    ;Get current queue count
    jcxz    TermCom20       ;No characters in queue

    cCall   GetSystemMsecCount
    mov di, ax

TermCom15:
    cmp QOutCount[si],cx    ;Queue count change?
    jne TermCom10       ;  Yes, restart timeout

    cCall   GetSystemMsecCount
    sub ax, di
    cmp ax, Timeout * 1000  ;Q: Timeout reached?
    jb  TermCom15       ;   No, keep waiting

IFDEF DEBUG_TimeOut
.286
    pusha
    lea cx, szSendTO
    call    Contention_Dlg
    popa
    jz  TermCom10
.8086
ENDIF

TermCom17:
    mov cx, TimeoutError    ;   Yes, show timeout error

TermCom20:
    pop ax          ;Restore cid

TermCom30:
    mov dx,Port[si]     ;Get port base address
    call    Terminate       ;The real work is done here
    mov ax,cx           ;Set return code

TermCom60:
    pop di
    pop si
    ret

$TRMCOM endp
page

;----------------------------Private-Routine----------------------------;
;
; Terminate - Terminate Device
;
; Restore the port I/O address and make sure that interrupts are off
;
; Entry:
;   AH = Device Id.
;   DX = Device I/O port address.
;   SI --> DEB
; Returns:
;   AX = 0
; Error Returns:
;   AX = -1
; Registers Destroyed:
;   AX,BX,DX,FLAGS
; History:
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public Terminate                       ;Public for debugging
Terminate proc near

    or  ah,ah           ;LPT port?
    jns Terminate10     ;  No, process COM port
    .errnz  LPTx-10000000b

Terminate5:
    call    ReleasePort386      ; give port back to 386...
    jmp Terminate50     ;That's all


;-----------------------------------------------------------------------;
;   It is a com port!
;
;       We delay for a bit while the last character finishes transmitting
;       Then we drop DTR and RTS, and disable the interrupt generation at
;       the 8250.  Even if fRTSDisable or fDTRDisable is set, those lines
;       will be dropped when the port is closed.
;-----------------------------------------------------------------------;
;
;   When the OUT2 bit is reset to 0 to disable interrupts, many ports
;   generate an interrupt which can not be identified, because the the
;   interrupt ID register will not be set.  To work around this hardware
;   problem we first mask the IRQ, then set the port into loopback mode
;   and output a NULL to generate a receive interrupt request.  Then we
;   reset OUT2 and unmask the IRQ.  This will cause the interrupt to occur
;   and the interrupt handler will be able to correctly identify the
;   interrupt as coming from the com port.

Terminate10:
    inc dx          ;Disable chip interrupts
    .errnz ACE_IER-ACE_RBR-1
    mov al, ACE_ERBFI       ;   except receive
    out dx,al
    call    FlagNotActive       ; don't need to check for postmessage
                    ;   on timer ticks
    add dl,ACE_LSR-ACE_IER  ;--> line status register
    iodelay

Terminate20:
    in  al,dx           ;Wait until xmit is empty
    and al,ACE_THRE+ACE_TSRE
    cmp al,ACE_THRE+ACE_TSRE
    jne Terminate20     ;Not empty yet

Terminate30:
    xor al, al
    test    EFlags[si], fFIFOpre    ;Q: leave FIFO enabled?
    jz  short @F        ;   N:
    mov al, ACE_TRIG14 OR ACE_EFIFO OR ACE_CRFIFO OR ACE_CTFIFO
@@:
    sub dl, ACE_LSR-ACE_FCR
    out dx, al
    iodelay
    call    MaskIRQ
    add dl, ACE_MCR-ACE_FCR ;--> Modem Control Register
    in  al,dx
    iodelay
    mov ah, al
    or  al,ACE_LOOP     ; turn on loopback
    out dx, al
    iodelay
    sub dl, ACE_MCR-ACE_THR
    xor al, al
    out dx, al          ; output a NULL to generate an int
    iodelay
    add dl, ACE_LSR-ACE_THR
Terminate35:
    in  al,dx           ;Wait until xmit is empty
    and al,ACE_THRE+ACE_TSRE
    cmp al,ACE_THRE+ACE_TSRE
    jne Terminate35     ;Not empty yet
    mov al, ah
    dec dl          ; now clear OUT2 and loopback
    .errnz  ACE_LSR-ACE_MCR-1
    and al,ACE_DTR+ACE_RTS  ;Leave DTR, RTS high if already so
    out dx,al           ;  but tri-state IRQ line

    call    UnmaskIRQ       ; this will cause the receive int
                    ; to occur and be processed
    sub dl, ACE_MCR-ACE_IER ; clear the receive int enable
    xor al, al
    out dx, al
    dec dx
    .errnz  ACE_IER-ACE_RBR-1
    call    MaskIRQ

;******* DANGER! ***** NOTICE! ***** DANGER! ***** WARNING! ***** NOTICE!
;
; Terminate45 is a secondary entrypoint into this routine--it's called
; by the initialization code when that code is unable to properly init
; a com port and needs to clean-up the mess it's made.
;
;******* DANGER! ***** NOTICE! ***** DANGER! ***** WARNING! ***** NOTICE!

Terminate45:
    push    cx          ;Save original cx
    push    bx          ;Save original bx

    cmp [fVPICD], 0     ;Q: VPICD bimodel services available?
    jl  short @F        ;   N:
    mov ax, ds          ;   Y: use them
    mov es, ax
    lea di, [si+SIZE ComDEB]
    mov ax, VPICD_Remove_Handler
    call    [lpfnVPICD]
@@:

    mov di, [si.IRQhook]
    dec [di.HookCnt]        ;Q: last port using IRQ?
    jne short Terminate495  ;   N: unmask IRQ again
    mov al, 0FFh
    xchg    al, [di.VecN]       ;Interrupt vector number
    cmp al, 0FFh        ;Q: IRQ vector hooked?
    je  short Terminate49   ;   no...

IFDEF No_DOSX_Bimodal_Services
    cmp [Using_DPMI], 0
    jz  short term_no_dpmi

;
; unhook RM vector thru DPMI for standard mode
;
    push    ax
    mov ax, Int31_Get_Version SHL 8
    int 31h
    mov bl, [si.IntVecNum]
    mov bh, bl
    add bl, dh          ; assume master PIC
    sub bh, 8           ;Q: IRQ in master?
    jb  @f          ;   Y: add master's base vec
    add bh, dl          ;   N: add slave's base vec
    mov bl, bh
@@:
    mov dx, wo [di.RM_OldIntVec][0]
    mov cx, wo [di.RM_OldIntVec][2]
    mov ax, Set_RM_IntVector
    int 31h
    pop ax
term_no_dpmi:
ENDIF
    mov dx, __WinFlags      ;In Standard mode the PIC interrupt
    test    dl, WF_STANDARD     ;  priorities are changed to favor
    jz  Terminate48     ;  the comm ports.

    call    Rotate_PIC      ;This port no longer needs priority

Terminate48:
    ; *** reset int vector to it's previous state
    assumes ds,nothing
    push    ds          ;Save original DS [rkh] ...
    lds dx, [di.OldIntVec]
    mov ah, 25h         ;DOS Set Vector Function
    int 21h         ;Set the DOS vector
    pop ds          ;Original DS
    assumes ds,data

; *** interrupt vectors have been reset if needed at this point ***
;
Terminate49:
    mov cl, [di.OldMask]

; Set the 8259 interrupt mask bit for this IRQ.  Leave interrupts enabled
; if they were already enabled when the comm port was initialized by us.

    or  cl, cl
    jnz @f
Terminate495:
    call    UnmaskIRQ
@@:

    xor ax, ax
    xchg    ax, [si.NextDEB]
    cmp [di.First_DEB], si  ;Q: DEB first for IRQ hook?
    je  short Terminate46   ;   Y:
    mov bx, [di.First_DEB]  ;   N: get first
Terminate453:
    cmp [bx.NextDEB], si    ;Q: does this DEB point to one terminating?
    je  Terminate455        ;   Y:
    mov bx, [bx.NextDEB]    ;   N: get next DEB
    jmp Terminate453
Terminate455:
    mov [bx.NextDEB], ax    ; link previous DEB to NextDEB
    jmp short Terminate47
Terminate46:
    mov [di.First_DEB], ax  ; point IRQ hook at NextDEB
Terminate47:
    pop bx          ;Original BX

    call    ReleaseCOMport386   ; give port back to 386...

    pop cx          ;Original CX

Terminate50:                ;Also called from $INICOM !
    xor ax,ax           ;Indicate no error
    ret             ;Port is closed and deallocated

Terminate   endp
page

;----------------------------Public Routine-----------------------------;
;
; $ENANOTIFY - Enable Event Notification
;
; Entry:
;   AH     =  Device ID
;   BX     =  Window handle for PostMessage
;   CX     =  Receive threshold
;   DX     =  Transmit threshold
; Returns:
;   AX = 1, if no errors occured
; Error Returns:
;   AX = 0
; Registers Preserved:
;   BX,SI,DI,DS
; Registers Destroyed:
;   AX,CX,DX,ES,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public  $ENANOTIFY
$ENANOTIFY proc near
    push    si
    call    GetDEB
    mov ax, 0
    jc  scb_exit

    mov ax, cx
    inc ax
    jz  short scb_recv_ok
    cmp cx, [si.QInSize]    ;Q: receive threshold reasonable?
    jb  short scb_recv_ok   ;   Y:
%OUT should we return an error, if thresholds invalid?
    mov cx, [si.QInSize]    ;   N:
    sub cx, 10
scb_recv_ok:
    inc dx
    jz  short scb_send_ok
    dec dx
    cmp dx, [si.QOutSize]   ;Q: receive threshold reasonable?
    jb  short scb_send_ok   ;   Y:
    mov dx, [si.QOutSize]   ;   N:
    sub dx, 10
scb_send_ok:
    mov [si.NotifyHandle], bx
    mov [si.NotifyFlagsHI], CN_Notify
    or  bx, bx          ;Q: null callback?
    jnz scb_save_thresholds ;   N: save thresholds
    or  cx, -1          ;   Y: zero thresholds
    xor dx, dx
    mov [si.NotifyFlagsHI], 0
scb_save_thresholds:
    mov [si.RecvTrigger], cx
    mov [si.SendTrigger], dx
    or  [si.NotifyFlagsHI], CN_TRANSMIT ; we don't want to send
                    ; a transmit trigger notification until
                    ; the transmit buffer has been filled
                    ; above the trigger level and then
                    ; emptied below it again!

    cmp wo lpPostMessage[2], 0  ;Q: gotten addr of PostMessage yet?
    jne short scb_good      ;   Y:
    push    ds          ;   N: get module handle of USER
    lea ax, szUser
    push    ax
    cCall   GetModuleHandle

    push    ax          ; module handle
    mov ax, POSTMESSAGE
    cwd
    push    dx
    push    ax
    cCall   GetProcAddress
    mov wo lpPostMessage[0], ax ; save received proc address
    mov wo lpPostMessage[2], dx

scb_good:
    mov ax, 1

scb_exit:
    pop si
    ret
$ENANOTIFY endp
page

;----------------------------Public Routine-----------------------------;
;
; $SETQUE - Set up Queue Pointers
;
; Sets pointers to Receive and Transmit Queues, as provided by the
; caller, and initializes those queues to be empty.
;
; Queues must be set before $INICOM is called!
;
; Entry:
;   AH     =  Device ID
;   ES:BX --> Queue Definition Block
; Returns:
;   AX = 0 if no errors occured
; Error Returns:
;   AX = error code
; Registers Preserved:
;   BX,DX,SI,DI,DS
; Registers Destroyed:
;   AX,CX,ES,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public $SETQUE
$SETQUE proc near

    push    si          ;These will be used
    push    di
    call    GetDEB          ;Get DEB
    jc  SetQue10        ;Invalid, ignore the call
    js  SetQue10        ;Ignore call for LPT ports
    push    ds          ;Set ds:si --> QDB
    push    es          ;Set es:di --> to ComDCB.QInAddr
    pop ds
    assumes ds,nothing
    pop es
    assumes es,Data
    lea di,QInAddr[si]
    mov si,bx
    cld
    FCLI             ;No one else can play with queues
    movsw               ; QInAddr     = QueueRxAddr
    movsw
    .errnz QueueRxAddr
    sub si, 4           ; AltQInAddr  = QueueRxAddr
    mov cx, 5           ; QInSize     = QueueRxSize
    rep movsw           ; QOutAddr    = QueueTxAddr
    sub si, 4
    mov cx, 3           ; AltQOutAddr = QueueTxAddr
    rep movsw           ; QOutSize    = QueueTxSize

    xor ax,ax           ;Will do some zero filling
    mov cl,(EFlags-QInCount)/2
    .errnz (EFlags-QInCount) AND 0FE01h
    rep stosw
    FSTI
    push    es          ;Restore the data segment
    pop ds
    assumes ds,Data
    assumes es,nothing

SetQue10:
    pop di          ;Restore saved registers
    pop si
    ret

; The above code made a few assumptions about how memory
; was allocated within the structures:

    .errnz AltQInAddr-QInAddr-4
    .errnz (QueueRxSize-QueueRxAddr)-(QInSize-AltQInAddr)
    .errnz (QueueTxAddr-QueueRxSize)-(QOutAddr-QInSize)
    .errnz AltQOutAddr-QOutAddr-4
    .errnz (QueueTxSize-QueueTxAddr)-(QOutSize-AltQOutAddr)

    .errnz QueueRxSize-QueueRxAddr-4
    .errnz QueueTxAddr-QueueRxSize-2
    .errnz QueueTxSize-QueueTxAddr-4

    .errnz QInSize-AltQInAddr-4
    .errnz QOutAddr-QInSize-2
    .errnz QOutSize-AltQOutAddr-4

    .errnz QInCount-QOutSize-2
    .errnz QInGet-QInCount-2
    .errnz QInPut-QInGet-2
    .errnz QOutCount-QInPut-2
    .errnz QOutGet-QOutCount-2
    .errnz QOutPut-QOutGet-2
    .errnz EFlags-QOutPut-2       ;First non-queue item

$SETQUE endp
page

;----------------------------Public Routine-----------------------------;
;
; $SETCOM - Set Communications parameters
;
; Re-initalizes the requested port if present, and sets up the
; port with the given attributes when they are valid.
;
; For LPT ports, just copies whatever is given since it's ignored
; anyway.
;
; Entry:
;   ES:BX --> DCB with all fields set.
; Returns:
;   'Z' Set if no errors occured
;   AX = 0
; Error Returns:
;   'Z' clear if errors occured
;   AX = initialization error code.
; Registers Destroyed:
;   AX,BX,CX,DX,ES,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public $SETCOM
$SETCOM proc near

    cld
    push    si
    push    di
    mov ah,es:[bx.DCB_Id]   ;Get device i.d.
    call    GetDEB          ;Get DEB pointer in SI
    mov ax,IE_BadID     ;Assume unknown device
    jc  SetCom10        ;Invalid device, return error
    jns SetCom20        ;COM port
    call    SetCom100       ;Copy the DCB

SetCom5:
    xor ax,ax           ;Show no error

SetCom10:
    or  ax,ax           ;Set/clear 'Z'
    pop di          ;  and exit
    pop si
    ret

;-----------------------------------------------------------------------;
;       Have a comm device, check all the serial parameters to make
;       sure they are correct before moving the new DCB into our space
;       and changing the ACE parameters.
;-----------------------------------------------------------------------;

SetCom20:
    call    SetCom300       ;Baud rate valid?
    jcxz    SetCom10        ;  No, return error
    call    SetCom400       ;Byte size/parity/stop bits correct?
    jc  SetCom10        ;  No, return error

; The parameters seem correct.  Copy the DCB into our space and
; initialize the ACE with the new parameters

    mov dx,Port[si]     ;Disable interrupts from the 8250
    inc dx
    .errnz ACE_IER-1
    xor ax,ax
    out dx,al
    call    FlagNotActive

    call    SetCom100       ;Copy the DCB
    mov bx,si           ;Set ES:BX --> DCB
    call    SetCom200       ;Get timeout masks
    xchg    al,ah           ;Want them in the correct registers
    mov wo MSRMask[si],ax
    .errnz MSRInfinite-MSRMask-1

    call    SetCom400       ;Get line control byte
    push    ax          ;  and save LCR value
    inc dx          ;--> LCR
    inc dx
    .errnz ACE_LCR-ACE_IER-2
    or  al,ACE_DLAB     ;Want access to divisor latch
    out dx,al
    mov RxMask[si],ah       ;Save Receive character mask
    mov ax,di           ;Get flags mask, error mask
    and [si.DCB_Flags],ah   ;Disable parity checking if no parity
    mov ErrorMask[si],al    ;Save line status error mask

    call    SetCom300       ;Get baud rate
    sub dl,ACE_LCR-ACE_DLL  ;--> LSB of divisor latch
    mov al,cl
    out dx,al
    mov al,ch
    inc dx          ;--> MSB of divisor latch
    .errnz ACE_DLM-ACE_DLL-1
    iodelay
    out dx,al
    inc dx          ;--> LCR and clear divisor access bit
    inc dx
    .errnz ACE_LCR-ACE_DLM-2
    pop ax
    out dx,al

    inc dx          ;--> Modem Control Register
    .errnz ACE_MCR-ACE_LCR-1

;-----------------------------------------------------------------------;
;       Compute initial state of DTR and RTS.  If they have been disabled,
;       then do not raise them, and disallow being used as a handshaking
;       line.  Also compute the bits to use as hardware handshake bits
;       (DTR and/or RTS as indicated, qualified with the disabled flags).
;-----------------------------------------------------------------------;

    mov al,[si.DCB_Flags]   ;Align DTR/RTS disable flags for 8250
    and al,fRTSDisable+fDTRDisable
    rol al,1            ;d0 = DTR, d2 = RTS  (1 = disabled)
    shr al,1            ;'C'= DTR, d1 = RTS
    adc al,0            ;d0 = DTR, d1 = RTS
    .errnz  fRTSDisable-00000010b
    .errnz  fDTRDisable-10000000b
    .errnz  ACE_DTR-00000001b
    .errnz  ACE_RTS-00000010b

    mov ah,al           ;Save disable mask
    xor al,ACE_DTR+ACE_RTS+ACE_OUT2
    out dx,al           ;Set Modem Control Register

    mov al,[si.DCB_Flags2]  ;Get hardware handshake flags
    rol al,1            ;Align flags as needed
    rol al,1
    rol al,1
    and al,ACE_DTR+ACE_RTS  ;Mask bits of interest
    not ah          ;Want inverse of disable mask
    and al,ah           ;al = bits to handshake with
    mov HHSLines[si],al     ;Save for interrupt code

    .errnz  fDTRFlow-00100000b
    .errnz  fRTSFlow-01000000b
    .errnz  ACE_DTR-00000001b
    .errnz  ACE_RTS-00000010b

    mov al,[si.DCB_Flags]   ;Compute the mask for the output
    shl al,1            ;  hardware handshake lines
    and al,ACE_DSR+ACE_CTS
    mov OutHHSLines[si],al

    .errnz  fOutXCTSFlow-00001000b
    .errnz  fOutXDSRFlow-00010000b
    .errnz  ACE_CTS-00010000b
    .errnz  ACE_DSR-00100000b

; Compute the queue count where XOff should be issued (or hardware
; lines dropped).  This will prevent having to do it at interrupt
; time.

    mov ax,QInSize[si]      ;Get where they want it
    sub ax,[si.DCB_XoffLim] ;  and compute queue count
    mov XOffPoint[si],ax

; Enable FIFO if possible when baudrate >= 4800
;
    sub dl,ACE_MCR - ACE_FCR    ; dx = FCR
    test    EFlags[si], fNoFIFO ;Q: FIFO can be enabled?
    jnz sc_nofifo       ;   N:
    mov ax, [si.DCB_BaudRate]
    cmp ax, 4800
    jb  sc_nofifo
    cmp ah, -1          ;Q: baudrate index?
    jne sc_fifo         ;   N: baudrate >= 4800, enable FIFO
    cmp ax, CBR_4800
    jb  sc_nofifo
%OUT this isn't correct, if lower baudrates are assigned indices above CBR_4800

sc_fifo:
    mov al, ACE_TRIG14 OR ACE_EFIFO OR ACE_CRFIFO OR ACE_CTFIFO
    out dx, al          ; attempt to enable FIFO
    test    EFlags[si], fFIFOchkd   ;Q: FIFO detect been done?
    jnz sc_fifodone     ;   Y: enabled FIFO
    iodelay
    .errnz  ACE_IIDR-ACE_FCR
    in  al, dx
    or  EFlags[si], fFIFOchkd
    test    al, ACE_FIFO_E2     ;Q: FIFO enabled?
    jz  short @F
    test    al, ACE_FIFO_E1     ;Q: 16550A detected?
    jnz sc_fifodone     ;   Y: enabled FIFO
@@:
    iodelay
    or  EFlags[si], fNoFIFO

sc_nofifo:
    xor al, al
    out dx, al
sc_fifodone:

    sub dl,ACE_FCR-ACE_RBR  ; dx -> RBR
;
; Delay for things to settle
;
    push    dx
    cCall   GetSystemMsecCount
    pop dx
    mov cx, ax
delay_loop:
    in  al, dx          ;Read it once
    push    dx
    cCall   GetSystemMsecCount
    pop dx
    sub ax, cx
    cmp ax, DELAY_TIME      ;Q: Timeout reached?
ifndef WOW
    jb  delay_loop      ;   N:
endif

    add dl,ACE_MSR      ;--> Modem Status reg
    in  al,dx           ;Throw away 1st status read
    iodelay
    in  al,dx           ;Save 2nd for MSRWait (Clear MSR int)
    mov MSRShadow[si],al

; Win 3.0 didn't check hardware handshaking until the line status changed.
; Allow some apps to keep that behavior.

    push    dx
    xor ax, ax
    cCall   GetAppCompatFlags,<ax>
    pop dx
    test    ax, GACF_DELAYHWHNDSHAKECHK
    jnz short sc_HHSup

;
; HACK FOR SOME MODEMS:  apparently some modems set CTS, but don't set DSR
; which means that COMM.DRV won't send if the app specifies that hardware
; handshaking is based on CTS & DSR being set.
;
    mov ah,OutHHSLines[si]
    mov al, MSRShadow[si]
    and al,ah           ;Only leave bits of interest
    cmp al, ah          ;Q: handshaking lines ok?
    je  short sc_HHSup      ;   Y:
    cmp ah, ACE_CTS OR ACE_DSR  ;Q: app looking for both high?
    jne short sc_HHSdown    ;   N: skip hack
    test    [si.EFlags], fUseDSR    ;Q: DSR is always significant?
    jnz short sc_HHSdown    ;   Y: skip hack
    cmp al, ACE_CTS     ;Q: DSR low & CTS high
    jne short sc_HHSdown    ;   N: skip hack
    and ah, NOT ACE_DSR     ;   Y: ignore DSR line
    mov OutHHSLines[si], ah
    jmp short sc_HHSup

sc_HHSdown:
    or  [si.HSFlag], HHSDown OR HHSAlwaysDown ; flag handshaking down
sc_HHSup:

;-----------------------------------------------------------------------;
;       Now, at last, interrupts can be enabled.  Don't enable the
;       transmitter empty interrupt.  It will be enabled by the first
;       call to KickTx.
;-----------------------------------------------------------------------;

    sub dl,ACE_MSR-ACE_IER  ;--> Interrupt Enable Register

; flag port as being active
    push    cx
    mov cl, [si.DCB_Id]
    mov ax, 1
    shl ax, cl
    or  [activeCOMs], ax
    pop cx

    mov al,ACE_ERBFI+ACE_ELSI+ACE_EDSSI
    FCLI
    out dx,al           ;Enable interrupts.
    add dl,ACE_LSR-ACE_IER  ;--> Line Status Register
    iodelay
    in  al,dx           ;Clear any Line Status interrupt
    sub dl,ACE_LSR      ;--> Receiver Buffer Register
    iodelay
    in  al,dx           ;Clear any Received Data interrupt
    FSTI
    jmp SetCom5         ;All done

$SETCOM endp
page

FlagNotActive proc near
    push    cx
    mov cl, [si.DCB_Id]
    mov ax, NOT 1
    rol ax, cl
    and [activeCOMs], ax
    pop cx
    ret
FlagNotActive endp

;----------------------------Private-Routine----------------------------;
;
; SetCom100
;
;  Copy the given DCB into the appropriate DEB.  The check has
;  already been made to determine that the ID was valid, so
;  that check can be skipped.
;
; Entry:
;   ES:BX --> DCB
;   DS:SI --> DEB
; Returns:
;   DS:SI --> DEB
;   ES     =  Data
; Error Returns:
;   None
; Registers Destroyed:
;   AX,CX,ES,DI,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

SetCom100 proc near
    push    si          ;Save DEB pointer
    mov di,si
    mov si,bx
    push    es
    mov ax,ds
    pop ds
    assumes ds,nothing

    mov es,ax
    assumes es,Data

    mov cx,DCBSize
    cld
    rep movsb
    mov ds,ax
    assumes ds,Data

    pop si          ;Restore DEB pointer
    ret

SetCom100   endp
page

;----------------------------Private-Routine----------------------------;
;
; SetCom200
;
; Based on whether or not a timeout has been specified for each
; signal, set up a mask byte which is used to mask off lines for
; which we wish to detect timeouts.  0 indicates that the line is
; to be ignored.
;
; Also set up a mask to indicate those lines which are set for
; infinite timeout.  1 indicates that the line has infinite
; timeout.
;
; Entry:
;   ES:BX --> DCB
; Returns:
;   ES:BX --> DCB
;   AH = lines to check
;   AL = lines with infinite timeout
; Error Returns:
;   None
; Registers Destroyed:
;   AX,CX,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

SetCom200 proc near

    xor ax,ax
    xor cx,cx           ;Get mask of lines with timeout = 0
    call    SetCom210
    not al          ;Invert result to get lines to check
    and al,ACE_CTS+ACE_DSR+ACE_RLSD
    xchg    ah,al
    dec cx          ;Get mask of infinite timeouts

SetCom210:
    cmp es:[bx.DCB_RlsTimeout],cx   ;Timeout set to passed value?
    jne SetCom220       ;  No
    or  al,ACE_RLSD     ;  Yes, show checking line

SetCom220:
    cmp es:[bx.DCB_CtsTimeout],cx   ;Timeout set to passed value?
    jne SetCom230       ;  No
    or  al,ACE_CTS      ;  Yes, show checking line

SetCom230:
    cmp es:[bx.DCB_DsrTimeout],cx   ;Timeout set to passed value?
    jne SetCom240       ;  No
    or  al,ACE_DSR      ;  Yes, show checking line

SetCom240:
    ret

SetCom200   endp
page

;----------------------------Private-Routine----------------------------;
;
; SetCom300
;
; Calculate the correct baudrate divisor for the comm chip.
;
; Note that the baudrate is allowed to be any integer in the
; range 2-19200.  The divisor is computed as 115,200/baudrate.
;
; Entry:
;   ES:BX --> DCB
; Returns:
;   ES:BX --> DCB
;   CX = baudrate
; Error Returns:
;   CX = 0 if error
;   AX = error code if invalid baud rate
; Registers Destroyed:
;   AX,CX,FLAGS
; History:
;-----------------------------------------------------------------------;

BaudRateByIndexTable label word
    dw 1047     ; CBR_110
    dw 384      ; CBR_300
    dw 192      ; CBR_600
    dw 96       ; CBR_1200
    dw 48       ; CBR_2400
    dw 24       ; CBR_4800
    dw 12       ; CBR_9600
    dw 9        ; CBR_14400
    dw 6        ; CBR_19200
    dw 0        ;    0FF19h  (reserved)
    dw 0        ;    0FF1Ah  (reserved)
    dw 3        ; CBR_38400
    dw 0        ;    0FF1Ch  (reserved)
    dw 0        ;    0FF1Dh  (reserved)
    dw 0        ;    0FF1Eh  (reserved)
    dw 2        ; CBR_56000

assumes ds,Data
assumes es,nothing

SetCom300 proc near

    push    dx
    mov cx,es:[bx.DCB_BaudRate] ;Get requested baud rate
    xor ax,ax           ;Assume error
    cmp cx, CBR_110     ;Q: baudrate specified as an index?
    jae by_index
    cmp cx,2            ;Within valid range?
    jnae    SetCom310       ;  No, return error

    mov dx,1            ;(dx:ax) = 115,200
    mov ax,0C200h
    div cx          ;(ax) = 115,200/baud

SetCom310:
    mov cx,ax           ;(cx) = baud rate, or error code (0)
    mov ax,IE_Baudrate      ;Set error code incase bad baud
    pop dx
    ret

by_index:
    cmp cx, CBR_56000       ;Q: above supported?
    ja  SetCom310       ;   Y: return error
    push    bx
    mov bx, cx
    sub bx, CBR_110
    shl bx, 1
    mov ax, cs:[bx+BaudRateByIndexTable]    ; get divisor
    pop bx
    jmp SetCom310       ;   Y: return error


SetCom300   endp
page

;----------------------------Private-Routine----------------------------;
;
; SetCom400
;
; Check the line configuration (Parity, Stop bits, Byte size)
;
; Entry:
;   ES:BX --> DCB
; Returns:
;   ES:BX --> DCB
;   'C' clear if OK
;   AL = Line Control Register
;   AH = RxMask
;   DI[15:8] = Flags mask (to remove parity checking)
;   DI[7:0]  = Error mask (to remove parity error)
; Error Returns:
;   'C' set if error
;   AX = error code
; Registers Destroyed:
;   AX,CX,DI,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

SetCom400   proc   near

    mov ax,wo es:[bx.DCB_ByteSize]  ;al = byte size, ah = parity
    cmp ah,SpaceParity      ;Parity out of range?
    ja  SetCom470       ;  Yes, return error
    mov di,0FF00h+ACE_OR+ACE_PE+ACE_FE+ACE_BI
    or  ah,ah           ;Is parity "NONE"?
    jnz SetCom410       ;  No, something is there for parity
    xor di,(fParity*256)+ACE_PE ;Disable parity checking

SetCom410:
    cmp al,8            ;Byte size out of range?
    ja  SetCom460       ;  Yes, error

SetCom420:
    sub al,5            ;Shift byte size to bits 0&1
    .errnz ACE_WLS-00000011b    ;Word length must be these bits
    jc  SetCom460       ;Byte size is illegal, return error
    add ah,ah           ;Map parity to ACE bits
    jz  SetCom430       ;0=>0, 1=>1, 2=>3, 3=>5, 4=>7
    dec ah

SetCom430:
    shl ah,1            ;Align with 8250 parity bits
    shl ah,1
    shl ah,1
    or  al,ah           ;Add to byte size

    .errnz NoParity-0
    .errnz OddParity-1
    .errnz EvenParity-2
    .errnz MarkParity-3
    .errnz SpaceParity-4
    .errnz ACE_PEN-00001000b
    .errnz ACE_PSB-00110000b
    .errnz ACE_EPS-00010000b
    .errnz  ACE_SP-00100000b

    or  al,ACE_2SB      ;Assume 2 stop bits
    mov ah,es:[bx.DCB_StopBits] ;Get # of stop bits 0=1,1/2= .GT. 1
    or  ah,ah           ;Out of range?
    js  SetCom470       ;  Yes, return error
    jz  SetCom440       ;One stop bit
    sub ah,2
    jz  SetCom450       ;Two stop bits
    jns SetCom470       ;Not 1.5, return error
    test    al,ACE_WLS      ;1.5 stop bits, 5 bit words?
    jnz SetCom470       ;  No, illegal
    .errnz OneStopBit-0
    .errnz One5StopBits-1
    .errnz TwoStopBits-2
    .errnz ACE_5BW

SetCom440:
    and al,NOT ACE_2SB      ;Show 1 (or 1.5) stop bit(s)


; From the byte size, get a mask to be used for stripping
; off unused bits as the characters are received.

SetCom450:
    push    dx
    mov cl,es:[bx.DCB_ByteSize] ;Get data byte size
    mov dx,00FFh        ;Turn into mask by shifting bits
    shl dx,cl
    mov ah,dh           ;Return mask in ah
    pop dx
    clc             ;Show all is fine
    ret

SetCom460:
    mov ax,IE_ByteSize      ;Show byte size is wrong
    stc             ;Show error
    ret

SetCom470:
    mov ax,IE_Default       ;Show something is wrong
    stc             ;Show error
    ret

SetCom400 endp
page

;----------------------------------------------------------------------------
; SuspendOpenCommPorts:
;
; This routine is called from 286 Winoldaps to simply deinstall the comm port
; hooks.
;----------------------------------------------------------------------------

cProc   SuspendOpenCommPorts,<FAR,PUBLIC,PASCAL>

cBegin  nogen

    assumes cs,Code
    assumes ds,Data

%OUT not masking IRQ's

    ; Nothing to do under 3.1!

    ret

cEnd    nogen

;----------------------------------------------------------------------------;
; ReactivateOpenCommPorts:                           ;
;                                        ;
; This routine reinstalls the comm hooks in real mode and reads the 8250     ;
; data and status registers to clear pending interrupts.             ;
;----------------------------------------------------------------------------;

cProc   ReactivateOpenCommPorts,<FAR,PASCAL,PUBLIC>,<si,di>

cBegin
    call    Rotate_PIC      ;make comm ports highest priority

    mov cx, MAXCOM+1
    mov di,dataOffset COMptrs
rcp_loop:
    mov si, [di]
    mov dx, Port[si]
    or  dx, dx
    jz  @f
    call    InitAPort       ;read comm port regs to clr pending ints
@@:
    add di, 2
    loop    rcp_loop

cEnd

;----------------------------------------------------------------------------;
; InitAPort:                                     ;
;                                        ;
; reads the data,status & IIR registers of a port (has to be 8250!)      ;
;                                        ;
; If the port has an out queue pending, then this woutine will also start    ;
; the transmit process by faking a comm interrupt.               ;
;----------------------------------------------------------------------------;

public     InitAPort
InitAPort  proc near

    add dl,ACE_RBR      ;dx=receive buffer register
    in  al,dx           ;read the data port
    jmp short $+2       ;i/o delay
    add dl,ACE_LSR - ACE_RBR    ;get to the status port
    in  al,dx           ;read it too.
    jmp short $+2       ;i/o delay
    add dl,ACE_IIDR - ACE_LSR   ;get to the line status register
    in  al,dx           ;read it once more
    jmp short $+2       ;i/o delay
    add dl,ACE_MSR - ACE_IIDR   ;get to the modem status register
    in  al,dx           ;read it once more
    jmp short $+2       ;i/o delay
    add dl,ACE_RBR - ACE_MSR    ;get to the receive buffer register
    in  al,dx           ;read it once more
    jmp short $+2       ;i/o delay
    call    UnmaskIRQ

; now if the port has characters pending to be sent out then we must fake a
; comm interrupt.

    cmp [si].QOutCount,0    ;characters pending to be sent ?
    jz  @f          ;no.
    FCLI             ;disable interrupts
    call    FakeCOMIntFar       ;fake an interrupt
    FSTI             ;renable interrupts
@@:
    ret

InitAPort endp

page

;----------------------------Public Routine-----------------------------;
;
; $DCBPtr - Return Pointer To DCB
;
; Returns a long pointer to the DCB for the requested device.
;
; Entry:
;   AH = Device ID
; Returns:
;   DX:AX = pointer to DCB.
; Error Returns:
;   DX:AX = 0
; Registers Preserved:
;   SI,DI,DS
; Registers Destroyed:
;   BX,CX,ES,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

   assumes ds,Data
   assumes es,nothing

   public   $DCBPTR
$DCBPTR proc   near

        push    si
        xor     dx,dx
        call    GetDEB                  ;Get pointer to DEB
        mov     ax,dx
        jc      DCBPtr10                ;Jump if invalid device
        mov     ax,si                   ;else return value here
        mov     dx,ds

DCBPtr10:
        pop     si
        ret

$DCBPTR endp
page

;----------------------------Private-Routine----------------------------;
;
; GetDEB - Get Pointer To Device's DEB
;
; Returns a pointer to appropriate DEB, based on device number.
;
; Entry:
;   AH = cid
; Returns:
;   'C' clear
;   'S' set if LPT device
;   DS:SI --> DEB is valid cid
;   AH     =  cid
; Error Returns:
;   'C' set if error (cid is invalid)
;   AX = 8000h
; Registers Preserved:
;   BX,CX,DX,DI,DS,ES
; Registers Destroyed:
;   AX,SI,FLAGS
; History:
;-----------------------------------------------------------------------;

;------------------------------Pseudo-Code------------------------------;
; {
; }
;-----------------------------------------------------------------------;

assumes ds,Data
assumes es,nothing

public GetDEB               ;Public for debugging
GetDEB proc near

    push    cx
    mov cl, ah
    and cx, (NOT LPTx AND 0FFh)
    test    ah, ah          ;Q: LPT id?
    js  short GetDEB10      ;   Y:
.errnz LPTx - 80h
    cmp ah, MAXCOM      ;Q: Within range?
    ja  GetDEB30        ;   N: return invalid ID
    shl cx, 1
    mov si, cx
    mov si, [si+COMptrs]
    jmp short GetDEB20

GetDEB10:
    cmp ah, LPTx+MAXLPT     ;Q: Within range?
    ja  GetDEB30        ;   N: return invalid ID
    mov si, DataOFFSET LPT1
    jcxz    GetDEB20
GetDEB15:
    add si, SIZE LptDEB
    loop    GetDEB15
GetDEB20:
    pop cx
    or  ah, ah          ; clear Carry & set S, if LPT port
    ret

GetDEB30:
    pop cx
    mov ax,8000h        ;Set error code
    stc             ;Set 'C' to show error
    ret

GetDEB endp
page


CvtHex proc near
;   assume DS=SS
    push    si
    mov cl, 4
    mov si, di
    xor dx, dx
    cld
ch_lp:
    lodsb
    sub al, '0'         ;Q: char < '0'
    jb  ch_exit         ;   Y: return
    cmp al, 9           ;Q: char <= '9'
    jbe ch_got_digit        ;   Y: move digit into result
    sub al, 'A' - '0'       ;Q: char < 'A'
    jb  ch_exit         ;   Y: return
    add al, 10
    cmp al, 15          ;Q: char <= 'F'
    jbe ch_got_digit        ;   Y: move hex char into result
    sub al, 10 + 'a' - 'A'  ;Q: char < 'a'
    jb  ch_exit         ;   Y: return
    add al, 10
    cmp al, 15          ;Q: char > 'f'
    ja  ch_exit         ;   Y: return
ch_got_digit:
    shl dx, cl
    or  dl, al
    jmp ch_lp
ch_exit:
    mov ax, dx
    pop si
    ret
CvtHex endp

.286
; attempt to read base from SYSTEM.INI
GetComBase proc near
    push    ds              ; save our DS
    sub sp, 6
    mov di, sp
    mov byte ptr ss:[di], 0
    push    ds
    push    DataOFFSET lpCommSection
    push    ds
    push    DataOFFSET lpCommBase
    push    ss              ; temp buffer
    push    di
    push    ss              ; default = temp buffer
    push    di
    push    5
    push    ds
    push    DataOFFSET lpSYSTEMINI
    mov cx, ss              ; temporarily assign DS=SS
    mov ds, cx              ;   to allow KERNEL to thunk
    assumes ds,nothing
    call    GetPrivateProfileString     ;   our segment in real mode
    or  ax, ax
    jz  short gcb_exit
    call    CvtHex              ; DS still equal to SS
gcb_exit:
    add sp, 6
    pop ds              ; restore our DS
    assumes ds,Data
    ret
GetComBase endp

GetPortIRQ proc near
    push    ds              ; save our DS
    push    ds
    push    DataOFFSET lpCommSection
    push    ds
    push    DataOFFSET lpCommIrq
    push    bx
    mov bl, [si.DCB_Id]
    cmp bl, 4
    jb  @f
    mov bl, 4
@@:
    xor bh, bh
    mov bl, [bx+default_table]
    mov cx, bx
    pop bx
    push    cx              ; default
    push    ds
    push    DataOFFSET lpSYSTEMINI
    mov cx, ss              ; temporarily assign DS=SS
    mov ds, cx              ;   to allow KERNEL to thunk
    assumes ds,nothing
    call    GetPrivateProfileInt        ;   our segment in real mode
    pop ds              ; restore our DS
    assumes ds,Data
    ret
GetPortIRQ endp


GetPortFlags proc near
    mov al, [si.DCB_Id]
.erre MAXCOM LT 9           ;only single digit port numbers supported
    add al, '1'
    mov [CommFIFOX], al
    mov [CommDSRx], al
    call    GetPortFIFO
    call    GetPortDSR
    ret
GetPortFlags endp

GetPortFIFO proc near
    push    ds              ; save our DS
    push    ds
    push    DataOFFSET lpCommSection
    push    ds
    push    DataOFFSET lpCommFifo
    push    2
    push    ds
    push    DataOFFSET lpSYSTEMINI
    mov cx, ss              ; temporarily assign DS=SS
    mov ds, cx              ;   to allow KERNEL to thunk
    assumes ds,nothing
    call    GetPrivateProfileInt        ;   our segment in real mode
    pop ds              ; restore our DS
    assumes ds,Data
    cmp ax, 1
    ja  short gpf_exit          ; just check at open
    jb  short gpf_no_fifo       ; force OFF, if = 0
    or  EFlags[si], fFIFOchkd       ; flag as checked, to force ON
    jmp short gpf_exit

gpf_no_fifo:
    or  EFlags[si], fNoFIFO OR fFIFOchkd    ; force OFF

gpf_exit:
    ret
GetPortFIFO endp

GetPortDSR proc near
    push    ds              ; save our DS
    push    ds
    push    DataOFFSET lpCommSection
    push    ds
    push    DataOFFSET lpCommDSR
    push    0
    push    ds
    push    DataOFFSET lpSYSTEMINI
    mov cx, ss              ; temporarily assign DS=SS
    mov ds, cx              ;   to allow KERNEL to thunk
    assumes ds,nothing
    call    GetPrivateProfileInt        ;   our segment in real mode
    pop ds              ; restore our DS
    assumes ds,Data
    or  ax, ax
    jz  short gpd_exit
    or  EFlags[si], fUseDSR

gpd_exit:
    ret
GetPortDSR endp


; FindCOMPort
;
; DS:SI -> DEB
;
    PUBLIC FindCOMPort
FindCOMPort proc near
;
; Examine BIOS data area to get base I/O addresses for COM and LPT ports
;
    push    bx
    push    cx
    push    es
    mov ax, __0040H
    mov es, ax
    assumes es,nothing

    mov al, [si.DCB_Id]
    mov ah, al
.erre MAXCOM LT 9           ;only single digit port numbers supported
    add ah, '1'
    mov [CommBaseX], ah
    mov [CommIRQX], ah
    mov [CommFIFOX], ah
    mov [CommDSRx], ah

    cmp al, 4
    jae fcp_not_phys_com
    xor ah, ah
    shl ax, 1
    mov bx, ax
    mov ax, es:[bx+RS232B]
    or  ax, ax
    jnz fcp_got_com_base
fcp_not_phys_com:
    call    GetComBase
    or  ax, ax
    jnz fcp_got_com_base
    mov bl, [si.DCB_Id]
    cmp bl, 2
    jne fcp_invalid     ; jump, if base = 0 & com port <> com3
    mov ax, 3E8h        ; default COM3 to 3E8h
fcp_got_com_base:
    push    ax
    call    GetPortIRQ
    mov dx, ax
    pop ax
    or  dl, dl          ;Q: non-zero IRQ?
    jz  fcp_invalid     ;   N:
    cmp dl, 15          ;Q: IRQ in range?
    ja  fcp_invalid     ;   N:
    xor dh, dh
    push    ax
    push    dx
    call    GetPortFIFO
    call    GetPortDSR
    pop dx
    pop ax
    clc
fcp_exit:
    pop es
    pop cx
    pop bx
    ret

fcp_invalid:
    or  ax, -1
    mov dx, ax
    stc
    jmp fcp_exit

FindCOMPort endp
.8086

page
;--------------------------Private Routine-----------------------------;
;
; Rotate the PIC interrupt priorities so the communication ports are
; highest priority.
;
; NOTE: Only rotates priorities on master PIC.
;
;-----------------------------------------------------------------------;

    assumes ds,Data
    assumes es,nothing

    public Rotate_PIC

Rotate_PIC proc near

    push    ax
    push    cx
    push    di

    mov al, 8           ; 0 - 7 rotated
    mov cx, MAXCOM+1
    mov di, DataOFFSET IRQhooks
rp_loop:
    mov ah, [di.IRQn]
    cmp ah, 0           ;End of hooked IRQ list?
    je  rp_set
    cmp [di.VecN], 0FFh     ;Hooked?
    je  rp_next
    cmp ah, 8           ;If on slave PIC, treat as IRQ2
    jb  @f
    mov ah, 2
@@:
    cmp ah, al
    jae rp_next
    mov al, ah          ;AL = lowest hooked comm IRQ
rp_next:
    add di, SIZE IRQ_Hook_Struc
    loop    rp_loop

rp_set:
    dec al          ;Setting IRQ(n-1) as the lowest
    and al,  07h        ;  priority makes IRQn the highest
    or  al, 0C0h
    out INTA0, al

    pop di
    pop cx
    pop ax
    ret

Rotate_PIC endp


ifdef DEBUG
    public  InitCom10, InitCom20, InitCom40, InitCom50, InitCom59
    public  InitCom60, InitCom70, InitCom80, InitCom90, InitCom100
    public  TermCom10, TermCom15, TermCom20, TermCom30
    public  TermCom60, Terminate5, Terminate10, Terminate20, Terminate30
    public  Terminate45, Terminate49, Terminate50
    public  SetQue10
    public  SetCom5, SetCom10, SetCom20, SetCom210, SetCom220, SetCom230
    public  SetCom240, SetCom310, SetCom410, SetCom420, SetCom430
    public  SetCom440, SetCom450, SetCom460, SetCom470
    public  GetDEB10, GetDEB20, GetDEB30
    public  DCBPtr10
endif

sEnd    code

page

createSeg _INIT,init,word,public,CODE
sBegin init
assumes cs,init



;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
IBMmodel proc near
      push  ax
      push  bx
      push  es

      mov   ah, 0c0h
      int   15h
      jc    IBMmodel_exit

      assumes es,nothing

      cmp   by es:[bx+2], 0f8h      ; PS/2 80
      je    IBMmodel_exit       ;   return carry clear

      cmp   by es:[bx+2], 0fch      ; AT or PS/2 50 or 60
      jne   OldBios         ; assume OldBios

      cmp   by es:[bx+3], 04h       ; PS/2 50
      je    IBMmodel_exit       ;   return carry clear
      cmp   by es:[bx+3], 05h       ; PS/2 60
      je    IBMmodel_exit       ;   return carry clear

OldBios:
      stc

IBMmodel_exit:
      pop   es
      pop   bx
      pop   ax
      ret

IBMmodel endp

cProc LoadLib, <FAR,PUBLIC,NODATA>,<si,di>
cBegin

    push    ds
    mov ax, __F000H
    mov ds, ax
    assumes ds, ROMBios
    mov al, [MachineID]
    pop ds
    assumes ds,Data
    mov [$MachineID], al

    call    IBMmodel        ;Q: PS/2?
    jc  @F          ;   N:
    mov [default_table+2], 3    ;   Y: change COM3 default IRQ to 3
@@:

    push    ds
    mov ax, __0040H
    mov ds, ax
    assumes ds,nothing
    cmp word ptr ds:[RS232B], 2F8h  ;Q: COM2 base in COM1 slot?
    pop ds
    assumes ds,Data
    jne @F              ;   N: leave IRQ default as 4
    mov [default_table], 3      ;   Y: change IRQ default to 3
@@:

    mov [fVPICD], -1        ; assume no

    xor di, di
    mov es, di
    mov ax, GET386API
    mov bx, VPICD
    int MULTIPLEX
    mov wo [lpfnVPICD], di
    mov wo [lpfnVPICD+2], es
    mov ax, es
    or  ax, di
    jz  short no_VPICD      ; jump if no bimodel services available
;
; version check VPICD
;
    mov ax, VPICD_API_Get_Ver
    call    [lpfnVPICD]
%OUT version check VPICD

    mov [fVPICD], 1     ; flag services are available

IFDEF No_DOSX_Bimodal_Services
    jmp short skip_dosx_stuff

no_VPICD:
    mov ax, __WinFlags
    and al, WF_PMODE or WF_WIN286
    cmp al, WF_PMODE or WF_WIN286
    jne skip_dosx_stuff

.286
    mov ax, Int31_Get_Version SHL 8
    int 31h
    test    bl, 10b         ;Q: processor goes to real mode
                    ;   for int reflection?
    jz  skip_dosx_stuff     ;   N:
    mov [Using_DPMI], 0FFh  ;   Y: flag use of DPMI

    mov ax, ds
    cCall   GetSelectorBase,<ax>    ;DX:AX = segment of selector
    shr ax, 4
    shl dl, 4
    or  ah, dl          ;AX now points to interrupt *segment*
    push    ax          ;save on stack
    mov ax, _INTERRUPT      ;write data SEGMENT into _INTERRUPT
    cCall   AllocCStoDSAlias,<ax>   ; code segment -- requires a data alias
    mov es, ax
    pop ax
    mov es:[RM_IntDataSeg],ax
    push    ds
    push    es
    mov ax, ds
    mov es, ax
    mov ax, _INTERRUPT
    mov ds, ax
    mov ax, (Int31_Trans_Serv SHL 8) + Trans_Call_Back
    mov si, IntCodeOFFSET Entry_From_RM
    mov di, DataOFFSET RM_Call_Struc
    int 31h
    pop es
    pop ds
    mov ax, 0
    jnc @f
    jmp short LoadExit
@@:
    mov wo es:[RM_CallBack], dx
    mov wo es:[RM_CallBack+2], cx
    cCall   FreeSelector,<es>    ;don't need CS alias any longer
.8086
skip_dosx_stuff:
ELSE
no_VPICD:
ENDIF

;
; find base values for LPT ports
;
    mov cx, __0040h
    mov es, cx
    mov cx, MAXLPT+1
    mov si, DataOFFSET LPT1
ll_initl_lp:
    mov bx, [si.BIOSPortLoc]
    or  bx, bx
    jz  ll_not_phys_lpt
    mov ax, es:[bx]
    or  ah, ah          ;Q: lpt redirected, or 0?
    jz  ll_not_phys_lpt     ;   Y:
    cmp bx, LPTB        ;Q: first LPT?
    je  ll_got_lpt_base     ;   Y:
    cmp ax, es:[bx-2]       ;Q: base same as previous (redirected)?
    jne ll_got_lpt_base     ;   N: must be real
ll_not_phys_lpt:
%OUT attempt to read base from SYSTEM.INI

ll_got_lpt_base:
    mov [si.Port], ax
    loop    ll_initl_lp

;
; create system timer for signalling chars in receive buffer
;

ifndef WOW
    mov ax, 100         ; create 100msec timer
    push    ax
    mov ax, _INTERRUPT
    push    ax
    mov ax, IntCodeOFFSET TimerProc
    push    ax
    call    CreateSystemTimer   ; ax = 0, if failed
%OUT should I display an error message here?

endif
    assumes es,nothing
LoadExit:
cEnd

sEnd    init

End LoadLib