WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/network/stack.inc

 ;;                                                              ;;
 ;;10.01.2007 Bugfix for checksum function from Paolo Franchetti ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 1369 $
+$Revision: 2434 $
 ;*******************************************************************
 uglobal
 StackCounters:
+  dumped_rx_count     dd  0
-  dumped_rx_count     dd  0
+  arp_tx_count:
+                      dd  0
-  arp_tx_count:       dd  0
+  arp_rx_count:
+                      dd  0
-  arp_rx_count:       dd  0
+  ip_rx_count:
+                      dd  0
-  ip_rx_count:        dd  0
+  ip_tx_count:
-  ip_tx_count:        dd  0
+                      dd  0
 endg
 ; socket buffers
 macro _memset_dw adr,value,amount
+{
         mov     edi, adr
         mov     ecx, amount
         if value = 0
-                xor     eax, eax
+        xor     eax, eax
         else
-                mov     eax, value
+        mov     eax, value
         end if
         cld
-        rep     stosd
+        rep stosd
+}
         ; The following block sets up the 1s timer
         mov     al, 0x0
         out     0x70, al
         in      al, 0x71
         mov     [last_1sTick], al
-ret
+        ret
+;
 ;***************************************************************************
 align 4
 stack_handler:
-    call    ethernet_driver
+        call    ethernet_driver
-    call    ip_rx
+        call    ip_rx
     ; Test for 10ms tick, call tcp timer
-    mov     eax, [timer_ticks] ;[0xfdf0]
+        mov     eax, [timer_ticks];[0xfdf0]
-    cmp     eax, [last_1hsTick]
+        cmp     eax, [last_1hsTick]
-    je      sh_001
+        je      sh_001
-    mov     [last_1hsTick], eax
+        mov     [last_1hsTick], eax
-    call    tcp_tx_handler
+        call    tcp_tx_handler
 sh_001:
     ; Test for 1 second event, call 1s timer functions
-    mov     al, 0x0   ;second
+        mov     al, 0x0;second
-    out     0x70, al
+        out     0x70, al
-    in      al, 0x71
+        in      al, 0x71
-    cmp     al, [last_1sTick]
+        cmp     al, [last_1sTick]
-    je      sh_exit
+        je      sh_exit
-    mov     [last_1sTick], al
+        mov     [last_1sTick], al
 ;;              Saves all used registers
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 proc checksum_jb stdcall uses ebx esi ecx,\
      buf_ptr:DWORD, buf_size:DWORD
-    xor     eax, eax
+        xor     eax, eax
-    xor     ebx, ebx  ;accumulator
+        xor     ebx, ebx;accumulator
-    mov     esi, dword[buf_ptr]
+        mov     esi, dword[buf_ptr]
-    mov     ecx, dword[buf_size]
+        mov     ecx, dword[buf_size]
-    shr     ecx, 1  ; ecx=ecx/2
+        shr     ecx, 1; ecx=ecx/2
-    jnc     @f      ; if CF==0 then size is even number
+        jnc     @f  ; if CF==0 then size is even number
-    mov     bh, byte[esi + ecx*2]
+        mov     bh, byte[esi + ecx*2]
   @@:
-    cld
+        cld
   .loop:
-    lodsw   ;eax=word[esi],esi=esi+2
+        lodsw   ;eax=word[esi],esi=esi+2
-    xchg    ah,al    ;cause must be a net byte-order
+        xchg    ah, al;cause must be a net byte-order
-    add     ebx, eax
+        add     ebx, eax
-    loop    .loop
+        loop    .loop
-    mov     eax, ebx
+        mov     eax, ebx
-    shr     eax, 16
+        shr     eax, 16
-    add     ax, bx
+        add     ax, bx
-    not     ax
+        not     ax
-    ret
+        ret
 endp
+;
 ;***************************************************************************
 checksum:
-    pusha
+        pusha
-    mov     eax, [checkAdd1]
+        mov     eax, [checkAdd1]
-    xor     edx, edx                  ; edx is the accumulative checksum
+        xor     edx, edx              ; edx is the accumulative checksum
-    xor     ebx, ebx
+        xor     ebx, ebx
-    mov     cx, [checkSize1]
+        mov     cx, [checkSize1]
-    shr     cx, 1
+        shr     cx, 1
-    jz      cs1_1
+        jz      cs1_1
 cs1:
-    mov     bh, [eax]
+        mov     bh, [eax]
-    mov     bl, [eax + 1]
+        mov     bl, [eax + 1]
-    add     eax, 2
+        add     eax, 2
-    add     edx, ebx
+        add     edx, ebx
-    loopw   cs1
+        loopw   cs1
 cs1_1:
-    and     word [checkSize1], 0x01
+        and     word [checkSize1], 0x01
-    jz      cs_test2
+        jz      cs_test2
-    mov     bh, [eax]
+        mov     bh, [eax]
-    xor     bl, bl
+        xor     bl, bl
-    add     edx, ebx
+        add     edx, ebx
 cs_test2:
-    mov     cx, [checkSize2]
+        mov     cx, [checkSize2]
-    cmp     cx, 0
+        cmp     cx, 0
-    jz      cs_exit                     ; Finished if no 2nd buffer
+        jz      cs_exit                 ; Finished if no 2nd buffer
-    mov     eax, [checkAdd2]
+        mov     eax, [checkAdd2]
-    shr     cx, 1
+        shr     cx, 1
-    jz      cs2_1
+        jz      cs2_1
 cs2:
-    mov     bh, [eax]
+        mov     bh, [eax]
+        mov     bl, [eax + 1]
+        add     eax, 2
+        add     edx, ebx
+        loopw   cs2
+cs2_1:
-    mov     bl, [eax + 1]
-    add     eax, 2
-    add     edx, ebx
-    loopw   cs2
-cs2_1:
-    and     word [checkSize2], 0x01
+        and     word [checkSize2], 0x01
-    jz      cs_exit
+        jz      cs_exit
-    mov     bh, [eax]
+        mov     bh, [eax]
+;
 ;***************************************************************************
 iglobal
 align 4
 f52call:
-	dd	app_stack_handler.00
+        dd      app_stack_handler.00
-	dd	app_stack_handler.01
+        dd      app_stack_handler.01
-	dd	app_stack_handler.02
+        dd      app_stack_handler.02
-	dd	app_stack_handler.03
+        dd      app_stack_handler.03
-	dd	app_stack_handler.fail	;04
+        dd      app_stack_handler.fail  ;04
-	dd	app_stack_handler.fail	;05
+        dd      app_stack_handler.fail  ;05
-	dd	stack_insert_packet	;app_stack_handler.06
+        dd      stack_insert_packet     ;app_stack_handler.06
-	dd	app_stack_handler.fail	;07
+        dd      app_stack_handler.fail  ;07
-	dd	stack_get_packet	;app_stack_handler.08
+        dd      stack_get_packet        ;app_stack_handler.08
-	dd	app_stack_handler.09
+        dd      app_stack_handler.09
-	dd	app_stack_handler.10
+        dd      app_stack_handler.10
-	dd	app_stack_handler.11
+        dd      app_stack_handler.11
-	dd	app_stack_handler.12
+        dd      app_stack_handler.12
-	dd	app_stack_handler.13
+        dd      app_stack_handler.13
-	dd	app_stack_handler.14
+        dd      app_stack_handler.14
-	dd	app_stack_handler.15
+        dd      app_stack_handler.15
 endg
 app_stack_handler:
 ;in ebx,ecx
 ;out eax
-	cmp	ebx,15
+        cmp     ebx, 15
-	ja	.fail			;if more than 15 then exit
+        ja      .fail                   ;if more than 15 then exit
-	jmp	dword [f52call+ebx*4]
+        jmp     dword [f52call+ebx*4]
 .00:
 ; Read the configuration word
-	mov	eax, [stack_config]
+        mov     eax, [stack_config]
-	ret
+        ret
 .01:
 ; read the IP address
-	mov     eax, [stack_ip]
+        mov     eax, [stack_ip]
-	ret
+        ret
 .02:
 ; write the configuration word
-	mov     [stack_config], ecx
+        mov     [stack_config], ecx
+;
 ; If ethernet now enabled, probe for the card, reset it and empty
 ; the packet buffer
 ; If all successfull, enable the card.
 ; If ethernet now disabled, set it as disabled. Should really
 ; empty the tcpip data area too.
 ; ethernet interface is '3' in ls 7 bits
-	and     cl, 0x7f
+        and     cl, 0x7f
-	cmp     cl, 3
+        cmp     cl, 3
-	je      ash_eth_enable
+        je      ash_eth_enable
 ; Ethernet isn't enabled, so make sure that the card is disabled
-	mov     [ethernet_active], byte 0
+        mov     [ethernet_active], byte 0
-	ret
+        ret
 .03:
 ; write the IP Address
-	mov     [stack_ip], ecx
+        mov     [stack_ip], ecx
-	ret
+        ret
 ;old functions was deleted
 ;.06:
 ; Insert an IP packet into the stacks received packet queue
-;	call    stack_insert_packet
+;       call    stack_insert_packet
-;	ret
+;       ret
 ; Test for any packets queued for transmission over the network
 ;.08:
-;	call    stack_get_packet
+;       call    stack_get_packet
 ; Extract a packet queued for transmission by the network
-;	ret
+;       ret
 .09:
 ; read the gateway IP address
-	mov     eax, [gateway_ip]
+        mov     eax, [gateway_ip]
-	ret
+        ret
 .10:
 ; read the subnet mask
-	mov     eax, [subnet_mask]
+        mov     eax, [subnet_mask]
-	ret
+        ret
 .11:
 ; write the gateway IP Address
-	mov     [gateway_ip], ecx
+        mov     [gateway_ip], ecx
-	ret
+        ret
 .12:
 ; write the subnet mask
-	mov     [subnet_mask], ecx
+        mov     [subnet_mask], ecx
-	ret
+        ret
 .13:
 ; read the dns
-	mov     eax, [dns_ip]
+        mov     eax, [dns_ip]
-	ret
+        ret
 .14:
 ; write the dns IP Address
-	mov     [dns_ip], ecx
+        mov     [dns_ip], ecx
-	ret
+        ret
 .15:
+;
 ; in ecx we need 4 to read the last 2 bytes
 ; or we need 0 to read the first 4 bytes
-	cmp     ecx,4
+        cmp     ecx, 4
-        ja	.param_error
+        ja      .param_error
 ; read MAC, returned (in mirrored byte order) in eax
         mov     eax, [node_addr + ecx]
 ; modified by [smb]
+;
 ; ARPTable manager interface
     ;see "proc arp_table_manager" for more details
-    stdcall arp_table_manager,ecx,edx,esi  ;Opcode,Index,Extra
+        stdcall arp_table_manager, ecx, edx, esi;Opcode,Index,Extra
-    ret
+        ret
+;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ash_eth_enable:
 ; Probe for the card. This will reset it and enable the interface
 ; if found
-	call	eth_probe
+        call    eth_probe
-	test	eax,eax
+        test    eax, eax
-	jz	ash_eth_done            ; Abort if no hardware found
+        jz      ash_eth_done            ; Abort if no hardware found
-	mov     [ethernet_active], byte 1
+        mov     [ethernet_active], byte 1
 ash_eth_done:
-	ret
+        ret
 ;***************************************************************************
 ;   Function
+;
 ;***************************************************************************
 iglobal
 align 4
 f53call:
-	dd	socket_open			;00
+        dd      socket_open                     ;00
-	dd	socket_close			;01
+        dd      socket_close                    ;01
-	dd	socket_poll			;02
+        dd      socket_poll                     ;02
-	dd	socket_read			;03
+        dd      socket_read                     ;03
-	dd	socket_write			;04
+        dd      socket_write                    ;04
-	dd	socket_open_tcp			;05
+        dd      socket_open_tcp                 ;05
-	dd	socket_status			;06
+        dd      socket_status                   ;06
-	dd	socket_write_tcp		;07
+        dd      socket_write_tcp                ;07
-	dd	socket_close_tcp		;08
+        dd      socket_close_tcp                ;08
-	dd	is_localport_unused		;09
+        dd      is_localport_unused             ;09
-	dd	app_socket_handler.10
+        dd      app_socket_handler.10
-	dd	socket_read_packet		;11
+        dd      socket_read_packet              ;11
 endg
 app_socket_handler:
 ;in ebx,ecx,edx,wsi
 ;out eax
-	cmp	eax,255
+        cmp     eax, 255
-	je	stack_internal_status
+        je      stack_internal_status
-	cmp	eax,11
+        cmp     eax, 11
-	ja	.fail			;if more than 15 then exit
+        ja      .fail                   ;if more than 15 then exit
-	jmp	dword [f53call+eax*4]
+        jmp     dword [f53call+eax*4]
 .10:
-	mov     eax,dword[drvr_cable]
+        mov     eax, dword[drvr_cable]
-	test    eax,eax
+        test    eax, eax
-	jnz     @f                	; if function is not implented, return -1
+        jnz     @f                      ; if function is not implented, return -1
-	or      al,-1
+        or      al, -1
-	ret
+        ret
 @@:
-	jmp    dword[drvr_cable]
+        jmp     dword[drvr_cable]
 .fail:
-	or	eax,-1
+        or      eax, -1
 ;  6 : return status of packet driver
 ;  ( 0 == not active, FFFFFFFF = successful )
 stack_internal_status:
-    cmp     ebx, 100
+        cmp     ebx, 100
-    jnz     notsis100
+        jnz     notsis100
     ;  100 : return length of EMPTY QUEUE
-    mov     ebx, EMPTY_QUEUE
+        mov     ebx, EMPTY_QUEUE
-    call    queueSize
+        call    queueSize
-    ret
+        ret
 notsis100:
-    cmp     ebx, 101
+        cmp     ebx, 101
-    jnz     notsis101
+        jnz     notsis101
     ;  101 : return length of IPOUT QUEUE
-    mov     ebx, IPOUT_QUEUE
+        mov     ebx, IPOUT_QUEUE
-    call    queueSize
+        call    queueSize
-    ret
+        ret
 notsis101:
-    cmp     ebx, 102
+        cmp     ebx, 102
-    jnz     notsis102
+        jnz     notsis102
     ;  102 : return length of IPIN QUEUE
-    mov     ebx, IPIN_QUEUE
+        mov     ebx, IPIN_QUEUE
-    call    queueSize
+        call    queueSize
-    ret
+        ret
 notsis102:
-    cmp     ebx, 103
+        cmp     ebx, 103
-    jnz     notsis103
+        jnz     notsis103
     ;  103 : return length of NET1OUT QUEUE
-    mov     ebx, NET1OUT_QUEUE
+        mov     ebx, NET1OUT_QUEUE
-    call    queueSize
+        call    queueSize
-    ret
+        ret
 notsis103:
-    cmp     ebx, 200
+        cmp     ebx, 200
-    jnz     notsis200
+        jnz     notsis200
     ; 200 : return num entries in arp table
-    movzx   eax, byte [NumARP]
+        movzx   eax, byte [NumARP]
-    ret
+        ret
 notsis200:
-    cmp     ebx, 201
+        cmp     ebx, 201
-    jnz     notsis201
+        jnz     notsis201
     ; 201 : return arp table size
-    mov     eax, 20 ; ARP_TABLE_SIZE
+        mov     eax, 20; ARP_TABLE_SIZE
-    ret
+        ret
 notsis201:
-    cmp     ebx, 202
+        cmp     ebx, 202
-    jnz     notsis202
+        jnz     notsis202
     ; 202 - read the requested table entry
     ; into a temporary buffer
     ; ecx holds the entry number
-    mov     eax, ecx
+        mov     eax, ecx
-    mov     ecx, 14 ; ARP_ENTRY_SIZE
+        mov     ecx, 14; ARP_ENTRY_SIZE
-    mul     ecx
+        mul     ecx
-    mov     ecx, [eax + ARPTable]
+        mov     ecx, [eax + ARPTable]
-    mov     [ARPTmp], ecx
+        mov     [ARPTmp], ecx
-    mov     ecx, [eax + ARPTable+4]
+        mov     ecx, [eax + ARPTable+4]
-    mov     [ARPTmp+4], ecx
+        mov     [ARPTmp+4], ecx
-    mov     ecx, [eax + ARPTable+8]
+        mov     ecx, [eax + ARPTable+8]
-    mov     [ARPTmp+8], ecx
+        mov     [ARPTmp+8], ecx
-    mov     cx, [eax + ARPTable+12]
+        mov     cx, [eax + ARPTable+12]
-    mov     [ARPTmp+12], cx
+        mov     [ARPTmp+12], cx
-    ret
+        ret
 notsis202:
-    cmp     ebx, 203
+        cmp     ebx, 203
-    jnz     notsis203
+        jnz     notsis203
     ; 203 - return IP address
-    mov     eax, [ARPTmp]
+        mov     eax, [ARPTmp]
-    ret
+        ret
 notsis203:
-    cmp     ebx, 204
+        cmp     ebx, 204
-    jnz     notsis204
+        jnz     notsis204
     ; 204 - return MAC high dword
-    mov     eax, [ARPTmp+4]
+        mov     eax, [ARPTmp+4]
-    ret
+        ret
 notsis204:
-    cmp     ebx, 205
+        cmp     ebx, 205
-    jnz     notsis205
+        jnz     notsis205
     ; 205 - return MAC ls word
-    movzx   eax, word [ARPTmp+8]
+        movzx   eax, word [ARPTmp+8]
-    ret
+        ret
 notsis205:
-    cmp     ebx, 206
+        cmp     ebx, 206
-    jnz     notsis206
+        jnz     notsis206
     ; 206 - return status word
-    movzx   eax, word [ARPTmp+10]
+        movzx   eax, word [ARPTmp+10]
-    ret
+        ret
 notsis206:
-    cmp     ebx, 207
+        cmp     ebx, 207
-    jnz     notsis207
+        jnz     notsis207
     ; 207 - return ttl word
-    movzx   eax, word [ARPTmp+12]
+        movzx   eax, word [ARPTmp+12]
-    ret
+        ret
 notsis207:
-    cmp     ebx, 2
+        cmp     ebx, 2
-    jnz     notsis2
+        jnz     notsis2
     ;  2 : return number of IP packets received
-    mov     eax, [ip_rx_count]
+        mov     eax, [ip_rx_count]
-    ret
+        ret
 notsis2:
 ;       returns number of bytes read in eax
+;
 ;***************************************************************************
 stack_get_packet:
     ; Look for a buffer to tx
-    mov     eax, NET1OUT_QUEUE
+        mov     eax, NET1OUT_QUEUE
-    call    dequeue
+        call    dequeue
-    cmp     ax, NO_BUFFER
+        cmp     ax, NO_BUFFER
-    je      sgp_non_exit            ; Exit if no buffer available
+        je      sgp_non_exit        ; Exit if no buffer available
-    push    eax                     ; Save buffer number for freeing at end
+        push    eax                 ; Save buffer number for freeing at end
-    push    edx
+        push    edx
     ; convert buffer pointer eax to the absolute address
-    mov     ecx, IPBUFFSIZE
+        mov     ecx, IPBUFFSIZE
-    mul     ecx
+        mul     ecx
-    add     eax, IPbuffs
+        add     eax, IPbuffs
-    pop     edx
+        pop     edx
-    push    eax                     ; save address of IP data
+        push    eax                 ; save address of IP data
     ; Get the address of the callers data
-    mov     edi,[TASK_BASE]
+        mov     edi, [TASK_BASE]
-    add     edi,TASKDATA.mem_start
+        add     edi, TASKDATA.mem_start
-    add     edx,[edi]
+        add     edx, [edi]
-    mov     edi, edx
+        mov     edi, edx
-    pop     eax
+        pop     eax
-    mov     ecx, 1500           ; should get the actual number of bytes to write
+        mov     ecx, 1500       ; should get the actual number of bytes to write
-    mov     esi, eax
+        mov     esi, eax
-    cld
+        cld
-    rep     movsb               ; copy the data across
+        rep movsb               ; copy the data across
     ; And finally, return the buffer to the free queue
-    pop     eax
+        pop     eax
-    call    freeBuff
+        call    freeBuff
-    mov     eax, 1500
+        mov     eax, 1500
-    ret
+        ret
 ;       returns 0 in eax ok, -1 == failed
+;
 ;***************************************************************************
 stack_insert_packet:
-    mov     eax, EMPTY_QUEUE
+        mov     eax, EMPTY_QUEUE
-    call    dequeue
+        call    dequeue
-    cmp     ax, NO_BUFFER
+        cmp     ax, NO_BUFFER
-    je      sip_err_exit
+        je      sip_err_exit
-    push    eax
+        push    eax
     ; save the pointers to the data buffer & size
-    push    edx
+        push    edx
-    push    ecx
+        push    ecx
     ; convert buffer pointer eax to the absolute address
-    mov     ecx, IPBUFFSIZE
+        mov     ecx, IPBUFFSIZE
-    mul     ecx
+        mul     ecx
-    add     eax, IPbuffs
+        add     eax, IPbuffs
-    mov     edx, eax
+        mov     edx, eax
     ; So, edx holds the IPbuffer ptr
-    pop     ecx                     ; count of bytes to send
+        pop     ecx                 ; count of bytes to send
-    mov     ebx, ecx                ; need the length later
+        mov     ebx, ecx            ; need the length later
-    pop     eax                     ; get callers ptr to data to send
+        pop     eax                 ; get callers ptr to data to send
     ; Get the address of the callers data
-    mov     edi,[TASK_BASE]
+        mov     edi, [TASK_BASE]
-    add     edi,TASKDATA.mem_start
+        add     edi, TASKDATA.mem_start
-    add     eax,[edi]
+        add     eax, [edi]
-    mov     esi, eax
+        mov     esi, eax
-    mov     edi, edx
+        mov     edi, edx
-    cld
+        cld
-    rep     movsb               ; copy the data across
+        rep movsb               ; copy the data across

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/network/stack.inc – Rev 1635 → 2434