kolibrios/kernel/branches/net/drivers/sis900.asm

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                    ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved.       ;;
;; Distributed under terms of the GNU General Public License          ;;
;;                                                                    ;;
;;  Ethernet driver for KolibriOS                                     ;;
;;  This is an adaptation of MenuetOS driver with minimal changes.    ;;
;;  Changes were made by CleverMouse. Original copyright follows.     ;;
;;                                                                    ;;
;;  This driver is based on the SIS900 driver from                    ;;
;;  the etherboot 5.0.6 project. The copyright statement is           ;;
;;                                                                    ;;
;;          GNU GENERAL PUBLIC LICENSE                                ;;
;;             Version 2, June 1991                                   ;;
;;                                                                    ;;
;;  remaining parts Copyright 2004 Jason Delozier,                    ;;
;;   cordata51@hotmail.com                                            ;;
;;                                                                    ;;
;;  See file COPYING for details                                      ;;
;;                                                                    ;;
;;  Updates:                                                          ;;
;;    Revision Look up table and SIS635 Mac Address by Jarek Pelczar  ;;
;;                                                                    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

format MS COFF

        NUM_RX_DESC             =   4           ;* Number of RX descriptors *
        NUM_TX_DESC             =   1           ;* Number of TX descriptors *
        RX_BUFF_SZ              =   1520        ;* Buffer size for each Rx buffer *
        TX_BUFF_SZ              =   1516        ;* Buffer size for each Tx buffer *
        MAX_ETH_FRAME_SIZE      =   1516

        API_VERSION             =   0x01000100
        DRIVER_VERSION          =   5

        MAX_DEVICES             =   16

        DEBUG                   =   1
        __DEBUG__               =   1
        __DEBUG_LEVEL__         =   1

include 'proc32.inc'
include 'imports.inc'
include 'fdo.inc'
include 'netdrv.inc'

public START
public version

virtual at ebx
        device:

        ETH_DEVICE

        .io_addr        dd ?
        .pci_bus        db ?
        .pci_dev        db ?
        .irq_line       db ?
        .cur_rx         db ?
        .cur_tx         db ?
        .last_tx        db ?
        .pci_revision   db ?
        .table_entries  db ?

                        dw ? ; align 4

        .special_func   dd ?

        .txd            rd (4 * NUM_TX_DESC)
        .rxd            rd (4 * NUM_RX_DESC)

        .size = $ - device

end virtual

macro   ee_delay {
        push    eax
        in      eax, dx
        in      eax, dx
        in      eax, dx
        in      eax, dx
        in      eax, dx
        in      eax, dx
        in      eax, dx
        in      eax, dx
        in      eax, dx
        in      eax, dx
        pop     eax
}


section '.flat' code readable align 16

; Driver entry point - register our service when the driver is loading.
; TODO: add needed operations when unloading
START:
        cmp     dword [esp+4], 1
        jne     .exit
        stdcall RegService, my_service, service_proc
        ret     4
  .exit:
        xor     eax, eax
        ret     4

; Service procedure for the driver - handle all I/O requests for the driver.
; Currently handled requests are: SRV_GETVERSION = 0 and SRV_HOOK = 1.
service_proc:
; 1. Get parameter from the stack: [esp+4] is the first parameter,
;       pointer to IOCTL structure.
        mov     edx, [esp+4]    ; edx -> IOCTL
; 2. Get request code and select a handler for the code.
        mov     eax, [IOCTL.io_code]
        test    eax, eax        ; check for SRV_GETVERSION
        jnz     @f
; 3. This is SRV_GETVERSION request, no input, 4 bytes output, API_VERSION.
; 3a. Output size must be at least 4 bytes.
        cmp     [IOCTL.out_size], 4
        jl      .fail
; 3b. Write result to the output buffer.
        mov     eax, [IOCTL.output]
        mov     [eax], dword API_VERSION
; 3c. Return success.
        xor     eax, eax
        ret     4
  @@:
        dec     eax     ; check for SRV_HOOK
        jnz     .fail
; 4. This is SRV_HOOK request, input defines the device to hook, no output.
; 4a. The driver works only with PCI devices,
;       so input must be at least 3 bytes long.
        cmp     [IOCTL.inp_size], 3
        jl      .fail
; 4b. First byte of input is bus type, 1 stands for PCI.
        mov     eax, [IOCTL.input]
        cmp     byte [eax], 1
        jne     .fail
; 4c. Second and third bytes of the input define the device: bus and dev.
;       Word in bx holds both bytes.
        mov     bx, [eax+1]
; 4d. Check if the device was already hooked,
;       scan through the list of known devices.
; check if the device is already listed
        mov     esi, device_list
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .firstdevice

;        mov     eax, [IOCTL.input]                      ; get the pci bus and device numbers
        mov     ax, [eax+1]                            ;
  .nextdevice:
        mov     ebx, [esi]
        cmp     ax, word [device.pci_bus]               ; compare with pci and device num in device list (notice the usage of word instead of byte)
        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
        add     esi, 4
        loop    .nextdevice
; 4e. This device doesn't have its own eth_device structure yet, let's create one
  .firstdevice:
; 4f. Check that we have place for new device.
        cmp     [devices], MAX_DEVICES
        jge     .fail
; 4g. Allocate memory for device descriptor and receive+transmit buffers.
; 4h. Zero the structure.
        allocate_and_clear ebx, device.size, .fail
; 4i. Save PCI coordinates
        mov     eax, [IOCTL.input]
        mov     cl, [eax+1]
        mov     [device.pci_bus], cl
        mov     cl, [eax+2]
        mov     [device.pci_dev], cl
; 4j. Fill in the direct call addresses into the struct.
; Note that get_MAC pointer is filled in initialization by probe.
        mov     [device.reset], init
        mov     [device.transmit], transmit
;       mov     [device.get_MAC], read_mac
        mov     [device.set_MAC], write_mac
        mov     [device.unload], unload
        mov     [device.name], my_service

; 4k. Now, it's time to find the base io addres of the PCI device
; TODO: implement check if bus and dev exist on this machine

; Now, it's time to find the base io addres of the PCI device
        find_io [device.pci_bus], [device.pci_dev], [device.io_addr]

; We've found the io address, find IRQ now
        find_irq [device.pci_bus], [device.pci_dev], [device.irq_line]

; 4m. Add new device to the list (required for int_handler).
        mov     eax, [devices]
        mov     [device_list+4*eax], ebx
        inc     [devices]

; 4m. Ok, the eth_device structure is ready, let's probe the device
        call    probe
        test    eax, eax
        jnz     .destroy
; 4n. If device was successfully initialized, register it for the kernel.

        mov     [device.type], NET_TYPE_ETH
        call    NetRegDev

        cmp     eax, -1
        je      .destroy

        ret     4

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

  .find_devicenum:
        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
        ret     4

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

  .destroy:
        dec     [devices]
        ; todo: reset device into virgin state

  .err:
        stdcall KernelFree, ebx

  .fail:
        xor     eax, eax
        ret     4


;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
;;                                                                        ;;
;;        Actual Hardware dependent code starts here                      ;;
;;                                                                        ;;
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;

unload:
        ; TODO: (in this particular order)
        ;
        ; - Stop the device
        ; - Detach int handler
        ; - Remove device from local list
        ; - call unregister function in kernel
        ; - Remove all allocated structures and buffers the card used

        or      eax,-1

ret

;********************************************************************
;  Comments:
;    Known to work with the following SIS900 ethernet cards:
;      -  Device ID: 0x0900   Vendor ID: 0x1039   Revision: 0x91
;      -  Device ID: 0x0900   Vendor ID: 0x1039   Revision: 0x90
;
;    If your card is not listed, try it and let me know if it
;    functions properly and it will be aded to the list.  If not
;    we may be able to add support for it.
;
;  ToDo:
;     -  Enable MII interface for reading speed
;        and duplex settings.
;     -  Update receive routine to support packet fragmentation.
;     -  Add additional support for other sis900 based cards
;
;********************************************************************

        ETH_ALEN        =   6           ; Size of Ethernet address
        ETH_HLEN        =   14          ; Size of ethernet header
        ETH_ZLEN        =   60          ; Minimum packet length
        DSIZE           =   0x00000fff
        CRC_SIZE        =   4
        RFADDR_shift    =   16

; Symbolic offsets to registers.
        cr              =   0x0               ; Command Register
        cfg             =   0x4       ; Configuration Register
        mear            =   0x8       ; EEPROM Access Register
        ptscr           =   0xc       ; PCI Test Control Register
        isr             =   0x10      ; Interrupt Status Register
        imr             =   0x14      ; Interrupt Mask Register
        ier             =   0x18      ; Interrupt Enable Register
        epar            =   0x18      ; Enhanced PHY Access Register
        txdp            =   0x20      ; Transmit Descriptor Pointer Register
        txcfg           =   0x24      ; Transmit Configuration Register
        rxdp            =   0x30      ; Receive Descriptor Pointer Register
        rxcfg           =   0x34      ; Receive Configuration Register
        flctrl          =   0x38      ; Flow Control Register
        rxlen           =   0x3c      ; Receive Packet Length Register
        rfcr            =   0x48      ; Receive Filter Control Register
        rfdr            =   0x4C      ; Receive Filter Data Register
        pmctrl          =   0xB0      ; Power Management Control Register
        pmer            =   0xB4      ; Power Management Wake-up Event Register

; Command Register Bits
        RELOAD          =   0x00000400
        ACCESSMODE      =   0x00000200
        RESET           =   0x00000100
        SWI             =   0x00000080
        RxRESET         =   0x00000020
        TxRESET         =   0x00000010
        RxDIS           =   0x00000008
        RxENA           =   0x00000004
        TxDIS           =   0x00000002
        TxENA           =   0x00000001

; Configuration Register Bits
        DESCRFMT        =   0x00000100 ; 7016 specific
        REQALG          =   0x00000080
        SB              =   0x00000040
        POW             =   0x00000020
        EXD             =   0x00000010
        PESEL           =   0x00000008
        LPM             =   0x00000004
        BEM             =   0x00000001
        RND_CNT         =   0x00000400
        FAIR_BACKOFF    =   0x00000200
        EDB_MASTER_EN   =   0x00002000

; Eeprom Access Reigster Bits
        MDC             =   0x00000040
        MDDIR           =   0x00000020
        MDIO            =   0x00000010  ; 7016 specific
        EECS            =   0x00000008
        EECLK           =   0x00000004
        EEDO            =   0x00000002
        EEDI            =   0x00000001

; TX Configuration Register Bits
        ATP             =   0x10000000 ;Automatic Transmit Padding
        MLB             =   0x20000000 ;Mac Loopback Enable
        HBI             =   0x40000000 ;HeartBeat Ignore (Req for full-dup)
        CSI             =   0x80000000 ;CarrierSenseIgnore (Req for full-du

; RX Configuration Register Bits
        AJAB            =   0x08000000 ;
        ATX             =   0x10000000 ;Accept Transmit Packets
        ARP             =   0x40000000 ;accept runt packets (<64bytes)
        AEP             =   0x80000000 ;accept error packets

; Interrupt Reigster Bits
        WKEVT           =   0x10000000
        TxPAUSEEND      =   0x08000000
        TxPAUSE         =   0x04000000
        TxRCMP          =   0x02000000
        RxRCMP          =   0x01000000
        DPERR           =   0x00800000
        SSERR           =   0x00400000
        RMABT           =   0x00200000
        RTABT           =   0x00100000
        RxSOVR          =   0x00010000
        HIBERR          =   0x00008000
        SWINT           =   0x00001000
        MIBINT          =   0x00000800
        TxURN           =   0x00000400
        TxIDLE          =   0x00000200
        TxERR           =   0x00000100
        TxDESC          =   0x00000080
        TxOK            =   0x00000040
        RxORN           =   0x00000020
        RxIDLE          =   0x00000010
        RxEARLY         =   0x00000008
        RxERR           =   0x00000004
        RxDESC          =   0x00000002
        RxOK            =   0x00000001

; Interrupt Enable Register Bits
        IE              =   RxOK + TxOK

; Revision ID
        SIS900B_900_REV         =   0x03
        SIS630A_900_REV         =   0x80
        SIS630E_900_REV         =   0x81
        SIS630S_900_REV         =   0x82
        SIS630EA1_900_REV       =   0x83
        SIS630ET_900_REV        =   0x84
        SIS635A_900_REV         =   0x90
        SIS900_960_REV          =   0x91

; Receive Filter Control Register Bits
        RFEN            =   0x80000000
        RFAAB           =   0x40000000
        RFAAM           =   0x20000000
        RFAAP           =   0x10000000
        RFPromiscuous   =   0x70000000

; Reveive Filter Data Mask
        RFDAT           =   0x0000FFFF

; Eeprom Address
        EEPROMSignature =   0x00
        EEPROMVendorID  =   0x02
        EEPROMDeviceID  =   0x03
        EEPROMMACAddr   =   0x08
        EEPROMChecksum  =   0x0b

;The EEPROM commands include the alway-set leading bit.
        EEread          =   0x0180
        EEwrite         =   0x0140
        EEerase         =   0x01C0
        EEwriteEnable   =   0x0130
        EEwriteDisable  =   0x0100
        EEeraseAll      =   0x0120
        EEwriteAll      =   0x0110
        EEaddrMask      =   0x013F
        EEcmdShift      =   16

;For SiS962 or SiS963, request the eeprom software access
        EEREQ           =   0x00000400
        EEDONE          =   0x00000200
        EEGNT           =   0x00000100


;***************************************************************************
;
; probe
;
; Searches for an ethernet card, enables it and clears the rx buffer
;
; TODO: probe mii transceivers
;
;***************************************************************************
align 4
probe:
        DEBUGF  1, "Probe\n"

        movzx   eax, [device.pci_bus]
        movzx   edx, [device.pci_dev]
        stdcall PciWrite8, eax, edx, 0x40, 0    ; Wake Up Chip

        make_bus_master [device.pci_bus], [device.pci_dev]

; Get Card Revision
        movzx   eax, [device.pci_bus]
        movzx   edx, [device.pci_dev]
        stdcall PciRead8, eax, edx, 0x08
        mov     [device.pci_revision], al       ; save the revision for later use

; Look up through the specific_table
        mov     esi, specific_table
  .loop:
        cmp     dword [esi], 0                  ; Check if we reached end of the list
        je      .error
        cmp     al, [esi]                       ; Check if revision is OK
        je      .ok
        add     esi, 12                         ; Advance to next entry
        jmp     .loop

  .error:
        DEBUGF  1, "Device not supported!\n"
        or      eax, -1
        ret

; Find Get Mac Function
  .ok:
        mov     eax, [esi + 4]          ; Get pointer to "get MAC" function
        mov     [device.get_MAC], eax
        mov     eax, [esi + 8]          ; Get pointer to special initialization fn
        mov     [device.special_func], eax

; Get MAC
        call    [device.get_MAC]

; Call special initialization fn if requested

        cmp     [device.special_func], 0
        je      @f
        call    [device.special_func]
       @@:

; Set table entries

        mov      [device.table_entries], 16
        cmp      [device.pci_revision], SIS635A_900_REV
        jae      @f
        cmp      [device.pci_revision], SIS900B_900_REV
        je       @f
        mov      [device.table_entries], 8
       @@:

; TODO: Probe for mii transceiver


;***************************************************************************
;
; init
;
; resets the ethernet controller chip and various
;    data structures required for sending and receiving packets.
;
;***************************************************************************
align 4
init:
        DEBUGF  1, "Init\n"

        call    reset
        jnz     .ret
        call    init_rxfilter
        call    init_txd
        call    init_rxd
        call    set_rx_mode
        call    set_tx_mode
        ;call    check_mode

; enable interrupts on packet receive

        xor     eax, eax
        inc     eax     ; eax = 1 = RxOK
        set_io  0
        set_io  imr
        out     dx, eax

; globally enable interrupts

        set_io  ier
        out     dx, eax ; eax is still 1
        xor     eax, eax

        mov     [device.mtu], 1514

  .ret:
        ret

;***************************************************************************
;
; reset
;
; disables interrupts and soft resets the controller chip
;
;***************************************************************************
align 4
reset:
        DEBUGF  1, "reset\n"

        movzx   eax, [device.irq_line]
        stdcall AttachIntHandler, eax, int_handler, 0

;--------------------------------------------
; Disable Interrupts and reset Receive Filter

        set_io  0
        set_io  ier
        xor     eax, eax
        out     dx, eax

        set_io  imr
        out     dx, eax

        set_io  rfcr
        out     dx, eax

;-----------
; Reset Card

        set_io  cr
        in      eax, dx                         ; Get current Command Register
        or      eax, RESET + RxRESET + TxRESET  ; set flags
        out     dx, eax                         ; Write new Command Register

;----------
; Wait loop

        set_io  isr
        mov     ecx, 1000
  .loop:
        dec     ecx
        jz      .error
        in      eax, dx                         ; move interrup status to eax
        test    eax, 0x03000000    ; CHECKME
        jz      .loop

;------------------------------------------------------
; Set Configuration Register depending on Card Revision

        set_io  cfg
        mov     eax, PESEL                      ; Configuration Register Bit
        cmp     [device.pci_revision], SIS635A_900_REV
        je      .match
        cmp     [device.pci_revision], SIS900B_900_REV ; Check card revision
        je      .match
        out     dx, eax                         ; no revision match
        jmp     .done

  .match:                                       ; Revision match
        or      eax, RND_CNT                    ; Configuration Register Bit
        out     dx, eax

  .done:
        xor     eax, eax
        ret

  .error:
        DEBUGF  1, "Reset failed!\n"
        or      eax, -1
        ret


;***************************************************************************
;
; sis_init_rxfilter
;
; sets receive filter address to our MAC address
;
;***************************************************************************
align 4
init_rxfilter:
        DEBUGF  1, "Init RxFilter\n"

;------------------------------------
; Get Receive Filter Control Register

        set_io  0
        set_io  rfcr
        in      eax, dx
        push    eax

;-----------------------------------------------
; disable packet filtering before setting filter

        and     eax, not RFEN
        out     dx, eax

;--------------------------------------
; load MAC addr to filter data register

        xor     ecx, ecx
RXINT_Mac_Write:        ; high word of eax tells card which mac byte to write
        mov     eax, ecx
        set_io  0
        set_io  rfcr
        shl     eax, 16                                             ;
        out     dx, eax                                             ;
        set_io  rfdr
        mov     ax, word [device.mac+ecx*2]                         ; Get Mac ID word
        out     dx, ax                                              ; Send Mac ID
        inc     cl                                                  ; send next word
        cmp     cl, 3                                               ; more to send?
        jne     RXINT_Mac_Write

;------------------------
; enable packet filtering

        pop     eax                             ;old register value
        set_io  rfcr
        or      eax, RFEN    ;enable filtering
        out     dx, eax             ;set register

        ret

;***************************************************************************
;
; init_txd
;
; initializes the Tx descriptor
;
;***************************************************************************
align 4
init_txd:
        DEBUGF  1, "Init TxD\n"

;-------------------------
; initialize TX descriptor

        mov     dword [device.txd], 0           ; put link to next descriptor in link field
        mov     dword [device.txd + 4], 0       ; clear status field
        mov     dword [device.txd + 8], 0       ; ptr to buffer

;----------------------------------
; load Transmit Descriptor Register

        set_io  0
        set_io  txdp                            ; TX Descriptor Pointer
        lea     eax, [device.txd]
        GetRealAddr
        out     dx, eax                         ; move the pointer

        ret

;***************************************************************************
;
; init_rxd
;
; initializes the Rx descriptor ring
;
;***************************************************************************
align 4
init_rxd:
        DEBUGF  1, "Init RxD\n"

; init RX descriptors
        mov     ecx, NUM_RX_DESC
        lea     esi, [device.rxd]

  .loop:
        lea     eax, [esi + 16]                 ; next ptr
        GetRealAddr
        mov     dword [esi], eax
        mov     dword [esi + 4], RX_BUFF_SZ     ; size

        push    ecx
        stdcall KernelAlloc, RX_BUFF_SZ
        pop     ecx
        test    eax, eax
        jz      .fail
        mov     dword [esi + 12], eax           ; address
        GetRealAddr
        mov     dword [esi + 8], eax            ; real address
        add     esi, 16
        dec     ecx
        jnz     .loop

        lea     eax, [device.rxd]
        GetRealAddr
        mov     dword [esi - 16], eax           ; correct last descriptor link ptr

; And output ptr to first desc, to device

        set_io  0
        set_io  rxdp
        out     dx, eax

        mov     [device.cur_rx], 0      ; Set curent rx discriptor to 0

  .fail:        ;;; TODO: abort instead!
        ret


;***************************************************************************
;
; set_tx_mode
;
; sets the transmit mode to allow for full duplex
;
; If you are having problems transmitting packet try changing the
; Max DMA Burst, Possible settings are as follows:
;
; 0x00000000 = 512 bytes
; 0x00100000 = 4 bytes
; 0x00200000 = 8 bytes
; 0x00300000 = 16 bytes
; 0x00400000 = 32 bytes
; 0x00500000 = 64 bytes
; 0x00600000 = 128 bytes
; 0x00700000 = 256 bytes
;
;***************************************************************************
align 4
set_tx_mode:
        DEBUGF  1, "set TX mode\n"

        set_io  0
        set_io  cr
        in      eax, dx                         ; Get current Command Register
        or      eax, TxENA                      ; Enable Receive
        out     dx, eax

        set_io  txcfg                                   ; Transmit config Register offset
        mov     eax, ATP + HBI + CSI +0x00600120
        ; allow automatic padding
        ; allow heartbeat ignore
        ; allow carrier sense ignore
        ; Max DMA Burst (128 bytes)
        ; TX Fill Threshold
        ; TX Drain Threshold
        out      dx, eax

        ret

;***************************************************************************
;
; set_rx_mode
;
; sets the receive mode to accept all broadcast packets and packets
; with our MAC address, and reject all multicast packets.  Also allows
; full-duplex
;
; If you are having problems receiving packet try changing the
; Max DMA Burst, Possible settings are as follows:
;
; 0x00000000 = 512 bytes
; 0x00100000 = 4 bytes
; 0x00200000 = 8 bytes
; 0x00300000 = 16 bytes
; 0x00400000 = 32 bytes
; 0x00500000 = 64 bytes
; 0x00600000 = 128 bytes
; 0x00700000 = 256 bytes
;
;***************************************************************************
align 4
set_rx_mode:
        DEBUGF  1, "set RX mode\n"

;----------------------------------------------
; update Multicast Hash Table in Receive Filter

        xor      cl, cl
  .loop:
        set_io   0
        set_io   rfcr                   ; Receive Filter Control Reg offset
        mov      eax, 4                 ; determine table entry
        add      al, cl
        shl      eax, 16
        out      dx, eax                ; tell card which entry to modify

        set_io   rfdr                   ; Receive Filter Control Reg offset
        mov      eax, 0xffff            ; entry value
        out      dx, ax                 ; write value to table in card

        inc      cl                     ; next entry
        cmp      cl, [device.table_entries]
        jl       .loop

;------------------------------------
; Set Receive Filter Control Register

        set_io  rfcr                    ; Receive Filter Control Register offset
        mov     eax, RFAAB + RFAAM + RFAAP + RFEN
        ; accecpt all broadcast packets
        ; accept all multicast packets
        ; Accept all packets
        ; enable receiver filter
        out     dx, eax
;----------------
; Enable Receiver

        set_io  cr
        in      eax, dx                 ; Get current Command Register
        or      eax, RxENA              ; Enable Receive
        out     dx, eax

;-------------------
; Configure Receiver

        set_io  rxcfg                   ; Receive Config Register offset
        mov     eax, ATX + 0x00600002
        ; Accept Transmit Packets
        ; (Req for full-duplex and PMD Loopback)
        ; Max DMA Burst
        ; RX Drain Threshold, 8X8 bytes or 64bytes
        out     dx, eax

        ret

;***************************************************************************
;
; SIS960_get_mac_addr: - Get MAC address for SiS962 or SiS963 model
;
; SiS962 or SiS963 model, use EEPROM to store MAC address.
; EEPROM is shared by LAN and 1394.
; When access EEPROM, send EEREQ signal to hardware first, and wait for EEGNT.
; If EEGNT is ON, EEPROM is permitted to be accessed by LAN, otherwise is not.
; After MAC address is read from EEPROM, send
; EEDONE signal to refuse EEPROM access by LAN.
; The EEPROM map of SiS962 or SiS963 is different to SiS900.
; The signature field in SiS962 or SiS963 spec is meaningless.
;
; Return 0 is EAX = failure
;
;***************************************************************************
align 4
SIS960_get_mac_addr:
        DEBUGF  1, "SIS960 - get mac: "

;-------------------------------
; Send Request for eeprom access

        set_io  0
        set_io  mear            ; Eeprom access register
        mov     eax, EEREQ      ; Request access to eeprom
        out     dx, eax         ; Send request

;-----------------------------------------------------
; Loop 4000 times and if access not granted, error out

        mov     ecx, 4000
  .loop:
        in      eax, dx         ; get eeprom status
        test    eax, EEGNT      ; see if eeprom access granted flag is set
        jnz     .got_access     ; if it is, go access the eeprom
        loop    .loop           ; else keep waiting

        DEBUGF  1, "Access to EEprom failed!\n", 0

        set_io  mear            ; Eeprom access register
        mov     eax, EEDONE     ; tell eeprom we are done
        out     dx, eax

        or      eax, -1         ; error
        ret

  .got_access:

;------------------------------------------
; EEprom access granted, read MAC from card

    ; zero based so 3-16 bit reads will take place

        mov     ecx, 2
  .read_loop:
        mov     eax, EEPROMMACAddr      ; Base Mac Address
        add     eax, ecx                ; Current Mac Byte Offset
        push    ecx
        call    read_eeprom             ; try to read 16 bits
        pop     ecx
        mov     word [device.mac+ecx*2], ax     ; save 16 bits to the MAC ID varible
        dec     ecx                     ; one less word to read
        jns     .read_loop              ; if more read more
        mov     eax, 1                  ; return non-zero indicating success

        DEBUGF  2,"%x-%x-%x-%x-%x-%x\n",[device.mac]:2,[device.mac+1]:2,[device.mac+2]:2,[device.mac+3]:2,[device.mac+4]:2,[device.mac+5]:2

;-------------------------------------
; Tell EEPROM We are Done Accessing It

  .done:
        set_io  0
        set_io  mear            ; Eeprom access register
        mov     eax, EEDONE     ; tell eeprom we are done
        out     dx, eax

        xor     eax, eax        ; ok
        ret




;***************************************************************************
;
; get_mac_addr: - Get MAC address for stand alone SiS900 model
;
; Older SiS900 and friends, use EEPROM to store MAC address.
;
;***************************************************************************
align 4
SIS900_get_mac_addr:
        DEBUGF  1, "SIS900 - get mac: "

;------------------------------------
; check to see if we have sane EEPROM

        mov     eax, EEPROMSignature  ; Base Eeprom Signature
        call    read_eeprom           ; try to read 16 bits
        cmp     ax, 0xffff
        je      .err
        test    ax, ax
        je      .err

;-----------
; Read MacID

; zero based so 3-16 bit reads will take place

        mov     ecx, 2
  .loop:
        mov     eax, EEPROMMACAddr      ; Base Mac Address
        add     eax, ecx                ; Current Mac Byte Offset
        push    ecx
        call    read_eeprom             ; try to read 16 bits
        pop     ecx
        mov     word [device.mac+ecx*2], ax     ; save 16 bits to the MAC ID storage
        dec     ecx                             ; one less word to read
        jns     .loop                           ; if more read more

        DEBUGF  2,"%x-%x-%x-%x-%x-%x\n",[device.mac]:2,[device.mac+1]:2,[device.mac+2]:2,[device.mac+3]:2,[device.mac+4]:2,[device.mac+5]:2

        xor     eax, eax
        ret


  .err:
        DEBUGF  1, "Access to EEprom failed!\n", 0

        or      eax, -1
        ret


;***************************************************************************
;
; Get_Mac_SIS635_900_REV: - Get MAC address for model 635
;
;***************************************************************************
align 4
Get_Mac_SIS635_900_REV:

        DEBUGF  1, "SIS635 - get mac: "

        set_io  0
        set_io  rfcr
        in      eax, dx
        mov     edi, eax ; EDI=rfcrSave

        set_io  cr
        or      eax, RELOAD
        out     dx, eax

        xor     eax, eax
        out     dx, eax

;-----------------------------------------------
; Disable packet filtering before setting filter

        set_io  rfcr
        mov     eax, edi
        and     edi, not RFEN
        out     dx, eax

;---------------------------------
; Load MAC to filter data register

        mov     ecx, 3
        lea     edi, [device.mac]
  .loop:
        set_io  0
        set_io  rfcr
        mov     eax, ecx
        shl     eax, RFADDR_shift
        out     dx, eax

        set_io  rfdr
        in      eax, dx
        stosw
        loop    .loop

;------------------------
; Enable packet filtering

;        set_io  rfcr
;        mov     eax, edi
;        or      eax, RFEN
;        out     dx, eax

        DEBUGF  2,"%x-%x-%x-%x-%x-%x\n",[device.mac]:2,[device.mac+1]:2,[device.mac+2]:2,[device.mac+3]:2,[device.mac+4]:2,[device.mac+5]:2

        xor     eax, eax
        ret

;***************************************************************************
;
; read_eeprom
;
; reads and returns a given location from EEPROM
;
; IN:  si = addr
; OUT: ax = data
;
;***************************************************************************
align 4
read_eeprom:

        set_io  0
        set_io  mear

        xor     eax, eax              ; start send
        out     dx, eax
        ee_delay

        or      eax, EECLK
        out     dx, eax
        ee_delay

;------------------------------------
; Send the read command

        or      esi, EEread
        mov     ecx, 1 shl 9

  .loop:
        mov     eax, EECS
        test    esi, ecx
        jz      @f
        or      eax, EEDI
       @@:
        out     dx, eax
        ee_delay

        or      eax, EECLK
        out     dx, eax
        ee_delay

        shr     esi, 1
        jnc     .loop

        mov     eax, EECS
        out     dx, eax
        ee_delay

;------------------------
; Read 16-bits of data in

        xor     esi, esi
        mov     cx, 16
  .loop2:
        mov     eax, EECS
        out     dx, eax
        ee_delay

        or      eax, EECLK
        out     dx, eax
        ee_delay

        in      eax, dx
        shl     esi, 1
        test    eax, EEDO
        jz      @f
        inc     esi
       @@:
        loop    .loop2

;----------------------------
; Terminate the EEPROM access

        xor     eax, eax
        out     dx, eax
        ee_delay

        mov     eax, EECLK
        out     dx, eax
        ee_delay

        movzx   eax, si

        ret



align 4
write_mac:
        DEBUGF 1,'Setting MAC is not supported for SIS900 card.\n'
        add     esp, 6
        ret

;***************************************************************************
;
; int_handler
;
; handles received IRQs, which signal received packets
;
; Currently only supports one descriptor per packet, if packet is fragmented
; between multiple descriptors you will lose part of the packet
;
;***************************************************************************
align 4
int_handler:
        DEBUGF  1, "Int!\n"

; find pointer of device which made IRQ occur
        mov     esi, device_list
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .nothing
.nextdevice:
        mov     ebx, [esi]
        set_io  0
        set_io  isr
        in      eax, dx ; note that this clears all interrupts
        test    ax, IE
        jnz     .got_it
        loop    .nextdevice
.nothing:
        ret
.got_it:

        test    ax, RxOK
        jz      .no_rx

        push    ax

;-----------
; Get Status
        movzx   eax, [device.cur_rx]            ; find current discriptor
        shl     eax, 4                          ; * 16
        mov     ecx, dword[device.rxd+eax+4]    ; get receive status

;-------------------------------------------
; Check RX_Status to see if packet is waiting
        test    ecx, 0x80000000
        jnz     .is_packet
        ret

;----------------------------------------------
; There is a packet waiting check it for errors
  .is_packet:
        test    ecx, 0x67C0000                  ; see if there are any errors
        jnz     .error_status

;---------------------
; Check size of packet
        and     ecx, DSIZE                      ; get packet size minus CRC
        sub     ecx, CRC_SIZE                   ; make sure packet contains data
        jle     .error_size

; update statistics
        inc     dword [device.packets_rx]
        add     dword [device.bytes_rx], ecx
        adc     dword [device.bytes_rx+4], 0

        push    ebx
        push    .return
        push    ecx                             ; packet size
        push    [device.rxd+eax+12]             ; packet ptr
        DEBUGF  1, "Packet received OK\n"
        jmp     EthReceiver
  .return:
        pop     ebx

; Reset status, allow ethernet card access to descriptor
        movzx   ecx, [device.cur_rx]
        shl     ecx, 4                          ; *16
        mov     ecx, [device.rxd+ecx]
        stdcall KernelAlloc, RX_BUFF_SZ
        test    eax, eax
        jz      .fail
        mov     dword [ecx+12], eax
        GetRealAddr
        mov     dword [ecx+8], eax
        mov     dword [ecx+4], RX_BUFF_SZ

        inc     [device.cur_rx]                          ; get next descriptor
        and     [device.cur_rx], NUM_RX_DESC-1           ; only 4 descriptors 0-3

; Enable Receiver
        set_io  0
        set_io  cr              ; Command Register offset
        in      eax, dx         ; Get current Command Register
        or      eax, RxENA      ; Enable Receiver
        out     dx, eax

        pop     ax
        jmp     .no_rx

  .error_status:

        DEBUGF  1, "Packet error: %x\n", ecx
        jmp     .fail

  .error_size:

        DEBUGF  1, "Packet too large/small\n"
        jmp     .fail

  .no_rx:
    ;;    test    ax, TxOk
   ;;     jz      .no_tx

        ;;; TODO: free all unused buffers
     ;;   stdcall   KernelFree, eax

  .no_tx:

        ret


  .fail:
        DEBUGF  1, "FAILED\n"
        jmp     $
        ret


;***************************************************************************
;   Function
;      transmit
;   Description
;      Transmits a packet of data via the ethernet card
;         buffer pointer in [esp+4]
;         size of buffer in [esp+8]
;         pointer to device structure in ebx
;
;      only one transmit descriptor is used
;
;***************************************************************************
align 4
transmit:

        cmp     dword [esp+8], MAX_ETH_FRAME_SIZE
        ja      .error

        cmp     dword [esp+8], 60
        jb      .error

        movzx   ecx, [device.cur_tx]
        shl     ecx, 4
        mov     ecx, [device.txd+ecx]

;; TODO: check if desc is empty (for example: check for eax, 0x6200000  at [ecx+4]
;;; or: count number of available descriptors

        mov     eax, [esp+4]
        mov     dword [ecx + 12], eax
        GetRealAddr
        mov     dword [ecx + 8], eax

        mov     eax, [esp+8]
        and     eax, DSIZE
        or      eax, 0x80000000         ; card owns descriptor
        mov     dword [ecx + 4], eax

; update stats
        inc     [device.packets_tx]
        add     dword [device.bytes_tx], ecx
        adc     dword [device.bytes_tx + 4], 0

  .finish:
        xor     eax, eax
        ret     8

  .error:
        stdcall KernelFree, [esp+4]
        or      eax, -1
        ret     8


; End of code

align 4                                         ; Place all initialised data here

devices         dd 0

specific_table:
;    dd SIS630A_900_REV, Get_Mac_SIS630A_900_REV, 0
;    dd SIS630E_900_REV, Get_Mac_SIS630E_900_REV, 0
    dd SIS630S_900_REV, Get_Mac_SIS635_900_REV, 0
    dd SIS630EA1_900_REV, Get_Mac_SIS635_900_REV, 0
    dd SIS630ET_900_REV, Get_Mac_SIS635_900_REV, 0 ;SIS630ET_900_REV_SpecialFN
    dd SIS635A_900_REV, Get_Mac_SIS635_900_REV, 0
    dd SIS900_960_REV, SIS960_get_mac_addr, 0
    dd SIS900B_900_REV, SIS900_get_mac_addr, 0
    dd 0                                        ; end of list

version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
my_service      db 'SIS900',0                  ; max 16 chars include zero

include_debug_strings                          ; All data wich FDO uses will be included here

section '.data' data readable writable align 16; place all uninitialized data place here

device_list     rd MAX_DEVICES                 ; This list contains all pointers to device structures the driver is handling