source: xtideuniversalbios/trunk/Assembly_Library/Src/Serial/SerialServer.asm @ 601

; Project name  :   Assembly Library
; Description   :   Serial Server Support

;
; XTIDE Universal BIOS and Associated Tools
; Copyright (C) 2009-2010 by Tomi Tilli, 2011-2013 by XTIDE Universal BIOS Team.
;
; This program is free software; you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation; either version 2 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
; GNU General Public License for more details.
; Visit http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
;


%include "SerialServer.inc"

; Section containing code
SECTION .text

;--------------------------------------------------------------------
; SerialServer_SendReceive:
;   Parameters:
;       DX:     Packed I/O port and baud rate
;       ES:SI:  Ptr to buffer (for data transfer commands)
;       SS:BP:  Ptr to SerialServer_Command structure
;   Returns:
;       AH:     INT 13h Error Code
;       CX:     Number of 512-byte blocks transferred
;       CF:     Cleared if success, Set if error
;   Corrupts registers:
;       AL, BX, CX, DX
;--------------------------------------------------------------------
SerialServer_SendReceive:
    push    si
    push    di
    push    bp

;
; Unpack I/O port and baud from DPT
;       Port to DX for the remainder of the routine (+/- different register offsets)
;       Baud in CH until UART initialization is complete
;
    mov     ch, dh
    xor     dh, dh
    eSHL_IM dx, 2                       ; shift from one byte to two

    mov     al, [bp+SerialServer_Command.bSectorCount]
    mov     ah, [bp+SerialServer_Command.bCommand]

;
; Command byte and sector count live at the top of the stack, pop/push are used to access
;
    push    ax                          ; save sector count for return value
    push    ax                          ; working copy on the top of the stack

%ifndef EXCLUDE_FROM_XUB                ; DF already cleared in Int13h.asm
%ifdef CLD_NEEDED
    cld
%endif
%endif

;----------------------------------------------------------------------
;
; Initialize UART
;
; We do this each time since DOS (at boot) or another program may have
; decided to reprogram the UART
;
    mov     bl, dl                      ; setup BL with proper values for read/write loops (BH comes later)
    mov     al, 83h
    add     dl, Serial_UART_lineControl ; Clears CF
    out     dx, al

    mov     al, ch
    mov     dl, bl                      ; divisor low
    out     dx, al

%ifdef USE_UNDOC_INTEL
    salc                                ; Clear AL using CF
%else
    xor     al, al
%endif
    inc     dx                          ; divisor high
    push    dx
    out     dx, al

    mov     al, 47h
    inc     dx                          ; fifo
    out     dx, al

    mov     al, 03h
    inc     dx                          ; linecontrol
    out     dx, al

    mov     al, 0Bh
    inc     dx                          ; modemcontrol
    out     dx, al

    inc     dx                          ; linestatus (no output now, just setting up BH for later use)
    mov     bh, dl

    pop     dx                          ; base, interrupts disabled
%ifdef USE_UNDOC_INTEL
    salc                                ; Clear AL using CF
%else
    xor     al, al
%endif
    out     dx, al

;----------------------------------------------------------------------
;
; Send Command
;
; Sends first six bytes of IDEREGS_AND_INTPACK as the command
;
    push    es                          ; save off real buffer location
    push    si

    mov     si, bp                      ; point to IDEREGS for command dispatch;
    push    ss
    pop     es

    mov     di, 0FFFFh                  ; initialize checksum for write
    mov     bp, di

    mov     cx, 4                       ; writing 3 words (plus 1)

    cli                                 ; interrupts off...

    call    SerialServer_WriteProtocol.entry

    pop     di                          ; restore real buffer location (note change from SI to DI)
                                        ; Buffer is primarily referenced through ES:DI throughout, since
                                        ; we need to store (read sector) faster than we read (write sector)
    pop     es

    pop     ax                          ; load command byte (done before call to .nextSector on subsequent iterations)
    push    ax

%ifndef SERIALSERVER_NO_ZERO_SECTOR_COUNTS
    test    al, al                      ; if no sectors to be transferred, wait for the ACK checksum on the command
    jz      SHORT .zeroSectors
%endif

;
; Top of the read/write loop, one iteration per sector
;
.nextSector:
    mov     si, 0FFFFh                  ; initialize checksum for read or write
    mov     bp, si

    mov     cx, 0101h                   ; writing 256 words (plus 1)

    sahf                                ; command byte, are we doing a write?
    jnc     SHORT .readEntry

    xchg    si, di                      ; swap pointer and checksum, will be re-swap'ed in WriteProtocol
    call    SerialServer_WriteProtocol.entry

.zeroSectors:
    inc     cx                          ; CX = 1 now (0 out of WriteProtocol)
    jmp     SHORT .readEntry

;----------------------------------------------------------------------
;
; Timeout
;
; To save code space, we use the contents of DL to decide which byte in the word to return for reading.
;
.readTimeout:
    push    ax                          ; not only does this push preserve AX (which we need), but it also
                                        ; means the stack has the same number of bytes on it as when we are
                                        ; sending a packet, important for error cleanup and exit
    mov     ah, 1
    call    SerialServer_WaitAndPoll_Read
    pop     ax
    test    dl, 1
    jz      SHORT .readByte1Ready
    jmp     SHORT .readByte2Ready

;----------------------------------------------------------------------------
;
; Read Block (without interrupts, used when there is a FIFO, high speed)
;
; NOTE: This loop is very time sensitive.  Literally, another instruction
; cannot be inserted into this loop without us falling behind at high
; speed (460.8K baud) on a 4.77Mhz 8088, making it hard to receive
; a full 512 byte block.
;
.readLoop:
    stosw                               ; store word in caller's data buffer

    add     bp, ax                      ; update Fletcher's checksum
    adc     bp, 0
    add     si, bp
    adc     si, 0

.readEntry:
    mov     dl, bh
    in      al, dx
    shr     al, 1                       ; data ready (byte 1)?
    mov     dl, bl                      ; get ready to read data
    jnc     SHORT .readTimeout          ; nope not ready, update timeouts

;
; Entry point after initial timeout.  We enter here so that the checksum word
; is not stored (and is left in AX after the loop is complete).
;
.readByte1Ready:
    in      al, dx                      ; read data byte 1
    mov     ah, al                      ; store byte in ah for now

;
; note the placement of this reset of dl to bh, and that it is
; before the return, which is assymetric with where this is done
; above for byte 1.  The value of dl is used by the timeout routine
; to know which byte to return to (.read_byte1_ready or
; .read_byte2_ready)
;
    mov     dl, bh

    in      al, dx
    shr     al, 1                       ; data ready (byte 2)?
    jnc     SHORT .readTimeout
.readByte2Ready:
    mov     dl, bl
    in      al, dx                      ; read data byte 2
    xchg    al, ah                      ; ah was holding byte 1, reverse byte order
    loop    .readLoop
    sti                                 ; interrupts back on ASAP, between packets

;
; Compare checksums
;
    xchg    ax, bp
    xor     ah, al
    mov     cx, si
    xor     cl, ch
    mov     al, cl
    cmp     ax, bp
    jne     SHORT SerialServer_OutputWithParameters_Error

    pop     ax                          ; sector count and command byte
    dec     al                          ; decrement sector count
    push    ax                          ; save
    jz      SHORT SerialServer_OutputWithParameters_ReturnCodeInAL

    cli                                 ; interrupts back off for ACK byte to host
                                        ; (host could start sending data immediately)
    out     dx, al                      ; ACK with next sector number
    jmp     SHORT .nextSector

;---------------------------------------------------------------------------
;
; Cleanup, error reporting, and exit
;

;
; Used in situations where a call is underway, such as with SerialServer_WaitAndPoll
;
ALIGN JUMP_ALIGN
SerialServer_OutputWithParameters_ErrorAndPop4Words:
    add     sp, 8
;;; fall-through

ALIGN JUMP_ALIGN
SerialServer_OutputWithParameters_Error:
;----------------------------------------------------------------------
;
; Clear read buffer
;
; In case there are extra characters or an error in the FIFO, clear it out.
; In theory the initialization of the UART registers above should have
; taken care of this, but I have seen cases where this is not true.
;
    xor     cx, cx                      ; timeout this clearing routine, in case the UART isn't there
.clearBuffer:
    mov     dl, bh
    in      al, dx
    mov     dl, bl
    test    al, 8Fh
    jz      SHORT .clearBufferComplete
    test    al, 1
    in      al, dx
    loopnz  .clearBuffer                ; note ZF from test above

.clearBufferComplete:
    mov     al, 1                       ; error return code

ALIGN JUMP_ALIGN
SerialServer_OutputWithParameters_ReturnCodeInAL:
%if 0
    sti                                 ; all paths here will already have interrupts turned back on
%endif
    mov     ah, al                      ; for success, AL will already be zero

    pop     bx                          ; recover "ax" (command and count) from stack
    pop     cx                          ; recover saved sector count
    xor     ch, ch
    sub     cl, bl                      ; subtract off the number of sectors that remained

    pop     bp
    pop     di
    pop     si

    sahf                                ; error return code to CF
    ret


;--------------------------------------------------------------------
; SerialServer_WriteProtocol
;
; NOTE: As with its read counterpart, this loop is very time sensitive.
; Although it will still function, adding additional instructions will
; impact the write throughput, especially on slower machines.
;
;   Parameters:
;       ES:SI:  Ptr to buffer
;       CX:     Words to write, plus 1
;       BP/DI:  Initialized for Checksum (-1 in each)
;       DH:     I/O Port high byte
;       BX:     LineStatus Register address (BH) and Receive/Transmit Register address (BL)
;   Returns:
;       BP/SI:  Checksum for written bytes, compared against ACK from server in .readLoop
;       CX:     Zero
;       DL:     Receive/Transmit Register address
;       ES:DI:  Ptr to buffer
;   Corrupts registers:
;       AX
;--------------------------------------------------------------------
ALIGN JUMP_ALIGN
SerialServer_WriteProtocol:
.writeLoop:
    es lodsw                            ; fetch next word

    out     dx, al                      ; output first byte

    add     bp, ax                      ; update checksum
    adc     bp, 0
    add     di, bp
    adc     di, 0

    mov     dl, bh                      ; transmit buffer empty?
    in      al, dx
    test    al, 20h
    jz      SHORT .writeTimeout2        ; nope, use our polling routine

.writeByte2Ready:
    mov     dl, bl
    mov     al, ah                      ; output second byte
    out     dx, al

.entry:
    mov     dl, bh                      ; transmit buffer empty?
    in      al, dx
    test    al, 20h
    mov     dl, bl
    jz      SHORT .writeTimeout1        ; nope, use our polling routine

.writeByte1Ready:
    loop    .writeLoop

    mov     ax, di                      ; fold Fletcher's checksum and output
    xor     al, ah
    out     dx, al                      ; byte 1

    call    SerialServer_WaitAndPoll_Write

    mov     ax, bp
    xor     al, ah
    out     dx, al                      ; byte 2

    xchg    si, di                      ; preserve checksum word in si, move pointer back to di
    ret

.writeTimeout2:
    mov     dl, ah                      ; need to preserve AH, but don't need DL (will be reset upon return)
    call    SerialServer_WaitAndPoll_Write
    mov     ah, dl
    jmp     SHORT .writeByte2Ready

.writeTimeout1:
    ePUSH_T ax, .writeByte1Ready        ; return address for ret at end of SC_writeTimeout2
;;; fall-through

;--------------------------------------------------------------------
; SerialServer_WaitAndPoll
;
;   Parameters:
;       AH:     UART_LineStatus bit to test (20h for write, or 1h for read)
;               One entry point fills in AH with 20h for write
;       DX:     Port address (OK if already incremented to UART_lineStatus)
;       BX:
;       Stack:  2 words on the stack below the command/count word
;   Returns:
;       Returns when desired UART_LineStatus bit is cleared
;       Jumps directly to error exit if timeout elapses (and cleans up stack)
;   Corrupts registers:
;       AX
;--------------------------------------------------------------------

SerialServer_WaitAndPoll_SoftDelayTicks   EQU   20

ALIGN JUMP_ALIGN
SerialServer_WaitAndPoll_Write:
    mov     ah, 20h
;;; fall-through

ALIGN JUMP_ALIGN
SerialServer_WaitAndPoll_Read:
    push    cx
    push    dx

;
; We first poll in a tight loop, interrupts off, for the next character to come in/be sent
;
    xor     cx, cx
.readTimeoutLoop:
    mov     dl, bh
    in      al, dx
    test    al, ah
    jnz     SHORT .readTimeoutComplete
    loop    .readTimeoutLoop

;
; If that loop completes, then we assume there is a long delay involved, turn interrupts back on
; and wait for a given number of timer ticks to pass.
;
    sti
%ifndef SERIALSERVER_TIMER_LOCATION
    mov     cl, SerialServer_WaitAndPoll_SoftDelayTicks
    call    Timer_InitializeTimeoutWithTicksInCL
%else
    push    ax
    push    bx
    mov     ax, SerialServer_WaitAndPoll_SoftDelayTicks
    mov     bx, SERIALSERVER_TIMER_LOCATION
    call    TimerTicks_InitializeTimeoutFromAX
    pop     bx
    pop     ax
%endif

.WaitAndPoll:
%ifndef SERIALSERVER_TIMER_LOCATION
    call    Timer_SetCFifTimeout
%else
    push    ax
    push    bx
    mov     bx, SERIALSERVER_TIMER_LOCATION
    call    TimerTicks_GetTimeoutTicksLeftToAXfromDSBX
    pop     bx
    pop     ax
%endif
    jc      SerialServer_OutputWithParameters_ErrorAndPop4Words
    in      al, dx
    test    al, ah
    jz      SHORT .WaitAndPoll
    cli

.readTimeoutComplete:
    pop     dx
    pop     cx
    ret