Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;  3Com network driver for KolibriOS                           ;;

;;                                                              ;;

;;  Ported to KolibriOS net-branch by hidnplayr (28/05/10)      ;;

;;                                                              ;;

;;  Thanks to: scrap metal recyclers, whom provide me with      ;;

;;                         loads of hardware                    ;;

;;             diamond: who makes me understand KolibriOS       ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                                         ;;

;;  3C59X.INC                                                              ;;

;;                                                                         ;;

;;  Ethernet driver for Menuet OS                                          ;;

;;                                                                         ;;

;;  Driver for 3Com fast etherlink 3c59x and                               ;;

;;         etherlink XL 3c900 and 3c905 cards                              ;;

;;  References:                                                            ;;

;;    www.3Com.com - data sheets                                           ;;

;;    DP83840A.pdf - ethernet physical layer                               ;;

;;    3c59x.c - linux driver                                               ;;

;;    ethernet driver template by Mike Hibbett                             ;;

;;                                                                         ;;

;;  Credits                                                                ;;

;;   Mike Hibbett,                                                         ;;

;;         who kindly supplied me with a 3Com905C-TX-M card                ;;

;;                                                                         ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;; Copyright (c) 2004, Endre Kozma 

;; All rights reserved.

;;

;; Redistribution  and  use  in  source  and  binary  forms, with or without

;; modification, are permitted provided  that  the following  conditions are

;; met:

;;

;; 1. Redistributions of source code must retain the above  copyright notice,

;;    this list of conditions and the following disclaimer.

;;

;; 2. Redistributions  in  binary form  must  reproduce  the above copyright

;;    notice, this  list of conditions  and the  following disclaimer in the

;;    documentation and/or other  materials  provided with  the distribution.

;;

;; 3. The name of the author may not be used to  endorse or promote products

;;    derived from this software without  specific prior  written permission.

;;

;; THIS SOFTWARE IS  PROVIDED  BY  THE  AUTHOR  ``AS IS'' AND ANY EXPRESS OR

;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

;; OF  MERCHANTABILITY AND FITNESS  FOR A PARTICULAR  PURPOSE ARE DISCLAIMED.

;; IN  NO  EVENT  SHALL  THE  AUTHOR  BE  LIABLE  FOR  ANY  DIRECT, INDIRECT,

;; INCIDENTAL, SPECIAL, EXEMPLARY, OR  CONSEQUENTIAL DAMAGES (INCLUDING, BUT

;; NOT LIMITED TO, PROCUREMENT OF  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

;; DATA, OR  PROFITS; OR  BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON ANY

;; THEORY OF  LIABILITY, WHETHER IN  CONTRACT,  STRICT  LIABILITY,  OR  TORT

;; (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT OF THE USE OF

;; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

;;

;;  History

;;  =======

;;  $Log: 3C59X.INC,v $

;;  Revision 1.3  2004/07/11 12:21:12  kozma

;;  Support of vortex chips (3c59x) added.

;;  Support of 3c920 and 3c982 added.

;;  Corrections.

;;

;;  Revision 1.2  2004/06/12 19:40:20  kozma

;;  Function e3c59x_set_available_media added in order to set

;;  the default media in case auto detection finds no valid link.

;;  Incorrect mii check removed (3c900 Cyclone works now).

;;  Cleanups.

;;

;;  Revision 1.1  2004/06/12 18:27:15  kozma

;;  Initial revision

;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

format MS COFF

        API_VERSION             = 0x01000100

        DRIVER_VERSION          = 5

        MAX_DEVICES             = 16

        FORCE_FD                = 0     ; forcing full duplex mode makes sense at some cards and link types

        PROMISCIOUS             = 0     ; enables promiscous mode

        DEBUG                   = 1

        __DEBUG__               = 1

        __DEBUG_LEVEL__         = 2

include '../proc32.inc'

include '../imports.inc'

include '../fdo.inc'

include '../netdrv.inc'

public START

public service_proc

public version

struc DPD {     ; Download Packet Descriptor

        .next_ptr               dd ?

        .frame_start_hdr        dd ?

        .frag_addr              dd ?    ; for packet data

        .frag_len               dd ?    ; for packet data

        .realaddr               dd ?

        .size                   = 32

}

virtual at 0

  dpd DPD

end virtual

struc UPD {     ; Upload Packet Descriptor

        .next_ptr               dd ?

        .pkt_status             dd ?

        .frag_addr              dd ?

        .frag_len               dd ?    ; for packet data

        .realaddr               dd ?

        .size           = 32

}

virtual at 0

  upd UPD

end virtual

; Registers

        REG_POWER_MGMT_CTRL     = 0x7c

        REG_UP_LIST_PTR         = 0x38

        REG_UP_PKT_STATUS       = 0x30

        REG_TX_FREE_THRESH      = 0x2f

        REG_DN_LIST_PTR         = 0x24

        REG_DMA_CTRL            = 0x20

        REG_TX_STATUS           = 0x1b

        REG_RX_STATUS           = 0x18

        REG_TX_DATA             = 0x10

; Common window registers

        REG_INT_STATUS          = 0xe

        REG_COMMAND             = 0xe

; Register window 7

        REG_MASTER_STATUS       = 0xc

        REG_POWER_MGMT_EVENT    = 0xc

        REG_MASTER_LEN          = 0x6

        REG_VLAN_ETHER_TYPE     = 0x4

        REG_VLAN_MASK           = 0x0

        REG_MASTER_ADDRESS      = 0x0

; Register window 6

        REG_BYTES_XMITTED_OK    = 0xc

        REG_BYTES_RCVD_OK       = 0xa

        REG_UPPER_FRAMES_OK     = 0x9

        REG_FRAMES_DEFERRED     = 0x8

        REG_FRAMES_RCVD_OK      = 0x7

        REG_FRAMES_XMITTED_OK   = 0x6

        REG_RX_OVERRUNS         = 0x5

        REG_LATE_COLLISIONS     = 0x4

        REG_SINGLE_COLLISIONS   = 0x3

        REG_MULTIPLE_COLLISIONS = 0x2

        REG_SQE_ERRORS          = 0x1

        REG_CARRIER_LOST        = 0x0

; Register window 5

        REG_INDICATION_ENABLE   = 0xc

        REG_INTERRUPT_ENABLE    = 0xa

        REG_TX_RECLAIM_THRESH   = 0x9

        REG_RX_FILTER           = 0x8

        REG_RX_EARLY_THRESH     = 0x6

        REG_TX_START_THRESH     = 0x0

; Register window 4

        REG_UPPER_BYTES_OK      = 0xe

        REG_BAD_SSD             = 0xc

        REG_MEDIA_STATUS        = 0xa

        REG_PHYSICAL_MGMT       = 0x8

        REG_NETWORK_DIAGNOSTIC  = 0x6

        REG_FIFO_DIAGNOSTIC     = 0x4

        REG_VCO_DIAGNOSTIC      = 0x2   ; may not supported

; Bits in register window 4

        BIT_AUTOSELECT          = 24

; Register window 3

        REG_TX_FREE             = 0xc

        REG_RX_FREE             = 0xa

        REG_MEDIA_OPTIONS       = 0x8

        REG_MAC_CONTROL         = 0x6

        REG_MAX_PKT_SIZE        = 0x4

        REG_INTERNAL_CONFIG     = 0x0

; Register window 2

        REG_RESET_OPTIONS       = 0xc

        REG_STATION_MASK_HI     = 0xa

        REG_STATION_MASK_MID    = 0x8

        REG_STATION_MASK_LO     = 0x6

        REG_STATION_ADDRESS_HI  = 0x4

        REG_STATION_ADDRESS_MID = 0x2

        REG_STATION_ADDRESS_LO  = 0x0

; Register window 1

        REG_TRIGGER_BITS        = 0xc

        REG_SOS_BITS            = 0xa

        REG_WAKE_ON_TIMER       = 0x8

        REG_SMB_RXBYTES         = 0x7

        REG_SMB_DIAG            = 0x5

        REG_SMB_ARB             = 0x4

        REG_SMB_STATUS          = 0x2

        REG_SMB_ADDRESS         = 0x1

        REG_SMB_FIFO_DATA       = 0x0

; Register window 0

        REG_EEPROM_DATA         = 0xc

        REG_EEPROM_COMMAND      = 0xa

        REG_BIOS_ROM_DATA       = 0x8

        REG_BIOS_ROM_ADDR       = 0x4

; Physical management bits

        BIT_MGMT_DIR            = 2     ; drive with the data written in mgmtData

        BIT_MGMT_DATA           = 1     ; MII management data bit

        BIT_MGMT_CLK            = 0     ; MII management clock

; MII commands

        MII_CMD_MASK            = (1111b shl 10)

        MII_CMD_READ            = (0110b shl 10)

        MII_CMD_WRITE           = (0101b shl 10)

; MII registers

        REG_MII_BMCR            = 0     ; basic mode control register

        REG_MII_BMSR            = 1     ; basic mode status register

        REG_MII_ANAR            = 4     ; auto negotiation advertisement register

        REG_MII_ANLPAR          = 5     ; auto negotiation link partner ability register

        REG_MII_ANER            = 6     ; auto negotiation expansion register

; MII bits

        BIT_MII_AUTONEG_COMPLETE        = 5     ; auto-negotiation complete

        BIT_MII_PREAMBLE_SUPPRESSION    = 6

; eeprom bits and commands

        EEPROM_CMD_READ         = 0x80

        EEPROM_BIT_BUSY         = 15

; eeprom registers

        EEPROM_REG_OEM_NODE_ADDR= 0xa

        EEPROM_REG_CAPABILITIES = 0x10

; Commands for command register

        SELECT_REGISTER_WINDOW  = (1 shl 11)

        IS_VORTEX               = 0x1

        IS_BOOMERANG            = 0x2

        IS_CYCLONE              = 0x4

        IS_TORNADO              = 0x8

        EEPROM_8BIT             = 0x10

        HAS_PWR_CTRL            = 0x20

        HAS_MII                 = 0x40

        HAS_NWAY                = 0x80

        HAS_CB_FNS              = 0x100

        INVERT_MII_PWR          = 0x200

        INVERT_LED_PWR          = 0x400

        MAX_COLLISION_RESET     = 0x800

        EEPROM_OFFSET           = 0x1000

        HAS_HWCKSM              = 0x2000

        EXTRA_PREAMBLE          = 0x4000

; Status

        IntLatch                = 0x0001

        HostError               = 0x0002

        TxComplete              = 0x0004

        TxAvailable             = 0x0008

        RxComplete              = 0x0010

        RxEarly                 = 0x0020

        IntReq                  = 0x0040

        StatsFull               = 0x0080

        DMADone                 = 0x0100

        DownComplete            = 0x0200

        UpComplete              = 0x0400

        DMAInProgress           = 0x0800        ; 1 shl 11  (DMA controller is still busy)

        CmdInProgress           = 0x1000        ; 1 shl 12  (EL3_CMD is still busy)

        S_5_INTS                = HostError + RxEarly + UpComplete + DownComplete ;+ TxComplete + RxComplete  + TxAvailable

; Commands

        TotalReset              = 0 shl 11

        SelectWindow            = 1 shl 11

        StartCoax               = 2 shl 11

        RxDisable               = 3 shl 11

        RxEnable                = 4 shl 11

        RxReset                 = 5 shl 11

        UpStall                 = 6 shl 11

        UpUnstall               = (6 shl 11)+1

        DownStall               = (6 shl 11)+2

        DownUnstall             = (6 shl 11)+3

        RxDiscard               = 8 shl 11

        TxEnable                = 9 shl 11

        TxDisable               = 10 shl 11

        TxReset                 = 11 shl 11

        FakeIntr                = 12 shl 11

        AckIntr                 = 13 shl 11

        SetIntrEnb              = 14 shl 11

        SetStatusEnb            = 15 shl 11

        SetRxFilter             = 16 shl 11

        SetRxThreshold          = 17 shl 11

        SetTxThreshold          = 18 shl 11

        SetTxStart              = 19 shl 11

        StartDMAUp              = 20 shl 11

        StartDMADown            = (20 shl 11)+1

        StatsEnable             = 21 shl 11

        StatsDisable            = 22 shl 11

        StopCoax                = 23 shl 11

        SetFilterBit            = 25 shl 11

; Rx mode bits

        RxStation               = 1

        RxMulticast             = 2

        RxBroadcast             = 4

        RxProm                  = 8

; RX/TX buffers sizes

        MAX_ETH_PKT_SIZE        = 1536          ; max packet size

        NUM_RX_DESC             = 4             ; a power of 2 number

        NUM_TX_DESC             = 4             ; a power of 2 number

        MAX_ETH_FRAME_SIZE      = 1520          ; size of ethernet frame + bytes alignment

virtual at ebx

        device:

        ETH_DEVICE

        .dpd_buffer       rd (dpd.size*NUM_TX_DESC)/4

        .upd_buffer       rd (upd.size*NUM_RX_DESC)/4

        .curr_upd         dd ?

        .prev_dpd         dd ?

        .io_addr          dd ?

        .pci_bus          dd ?

        .pci_dev          dd ?

        .irq_line         db ?

                rb 3    ; alignment

        .prev_tx_frame            dd ?

        .ver_id                   db ?

        .full_bus_master          db ?

        .has_hwcksm               db ?

        .preamble                 db ?

        .dn_list_ptr_cleared      db ?

        .size = $ - device

end virtual

section '.flat' code readable align 16

;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                        ;;

;; proc START             ;;

;;                        ;;

;; (standard driver proc) ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;

align 4

proc START stdcall, state:dword

        cmp [state], 1

        jne .exit

  .entry:

        DEBUGF 1,"Loading driver\n"

        stdcall RegService, my_service, service_proc

        ret

  .fail:

  .exit:

        xor eax, eax

        ret

endp

;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                        ;;

;; proc SERVICE_PROC      ;;

;;                        ;;

;; (standard driver proc) ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;

align 4

proc service_proc stdcall, ioctl:dword

        mov     edx, [ioctl]

        mov     eax, [IOCTL.io_code]

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

        cmp     eax, 0 ;SRV_GETVERSION

        jne     @F

        cmp     [IOCTL.out_size], 4

        jb      .fail

        mov     eax, [IOCTL.output]

        mov     [eax], dword API_VERSION

        xor     eax, eax

        ret

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

  @@:

        cmp     eax, 1 ;SRV_HOOK

        jne     .fail

        cmp     [IOCTL.inp_size], 3               ; Data input must be at least 3 bytes

        jb      .fail

        mov     eax, [IOCTL.input]

        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]

        test    ecx, ecx

        jz      .maybeboomerang

        mov     esi, VORTEX_LIST

        mov     eax, [IOCTL.input]                      ; get the pci bus and device numbers

        mov     ax , [eax+1]                            ;

  .nextdevice:

        mov     ebx, [esi]

        cmp     al, byte[device.pci_bus]

        jne     @f

        cmp     ah, byte[device.pci_dev]

        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, [IOCTL.input]                      ; get the pci bus and device numbers

        mov     ax , [eax+1]                            ;

  .nextdevice2:

        mov     ebx, [esi]

        cmp     al, byte[device.pci_bus]

        jne     @f

        cmp     ah, byte[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]

        cmp     ecx, MAX_DEVICES                        ; First check if the driver can handle one more card

        jae     .fail

        allocate_and_clear ebx, device.size, .fail      ; Allocate the buffer for device structure

; Fill in the direct call addresses into the struct

        mov     [device.reset], reset

        mov     [device.transmit], null_op

        mov     [device.unload], null_op

        mov     [device.name], my_service

; save the pci bus and device numbers

        mov     eax, [IOCTL.input]

        movzx   ecx, byte[eax+1]

        mov     [device.pci_bus], ecx

        movzx   ecx, byte[eax+2]

        mov     [device.pci_dev], ecx

; Now, it's time to find the base io addres of the PCI device

        PCI_find_io

; We've found the io address, find IRQ now

        PCI_find_irq

        DEBUGF  1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\

        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4

; 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, [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     [VORTEX_LIST+4*eax], ebx                                ; (IRQ handler uses this list to find device)

        inc     [VORTEX_DEVICES]                                        ;

  .register:

        mov     [device.type], NET_TYPE_ETH

        call    NetRegDev

        cmp     eax, -1

        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

; If the device was already loaded, find the device number and return it in eax

  .find_devicenum:

        DEBUGF  1,"Trying to find device number of already registered device\n"

        call    NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx

                                                                        ; into a device number in edi

        mov     eax, edi                                                ; Application wants it in eax instead

        DEBUGF  1,"Kernel says: %u\n", eax

        ret

; If an error occured, remove all allocated data and exit (returning -1 in eax)

  .destroy:

        ; todo: reset device into virgin state

  .err:

        stdcall KernelFree, ebx

  .fail:

        or      eax, -1

        ret

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

endp

;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;

;;                                                                        ;;

;;        Actual Hardware dependent code starts here                      ;;

;;                                                                        ;;

;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;

;***************************************************************************

;   Function

;      probe

;   Description

;      Searches for an ethernet card, enables it and clears the rx buffer

;   Destroyed registers

;      eax, ebx, ecx, edx, edi, esi

;

;***************************************************************************

align 4

probe:

        DEBUGF  1,"Probing 3com card\n"

        PCI_make_bus_master

; wake up the card

        call    wake_up

        stdcall PciRead32, [device.pci_bus], [device.pci_dev], 0                                ; get device/vendor id

        DEBUGF  1,"Vendor id: 0x%x\n", ax

        cmp     ax, 0x10B7

        jne     .notfound

        shr     eax, 16

        DEBUGF  1,"Vendor ok!, device id: 0x%x\n", ax

; get chip version

        mov     ecx, HW_VERSIONS_SIZE/4-1

  .loop:

        cmp     ax, [hw_versions+ecx*4]

        jz      .found

        loop    .loop

  .notfound:

        DEBUGF  2,"Device id not found in list!\n"

        or      eax, -1

        ret

  .found:

        mov     esi, [hw_str+ecx*4]

        DEBUGF  1,"Hardware type: %s\n", esi

        mov     [device.name], esi

        mov     [device.ver_id], cl

        test    word [hw_versions+2+ecx*4], HAS_HWCKSM

        setnz   [device.has_hwcksm]

; set pci latency for vortex cards

        test    word [hw_versions+2+ecx*4], IS_VORTEX

        jz      .not_vortex

        mov     eax, 11111000b ; 248 = max latency

        stdcall PciWrite32, [device.pci_bus], [device.pci_dev], PCI_REG_LATENCY, eax

  .not_vortex:

; set RX/TX functions

        mov     ax, EEPROM_REG_CAPABILITIES

        call    read_eeprom

        test    al, 100000b ; full bus master?

        setnz   [device.full_bus_master]

        jnz     .boomerang_func

        mov     [device.transmit], vortex_transmit

        DEBUGF  2,"Device is a vortex type\n"

        DEBUGF  2,"I'm sorry but vortex code hasnt been tested yet\n"

        DEBUGF  2,"Please contact me on hidnplayr@kolibrios.org\n"

        DEBUGF  2,"If you can help me finish it!\n"

        or      eax, -1

        ret

        jmp     @f

  .boomerang_func: ; full bus master, so use boomerang functions

        mov     [device.transmit], boomerang_transmit

        DEBUGF  1,"Device is a boomerang type\n"

       @@:

        call    read_mac_eeprom

        test    byte [device.full_bus_master], 0xff

        jz      .set_preamble

; switch to register window 2

        set_io  0

        set_io  REG_COMMAND

        mov     ax, SELECT_REGISTER_WINDOW+2

        out     dx, ax

; activate xcvr by setting some magic bits

        set_io  REG_RESET_OPTIONS

        in      ax, dx

        and     ax, not 0x4010

        movzx   ecx, [device.ver_id]

        test    word [ecx*4+hw_versions+2], INVERT_LED_PWR

        jz      @f

        or      al, 0x10

       @@:

        test    word [ecx*4+hw_versions+2], INVERT_MII_PWR

        jz      @f

        or      ah, 0x40

       @@:

        out     dx, ax

  .set_preamble:

; use preamble as default

        mov     byte [device.preamble], 1 ; enable preamble

        call    global_reset

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

; RESET

align 4

reset:

        movzx   eax, [device.irq_line]

        DEBUGF  1,"Attaching int handler to irq %x\n",eax:1

        movzx   ecx, [device.ver_id]

        test    word [hw_versions+2+ecx*4], IS_VORTEX

        jz      .not_vortex

        mov     esi, int_vortex

        jmp     .reg_int

.not_vortex:

        mov     esi, int_boomerang

.reg_int:

        stdcall AttachIntHandler, eax, esi, dword 0

        test    eax, eax

        jnz     @f

        DEBUGF  2,"Could not attach int handler!\n"

;        or      eax, -1

;        ret

  @@:

        set_io  0

        set_io  REG_COMMAND

        mov     ax, SELECT_REGISTER_WINDOW + 0

        out     dx, ax

        mov     ax, StopCoax

        out     dx, ax                        ; stop transceiver

        mov     ax, SELECT_REGISTER_WINDOW + 4

        out     dx, ax                        ; disable UTP

        set_io  REG_MEDIA_STATUS

        mov     ax, 0x0

        set_io  REG_COMMAND

        mov     ax, SELECT_REGISTER_WINDOW + 0

        out     dx, ax

        set_io  REG_FIFO_DIAGNOSTIC

        mov     ax, 0

        out     dx, ax                        ; disable card

        mov     ax, 1

        out     dx, ax                        ; enable card

        call    write_mac

;<<<<<<<<<<<<<<

        set_io  REG_COMMAND

        mov     ax, SELECT_REGISTER_WINDOW + 1

        out     dx, ax

        mov     ecx, 32

        set_io  0x0b

  .loop:

        in      al, dx

        loop    .loop

; Get rid of stray ints

        set_io  REG_COMMAND

        mov     ax, AckIntr + 0xff

        out     dx, ax

        mov     ax, SetStatusEnb + S_5_INTS

        out     dx, ax

        mov     ax, SetIntrEnb + S_5_INTS

        out     dx, ax

        call    set_rx_mode

        call    set_active_port

;>>>>>>>>>>

        call    create_rx_ring

        call    rx_reset

        call    tx_reset

;>>>>>>>>>>>>>>>>>>

        xor     eax, eax

; clear packet/byte counters

        lea     edi, [device.bytes_tx]

        mov     ecx, 6

        rep     stosd

; Set the mtu, kernel will be able to send now

        mov     [device.mtu], 1514

        ret

align 4

start_device:

        DEBUGF  1,"Starting the device\n"

        set_io  0

        set_io  REG_COMMAND

        mov     ax, SetTxThreshold + 60 ;2047 ; recommended by the manual :)

        out     dx, ax

        call    check_tx_status

        set_io  0

        set_io  REG_COMMAND

; switch to register window 4

        mov     ax, SELECT_REGISTER_WINDOW+4

        out     dx, ax

; wait for linkDetect

        set_io  REG_MEDIA_STATUS

        mov     ecx, 20 ; wait for max 2s

  .link_detect_loop:

        mov     esi, 100

        call    Sleep ; 100 ms

        in      ax, dx

        test    ah, 1000b ; linkDetect

        jnz     @f

        loop    .link_detect_loop

        DEBUGF  2,"Link detect timed-out!\n"

       @@:

; print link type

        xor     eax, eax

        bsr     ax, word [device.state]

        jz      @f

        sub     ax, 4

       @@:

        mov     esi, [link_str+eax*4]

        DEBUGF  1,"Established Link type: %s\n", esi

; enable interrupts

        set_io  REG_COMMAND

        mov     ax, SELECT_REGISTER_WINDOW + 1

        out     dx, ax

        mov     ax, AckIntr + 0xff

        out     dx, ax

        mov     ax, SetStatusEnb + S_5_INTS

        out     dx, ax

        mov     ax, SetIntrEnb + S_5_INTS

        out     dx, ax

; Start RX/TX

        set_io  0

        set_io  REG_COMMAND

        mov     ax, RxEnable

        out     dx, ax

        mov     ax, TxEnable

        out     dx, ax

        set_io  REG_COMMAND

        mov     ax, SetRxThreshold + 208

        out     dx, ax

        mov     ax, SetTxThreshold + 60 ;16 ; recommended by the manual :)

        out     dx, ax

        mov     ax, SELECT_REGISTER_WINDOW + 1

        out     dx, ax

        ret

align 4

set_rx_mode:

        DEBUGF  1,"Setting RX mode\n"

        set_io  0

        set_io  REG_COMMAND

if      defined PROMISCIOUS

        mov     ax, SetRxFilter + RxStation + RxMulticast + RxBroadcast + RxProm

else if  defined ALLMULTI

        mov     ax, SetRxFilter + RxStation + RxMulticast + RxBroadcast

else

        mov     ax, SetRxFilter + RxStation + RxBroadcast

end if

        out     dx, ax

        ret

;***************************************************************************

;   Function

;      global_reset

;   Description

;      resets the device

;   Parameters:

;

;   Return value:

;   Destroyed registers

;      ax, ecx, edx, esi

;

;***************************************************************************1

align 4

global_reset:

        DEBUGF 1,"Global reset..\n"

; GlobalReset

        set_io  0

        set_io  REG_COMMAND

        xor     eax, eax

;       or      al, 0x14

        out     dx, ax

; wait for GlobalReset to complete

        mov     ecx, 64000

  .loop:

        in      ax , dx

        test    ah , 10000b ; check CmdInProgress

        loopz   .loop

        DEBUGF 1,"Waiting for nic to boot..\n"

; wait for 2 seconds for NIC to boot

        mov     esi, 2000

        call    Sleep ; 2 seconds

        DEBUGF 1,"Ok!\n"

        ret

;***************************************************************************

;   Function

;      tx_reset

;   Description

;      resets and enables transmitter engine

;

;***************************************************************************

align 4

tx_reset:

        DEBUGF 1,"tx reset\n"

; TxReset

        set_io  0

        set_io  REG_COMMAND

        mov     ax, TxReset

        out     dx, ax

; Wait for TxReset to complete

        mov     ecx, 200000

.tx_reset_loop:

        in      ax, dx

        test    ah, 10000b ; check CmdInProgress

        jz      .tx_set_prev

        dec     ecx

        jnz     .tx_reset_loop

.tx_set_prev:

; init last_dpd

        lea     eax, [device.dpd_buffer + (NUM_TX_DESC-1)*dpd.size]

        mov     [device.prev_dpd], eax

.tx_enable:

        ret

;***************************************************************************

;   Function

;      rx_reset

;   Description

;      resets and enables receiver engine

;

;***************************************************************************

align 4

rx_reset:

        DEBUGF 1,"rx reset\n"

        set_io  0

        set_io  REG_COMMAND

        mov     ax, RxReset or 0x4

        out     dx, ax

; wait for RxReset to complete

        mov     ecx, 200000

  .loop:

        in      ax, dx

        test    ah, 10000b ; check CmdInProgress

        jz      .done

        dec     ecx

        jnz     .loop

  .done:

        lea     eax, [device.upd_buffer]

        mov     [device.curr_upd], eax

        GetRealAddr

        set_io  0

        set_io  REG_UP_LIST_PTR

        out     dx, eax

  .rx_enable:

        ret

align 4

create_rx_ring:

; create upd ring

        lea     eax, [device.upd_buffer]

        GetRealAddr

        mov     edi, eax                                                ; real addr of first descr

        lea     esi, [device.upd_buffer]                                ; ptr to first descr

        lea     edx, [device.upd_buffer + (NUM_RX_DESC-1)*upd.size]     ; ptr to last descr

        mov     ecx, NUM_RX_DESC

  .upd_loop:

        mov     [edx + upd.next_ptr], edi

        push    ecx edx

        stdcall KernelAlloc, MAX_ETH_FRAME_SIZE

        pop     edx ecx

        mov     [esi + upd.realaddr], eax

        call    GetPgAddr

        mov     [esi + upd.frag_addr], eax

        and     [esi + upd.pkt_status], 0

        mov     [esi + upd.frag_len], MAX_ETH_FRAME_SIZE or (1 shl 31)

        DEBUGF  1,"UPD: lin=%x phys=%x len=%x next ptr=%x\n", [esi+upd.realaddr]:8, [esi+upd.frag_addr]:8, [esi+upd.frag_len]:8, edi

        DEBUGF  1,"UPD: cur=%x prev=%x\n", esi, edx

        mov     edx, esi

        add     esi, upd.size

        add     edi, upd.size

        dec     ecx

        jnz     .upd_loop

        ret

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

;   Function

;      try_link_detect

;   Description

;      try_link_detect checks if link exists

;   Parameters

;      ebx = device structure

;   Return value

;      al - 0 ; no link detected

;      al - 1 ; link detected

;   Destroyed registers

;      eax, ebx, ecx, edx, edi, esi

;

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

align 4

try_link_detect:

        DEBUGF  1,"trying to detect link\n"

; create self-directed packet

        stdcall KernelAlloc, 20 ; create a buffer for the self-directed packet

        test    eax, eax

        jz      .fail

        pushd   20              ; Packet parameters for device.transmit

        push    eax             ;

        mov     edi, eax

        lea     esi, [device.mac]

        movsw

        movsd

        sub     esi, 6

        movsw

        movsd

        mov     ax , 0x0608

        stosw

; download self-directed packet

        call    [device.transmit]

; switch to register window 4

        set_io  0

        set_io  REG_COMMAND

        mov     ax, SELECT_REGISTER_WINDOW+4

        out     dx, ax

; See if we have received the packet by now..

        cmp     [device.packets_rx], 0

        jnz     .link_detected

; switch to register window 4

        set_io  REG_COMMAND

        mov     ax, SELECT_REGISTER_WINDOW+4

        out     dx, ax

; read linkbeatdetect

        set_io  REG_MEDIA_STATUS

        in      ax, dx

        test    ah, 1000b ; test linkBeatDetect

        jnz     .link_detected

        xor     al, al

        jmp     .finish

  .link_detected:

        DEBUGF  1,"link detected!\n"

        setb    al

  .finish:

        test    al, al

        jz      @f

        or      byte [device.state+1], 100b

       @@:

        ret

  .fail:

        ret

;***************************************************************************

;   Function

;      try_phy

;   Description

;      try_phy checks the auto-negotiation function

;      in the PHY at PHY index. It can also be extended to

;      include link detection for non-IEEE 802.3u

;      auto-negotiation devices, for instance the BCM5000.              ; TODO: BCM5000