; kern_wasm.asm
;
; Open Watcom WASM/MASM-syntax port of the old TASM IDEAL kern.asm.
; Intended for 16-bit DOS large memory model builds on Linux with Open Watcom v2.
;
; Keep kern.asm as the historical TASM source and use this file for the
; reproducible Open Watcom build.

.386
.model large

.data
enterIPX dd 0

.code

public  _IPXinit
public  _IPXopen_socket
public  _IPXclose_socket
public  _IPXlisten
public  _xmemmove
public  _Net_Call
public  _C32_LoadNios_Probe
public  _Net_Call_VLM_Raw

_IPXinit proc far
        push    bp
        mov     bp, sp
        push    ds
        push    si
        push    di

        mov     ax, 7A00h
        int     2Fh
        cmp     al, 0FFh
        jne     ipxinit_done

        mov     cx, @data
        mov     ds, cx
        mov     word ptr enterIPX, di
        mov     ax, es
        mov     word ptr enterIPX+2, ax
        mov     al, 1

ipxinit_done:
        mov     ah, 0

        pop     di
        pop     si
        pop     ds
        pop     bp
        ret
_IPXinit endp

_xmemmove proc far
        push    bp
        mov     bp, sp

        ; far procedure stack layout, large model:
        ; [bp+0]  old bp
        ; [bp+2]  return offset
        ; [bp+4]  return segment
        ; [bp+6]  z offset
        ; [bp+8]  z segment
        ; [bp+10] q offset
        ; [bp+12] q segment
        ; [bp+14] nmbr

        cli
        mov     cx, [bp+14]
        or      cx, cx
        jz      xmem_done

        push    ds
        push    si
        push    di
        pushf

        lds     si, dword ptr [bp+10]
        les     di, dword ptr [bp+6]
        cmp     di, si
        jl      xmem_forward

        std
        dec     cx
        add     di, cx
        add     si, cx
        inc     cx
        jmp     xmem_copy

xmem_forward:
        cld

xmem_copy:
        rep     movsb

        popf
        pop     di
        pop     si
        pop     ds

xmem_done:
        pop     bp
        sti
        ret
_xmemmove endp

_IPXopen_socket proc far
        push    bp
        mov     bp, sp
        push    ds
        push    si
        push    di

        ; int IPXopen_socket(UI sock, int live)
        mov     ax, [bp+8]       ; live
        mov     dx, [bp+6]       ; sock
        mov     bx, @data
        mov     ds, bx
        mov     bx, 0
        call    dword ptr enterIPX

        cmp     al, 0FFh
        jne     ipxopen_not_already
        mov     ax, -1           ; socket already open
        jmp     ipxopen_done

ipxopen_not_already:
        cmp     al, 0FEh
        jne     ipxopen_ok
        mov     ax, -2           ; socket table full
        jmp     ipxopen_done

ipxopen_ok:
        mov     ax, dx

ipxopen_done:
        pop     di
        pop     si
        pop     ds
        pop     bp
        ret
_IPXopen_socket endp

_IPXclose_socket proc far
        push    bp
        mov     bp, sp
        push    ds
        push    si
        push    di

        ; void IPXclose_socket(UI sock)
        mov     dx, [bp+6]
        mov     bx, @data
        mov     ds, bx
        mov     bx, 1
        call    dword ptr enterIPX

        pop     di
        pop     si
        pop     ds
        pop     bp
        ret
_IPXclose_socket endp

_IPXlisten proc far
        push    bp
        mov     bp, sp
        push    ds
        push    si
        push    di

        ; int IPXlisten(ECB *ecb)
        les     si, dword ptr [bp+6]
        mov     bx, @data
        mov     ds, bx
        mov     bx, 4
        call    dword ptr enterIPX

        pop     di
        pop     si
        pop     ds
        pop     bp
        mov     ah, 0
        ret
_IPXlisten endp

_Net_Call proc far
        push    bp
        mov     bp, sp

        ; int Net_Call(UI func, void *req, void *repl)
        ; [bp+6]  func
        ; [bp+8]  req offset
        ; [bp+10] req segment
        ; [bp+12] repl offset
        ; [bp+14] repl segment
        mov     ax, [bp+6]

        push    ds
        push    si
        push    di
        pushf

        lds     si, dword ptr [bp+8]
        les     di, dword ptr [bp+12]
        int     21h

        popf
        pop     di
        pop     si
        pop     ds
        pop     bp
        mov     ah, 0
        ret
_Net_Call endp

; int Net_Call_VLM_Raw(UI ax, UI bx, UI cx, UI dx,
;                      void *req, void *repl,
;                      UI p1, UI p2, UI p3)
;
; Experimental VLM entry caller.
; INT 2F AX=7A20 returns ES:BX = VLM entry if AX == 0000.
;
; Register setup for VLM entry:
;   AX, BX, CX, DX from function args
;   DS:SI = req
;   ES:DI = repl
;
; Extra stack args pushed before calling VLM entry:
;   p3, p2, p1
;
; For NWCREQUEST/VLM test:
;   AX=function
;   BX=numReqFrags
;   CX=connid
;   DX=numReplyFrags
;   DS:SI=reqFragList
;   ES:DI=replyFragList
;   p1=6, p2=20h, p3=0
_Net_Call_VLM_Raw proc far
        push    bp
        mov     bp, sp
        sub     sp, 4

        push    ds
        push    si
        push    di
        push    es

        mov     ax, 7A20h
        xor     bx, bx
        int     2Fh
        or      ax, ax
        jz      vlm_raw_found

        mov     ax, 88FFh
        jmp     short vlm_raw_done

vlm_raw_found:
        ; save VLM entry ES:BX in stack locals
        mov     [bp-4], bx
        mov     ax, es
        mov     [bp-2], ax

        ; load caller-requested registers
        mov     ax, [bp+6]
        mov     bx, [bp+8]
        mov     cx, [bp+10]
        mov     dx, [bp+12]
        lds     si, dword ptr [bp+14]
        les     di, dword ptr [bp+18]

        push    word ptr [bp+26]
        push    word ptr [bp+24]
        push    word ptr [bp+22]
        call    dword ptr [bp-4]

vlm_raw_done:
        pop     es
        pop     di
        pop     si
        pop     ds

        mov     sp, bp
        pop     bp
        ret
_Net_Call_VLM_Raw endp


; int C32_LoadNios_Probe(UI axfunc, void *outbuf)
;
; Probe the Client32/NIOS INT 2F entry used by DeveloperNet dninit.asm:
;   AX = axfunc, normally D8C1h
;   INT 2Fh
;   AX = 0000 on success
;   ESI and ECX contain Client32/NIOS function pointers/data
;
; outbuf layout, little endian:
;   +00 word AX after int 2F
;   +02 dword ESI after int 2F
;   +06 dword ECX after int 2F
;   +0A word BX
;   +0C word CX low
;   +0E word DX
;   +10 word SI low
;   +12 word DI low
_C32_LoadNios_Probe proc far
        push    bp
        mov     bp, sp

        push    ds
        push    es
        push    si
        push    di

        xor     ecx, ecx
        xor     esi, esi
        xor     ebx, ebx
        xor     edx, edx
        xor     edi, edi

        mov     ax, [bp+6]
        int     2Fh

        les     di, dword ptr [bp+8]

        mov     es:[di+0], ax
        mov     dword ptr es:[di+2], esi
        mov     dword ptr es:[di+6], ecx
        mov     es:[di+10], bx
        mov     es:[di+12], cx
        mov     es:[di+14], dx
        mov     es:[di+16], si
        ; DI currently points at outbuf, so store caller-visible DI is not useful.
        mov     word ptr es:[di+18], 0

        pop     di
        pop     si
        pop     es
        pop     ds
        pop     bp
        xor     ah, ah
        ret
_C32_LoadNios_Probe endp


end