WebSVN – Kolibri OS – Diff – /drivers/ethernet/3c59x.asm

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                              ;;
-;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
+;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;  3Com network driver for KolibriOS                           ;;
 ;;                                                              ;;
 ;;  Ported to KolibriOS net-branch by hidnplayr                 ;;
         CURRENT_API             = 0x0200
         COMPATIBLE_API          = 0x0100
+        API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
-        API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
+; configureable area
         MAX_DEVICES             = 16    ; Maximum number of devices this driver may handle
-        MAX_DEVICES             = 16
         FORCE_FD                = 0     ; forcing full duplex mode makes sense at some cards and link types
-        NUM_RX_DESC             = 4     ; a power of 2 number
+        NUM_RX_DESC             = 32    ; Number of receive descriptors (must be power of 2)
+        NUM_TX_DESC             = 16    ; Number of transmit descriptors (must be power of 2)
-        NUM_TX_DESC             = 4     ; a power of 2 number
+        __DEBUG__               = 1     ; 1 = on, 0 = off
         __DEBUG_LEVEL__         = 2     ; 1 = verbose, 2 = errors only
         __DEBUG__               = 1
-        __DEBUG_LEVEL__         = 2     ; 1 = verbose, 2 = errors only
+; end configureable area
 section '.flat' readable writable executable
+include '../proc32.inc'
+include '../struct.inc'
+include '../macros.inc'
+include '../fdo.inc'
+include '../netdrv.inc'
+if (bsr NUM_RX_DESC)>(bsf NUM_RX_DESC)
+  display 'NUM_RX_DESC must be a power of two'
+  err
 end if
 include '../proc32.inc'
-include '../struct.inc'
+if (bsr NUM_TX_DESC)>(bsf NUM_TX_DESC)
-include '../macros.inc'
+  display 'NUM_TX_DESC must be a power of two'
-include '../fdo.inc'
+  err
         cmp     byte [eax], 1                           ; 1 means device number and bus number (pci) are given
         jne     .fail                                   ; other types of this hardware dont exist
 ; check if the device is already listed
-        mov     ecx, [vortex_devices]
+        mov     ecx, [devices]
         test    ecx, ecx
-        jz      .maybeboomerang
+        jz      .firstdevice
-        mov     esi, vortex_list
+        mov     esi, device_list
         mov     eax, [edx + IOCTL.input]                ; get the pci bus and device numbers
         mov     ax , [eax+1]                            ;
         je      .find_devicenum                         ; Device is already loaded, let's find it's device number
        @@:
         add     esi, 4
         loop    .nextdevice
-  .maybeboomerang:
-        mov     ecx, [boomerang_devices]
-        test    ecx, ecx
-        jz      .firstdevice
-        mov     esi, boomerang_list
-        mov     eax, [edx + IOCTL.input]                ; get the pci bus and device numbers
-        mov     ax, [eax+1]                             ;
-  .nextdevice2:
-        mov     ebx, [esi]
-        cmp     al, byte[ebx + device.pci_bus]
-        jne     @f
-        cmp     ah, byte[ebx + device.pci_dev]
-        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
-       @@:
-        add     esi, 4
-        loop    .nextdevice2
 ; This device doesnt have its own eth_device structure yet, lets create one
-  .firstdevice:
-        mov     ecx, [boomerang_devices]
-        add     ecx, [vortex_devices]
+  .firstdevice:
-        cmp     ecx, MAX_DEVICES                        ; First check if the driver can handle one more card
+        cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
         jae     .fail
 ; Ok, the eth_device structure is ready, let's probe the device
         call    probe                                                   ; this function will output in eax
         test    eax, eax
         jnz     .err                                                    ; If an error occured, exit
-        movzx   ecx, [ebx + device.ver_id]
-        test    word [hw_versions+2+ecx*4], IS_VORTEX
-        jz      .not_vortex
-        mov     eax, [vortex_devices]                                   ; Add the device structure to our device list
+        mov     eax, [devices]                                          ; Add the device structure to our device list
-        mov     [vortex_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
+        mov     [device_list+4*eax], ebx                                ;
-        inc     [vortex_devices]                                        ;
+        inc     [devices]                                               ;
   .register:
         je      .destroy
         call    start_device
-        ret
-  .not_vortex:
-        mov     eax, [boomerang_devices]                                ; Add the device structure to our device list
-        mov     [boomerang_list+4*eax], ebx                             ; (IRQ handler uses this list to find device)
-        inc     [boomerang_devices]
-        jmp     .register
+        ret
 ; If the device was already loaded, find the device number and return it in eax
         set_io  [ebx + device.io_addr], REG_COMMAND
         xor     eax, eax
 ;       or      al, 0x14
         out     dx, ax
 ; wait for GlobalReset to complete
-        mov     ecx, 64000
+        mov     ecx, 2000
   .rsloop:
-        in      ax , dx
+        in      ax, dx
-        test    ah , 10000b             ; CmdInProgress
+        test    ah, 10000b             ; CmdInProgress
+        pusha
+        mov     esi, 1
+        invoke  Sleep
+        popa
         loopz   .rsloop
-        DEBUGF 1,"Waiting for nic to boot..\n"
+        DEBUGF 1,"Waiting for NIC to boot..\n"
 ; wait for 2 seconds for NIC to boot
         mov     esi, 2000               ; WTF? FIXME
         invoke  Sleep ; 2 seconds
         DEBUGF 1,"PHY=%u\n", ah
         DEBUGF 1,"Detecting if device is auto-negotiation capable\n"
         mov     al, MII_BMCR
         push    eax
-        call    mdio_read       ; returns with window #4
+        call    mdio_read
-        or      ah, 0x80        ; software reset
+        or      ax, BMCR_RESET
         mov     esi, eax
         mov     eax, [esp]
-        call    mdio_write      ; returns with window #4
+        call    mdio_write
 ; wait for reset to complete
+        mov     esi, 2000
-        mov     esi, 2000
+        invoke  Sleep           ; 2s FIXME
-        invoke  Sleep           ; 2s FIXME
+        mov     eax, [esp]
-        mov     eax, [esp]
+        mov     al, MII_BMCR
-        call    mdio_read       ; returns with window #4
+        call    mdio_read
-        test    ah, 0x80
-        jnz     .fail1
+        test    ax, BMCR_RESET
-        mov     eax, [esp]
+        jnz     .fail1
+; wait for a while after reset
-; wait for a while after reset
+        mov     esi, 20
-        mov     esi, 20
+        invoke  Sleep           ; 20ms
-        invoke  Sleep           ; 20ms
         mov     eax, [esp]
-        mov     al , MII_BMSR
+        mov     al, MII_BMSR
-        call    mdio_read        ; returns with window #4
+        call    mdio_read
-        test    al, 1            ; extended capability supported?
-        jz      .fail2
-        DEBUGF  1,"Extended capability supported\n"
+        test    al, BMSR_ERCAP
+        jz      .fail2
-; auto-neg capable?
+        DEBUGF  1,"Extended capability supported\n"
-        test    al , 1000b
-        jz      .fail2           ; not auto-negotiation capable
-        DEBUGF  1,"Auto-negotiation capable\n"
+        test    al, BMSR_ANEGCAPABLE
         jz      .fail2
-; auto-neg complete?
+        DEBUGF  1,"Auto-negotiation capable\n"
-        test    al , 100000b
+        test    al, BMSR_ANEGCOMPLETE
         jnz     .auto_neg_ok
         DEBUGF  1,"Restarting auto-negotiation\n"
 ; restart auto-negotiation
         mov     eax, [esp]
         mov     al, MII_ADVERTISE
         push    eax
         call    mdio_read       ; returns with window #4
-        or      ax , 1111b shl 5; advertise only 10base-T and 100base-TX
+        or      ax, ADVERTISE_10HALF or ADVERTISE_10FULL or ADVERTISE_100HALF or ADVERTISE_100FULL
         mov     esi, eax
         pop     eax
         call    mdio_write      ; returns with window #4
         mov     eax, [esp]
         call    mdio_read       ; returns with window #4
         mov     esi, eax
-        or      bh , 10010b     ; restart auto-negotiation
+        or      bx, BMCR_ANENABLE or BMCR_ANRESTART
         mov     eax, [esp]
+        call    mdio_write      ; returns with window #4
-        call    mdio_write      ; returns with window #4
+        mov     esi, 4000
-        mov     esi, 4000
+        invoke  Sleep  ; 4 seconds
-        invoke  Sleep  ; 4 seconds
+        mov     eax, [esp]
         mov     eax, [esp]
+        mov     al, MII_BMSR
-        mov     al , MII_BMSR
+        call    mdio_read ; returns with window #4
-        call    mdio_read ; returns with window #4
+        test    al, BMSR_ANEGCOMPLETE
-        test    al , 100000b ; auto-neg complete?
+        jnz     .auto_neg_ok
         jnz     .auto_neg_ok
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                         ;;
 ;; Transmit (vortex)                       ;;
 ;;                                         ;;
-;; In: buffer pointer in [esp+4]           ;;
+;; In: pointer to device structure in ebx  ;;
-;;     pointer to device structure in ebx  ;;
+;; Out: eax = 0 on success                 ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 16
 proc vortex_transmit stdcall bufferptr
         pushf
-        cli
+        spin_lock_irqsave
         mov     esi, [bufferptr]
         DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [esi + NET_BUFF.length]
         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     [esi + NET_BUFF.length], 1514
-        ja      .fail
+        ja      .error
         cmp     [esi + NET_BUFF.length], 60
 ; check for master operation in progress
         set_io  [ebx + device.io_addr], REG_MASTER_STATUS
         in      ax, dx
         test    ah, 0x80
-        jnz     .fail ; no DMA for sending
+        jnz     .overrun ; no DMA for sending
 ; program frame address to be sent
         set_io  [ebx + device.io_addr], REG_MASTER_ADDRESS
 ; start DMA Down
         set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, (10100b shl 11) + 1 ; StartDMADown
+        out     dx, ax
-        out     dx, ax
+; Update stats
+        inc     [ebx + device.packets_tx]
+        mov     eax, [esi + NET_BUFF.length]
+        add     dword[ebx + device.bytes_tx], eax
+        adc     dword[ebx + device.bytes_tx + 4], 0
-  .finish:
-        popf
+        spin_unlock_irqrestore
         xor     eax, eax
         ret
+  .error:
+        DEBUGF  2, "TX packet error\n"
+        inc     [ebx + device.packets_tx_err]
+        invoke  NetFree, [bufferptr]
+        spin_unlock_irqrestore
+        or      eax, -1
+        ret
+  .overrun:
-  .fail:
+        DEBUGF  2, "TX overrun\n"
+        inc     [ebx + device.packets_tx_ovr]
-        DEBUGF  2,"Send failed\n"
+        invoke  NetFree, [bufferptr]
         invoke  NetFree, [bufferptr]
-        popf
+        spin_unlock_irqrestore
         or      eax, -1
         ret
 endp
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                         ;;
 ;; Transmit (boomerang)                    ;;
 ;;                                         ;;
-;; In: buffer pointer in [esp+4]           ;;
+;; In: pointer to device structure in ebx  ;;
-;;     pointer to device structure in ebx  ;;
+;; Out: eax = 0 on success                 ;;
 ;;                                         ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-proc boomerang_transmit stdcall bufferptr
+align 16
 proc boomerang_transmit stdcall bufferptr
         pushf
-        cli
+        spin_lock_irqsave
         mov     esi, [bufferptr]
         DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [esi + NET_BUFF.length]
         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
         mov     ax, ((110b shl 11)+3)
         out     dx, ax
   .finish:
+        mov     [ebx + device.curr_tx], edi
-        mov     [ebx + device.curr_tx], edi
+; Update stats
+        inc     [ebx + device.packets_tx]
+        mov     eax, [esi + NET_BUFF.length]
+        add     dword[ebx + device.bytes_tx], eax
+        adc     dword[ebx + device.bytes_tx + 4], 0
-        popf
+        spin_unlock_irqrestore
         xor     eax, eax
         ret
+  .error:
+        DEBUGF  2, "TX packet error\n"
+        inc     [ebx + device.packets_tx_err]
+        invoke  NetFree, [bufferptr]
+        spin_unlock_irqrestore
+        or      eax, -1
+        ret
+  .overrun:
-  .fail:
+        DEBUGF  2, "TX overrun\n"
+        inc     [ebx + device.packets_tx_ovr]
-        DEBUGF  2,"Send failed\n"
+        invoke  NetFree, [bufferptr]
         invoke  NetFree, [bufferptr]
-        popf
+        spin_unlock_irqrestore
         or      eax, -1
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                          ;;
 ;; Vortex Interrupt handler ;;
 ;;                          ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-align 4
+align 16
 int_vortex:
-        push    ebx esi edi
-        DEBUGF  1,"INT\n"
-; find pointer of device wich made IRQ occur
+        push    ebx esi edi
-        mov     ecx, [vortex_devices]
-        test    ecx, ecx
-        jz      .nothing
-        mov     esi, vortex_list
+        mov     ebx, [esp+4*4]
-  .nextdevice:
+        DEBUGF  1,"INT for 0x%x\n", ebx
         mov     ebx, [esi]
 ; TODO? if we are paranoid, we can check that the value from ebx is present in the current device_list
         set_io  [ebx + device.io_addr], 0
-        set_io  [ebx + device.io_addr], REG_INT_STATUS
-        in      ax, dx
-        and     ax, S_5_INTS
-        jnz     .nothing
-        add     esi, 4
-        test    ax , ax
-        jnz     .got_it
-        loop    .nextdevice
-  .nothing:
-        pop     edi esi ebx
-        xor     eax, eax
+        set_io  [ebx + device.io_addr], REG_INT_STATUS
-        ret
+        in      ax, dx
         and     ax, S_5_INTS
-.got_it:
+        jnz     .nothing
         set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, (01000b shl 11)
         out     dx, ax
-  .finish:
   .finish:
-  .noRX:
   .noRX:
         test    ax, DMADone
         jz      .noDMA
         mov     ax, 0x1000
         out     dx, ax
   .nodmaclear:
   .nodmaclear:
-        pop     ax
-        DEBUGF  1, "DMA Done!\n", cx
+        pop     ax
   .noDMA:
         DEBUGF  1, "DMA Done!\n", cx
   .noDMA:
   .ACK:
         set_io  [ebx + device.io_addr], 0
+        set_io  [ebx + device.io_addr], REG_COMMAND
+        mov     ax, AckIntr + IntReq + IntLatch
+        out     dx, ax
+        pop     edi esi ebx
+        xor     eax, eax
+        inc     eax
-        set_io  [ebx + device.io_addr], REG_COMMAND
+        ret
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                             ;;
 ;; Boomerang Interrupt handler ;;
 ;;                             ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-align 4
+align 16
 int_boomerang:
+        push    ebx esi edi
-        push    ebx esi edi
-        DEBUGF  1,"INT\n"
+        mov     ebx, [esp+4*4]
-; find pointer of device wich made IRQ occur
-        mov     ecx, [boomerang_devices]
-        test    ecx, ecx
-        jz      .nothing
-        mov     esi, boomerang_list
+        DEBUGF  1,"INT for 0x%x\n", ebx
   .nextdevice:
-        mov     ebx, [esi]
+; TODO? if we are paranoid, we can check that the value from ebx is present in the current device_list
         set_io  [ebx + device.io_addr], 0
-        set_io  [ebx + device.io_addr], REG_INT_STATUS
-        in      ax, dx
-        test    ax, S_5_INTS
-        jnz     .got_it
-  .continue:
-        add     esi, 4
-        dec     ecx
-        jnz     .nextdevice
-  .nothing:
-        pop     edi esi ebx
-        xor     eax, eax
+        set_io  [ebx + device.io_addr], REG_INT_STATUS
+        in      ax, dx
-        ret
+        test    ax, S_5_INTS
         jz      .nothing
   .got_it:
         set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SetIntrEnb + S_5_INTS
         out     dx, ax
+        pop     edi esi ebx
+        xor     eax, eax
+        inc     eax
+        ret
+  .nothing:
+        pop     edi esi ebx
-        pop     edi esi ebx
+        xor     eax, eax
 HW_VERSIONS_SIZE = $ - hw_versions
 include_debug_strings                           ; All data wich FDO uses will be included here
-align 4
-vortex_devices          dd 0
+align 4
-boomerang_devices       dd 0

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/3c59x.asm – Rev 5522 → 9188