WebSVN – Kolibri OS – Diff – /drivers/ethernet/rhine.asm

 NIC_LB_NONE             = 0x00
 NIC_LB_INTERNAL         = 0x01
 NIC_LB_PHY              = 0x02    ; MII or Internal-10BaseT loopback
-PKT_BUF_SZ              = 1536    ; Size of each temporary Rx buffer.
+PKT_BUF_SZ              = 1514
 ; attach int handler
         movzx   eax, [ebx + device.irq_line]
         DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
         invoke  AttachIntHandler, eax, int_handler, ebx
         test    eax, eax
-        jnz     @f
+        jz      .err
-        DEBUGF  2,"Could not attach int handler!\n"
-        or      eax, -1
-        ret
-       @@:
 ; Soft reset the chip.
         set_io  [ebx + device.io_addr], 0
         set_io  [ebx + device.io_addr], byCR0
         call    MIIDelay
+; Initialize rings
+        call    init_ring
-; Initialize rings
+        test    eax, eax
-        call    init_ring
+        jnz     .err
         set_io  [ebx + device.io_addr], byTCR
         mov     al, 0x60
         out     dx, al
-; Set Fulldupex
 ; Set Fulldupex
         call    QueryAuto
         test    eax, eax        ; full duplex?
         jz      @f
 ; say reset was successful
         xor     eax, eax
+        ret
+  .err:
+        DEBUGF  2,"Error!\n"
+        or      eax, -1
         ret
    .rx_init:
         add     esi, sizeof.rx_head
         mov     [edi + rx_head.status], RX_SBITS_OWN_BIT
         mov     [edi + rx_head.control], PKT_BUF_SZ
         push    ecx
-        invoke  KernelAlloc, PKT_BUF_SZ
+        invoke  NetAlloc, PKT_BUF_SZ+NET_BUFF.data
         pop     ecx
+        test    eax, eax
+        jz      .out_of_mem
         mov     [edi + rx_head.buff_addr_virt], eax
         invoke  GetPhysAddr
+        add     eax, NET_BUFF.data
         mov     [edi + rx_head.buff_addr], eax                        ; buffer ptr
         mov     [edi + rx_head.next_desc], esi                        ; next head
         add     edi, sizeof.rx_head
         dec     ecx
         jnz     .rx_init
         xor     eax, eax
         mov     [ebx + device.cur_rx], ax
         mov     [ebx + device.cur_tx], ax
         mov     [ebx + device.last_tx], ax
+        xor     eax, eax
+        ret
+  .out_of_mem:
+        add     esp, 4
         or      eax, -1
         ret
         set_io  [ebx + device.io_addr], byMAR4
         out     dx, eax
         set_io  [ebx + device.io_addr], byRCR
-        mov     al, 0x6C                ;rx_mode = 0x0C;
+        mov     al, 0x6C                ; thresh or rx_mode
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                         ;;
 ;; Transmit                                ;;
 ;;                                         ;;
 ;; In: buffer pointer in [esp+4]           ;;
-;;     size of buffer in [esp+8]           ;;
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
-proc transmit stdcall bufferptr, buffersize
+proc transmit stdcall bufferptr
         pushf
+        cli
-        cli
+        mov     esi, [bufferptr]
-        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
+        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [esi + NET_BUFF.length]
-        mov     eax, [bufferptr]
+        lea     eax, [esi + NET_BUFF.data]
         DEBUGF  1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
         [eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
         [eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
         [eax+13]:2,[eax+12]:2
-        cmp     [buffersize], 1514
+        cmp     [esi + NET_BUFF.length], 1514
         ja      .fail
-        cmp     [buffersize], 60
+        cmp     [esi + NET_BUFF.length], 60
         jb      .fail
         add     edi, eax
         cmp     [edi + tx_head.buff_addr_virt], 0
         jne     .fail
+        mov     eax, esi
-        mov     eax, [bufferptr]
+        mov     [edi + tx_head.buff_addr_virt], eax
-        mov     [edi + tx_head.buff_addr_virt], eax
+        add     eax, [eax + NET_BUFF.offset]
         invoke  GetPhysAddr
         mov     [edi + tx_head.buff_addr], eax
-        mov     ecx, [buffersize]
+        mov     ecx, [esi + NET_BUFF.length]
         and     ecx, TX_CBITS_TX_BUF_SIZE
         or      ecx,  0x00E08000
         ;outw(IMRShadow,byIMR0); ;
 ; Update stats
         inc     [ebx + device.packets_tx]
-        mov     ecx, [buffersize]
+        mov     ecx, [esi + NET_BUFF.length]
         add     dword [ebx + device.bytes_tx], ecx
         adc     dword [ebx + device.bytes_tx + 4], 0
         DEBUGF  1,"Transmit OK\n"
         popf
         xor     eax, eax
         ret
   .fail:
         DEBUGF  2,"Transmit failed\n"
-        invoke  KernelFree, [bufferptr]
+        invoke  NetFree, [bufferptr]
         push    ebx esi edi
         DEBUGF  1,"INT\n"
 ; Find pointer of device which made IRQ occur
 ; Find pointer of device which made IRQ occur
         mov     ecx, [devices]
         test    ecx, ecx
         jz      .nothing
         xor     eax, eax
-        ret                             ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
         ret                             ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
   .got_it:
   .got_it:
         push    ebx
   .more_RX:
         pop     ebx
-; Get the current descriptor pointer
 ; Get the current descriptor pointer
         movzx   eax, [ebx + device.cur_rx]
         mov     ecx, sizeof.rx_head
         mul     ecx
         lea     edi, [ebx + device.rx_ring]
         add     edi, eax
 ; Check it's status
+; Check it's status
         test    [edi + rx_head.status], RX_SBITS_OWN_BIT
-        jnz     .not_bit_own
+        jnz     .not_RX
-        DEBUGF  1, "Packet status = 0x%x\n", [edi + rx_head.status]
         DEBUGF  1, "Packet status = 0x%x\n", [edi + rx_head.status]
 ; TODO: check error bits
 ; TODO: check error bits
 ; get length
 ; get length
-        mov     ecx, [edi + rx_head.status]
-        and     ecx, RX_SBITS_FRAME_LENGTH
+        mov     ecx, [edi + rx_head.status]
-        shr     ecx, 16
+        and     ecx, RX_SBITS_FRAME_LENGTH
-        sub     ecx, 4  ; We dont want CRC
+        shr     ecx, 16
+        sub     ecx, 4                          ; We dont want CRC
-; Update stats
-        add     dword [ebx + device.bytes_rx], ecx
+; Update stats
-        adc     dword [ebx + device.bytes_rx + 4], 0
-        inc     [ebx + device.packets_rx]
+        add     dword [ebx + device.bytes_rx], ecx
+        adc     dword [ebx + device.bytes_rx + 4], 0
+        inc     [ebx + device.packets_rx]
+; Push packet pointer, kernel will need it..
-; Push packet size and pointer, kernel will need it..
+        push    ebx
-        push    ebx
+        push    .more_RX                        ; return ptr
-        push    .more_RX        ; return ptr
+        mov     eax, [edi + rx_head.buff_addr_virt]
         push    eax
-        push    ecx             ; full packet size
+        mov     [eax + NET_BUFF.length], ecx
-        push    [edi + rx_head.buff_addr_virt]
+        mov     [eax + NET_BUFF.device], ebx
+        mov     [eax + NET_BUFF.offset], NET_BUFF.data
 ; reset the RX descriptor
         push    edi
-        push    edi
-        invoke  KernelAlloc, PKT_BUF_SZ
+        invoke  NetAlloc, PKT_BUF_SZ+NET_BUFF.data
         pop     edi
         mov     [edi + rx_head.buff_addr_virt], eax
+        invoke  GetPhysAddr
-        invoke  GetPhysAddr
-        mov     [edi + rx_head.buff_addr], eax
-        mov     [edi + rx_head.status], RX_SBITS_OWN_BIT
         add     eax, NET_BUFF.data
-; Use next descriptor next time
         mov     [edi + rx_head.buff_addr], eax
-        inc     [ebx + device.cur_rx]
+        mov     [edi + rx_head.status], RX_SBITS_OWN_BIT
         and     [ebx + device.cur_rx], RX_RING_SIZE - 1
         DEBUGF  1,"Freeing buffer 0x%x\n", [edi + tx_head.buff_addr_virt]
         push    [edi + tx_head.buff_addr_virt]
         mov     [edi + tx_head.buff_addr_virt], 0
-        invoke  KernelFree
+        invoke  NetFree
         inc     [ebx + device.last_tx]
         and     [ebx + device.last_tx], TX_RING_SIZE - 1
         jmp     .loop_tx
   .not_TX:
         ; On Rhine-II, Bit 3 indicates Tx descriptor write-back race.
 if 0
-        cmp     [ebx + device.chip_id], 0x3065 ;if (tp->chip_id == 0x3065)
+        cmp     [ebx + device.chip_id], 0x3065
         jne     @f
         push    ax
         xor     eax, eax

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/rhine.asm – Rev 5363 → 5522