freebsd-dev/contrib/libpcap/msdos/pkt_rx1.s

;
; This file requires NASM 0.97+ to assemble
;
; Currently used only for djgpp + DOS4GW targets
;
; these sizes MUST be equal to the sizes in PKTDRVR.H
;
%define  ETH_MTU     1500                  ; max data size on Ethernet
%define  ETH_MIN     60                    ; min/max total frame size
%define  ETH_MAX     (ETH_MTU+2*6+2)       ; =1514
%define  NUM_RX_BUF  32                    ; # of RX element buffers
%define  RX_SIZE     (ETH_MAX+6)           ; sizeof(RX_ELEMENT) = 1514+6
%idefine offset

struc RX_ELEMENT
      .firstCount  resw 1                  ; # of bytes on 1st call
      .secondCount resw 1                  ; # of bytes on 2nd call
      .handle      resw 1                  ; handle for upcall
    ; .timeStamp   resw 4                  ; 64-bit RDTSC value
      .destinAdr   resb 6                  ; packet destination address
      .sourceAdr   resb 6                  ; packet source address
      .protocol    resw 1                  ; packet protocol number
      .rxBuffer    resb ETH_MTU            ; RX buffer
endstruc

;-------------------------------------------

[org 0]  ; assemble to .bin file

_rxOutOfs   dw   offset _pktRxBuf          ; ring buffer offsets
_rxInOfs    dw   offset _pktRxBuf          ; into _pktRxBuf
_pktDrop    dw   0,0                       ; packet drop counter
_pktTemp    resb 20                        ; temp work area
_pktTxBuf   resb (ETH_MAX)                 ; TX buffer
_pktRxBuf   resb (RX_SIZE*NUM_RX_BUF)      ; RX structures
 LAST_OFS   equ  $

screenSeg   dw  0B800h
newInOffset dw  0

fanChars    db  '-\|/'
fanIndex    dw  0

%macro SHOW_RX 0
       push es
       push bx
       mov bx, [screenSeg]
       mov es, bx                    ;; r-mode segment of colour screen
       mov di, 158                   ;; upper right corner - 1
       mov bx, [fanIndex]
       mov al, [fanChars+bx]         ;; get write char
       mov ah, 15                    ;;  and white colour
       cld                           ;; Needed?
       stosw                         ;; write to screen at ES:EDI
       inc word [fanIndex]           ;; update next index
       and word [fanIndex], 3
       pop bx
       pop es
%endmacro

;PutTimeStamp
;       rdtsc
;       mov [si].timeStamp, eax
;       mov [si+4].timeStamp, edx
;       ret


;------------------------------------------------------------------------
;
; This routine gets called by the packet driver twice:
;   1st time (AX=0) it requests an address where to put the packet
;
;   2nd time (AX=1) the packet has been copied to this location (DS:SI)
;   BX has client handle (stored in RX_ELEMENT.handle).
;   CX has # of bytes in packet on both call. They should be equal.
; A test for equality is done by putting CX in _pktRxBuf [n].firstCount
; and _pktRxBuf[n].secondCount, and CL on first call in
; _pktRxBuf[n].rxBuffer[CX]. These values are checked in "PktReceive"
; (PKTDRVR.C)
;
;---------------------------------------------------------------------

_PktReceiver:
         pushf
         cli                         ; no distraction wanted !
         push ds
         push bx
         mov bx, cs
         mov ds, bx
         mov es, bx                  ; ES = DS = CS or seg _DATA
         pop bx                      ; restore handle

         cmp ax, 0                   ; first call? (AX=0)
         jne @post                   ; AX=1: second call, do post process

%ifdef DEBUG
         SHOW_RX                     ; show that a packet is received
%endif

         cmp cx, ETH_MAX             ; size OK ?
         ja  @skip                   ; no, too big

         mov ax, [_rxInOfs]
         add ax, RX_SIZE
         cmp ax, LAST_OFS
         jb  @noWrap
         mov ax, offset _pktRxBuf
@noWrap:
         cmp ax, [_rxOutOfs]
         je  @dump
         mov di, [_rxInOfs]          ; ES:DI -> _pktRxBuf[n]
         mov [newInOffset], ax

         mov [di], cx                ; remember firstCount.
         mov [di+4], bx              ; remember handle.
         add di, 6                   ; ES:DI -> _pktRxBuf[n].destinAdr
         pop ds
         popf
         retf                        ; far return to driver with ES:DI

@dump:   add word [_pktDrop+0], 1    ; discard the packet on 1st call
         adc word [_pktDrop+2], 0    ; increment packets lost

@skip:   xor di, di                  ; return ES:DI = NIL pointer
         xor ax, ax
         mov es, ax
         pop ds
         popf
         retf

@post:   or si, si                   ; DS:SI->_pktRxBuf[n][n].destinAdr
         jz @discard                 ; make sure we don't use NULL-pointer

       ;
       ; push si
       ; call bpf_filter_match       ; run the filter here some day
       ; pop si
       ; cmp ax, 0
       ; je  @discard

         mov [si-6+2], cx            ; store _pktRxBuf[n].secondCount
         mov ax, [newInOffset]
         mov [_rxInOfs], ax          ; update _pktRxBuf input offset

       ; call PutTimeStamp

@discard:
         pop ds
         popf
         retf

_pktRxEnd  db 0                      ; marker for end of r-mode code/data

END