home *** CD-ROM | disk | FTP | other *** search
/ The Pier Shareware 6 / The_Pier_Shareware_Number_6_(The_Pier_Exchange)_(1995).iso / 024 / psi110g.zip / PCGEN.ASM < prev    next >
Assembly Source File  |  1994-08-26  |  24KB  |  892 lines
  1. ; Collection of assembler support routines for NOS
  2. ; Copyright 1991 Phil Karn, KA9Q
  3.  
  4. ;%    .MODEL  MEMMOD,C
  5. include asmglobal.h        
  6.     LOCALS
  7.     %MACS
  8.     .LALL
  9.     extrn   ctick:proc
  10.     public  eoi
  11.  
  12. ; Hardware vector for timer linkage
  13. ; We use the timer hardware channel here instead of the indirect BIOS
  14. ; channel (1ch) because the latter is sluggish when running under DoubleDos
  15. TIMEVEC EQU     08h
  16.  
  17.     .DATA
  18.     public  Intstk,Stktop,Spsave,Sssave,Mtasker,Hashtab
  19.     extrn   Isat:word
  20. Spsave  dw      ?               ; Save location for SP during interrupts
  21. Sssave  dw      ?               ; Save location for SS during interrupts
  22. Intstk  dw      512 dup(?)      ; Interrupt working stack
  23. Stktop  equ     $               ; SP set here when entering interrupt
  24. Mtasker db      ?               ; Type of higher multitasker, if any
  25. Hashtab db      256 dup(?)      ; Modulus lookup table for iphash()
  26.     .CODE
  27. dbase   dw      @Data
  28. jtable  dw      l0,l1,l2,l3,l4,l5,l6,l7,l8,l9,l10,l11,l12,l13,l14,l15   
  29.  
  30. vector  dd      ?               ; place to stach chained vector
  31. vectlo  equ     word ptr vector
  32. vecthi  equ     word ptr vector+2
  33.  
  34. ; Re-arm 8259 interrupt controller(s)
  35. ; Should be called just after taking an interrupt, instead of just
  36. ; before returning. This is because the 8259 inputs are edge triggered, and
  37. ; new interrupts arriving during an interrupt service routine might be missed.
  38. eoi     proc
  39.     cmp     Isat,1
  40.     jnz     @@1             ; Only one 8259, so skip this stuff
  41.     mov     al,0bh          ; read in-service register from
  42.     out     0a0h,al         ; secondary 8259
  43.     nop                     ; settling delay
  44.     nop
  45.     nop
  46.     in      al,0a0h         ; get it
  47.     or      al,al           ; Any bits set?
  48.     jz      @@1             ; nope, not a secondary interrupt
  49.     mov     al,20h          ; Get EOI instruction
  50.     out     0a0h,al         ; Secondary 8259 (PC/AT only)
  51. @@1:    mov     al,20h          ; 8259 end-of-interrupt command
  52.     out     20h,al          ; Primary 8259
  53.     ret
  54. eoi     endp
  55.  
  56. ; Note that all hardware interrupt handlers are expected to return
  57. ; the original vector found when the device first attached.  We branch
  58. ; to it just after we've cleaned up here -- this implements shared
  59. ; interrupts through vector chaining.  If the original vector isn't
  60. ; available, the interrupt handler must return NULL to avoid a crash!
  61.  
  62.         public  doretch
  63.         label   doretch   far
  64.         cmp     ax,0            ; is a chained vector present?
  65.         jne     @@1             ; yes
  66.         if      @Datasize NE 0
  67.                 cmp     dx,ax
  68.                 jne     @@1
  69.         endif
  70.  
  71. ; common routine for interrupt return
  72.     public  doret
  73.     label   doret   far
  74.     pop     es
  75.     POPALL
  76.       ;  pop     di
  77.       ;  pop     si
  78.       ;  pop     bp
  79.       ;  pop     dx
  80.       ;  pop     cx
  81.       ;  pop     bx
  82.       ;  pop     ax
  83.     mov     ss,Sssave
  84.     mov     sp,Spsave       ; restore original stack context
  85.     pop     ds
  86.     iret
  87.  
  88. ; Code to handle vector chaining
  89. @@1:    mov     cs:vectlo,ax    ; stash vector for later branch
  90.         if      @Datasize NE 0
  91.                 mov     cs:vecthi,dx
  92.         endif
  93.         pop     es
  94.     POPALL
  95.         mov     ss,Sssave
  96.         mov     sp,Spsave       ; restore original stack context
  97.         pop     ds
  98.         if      @Datasize NE 0
  99.                 jmp     cs:[vector]     ; jump to the original interrupt handler
  100.         else
  101.                 jmp     cs:[vectlo]
  102.         endif
  103.  
  104. ; istate - return current interrupt state
  105.     public  istate
  106. istate  proc
  107.     pushf
  108.     pop     ax
  109.     and     ax,200h
  110.     jnz     @@1
  111.     ret
  112. @@1:    mov     ax,1
  113.     ret
  114. istate  endp
  115.  
  116. ; dirps - disable interrupts and return previous state: 0 = disabled,
  117. ;       1 = enabled
  118.     public dirps
  119. dirps   proc
  120.     pushf                   ; save flags on stack
  121.     pop     ax              ; flags -> ax
  122.     and     ax,200h         ; 1<<9 is IF bit
  123.     jz      @@1             ; ints are already off; return 0
  124.     mov     ax,1
  125.     cli                     ; interrupts now off
  126. @@1:    ret
  127. dirps   endp
  128.  
  129. ; restore - restore interrupt state: 0 = off, nonzero = on
  130.     public  restore
  131. restore proc
  132.     arg is:word
  133.     test    is,0ffffh
  134.     jz      @@1
  135.     sti
  136.     ret
  137. @@1:    cli     ; should already be off, but just in case...
  138.     ret
  139. restore endp
  140.  
  141. ; multitasker types
  142. NONE            equ     0
  143. DOUBLEDOS       equ     1
  144. DESQVIEW        equ     2
  145. WINDOWS3        equ     3
  146. DOS5STYLE       equ     4
  147. OS2STYLE        equ     5
  148. DPMISTYLE       equ     6
  149.  
  150. ; Relinquish processor so other task can run
  151.     public  giveup
  152. giveup  proc
  153.     pushf           ;save caller's interrupt state
  154.     sti             ;re-enable interrupts
  155.     cmp     mtasker, DOUBLEDOS
  156.     jnz     @@1
  157.     mov     al,2    ; 110 ms
  158.     mov     ah,0eeh
  159.     int     21h
  160.     popf            ; restore caller's interrupt state
  161.     ret
  162.  
  163. @@1:    cmp     mtasker, DESQVIEW
  164.     jnz     @@2
  165.     mov     ax, 1000h
  166.     int     15h
  167.     popf            ; restore interrupts
  168.     ret
  169.  
  170. @@2:    cmp     mtasker, WINDOWS3
  171.     je      @@4
  172.     cmp     mtasker, OS2STYLE
  173.     je      @@4
  174.     cmp     mtasker, DOS5STYLE
  175.     je      @@4
  176.     cmp     mtasker, DPMISTYLE
  177.     jne     @@3
  178. @@4:    mov     ax, 1680h       ; Release time for DOS 5, OS/2 VDM, Win 3.x
  179.     int     2fh
  180.     cmp     al, 80h ; call supported?
  181.     jz      @@3     ; nope
  182.     popf            ; yes - restore interrupts
  183.     ret
  184.  
  185. @@3:    hlt             ; wait for an interrupt
  186.     popf            ; restore interrupts
  187.     ret
  188. giveup  endp
  189.  
  190. ; check for a multitasker running
  191.     public  chktasker
  192. chktasker       proc
  193.     mov     mtasker,NONE
  194.  
  195.     ; Check for Microsoft Windows
  196.     mov     ax,1600h
  197.     int     2fh
  198.     test    al,7fh          ; 00h or 80h means Windows not multitasking
  199.     jz      @@4
  200.     mov     mtasker, WINDOWS3
  201.     ret
  202.  
  203.     ; Check for DoubleDos
  204. @@4:    mov     ah,0e4h
  205.     int     21h
  206.     cmp     al,1
  207.     jz      @@1
  208.     cmp     al,2
  209.     jnz     @@2
  210. @@1:    mov     mtasker, DOUBLEDOS
  211.     ret
  212.  
  213.     ; Check for DESQVIEW
  214. @@2:    mov     ax, 2b01h
  215.     mov     cx, 4445h
  216.     mov     dx, 5351h
  217.     int     21h
  218.     cmp     al, 0ffh
  219.     jz      @@3
  220.     mov     mtasker, DESQVIEW
  221.     ret
  222.  
  223.     ; Check for DOS 5.0 or OS/2 2.0 (N1BEE)
  224. @@3:    mov     ax, 3306h       ;Get true DOS version
  225.     xor     bx,bx
  226.     int     21h
  227.     cmp     bl, 20          ;DOS 20.x (OS/2 2.0 DOS emulation)
  228.     jne     @@5
  229.     mov     mtasker, OS2STYLE
  230.     ret
  231.  
  232. @@5:    cmp     bl, 5           ;DOS 5.x
  233.     je     @@5A
  234.     cmp     bl, 6               ;DOS 6.x
  235.     jne     @@6
  236. @@5A:
  237.     mov     mtasker, DOS5STYLE      ;Release time same way as Win 3.x
  238.     ret
  239.     
  240.     ; Handle OS/2 Virtual Boot Machine (N1BEE)
  241. @@6:    mov     ax, 1687h       ;Check DPMI installed state
  242.     int     2fh
  243.     or      ax,ax   
  244.     jnz     @@7
  245.     mov     mtasker, DPMISTYLE
  246. @@7:    ret
  247.  
  248. chktasker       endp
  249.  
  250.  
  251.  
  252. ; getss - Read SS for debugging purposes
  253.     public  getss
  254. getss   proc
  255.     mov     ax,ss
  256.     ret
  257. getss   endp
  258.  
  259. ; clockbits - Read low order bits of timer 0 (the TOD clock)
  260. ; This works only for the 8254 chips used in ATs and 386s.
  261. ;
  262. ; The timer runs in mode 3 (square wave mode), counting down
  263. ; by twos, twice for each cycle. So it is necessary to read back the
  264. ; OUTPUT pin to see which half of the cycle we're in. I.e., the OUTPUT
  265. ; pin forms the most significant bit of the count. Unfortunately,
  266. ; the 8253 in the PC/XT lacks a command to read the OUTPUT pin...
  267. ;
  268. ; The PC's clock design is soooo brain damaged...
  269.  
  270.     public  clockbits
  271. clockbits       proc
  272.     mov     al,0c2h ; latch timer 0 count and status for reading
  273.     pushf
  274.     cli             ; make chip references atomic
  275.     out     43h,al  ; send latch command
  276.     in      al,40h  ; get status of timer 0
  277.     mov     bl,al   ; save status
  278.     in      al,40h  ; get lsb of count
  279.     mov     ah,al   ; save lsb
  280.     in      al,40h  ; get msb of count
  281.     popf            ; no more chip references
  282.     and     bl,80h  ; we're only interested in the OUT bit
  283.     xchg    ah,al   ; ax = count in correct order
  284.     shr     ax,1    ; count /= 2
  285.     jz      @@3     ; zero count requires carry propagation
  286. @@2:    or      ah,bl   ; combine with OUT bit as most sig bit of count
  287.     ret
  288. @@3:    xor     bl,80h  ; propagate carry by toggling OUT bit when cnt == 0
  289.     or      ah,bl   ; combine with !OUT bit as most sig bit of count
  290.     ret
  291.  
  292. clockbits       endp
  293.  
  294. ; Internet checksum subroutine
  295. ; Compute 1's-complement sum of data buffer
  296. ; Uses an unwound loop inspired by "Duff's Device" for performance
  297. ;
  298. ; Called from C as
  299. ; unsigned short
  300. ; lcsum(buf,cnt)
  301. ; unsigned short *buf;
  302. ; unsigned short cnt;
  303.     public  lcsum
  304. lcsum   proc
  305.     arg     buf:ptr,cnt:word
  306.  
  307.     if      @Datasize NE 0
  308.         uses    ds,si
  309.         lds     si,buf  ; ds:si = buf
  310.     else
  311.         uses    si
  312.         mov     si,buf  ; ds:si = buf (ds already set)
  313.     endif
  314.  
  315.     mov     cx,cnt          ; cx = cnt
  316.     cld                     ; autoincrement si
  317.     mov     ax,cx
  318.     shr     cx,1            ; cx /= 16, number of loop iterations
  319.     shr     cx,1
  320.     shr     cx,1
  321.     shr     cx,1
  322.  
  323.     inc     cx              ; make fencepost adjustment for 1st pass
  324.     and     ax,15           ; ax = number of words modulo 16
  325.     shl     ax,1            ; *=2 for word table index
  326.     lea     bx,jtable       ; bx -> branch table
  327.     add     bx,ax           ; index into jump table
  328.     clc                     ; initialize carry = 0
  329.     mov     dx,0            ; clear accumulated sum
  330.     jmp     word ptr cs:[bx]        ; jump into loop
  331.  
  332. ; Here the real work gets done. The numeric labels on the lodsw instructions
  333. ; are the targets for the indirect jump we just made.
  334. ;
  335. ; Each label corresponds to a possible remainder of (count / 16), while
  336. ; the number of times around the loop is determined by the quotient.
  337. ;
  338. ; The loop iteration count in cx has been incremented by one to adjust for
  339. ; the first pass.
  340. ; 
  341. deloop: lodsw
  342.     adc     dx,ax
  343. l15:    lodsw
  344.     adc     dx,ax
  345. l14:    lodsw
  346.     adc     dx,ax
  347. l13:    lodsw
  348.     adc     dx,ax
  349. l12:    lodsw
  350.     adc     dx,ax
  351. l11:    lodsw
  352.     adc     dx,ax
  353. l10:    lodsw
  354.     adc     dx,ax
  355. l9:     lodsw
  356.     adc     dx,ax
  357. l8:     lodsw
  358.     adc     dx,ax
  359. l7:     lodsw
  360.     adc     dx,ax
  361. l6:     lodsw
  362.     adc     dx,ax
  363. l5:     lodsw
  364.     adc     dx,ax
  365. l4:     lodsw
  366.     adc     dx,ax
  367. l3:     lodsw
  368.     adc     dx,ax
  369. l2:     lodsw
  370.     adc     dx,ax
  371. l1:     lodsw
  372.     adc     dx,ax
  373. l0:     loop    deloop          ; :-)
  374.  
  375.     adc     dx,0            ; get last carries
  376.     adc     dx,0
  377.     mov     ax,dx           ; result into ax
  378.     xchg    al,ah           ; byte swap result (8088 is little-endian)
  379.     ret
  380. lcsum   endp
  381.  
  382. ; Link timer handler into timer chain
  383. ; Arg == address of timer handler routine
  384. ; MUST be called exactly once before uchtimer is called!
  385.  
  386. toff    dw      ?               ; save location for old vector
  387. tseg    dw      ?               ;  must be in code segment
  388.  
  389.     public  chtimer
  390. chtimer proc
  391.     arg     vec:far ptr
  392.     uses    ds
  393.  
  394.     mov     ah,35h          ; get current vector
  395.     mov     al,TIMEVEC
  396.     int     21h             ; puts vector in es:bx
  397.     mov     cs:tseg,es      ; stash
  398.     mov     cs:toff,bx
  399.  
  400.     mov     ah,25h
  401.     mov     al,TIMEVEC
  402.     lds     dx,vec          ; ds:si = vec
  403.  
  404.     int     21h             ; set new vector
  405.     ret
  406. chtimer endp
  407.  
  408. ; unchain timer handler from timer chain
  409. ; MUST NOT be called before chtimer!
  410.     public  uchtimer
  411. uchtimer        proc
  412.     uses    ds
  413.  
  414.     mov     ah,25h
  415.     mov     al,TIMEVEC
  416.     mov     dx,toff
  417.     mov     ds,tseg
  418.     int     21h             ; restore old vector
  419.     ret
  420. uchtimer        endp
  421.  
  422. ; Clock tick interrupt handler. Note the use of "label" rather than "proc"
  423. ; here, necessitated by the fact that "proc" automatically generates BP-saving
  424. ; code that we don't want here.
  425.  
  426.     public  btick
  427.     label   btick   far
  428.  
  429.     pushf
  430.     push    ds
  431.     cli
  432.     mov     ds,cs:dbase     ; establish interrupt data segment
  433.  
  434.     mov     Sssave,ss       ; stash user stack context
  435.     mov     Spsave,sp
  436.  
  437.     mov     ss,cs:dbase
  438.     lea     sp,Stktop
  439.  
  440.       ;  push    ax              ; save user regs on interrupt stack
  441.       ;  push    bx
  442.       ;  push    cx
  443.       ;  push    dx
  444.       ;  push    bp
  445.       ;  push    si
  446.       ;  push    di
  447.       ;  push    es
  448.     PUSHALL
  449.     push    es
  450.     call    ctick
  451.  
  452.     pop     es
  453.     POPALL
  454.       ;  pop     di
  455.       ;  pop     si
  456.       ;  pop     bp
  457.       ;  pop     dx
  458.       ;  pop     cx
  459.       ;  pop     bx
  460.       ;  pop     ax
  461.     mov     ss,Sssave
  462.     mov     sp,Spsave       ; restore original stack context
  463.     pop     ds
  464.     popf
  465.     jmp     dword ptr [toff]                ; link to previous vector
  466.  
  467. ; Convert 32-bit int in network order to host order (dh, dl, ah, al)
  468. ; Called from C as
  469. ; int32 get32(char *cp);
  470.  
  471.     public  get32
  472. get32   proc
  473.     arg     cp:ptr
  474.     if      @Datasize NE 0
  475.         uses    ds,si
  476.         lds     si,cp   ; ds:si = cp
  477.     else
  478.         uses    si
  479.         mov     si,cp   ; ds:si = cp (ds already set)
  480.     endif
  481.  
  482.     cld
  483.     lodsw
  484.     mov     dh,al   ; high word to dx, a-swapping as we go
  485.     mov     dl,ah
  486.     lodsw
  487.     xchg    al,ah   ; low word stays in ax, just swap
  488.     ret
  489. get32   endp
  490.  
  491. ; Convert 16-bit int in network order to host order (ah, al)
  492. ; Called from C as
  493. ; int16 get16(char *cp);
  494.  
  495.     public  get16
  496. get16   proc
  497.     arg     cp:ptr
  498.     if      @Datasize NE 0
  499.         uses    ds,si
  500.         lds     si,cp   ; ds:si = cp
  501.     else
  502.         uses    si
  503.         mov     si,cp   ; ds:si = cp (ds already set)
  504.     endif
  505.  
  506.     lodsw           ; note: direction flag is don't-care
  507.     xchg    al,ah   ; word stays in ax, just swap
  508.     ret
  509. get16   endp
  510.  
  511. ; Convert 32-bit int to network order, returning new pointer
  512. ; Called from C as
  513. ; char *put32(char *cp,int32 x);
  514.  
  515.     public  put32
  516. put32   proc
  517.     arg     cp:ptr,x:dword
  518.     if      @Datasize NE 0
  519.         uses    ds,di
  520.         les     di,cp   ; es:di = cp
  521.         mov     ax,ss   ; our parameter is on the stack, and ds might not
  522.         mov     ds,ax   ;   be pointing to ss.
  523.     else
  524.         uses    di
  525.         mov     di,cp   ; es:di = cp
  526.         mov     ax,ds   ; point es at data segment
  527.         mov     es,ax
  528.     endif
  529.  
  530.     cld
  531.     mov     ax,word ptr (x+2)       ; read high word of machine version
  532.     xchg    ah,al                   ; swap bytes
  533.     stosw                           ; output in network order
  534.     mov     ax,word ptr x           ; read low word of machine version
  535.     xchg    ah,al                   ; swap bytes
  536.     stosw                           ; put in network order
  537.  
  538.     mov     ax,di   ; return incremented output pointer
  539.     if      @Datasize NE 0
  540.         mov     dx,es   ; upper half of pointer
  541.     endif
  542.     ret
  543. put32   endp
  544.  
  545. ; Convert 16-bit int to network order, returning new pointer
  546. ; Called from C as
  547. ; char *put16(char *cp,int16 x);
  548.  
  549.     public  put16
  550. put16   proc
  551.     arg     cp:ptr,x:word
  552.     uses    di
  553.     if      @Datasize NE 0
  554.         les     di,cp   ;es:di = cp
  555.     else
  556.         mov     di,cp   ; es:di = cp
  557.         mov     ax,ds
  558.         mov     es,ax
  559.     endif
  560.     cld
  561.     mov     ax,x    ; fetch source word in machine order
  562.     xchg    ah,al   ; swap bytes
  563.     stosw           ; save in network order
  564.     mov     ax,di   ; return new output pointer to user
  565.     if      @Datasize NE 0
  566.         mov     dx,es   ; upper half of pointer
  567.     endif
  568.     ret
  569. put16   endp
  570.  
  571. ; kbraw - raw, nonblocking read from console
  572. ; If character is ready, return it; if not, return -1
  573.     public  kbraw
  574. kbraw   proc
  575.     mov     ah,06h  ; Direct Console I/O
  576.     mov     dl,0ffh ; Read from keyboard
  577.     int     21h     ; Call DOS
  578.     jz      @@1     ; zero flag set -> no character ready
  579.     mov     ah,0    ; valid char is 0-255
  580.     ret
  581. @@1:    mov     ax,-1   ; no char, return -1
  582.     ret
  583. kbraw   endp
  584.  
  585. if      @CPU AND 2
  586. ; fast I/O buffer routines
  587. ; version for 80186, 286, 386 (uses ins, outs instructions)
  588.  
  589. ; outbuf - put a buffer to an output port
  590.     public  outbuf
  591. outbuf  proc
  592.     arg     port:word,buf:ptr,cnt:word
  593.     if      @Datasize NE 0
  594.         uses    ds,si
  595.         lds     si,buf  ; ds:si = buf
  596.     else
  597.         uses    si
  598.         mov     si,buf  ;ds:si = buf (ds already set)
  599.     endif
  600.     mov     dx,port
  601.     mov     cx,cnt
  602.     cld
  603.     rep outsb               ; works only on PC/AT (80286)
  604.     mov     dx,ds
  605.     mov     ax,si           ; return pointer just past end of buffer
  606.     ret
  607. outbuf  endp
  608.  
  609. ; inbuf - get a buffer from an input port
  610.     public  inbuf
  611. inbuf   proc
  612.     arg     port:word,buf:ptr,cnt:word
  613.     uses    di
  614.     if      @Datasize NE 0
  615.         les     di,buf          ; es:di = buf
  616.     else
  617.         mov     di,buf          ; es:di = buf
  618.         mov     ax,ds
  619.         mov     es,ax
  620.     endif
  621.     mov     dx,port
  622.     mov     cx,cnt
  623.     cld
  624.     rep insb                ; works only on PC/AT (80286)
  625.     mov     dx,es
  626.     mov     ax,di           ; return pointer just past end of buffer
  627.     ret
  628. inbuf   endp
  629.  
  630. else
  631.  
  632. ; fast buffer I/O routines
  633. ; version for 8086/8
  634.  
  635. ; outbuf - put a buffer to an output port
  636.     public  outbuf
  637. outbuf  proc
  638.     arg     port:word,buf:ptr,cnt:word
  639.     if      @Datasize NE 0
  640.         uses    ds,si
  641.         lds     si,buf  ; ds:si = buf
  642.     else
  643.         uses    si
  644.         mov     si,buf  ; ds:si = buf (ds already set)
  645.     endif
  646.  
  647.     mov     dx,port
  648.     mov     cx,cnt
  649.     cld
  650.  
  651. ; If buffer doesn't begin on a word boundary, send the first byte
  652.     test    si,1    ; (buf & 1) ?
  653.     jz      @@even ; no
  654.     lodsb           ; al = *si++;
  655.     out     dx,al   ; out(dx,al);
  656.     dec     cx      ; cx--;
  657.     mov     cnt,cx  ; save for later test
  658. @@even:
  659.     shr     cx,1    ; cx = cnt >> 1; (convert to word count)
  660. ; Do the bulk of the buffer, a word at a time
  661.     jcxz    @@nobuf ; if(cx != 0){
  662. @@deloop:
  663.     lodsw           ; do { ax = *si++; (si is word pointer)
  664.     out     dx,al   ; out(dx,lowbyte(ax));
  665.     mov     al,ah
  666.     out     dx,al   ; out(dx,hibyte(ax));
  667.     loop    @@deloop        ; } while(--cx != 0); }
  668. ; now check for odd trailing byte
  669. @@nobuf:
  670.     mov     cx,cnt
  671.     test    cx,1
  672.     jz      @@cnteven
  673.     lodsb           ; al = *si++;
  674.     out     dx,al
  675. @@cnteven:
  676.     mov     dx,ds
  677.     mov     ax,si           ; return pointer just past end of buffer
  678.     ret
  679. outbuf  endp
  680.  
  681. ; inbuf - get a buffer from an input port
  682.     public  inbuf
  683. inbuf   proc
  684.     arg port:word,buf:ptr,cnt:word
  685.     uses    di
  686.     if      @Datasize NE 0
  687.         les     di,buf  ; es:di = buf
  688.     else
  689.         mov     di,buf  ; es:di = buf
  690.         mov     ax,ds
  691.         mov     es,ax
  692.     endif
  693.     mov     dx,port
  694.     mov     cx,cnt
  695.     cld
  696.  
  697. ; If buffer doesn't begin on a word boundary, get the first byte
  698.     test    di,1    ; if(buf & 1){
  699.     jz      @@bufeven ;
  700.     in      al,dx   ; al = in(dx);
  701.     stosb           ; *di++ = al
  702.     dec     cx      ; cx--;
  703.     mov     cnt,cx  ; cnt = cx; } save for later test
  704. @@bufeven:
  705.     shr     cx,1    ; cx = cnt >> 1; (convert to word count)
  706. ; Do the bulk of the buffer, a word at a time
  707.     jcxz    @@nobuf ; if(cx != 0){
  708. @@deloop:
  709.     in      al,dx   ; do { al = in(dx);
  710.     mov     ah,al
  711.     in      al,dx   ; ah = in(dx);
  712.     xchg    al,ah
  713.     stosw           ; *si++ = ax; (di is word pointer)
  714.     loop    @@deloop        ; } while(--cx != 0);
  715. ; now check for odd trailing byte
  716. @@nobuf:
  717.     mov     cx,cnt
  718.     test    cx,1
  719.     jz      @@cnteven
  720.     in      al,dx
  721.     stosb           ; *di++ = al
  722. @@cnteven:
  723.     mov     dx,es
  724.     mov     ax,di           ; return pointer just past end of buffer
  725.     ret
  726. inbuf   endp
  727.  
  728. endif
  729.  
  730.     public  longdiv
  731.  
  732. ; long unsigned integer division - divide an arbitrary length dividend by
  733. ; a 16-bit divisor. Replaces the dividend with the quotient and returns the
  734. ; remainder. Called from C as
  735. ;
  736. ; unsigned short
  737. ; longdiv(unsigned short divisor,int cnt,unsigned short *dividend);
  738. ;
  739. ;Register usage:
  740. ; di - divisor
  741. ; si - pointer into dividend array
  742. ; cx - loop counter, initialized to the number of 16-bit words in the dividend
  743. ; ax - low word of current dividend before each divide, current quotient after
  744. ; dx - remainder from previous divide carried over, becomes high word of
  745. ;      dividend for next divide
  746.  
  747. longdiv proc
  748.     arg     divisor:word,cnt:word,dividend:ptr
  749.     if      @Datasize NE 0
  750.         uses    ds,si,di
  751.         lds     si,dividend
  752.     else
  753.         uses    si,di
  754.         mov     si,dividend     ;si -> dividend array
  755.     endif
  756.  
  757.     cmp     divisor,0               ; divisor == 0?
  758.     jne     @2                      ; no, ok
  759.     xor     ax,ax                   ; yes, avoid divide-by-zero trap
  760.     jmp     short @1
  761.  
  762. @2:     mov     dx,0                    ; init remainder = 0
  763.     mov     cx,cnt                  ; init cnt
  764.     mov     di,divisor              ; cache divisor in register
  765.  
  766. @@deloop:
  767.     mov     ax,word ptr [si]        ; fetch current word of dividend
  768.     cmp     ax,0                    ; dividend == 0 ?
  769.     jne     @7                      ; nope, must do division
  770.     cmp     dx,0                    ; remainder also == 0?
  771.     je      @4                      ; yes, skip division, continue
  772.  
  773. @7:     div     di                      ; do division
  774.     mov     word ptr [si],ax        ; save quotient
  775.  
  776. @4:     inc     si                      ; next word of dividend
  777.     inc     si
  778.     loop    @@deloop
  779.  
  780.     mov     ax,dx                   ; return last remainder
  781. @1:     ret
  782.  
  783. longdiv endp
  784.  
  785. ; long unsigned integer multiplication - multiply an arbitrary length
  786. ; multiplicand by a 16-bit multiplier, leaving the product in place of
  787. ; the multipler, returning the carry. Called from C as
  788. ;
  789. ; unsigned short
  790. ; longmul(unsigned short multiplier,int cnt,unsigned short *multiplier);
  791. ;
  792. ; Register usage:
  793. ; di = multiplier
  794. ; si = pointer to current word of multiplicand
  795. ; bx = carry from previous round
  796. ; cx = count of words in multiplicand
  797. ; dx,ax = scratch for multiply
  798.  
  799.     public longmul
  800. longmul proc    far
  801.     arg     multiplier:word,n:word,multiplicand:ptr
  802.     if      @Datasize NE 0
  803.         uses    ds,si,di
  804.         lds     si,multiplicand
  805.     else
  806.         uses    si,di
  807.         mov     si,multiplicand ; si -> multiplicand array
  808.     endif
  809.  
  810.     mov     di,multiplier           ; cache multiplier in register
  811.     xor     bx,bx                   ; init carry = 0
  812.     mov     cx,n                    ; fetch n
  813.     mov     ax,cx
  814.     shl     ax,1                    ; *2 = word offset
  815.     add     si,ax                   ; multiplicand += n
  816.  
  817. @@deloop:
  818.     dec     si
  819.     dec     si                      ; work from right to left
  820.     mov     ax,word ptr [si]        ; fetch current multiplicand
  821.     or      ax,ax                   ; skip multiply if zero
  822.     jz      @@nomult
  823.     mul     di                      ; dx:ax <- ax * di
  824. @@nomult:
  825.     add     ax,bx                   ; add carry from previous multiply
  826.     mov     word ptr [si],ax        ; save low order word of product
  827.     mov     bx,0                    ; clear previous carry, leaving CF alone
  828.     adc     bx,dx                   ; save new carry
  829.     xor     dx,dx                   ; clear in case we skip the next mult
  830.     loop    @@deloop
  831.  
  832.     mov     ax,bx                   ; return final carry
  833.     ret
  834. longmul endp
  835.  
  836. ifdef   notdef
  837. ; divide 32 bits by 16 bits, returning both quotient and remainder
  838. ; This allows C programs that need both to avoid having to do two divisions
  839. ;
  840. ; Called from C as
  841. ;       long divrem(dividend,divisor)
  842. ;       long dividend;
  843. ;       short divisor;
  844. ;
  845. ;       The quotient is returned in the low 16 bits of the result,
  846. ;       and the remainder is returned in the high 16 bits.
  847.  
  848.     public  divrem
  849. divrem  proc
  850.     arg     dividend:dword,divisor:word
  851.     mov     ax,word ptr dividend
  852.     mov     dx,word ptr (dividend+2)
  853.     div     divisor
  854.     ret
  855. divrem  endp
  856. endif   
  857.  
  858. ; General purpose hash function for IP addresses
  859. ; Uses lookup table Hashtab[] initialized in ip.c
  860. ; Called from C as
  861. ; char hash_ip(int32 ipaddr);
  862.  
  863.     public hash_ip
  864. hash_ip proc
  865.     arg     ipaddr:dword
  866.     lea     bx,Hashtab
  867.     mov     ax,word ptr ipaddr
  868.     xor     ax,word ptr (ipaddr+2)
  869.     xor     al,ah
  870.     xlat
  871.     xor     ah,ah
  872.     ret
  873. hash_ip endp
  874.  
  875. ; Compute int(log2(x))
  876. ; Called from C as
  877. ; int log2(int16 x);
  878.  
  879.     public  log2
  880. log2    proc
  881.     arg     x:word
  882.     mov     cx,16
  883.     mov     ax,x
  884. @@2:    rcl     ax,1 
  885.     jc      @@1
  886.     loop    @@2
  887. @@1:    dec     cx
  888.     mov     ax,cx
  889.     ret
  890. log2    endp
  891.     end
  892.