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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2014. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;; i8255x (Intel eepro 100) driver for KolibriOS                   ;;
;;                                                                 ;;
;;    Written by hidnplayr@kolibrios.org                           ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;; Some parts of this driver are based on the code of eepro100.c   ;;
;;  from linux.                                                    ;;
;;                                                                 ;;
;; Intel's programming manual for i8255x:                          ;;
;; http://www.intel.com/design/network/manuals/8255x_opensdm.htm   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; TODO: use separate descriptors in memory instead of placing them in front of packets!
 
 
format MS COFF
 
        API_VERSION             = 0x01000100
        DRIVER_VERSION          = 5
 
        MAX_DEVICES             = 16
 
        DEBUG                   = 1
        __DEBUG__               = 1
        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
 
include '../struct.inc'
include '../macros.inc'
include '../proc32.inc'
include '../imports.inc'
include '../fdo.inc'
include '../netdrv.inc'
 
public START
public service_proc
public version
 
virtual at ebx
 
        device:
 
        ETH_DEVICE
 
        .io_addr        dd ?
        .pci_bus        dd ?
        .pci_dev        dd ?
        .irq_line       db ?
 
        .rx_desc        dd ?
 
        .ee_bus_width   db ?
 
                        rb 0x100 - (($ - device) and 0xff)
 
        txfd:
        .status         dw ?
        .command        dw ?
        .link           dd ?
        .tx_desc_addr   dd ?
        .count          dd ?
 
        .tx_buf_addr0   dd ?
        .tx_buf_size0   dd ?
 
                        rb 0x100 - (($ - device) and 0xff)
 
        confcmd:
        .status         dw ?
        .command        dw ?
        .link           dd ?
        .data           rb 64
 
                        rb 0x100 - (($ - device) and 0xff)
 
        lstats:
        tx_good_frames          dd ?
        tx_coll16_errs          dd ?
        tx_late_colls           dd ?
        tx_underruns            dd ?
        tx_lost_carrier         dd ?
        tx_deferred             dd ?
        tx_one_colls            dd ?
        tx_multi_colls          dd ?
        tx_total_colls          dd ?
 
        rx_good_frames          dd ?
        rx_crc_errs             dd ?
        rx_align_errs           dd ?
        rx_resource_errs        dd ?
        rx_overrun_errs         dd ?
        rx_colls_errs           dd ?
        rx_runt_errs            dd ?
 
        last_tx_buffer          dd ?    ;;; fixme
 
        sizeof.device_struct = $ - device
 
end virtual
 
 
virtual at 0
 
        rxfd:
        .status         dw ?
        .command        dw ?
        .link           dd ?
        .rx_buf_addr    dd ?
        .count          dw ?
        .size           dw ?
        .packet:
 
end virtual
 
 
; Serial EEPROM
 
EE_SK           = 1 shl 0      ; serial clock
EE_CS           = 1 shl 1      ; chip select
EE_DI           = 1 shl 2      ; data in
EE_DO           = 1 shl 3      ; data out
EE_MASK         = EE_SK + EE_CS + EE_DI + EE_DO
 
; opcodes, first bit is start bit and must be 1
EE_READ         = 110b
EE_WRITE        = 101b
EE_ERASE        = 111b
 
; The SCB accepts the following controls for the Tx and Rx units:
 
CU_START        = 0x0010
CU_RESUME       = 0x0020
CU_STATSADDR    = 0x0040
CU_SHOWSTATS    = 0x0050        ; Dump statistics counters.
CU_CMD_BASE     = 0x0060        ; Base address to add CU commands.
CU_DUMPSTATS    = 0x0070        ; Dump then reset stats counters.
 
RX_START        = 0x0001
RX_RESUME       = 0x0002
RX_ABORT        = 0x0004
RX_ADDR_LOAD    = 0x0006
RX_RESUMENR     = 0x0007
INT_MASK        = 0x0100
DRVR_INT        = 0x0200        ; Driver generated interrupt
 
CmdIASetup      = 0x0001
CmdConfigure    = 0x0002
CmdTx           = 0x0004
CmdTxFlex       = 0x0008
Cmdsuspend      = 0x4000
 
 
reg_scb_status  = 0
reg_scb_cmd     = 2
reg_scb_ptr     = 4
reg_port        = 8
reg_eeprom      = 14
reg_mdi_ctrl    = 16
 
 
macro delay {
        push    eax
        in      ax, dx
        in      ax, dx
        in      ax, dx
        in      ax, dx
        in      ax, dx
        in      ax, dx
        in      ax, dx
        in      ax, dx
        in      ax, dx
        in      ax, dx
        pop     eax
}
 
section '.flat' code readable align 16
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc START             ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
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, [edx + IOCTL.io_code]
 
;------------------------------------------------------
 
        cmp     eax, 0 ;SRV_GETVERSION
        jne     @F
 
        cmp     [edx + IOCTL.out_size], 4
        jb      .fail
        mov     eax, [edx + IOCTL.output]
        mov     [eax], dword API_VERSION
 
        xor     eax, eax
        ret
 
;------------------------------------------------------
  @@:
        cmp     eax, 1 ;SRV_HOOK
        jne     .fail
 
        cmp     [edx + IOCTL.inp_size], 3               ; Data input must be at least 3 bytes
        jb      .fail
 
        mov     eax, [edx + IOCTL.input]
        cmp     byte [eax], 1                           ; 1 means device number and bus number (pci) are given
        jne     .fail                                   ; other types arent supported for this card yet
 
; check if the device is already listed
 
        mov     esi, device_list
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .firstdevice
 
;        mov     eax, [edx + 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
 
 
; This device doesnt have its own eth_device structure yet, lets create one
  .firstdevice:
        cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
        jae     .fail
 
        allocate_and_clear ebx, sizeof.device_struct, .fail      ; Allocate the buffer for device structure
 
; Fill in the direct call addresses into the struct
 
        mov     [device.reset], reset
        mov     [device.transmit], transmit
        mov     [device.unload], unload
        mov     [device.name], my_service
 
; save the pci bus and device numbers
 
        mov     eax, [edx + 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
 
        pushf
        cli                     ; disable ints until initialisation is done
 
        call    probe                                                   ; this function will output in eax
        test    eax, eax
        jnz     .err                                                    ; If an error occured, exit
 
        mov     eax, [devices]                                          ; Add the device structure to our device list
        mov     [device_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
        inc     [devices]                                               ;
 
        popf
 
        mov     [device.type], NET_TYPE_ETH
        call    NetRegDev
 
        cmp     eax, -1
        je      .err
 
        ret
 
; If the device was already loaded, find the device number and return it in eax
 
  .find_devicenum:
        DEBUGF  2,"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  2,"Kernel says: %u\n", eax
        ret
 
; If an error occured, remove all allocated data and exit (returning -1 in eax)
 
  .err:
        stdcall KernelFree, ebx
 
  .fail:
        or      eax, -1
        ret
 
;------------------------------------------------------
endp
 
 
 
 
 
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
;;                                                                        ;;
;;        Actual Hardware dependent code starts here                      ;;
;;                                                                        ;;
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 
 
unload:
        ; TODO: (in this particular order)
        ;
        ; - Stop the device
        ; - Detach int handler
        ; - Remove device from local list (device_list)
        ; - call unregister function in kernel
        ; - Remove all allocated structures and buffers the card used
 
        or      eax,-1
 
ret
 
 
;-------------
;
; Probe
;
;-------------
 
align 4
probe:
 
        DEBUGF  1,"Probing\n"
 
        PCI_make_bus_master
 
;---------------------------
; First, identify the device
 
        stdcall PciRead32, [device.pci_bus], [device.pci_dev], PCI_VENDOR_ID                                ; get device/vendor id
 
        DEBUGF  1,"Vendor_id=0x%x\n", ax
 
        cmp     ax, 0x8086
        jne     .notfound
        shr     eax, 16
 
        DEBUGF  1,"Device_id=0x%x\n", ax
 
        mov     ecx, DEVICE_IDs
        mov     edi, device_id_list
        repne   scasw
        jne     .notfound
        jmp     .found
 
  .notfound:
        DEBUGF  2,"Unsupported device!\n"
        or      eax, -1
        ret
 
  .found:
 
        call    ee_get_width
        call    MAC_read_eeprom
 
        ;;; TODO: detect phy
 
 
 
;----------
;
;  Reset
;
;----------
 
align 4
reset:
 
        movzx   eax, [device.irq_line]
        DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
        stdcall AttachIntHandler, eax, int_handler, dword 0
        test    eax, eax
        jnz     @f
        DEBUGF  2,"Could not attach int handler!\n"
;        or      eax, -1
;        ret
  @@:
 
        DEBUGF  1,"Resetting\n"
 
;---------------
; reset the card
 
        set_io  0
        set_io  reg_port
        xor     eax, eax        ; Software Reset
        out     dx, eax
 
        mov     esi, 10
        call    Sleep           ; Give the card time to warm up.
 
;---------------------------------
; Tell device where to store stats
 
        lea     eax, [lstats]
        GetRealAddr
        set_io  0
        set_io  reg_scb_ptr
        out     dx, eax
 
        mov     ax, INT_MASK + CU_STATSADDR
        set_io  reg_scb_cmd
        out     dx, ax
        call    cmd_wait
 
;-----------------
; setup RX
 
        set_io  reg_scb_ptr
        xor     eax, eax
        out     dx, eax
 
        set_io  reg_scb_cmd
        mov     ax, INT_MASK + RX_ADDR_LOAD
        out     dx, ax
        call    cmd_wait
 
;-----------------------------
; Create RX and TX descriptors
 
        call    create_ring
 
; RX start
 
        set_io  0
        set_io  reg_scb_ptr
        mov     eax, [device.rx_desc]
        GetRealAddr
        out     dx, eax
 
        mov     ax, INT_MASK + RX_START
        set_io  reg_scb_cmd
        out     dx, ax
        call    cmd_wait
 
; Set-up TX
 
        set_io  reg_scb_ptr
        xor     eax, eax
        out     dx, eax
 
        set_io  reg_scb_cmd
        mov     ax, INT_MASK + CU_CMD_BASE
        out     dx, ax
        call    cmd_wait
 
;  --------------------
 
        mov     [confcmd.command], CmdConfigure + Cmdsuspend
        mov     [confcmd.status], 0
        lea     eax, [txfd]
        GetRealAddr
        mov     [confcmd.link], eax
 
        mov     esi, confcmd_data
        lea     edi, [confcmd.data]
        mov     ecx, 22
        rep     movsb
 
        mov     byte[confcmd.data + 1], 0x88  ; fifo of 8 each
        mov     byte[confcmd.data + 4], 0
        mov     byte[confcmd.data + 5], 0x80
        mov     byte[confcmd.data + 15], 0x48
        mov     byte[confcmd.data + 19], 0x80
        mov     byte[confcmd.data + 21], 0x05
 
        mov     [txfd.command], CmdIASetup
        mov     [txfd.status], 0
        lea     eax, [confcmd]
        GetRealAddr
        mov     [txfd.link], eax
 
;;; copy in our MAC
 
        lea     edi, [txfd.tx_desc_addr]
        lea     esi, [device.mac]
        movsd
        movsw
 
        set_io  reg_scb_ptr
        lea     eax, [txfd]
        GetRealAddr
        out     dx, eax
 
; Start CU & enable ints
 
        set_io  reg_scb_cmd
        mov     ax, CU_START
        out     dx, ax
        call    cmd_wait
 
;-----------------------
; build txfd structure (again!)
 
        lea     eax, [txfd]
        GetRealAddr
        mov     [txfd.link], eax
        mov     [txfd.count], 0x02208000
        lea     eax, [txfd.tx_buf_addr0]
        GetRealAddr
        mov     [txfd.tx_desc_addr], eax
 
; Indicate that we have successfully reset the card
 
        DEBUGF  1,"Reset complete\n"
 
        mov     [device.mtu], 1514
 
; Set link state to unknown
        mov     [device.state], ETH_LINK_UNKOWN
 
        xor     eax, eax        ; indicate that we have successfully reset the card
        ret
 
 
align 4
create_ring:
 
        DEBUGF  1,"Creating ring\n"
 
;---------------------
; build rxfd structure
 
        stdcall KernelAlloc, 2000
        mov     [device.rx_desc], eax
        mov     esi, eax
        GetRealAddr
        mov     [esi + rxfd.status], 0x0000
        mov     [esi + rxfd.command], 0x0000
        mov     [esi + rxfd.link], eax
        mov     [esi + rxfd.count], 0
        mov     [esi + rxfd.size], 1528
 
;-----------------------
; build txfd structure
 
        lea     eax, [txfd]
        GetRealAddr
        mov     [txfd.link], eax
        mov     [txfd.count], 0x02208000
        lea     eax, [txfd.tx_buf_addr0]
        GetRealAddr
        mov     [txfd.tx_desc_addr], eax
 
        ret
 
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                         ;;
;; Transmit                                ;;
;;                                         ;;
;; In: buffer pointer in [esp+4]           ;;
;;     size of buffer in [esp+8]           ;;
;;     pointer to device structure in ebx  ;;
;;                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
transmit:
 
        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [esp+4], [esp+8]
        mov     eax, [esp+4]
        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     dword [esp+8], 1514
        ja      .error                          ; packet is too long
        cmp     dword [esp+8], 60
        jb      .error                          ; packet is too short
 
        ;;; TODO: check if current descriptor is in use
        ; fill in buffer address and size
        mov     eax, [esp+4]
        mov     [last_tx_buffer], eax   ;;; FIXME
        GetRealAddr
        mov     [txfd.tx_buf_addr0], eax
        mov     eax, [esp+8]
        mov     [txfd.tx_buf_size0], eax
 
        mov     [txfd.status], 0
        mov     [txfd.command], Cmdsuspend + CmdTx + CmdTxFlex + 1 shl 15 ;;; EL bit
 
 ;       mov     [txfd.count], 0x02208000   ;;;;;;;;;;;
 
        ; Inform device of the new/updated transmit descriptor
        lea     eax, [txfd]
        GetRealAddr
        set_io  0
        set_io  reg_scb_ptr
        out     dx, eax
 
        ; Start the transmit
        mov     ax, CU_START
        set_io  reg_scb_cmd
        out     dx, ax
        call    cmd_wait
 
;        set_io  0               ;; why?
;        in      ax, dx          ;;
;
;  @@:
;        cmp     [txfd.status], 0  ; wait for completion? dont seems a good idea to me..
;        je      @r
;
;        set_io  0               ;; why?
;        in      ax, dx          ;;
 
; Update stats
        inc     [device.packets_tx]
        mov     eax, [esp + 8]
        add     dword [device.bytes_tx], eax
        adc     dword [device.bytes_tx + 4], 0
 
        DEBUGF  1,"Transmit OK\n"
 
        xor     eax, eax
        ret     8
 
  .error:
        stdcall KernelFree, [esp+4]
        or      eax, -1
        ret     8
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; Interrupt handler ;;
;;                   ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
int_handler:
 
        push    ebx esi edi
 
        DEBUGF  1,"INT\n"
 
; find pointer of device wich made IRQ occur
 
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .nothing
        mov     esi, device_list
  .nextdevice:
        mov     ebx, [esi]
 
;        set_io  0              ; reg_scb_status = 0
        set_io  reg_scb_status
        in      ax, dx
        out     dx, ax                              ; send it back to ACK
        test    ax, ax
        jnz     .got_it
  .continue:
        add     esi, 4
        dec     ecx
        jnz     .nextdevice
  .nothing:
        pop     edi esi ebx
        xor     eax, eax
 
        ret                                         ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
 
  .got_it:
 
        DEBUGF  1,"Device: %x Status: %x\n", ebx, ax
 
        test    ax, 1 shl 14    ; did we receive a frame?
        jz      .no_rx
 
        push    ax
 
        DEBUGF  1,"Receiving\n"
 
        push    ebx
  .rx_loop:
        pop     ebx
 
        mov     esi, [device.rx_desc]
        cmp     [esi + rxfd.status], 0        ; we could also check bits C and OK (bit 15 and 13)
        je      .nodata
 
        DEBUGF  1,"rxfd status=0x%x\n", [esi + rxfd.status]:4
 
        movzx   ecx, [esi + rxfd.count]
        and     ecx, 0x3fff
 
        push    ebx
        push    .rx_loop
        push    ecx
        add     esi, rxfd.packet
        push    esi
 
; Update stats
        add     dword [device.bytes_rx], ecx
        adc     dword [device.bytes_rx + 4], 0
        inc     dword [device.packets_rx]
 
; allocate new descriptor
 
        stdcall KernelAlloc, 2000
        mov     [device.rx_desc], eax
        mov     esi, eax
        GetRealAddr
        mov     [esi + rxfd.status], 0x0000
        mov     [esi + rxfd.command], 0xc000    ; End of list + Suspend
        mov     [esi + rxfd.link], eax
        mov     [esi + rxfd.count], 0
        mov     [esi + rxfd.size], 1528
 
; restart RX
 
        set_io  0
        set_io  reg_scb_ptr
;        lea     eax, [device.rx_desc]
;        GetRealAddr
        out     dx, eax
 
        set_io  reg_scb_cmd
        mov     ax, RX_START
        out     dx, ax
        call    cmd_wait
 
; And give packet to kernel
 
        jmp     Eth_input
 
  .nodata:
        DEBUGF  1, "no more data\n"
        pop     ax
 
  .no_rx:
 
; Cleanup after TX
        cmp     [txfd.status], 0
        je      .done
        cmp     [last_tx_buffer], 0
        je      .done
        push    ax
        DEBUGF  1, "Removing packet 0x%x from RAM!\n", [last_tx_buffer]
        stdcall KernelFree, [last_tx_buffer]
        mov     [last_tx_buffer], 0
        pop     ax
 
  .done:
        and     ax, 00111100b
        cmp     ax, 00001000b
        jne     .fail
 
        DEBUGF  1, "out of resources!\n"
; Restart the RX
 
; allocate new descriptor
 
        stdcall KernelAlloc, 2000
        mov     [device.rx_desc], eax
        mov     esi, eax
        GetRealAddr
        mov     [esi + rxfd.status], 0x0000
        mov     [esi + rxfd.command], 0xc000    ; End of list + Suspend
        mov     [esi + rxfd.link], eax
        mov     [esi + rxfd.count], 0
        mov     [esi + rxfd.size], 1528
 
; restart RX
 
        set_io  0
        set_io  reg_scb_ptr
;        lea     eax, [device.rx_desc]
;        GetRealAddr
        out     dx, eax
 
        set_io  reg_scb_cmd
        mov     ax, RX_START
        out     dx, ax
        call    cmd_wait
 
  .fail:
        pop     edi esi ebx
        xor     eax, eax
        inc     eax
 
        ret
 
 
 
 
align 4
cmd_wait:
 
        in      al, dx
        test    al, al
        jnz     cmd_wait
 
        ret
 
 
 
 
 
 
align 4
ee_read:        ; esi = address to read
 
        DEBUGF  1,"Eeprom read from 0x%x\n", esi
 
        set_io  0
        set_io  reg_eeprom
 
;-----------------------------------------------------
; Prepend start bit + read opcode to the address field
; and shift it to the very left bits of esi
 
        mov     cl, 29
        sub     cl, [device.ee_bus_width]
        shl     esi, cl
        or      esi, EE_READ shl 29
 
        movzx   ecx, [device.ee_bus_width]
        add     ecx, 3
 
        mov     al, EE_CS
        out     dx, al
        delay
 
;-----------------------
; Write this to the chip
 
  .loop:
        mov     al, EE_CS + EE_SK
        shl     esi, 1
        jnc     @f
        or      al, EE_DI
       @@:
        out     dx, al
        delay
 
        and     al, not EE_SK
        out     dx, al
        delay
 
        loop    .loop
 
;------------------------------
; Now read the data from eeprom
 
        xor     esi, esi
        mov     ecx, 16
 
  .loop2:
        shl     esi, 1
        mov     al, EE_CS + EE_SK
        out     dx, al
        delay
 
        in      al, dx
        test    al, EE_DO
        jz      @f
        inc     esi
       @@:
 
        mov     al, EE_CS
        out     dx, al
        delay
 
        loop    .loop2
 
;-----------------------
; de-activate the eeprom
 
        xor     ax, ax
        out     dx, ax
 
 
        DEBUGF  1,"0x%x\n", esi:4
        ret
 
 
 
align 4
ee_write:       ; esi = address to write to, di = data
 
        DEBUGF  1,"Eeprom write 0x%x to 0x%x\n", di, esi
 
        set_io  0
        set_io  reg_eeprom
 
;-----------------------------------------------------
; Prepend start bit + write opcode to the address field
; and shift it to the very left bits of esi
 
        mov     cl, 29
        sub     cl, [device.ee_bus_width]
        shl     esi, cl
        or      esi, EE_WRITE shl 29
 
        movzx   ecx, [device.ee_bus_width]
        add     ecx, 3
 
        mov     al, EE_CS       ; enable chip
        out     dx, al
 
;-----------------------
; Write this to the chip
 
  .loop:
        mov     al, EE_CS + EE_SK
        shl     esi, 1
        jnc     @f
        or      al, EE_DI
       @@:
        out     dx, al
        delay
 
        and     al, not EE_SK
        out     dx, al
        delay
 
        loop    .loop
 
;-----------------------------
; Now write the data to eeprom
 
        mov     ecx, 16
 
  .loop2:
        mov     al, EE_CS + EE_SK
        shl     di, 1
        jnc     @f
        or      al, EE_DI
       @@:
        out     dx, al
        delay
 
        and     al, not EE_SK
        out     dx, al
        delay
 
        loop    .loop2
 
;-----------------------
; de-activate the eeprom
 
        xor     al, al
        out     dx, al
 
 
        ret
 
 
 
align 4
ee_get_width:
 
        set_io  0
        set_io  reg_eeprom
 
        mov     al, EE_CS      ; activate eeprom
        out     dx, al
        delay
 
        mov     si, EE_READ shl 13
        xor     ecx, ecx
  .loop:
        mov     al, EE_CS + EE_SK
        shl     si, 1
        jnc     @f
        or      al, EE_DI
       @@:
        out     dx, al
        delay
 
        and     al, not EE_SK
        out     dx, al
        delay
 
        inc     ecx
 
        cmp     ecx, 15
        jae     .give_up
 
        in      al, dx
        test    al, EE_DO
        jnz     .loop
 
        xor     al, al
        out     dx, al          ; de-activate eeprom
 
        sub     cl, 3           ; dont count the opcode bits
        mov     [device.ee_bus_width], cl
        DEBUGF  1, "Eeprom width=%u bit\n", ecx
 
        ret
 
  .give_up:
        DEBUGF  2, "Eeprom not found!\n"
 
        xor     al, al
        out     dx, al          ; de-activate eeprom
 
        ret
 
 
 
; cx = phy addr
; dx = phy reg addr
 
; ax = data
 
align 4
mdio_read:
 
        DEBUGF  1,"MDIO read\n"
 
        shl     ecx, 21                 ; PHY addr
        shl     edx, 16                 ; PHY reg addr
 
        mov     eax, ecx
        or      eax, edx
        or      eax, 10b shl 26         ; read opcode
 
        set_io  0
        set_io  reg_mdi_ctrl
        out     dx, eax
 
  .wait:
        delay
        in      eax, dx
        test    eax, 1 shl 28           ; ready bit
        jz      .wait
 
        ret
 
; ax = data
; cx = phy addr
; dx = phy reg addr
 
; ax = data
 
align 4
mdio_write:
 
        DEBUGF  1,"MDIO write\n"
 
        and     eax, 0xffff
 
        shl     ecx, 21                 ; PHY addr
        shl     edx, 16                 ; PHY reg addr
 
        or      eax, ecx
        or      eax, edx
        or      eax, 01b shl 26         ; write opcode
 
        set_io  0
        set_io  reg_mdi_ctrl
        out     dx, eax
 
  .wait:
        delay
        in      eax, dx
        test    eax, 1 shl 28           ; ready bit
        jz      .wait
 
        ret
 
read_mac:
 
        ret
 
 
 
align 4
MAC_read_eeprom:
 
        mov     esi, 0
        call    ee_read
        mov     word[device.mac], si
 
        mov     esi, 1
        call    ee_read
        mov     word[device.mac+2], si
 
        mov     esi, 2
        call    ee_read
        mov     word[device.mac+4], si
 
 
        ret
 
 
align 4
MAC_write:
 
;;;;
 
        ret
 
 
 
 
; End of code
 
align 4                                         ; Place all initialised data here
 
devices         dd 0                              ; number of currently running devices
version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
my_service      db 'i8255x', 0                    ; max 16 chars include zero
devicename      db 'Intel Etherexpress pro/100', 0
 
confcmd_data    db 22, 0x08, 0, 0, 0, 0x80, 0x32, 0x03, 1
                db 0, 0x2e, 0, 0x60, 0, 0xf2, 0x48, 0, 0x40, 0xf2
                db 0x80, 0x3f, 0x05                                     ; 22 bytes total
 
 
device_id_list:
 
        dw 0x1029
        dw 0x1030
        dw 0x1031
        dw 0x1032
        dw 0x1033
        dw 0x1034
        dw 0x1038
        dw 0x1039
        dw 0x103A
        dw 0x103B
        dw 0x103C
        dw 0x103D
        dw 0x103E
        dw 0x1050
        dw 0x1051
        dw 0x1052
        dw 0x1053
        dw 0x1054
        dw 0x1055
        dw 0x1056
        dw 0x1057
        dw 0x1059
        dw 0x1064
        dw 0x1065
        dw 0x1066
        dw 0x1067
        dw 0x1068
        dw 0x1069
        dw 0x106A
        dw 0x106B
        dw 0x1091
        dw 0x1092
        dw 0x1093
        dw 0x1094
        dw 0x1095
        dw 0x10fe
        dw 0x1209
        dw 0x1229
        dw 0x2449
        dw 0x2459
        dw 0x245D
        dw 0x27DC
 
DEVICE_IDs = ($ - device_id_list) / 2
 
mac_82557_D100_A  = 0
mac_82557_D100_B  = 1
mac_82557_D100_C  = 2
mac_82558_D101_A4 = 4
mac_82558_D101_B0 = 5
mac_82559_D101M   = 8
mac_82559_D101S   = 9
mac_82550_D102    = 12
mac_82550_D102_C  = 13
mac_82551_E       = 14
mac_82551_F       = 15
mac_82551_10      = 16
mac_unknown       = 0xFF
 
phy_100a     = 0x000003E0
phy_100c     = 0x035002A8
phy_82555_tx = 0x015002A8
phy_nsc_tx   = 0x5C002000
phy_82562_et = 0x033002A8
phy_82562_em = 0x032002A8
phy_82562_ek = 0x031002A8
phy_82562_eh = 0x017002A8
phy_82552_v  = 0xd061004d
phy_unknown  = 0xFFFFFFFF
 
 
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

Rev 4467	Rev 4470
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; i8255x (Intel eepro 100) driver for KolibriOS ;;	6	;; i8255x (Intel eepro 100) driver for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by hidnplayr@kolibrios.org ;;	8	;; Written by hidnplayr@kolibrios.org ;;
9	;; ;;	9	;; ;;
10	;; GNU GENERAL PUBLIC LICENSE ;;	10	;; GNU GENERAL PUBLIC LICENSE ;;
11	;; Version 2, June 1991 ;;	11	;; Version 2, June 1991 ;;
12	;; ;;	12	;; ;;
13	;; Some parts of this driver are based on the code of eepro100.c ;;	13	;; Some parts of this driver are based on the code of eepro100.c ;;
14	;; from linux. ;;	14	;; from linux. ;;
15	;; ;;	15	;; ;;
16	;; Intel's programming manual for i8255x: ;;	16	;; Intel's programming manual for i8255x: ;;
17	;; http://www.intel.com/design/network/manuals/8255x_opensdm.htm ;;	17	;; http://www.intel.com/design/network/manuals/8255x_opensdm.htm ;;
18	;; ;;	18	;; ;;
19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
20		20
21	; TODO: use separate descriptors in memory instead of placing them in front of packets!	21	; TODO: use separate descriptors in memory instead of placing them in front of packets!
22		22
23		23
24	format MS COFF	24	format MS COFF
25		25
26	API_VERSION = 0x01000100	26	API_VERSION = 0x01000100
27	DRIVER_VERSION = 5	27	DRIVER_VERSION = 5
28		28
29	MAX_DEVICES = 16	29	MAX_DEVICES = 16
30		30
31	DEBUG = 1	31	DEBUG = 1
32	__DEBUG__ = 1	32	__DEBUG__ = 1
33	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only	33	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only
34		34
35	include '../struct.inc'	35	include '../struct.inc'
36	include '../macros.inc'	36	include '../macros.inc'
37	include '../proc32.inc'	37	include '../proc32.inc'
38	include '../imports.inc'	38	include '../imports.inc'
39	include '../fdo.inc'	39	include '../fdo.inc'
40	include '../netdrv.inc'	40	include '../netdrv.inc'
41		41
42	public START	42	public START
43	public service_proc	43	public service_proc
44	public version	44	public version
45		45
46	virtual at ebx	46	virtual at ebx
47		47
48	device:	48	device:
49		49
50	ETH_DEVICE	50	ETH_DEVICE
51		51
52	.io_addr dd ?	52	.io_addr dd ?
53	.pci_bus dd ?	53	.pci_bus dd ?
54	.pci_dev dd ?	54	.pci_dev dd ?
55	.irq_line db ?	55	.irq_line db ?
56		56
57	.rx_desc dd ?	57	.rx_desc dd ?
58		58
59	.ee_bus_width db ?	59	.ee_bus_width db ?
60		60
61	rb 0x100 - (($ - device) and 0xff)	61	rb 0x100 - (($ - device) and 0xff)
62		62
63	txfd:	63	txfd:
64	.status dw ?	64	.status dw ?
65	.command dw ?	65	.command dw ?
66	.link dd ?	66	.link dd ?
67	.tx_desc_addr dd ?	67	.tx_desc_addr dd ?
68	.count dd ?	68	.count dd ?
69		69
70	.tx_buf_addr0 dd ?	70	.tx_buf_addr0 dd ?
71	.tx_buf_size0 dd ?	71	.tx_buf_size0 dd ?
72		72
73	rb 0x100 - (($ - device) and 0xff)	73	rb 0x100 - (($ - device) and 0xff)
74		74
75	confcmd:	75	confcmd:
76	.status dw ?	76	.status dw ?
77	.command dw ?	77	.command dw ?
78	.link dd ?	78	.link dd ?
79	.data rb 64	79	.data rb 64
80		80
81	rb 0x100 - (($ - device) and 0xff)	81	rb 0x100 - (($ - device) and 0xff)
82		82
83	lstats:	83	lstats:
84	tx_good_frames dd ?	84	tx_good_frames dd ?
85	tx_coll16_errs dd ?	85	tx_coll16_errs dd ?
86	tx_late_colls dd ?	86	tx_late_colls dd ?
87	tx_underruns dd ?	87	tx_underruns dd ?
88	tx_lost_carrier dd ?	88	tx_lost_carrier dd ?
89	tx_deferred dd ?	89	tx_deferred dd ?
90	tx_one_colls dd ?	90	tx_one_colls dd ?
91	tx_multi_colls dd ?	91	tx_multi_colls dd ?
92	tx_total_colls dd ?	92	tx_total_colls dd ?
93		93
94	rx_good_frames dd ?	94	rx_good_frames dd ?
95	rx_crc_errs dd ?	95	rx_crc_errs dd ?
96	rx_align_errs dd ?	96	rx_align_errs dd ?
97	rx_resource_errs dd ?	97	rx_resource_errs dd ?
98	rx_overrun_errs dd ?	98	rx_overrun_errs dd ?
99	rx_colls_errs dd ?	99	rx_colls_errs dd ?
100	rx_runt_errs dd ?	100	rx_runt_errs dd ?
101		101
102	last_tx_buffer dd ? ;;; fixme	102	last_tx_buffer dd ? ;;; fixme
103		103
104	sizeof.device_struct = $ - device	104	sizeof.device_struct = $ - device
105		105
106	end virtual	106	end virtual
107		107
108		108
109	virtual at 0	109	virtual at 0
110		110
111	rxfd:	111	rxfd:
112	.status dw ?	112	.status dw ?
113	.command dw ?	113	.command dw ?
114	.link dd ?	114	.link dd ?
115	.rx_buf_addr dd ?	115	.rx_buf_addr dd ?
116	.count dw ?	116	.count dw ?
117	.size dw ?	117	.size dw ?
118	.packet:	118	.packet:
119		119
120	end virtual	120	end virtual
121		121
122		122
123	; Serial EEPROM	123	; Serial EEPROM
124		124
125	EE_SK = 1 shl 0 ; serial clock	125	EE_SK = 1 shl 0 ; serial clock
126	EE_CS = 1 shl 1 ; chip select	126	EE_CS = 1 shl 1 ; chip select
127	EE_DI = 1 shl 2 ; data in	127	EE_DI = 1 shl 2 ; data in
128	EE_DO = 1 shl 3 ; data out	128	EE_DO = 1 shl 3 ; data out
129	EE_MASK = EE_SK + EE_CS + EE_DI + EE_DO	129	EE_MASK = EE_SK + EE_CS + EE_DI + EE_DO
130		130
131	; opcodes, first bit is start bit and must be 1	131	; opcodes, first bit is start bit and must be 1
132	EE_READ = 110b	132	EE_READ = 110b
133	EE_WRITE = 101b	133	EE_WRITE = 101b
134	EE_ERASE = 111b	134	EE_ERASE = 111b
135		135
136	; The SCB accepts the following controls for the Tx and Rx units:	136	; The SCB accepts the following controls for the Tx and Rx units:
137		137
138	CU_START = 0x0010	138	CU_START = 0x0010
139	CU_RESUME = 0x0020	139	CU_RESUME = 0x0020
140	CU_STATSADDR = 0x0040	140	CU_STATSADDR = 0x0040
141	CU_SHOWSTATS = 0x0050 ; Dump statistics counters.	141	CU_SHOWSTATS = 0x0050 ; Dump statistics counters.
142	CU_CMD_BASE = 0x0060 ; Base address to add CU commands.	142	CU_CMD_BASE = 0x0060 ; Base address to add CU commands.
143	CU_DUMPSTATS = 0x0070 ; Dump then reset stats counters.	143	CU_DUMPSTATS = 0x0070 ; Dump then reset stats counters.
144		144
145	RX_START = 0x0001	145	RX_START = 0x0001
146	RX_RESUME = 0x0002	146	RX_RESUME = 0x0002
147	RX_ABORT = 0x0004	147	RX_ABORT = 0x0004
148	RX_ADDR_LOAD = 0x0006	148	RX_ADDR_LOAD = 0x0006
149	RX_RESUMENR = 0x0007	149	RX_RESUMENR = 0x0007
150	INT_MASK = 0x0100	150	INT_MASK = 0x0100
151	DRVR_INT = 0x0200 ; Driver generated interrupt	151	DRVR_INT = 0x0200 ; Driver generated interrupt
152		152
153	CmdIASetup = 0x0001	153	CmdIASetup = 0x0001
154	CmdConfigure = 0x0002	154	CmdConfigure = 0x0002
155	CmdTx = 0x0004	155	CmdTx = 0x0004
156	CmdTxFlex = 0x0008	156	CmdTxFlex = 0x0008
157	Cmdsuspend = 0x4000	157	Cmdsuspend = 0x4000
158		158
159		159
160	reg_scb_status = 0	160	reg_scb_status = 0
161	reg_scb_cmd = 2	161	reg_scb_cmd = 2
162	reg_scb_ptr = 4	162	reg_scb_ptr = 4
163	reg_port = 8	163	reg_port = 8
164	reg_eeprom = 14	164	reg_eeprom = 14
165	reg_mdi_ctrl = 16	165	reg_mdi_ctrl = 16
166		166
167		167
168	macro delay {	168	macro delay {
169	push eax	169	push eax
170	in ax, dx	170	in ax, dx
171	in ax, dx	171	in ax, dx
172	in ax, dx	172	in ax, dx
173	in ax, dx	173	in ax, dx
174	in ax, dx	174	in ax, dx
175	in ax, dx	175	in ax, dx
176	in ax, dx	176	in ax, dx
177	in ax, dx	177	in ax, dx
178	in ax, dx	178	in ax, dx
179	in ax, dx	179	in ax, dx
180	pop eax	180	pop eax
181	}	181	}
182		182
183	section '.flat' code readable align 16	183	section '.flat' code readable align 16
184		184
185	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	185	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
186	;; ;;	186	;; ;;
187	;; proc START ;;	187	;; proc START ;;
188	;; ;;	188	;; ;;
189	;; (standard driver proc) ;;	189	;; (standard driver proc) ;;
190	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	190	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
191		191
192	proc START stdcall, state:dword	192	proc START stdcall, state:dword
193		193
194	cmp [state], 1	194	cmp [state], 1
195	jne .exit	195	jne .exit
196		196
197	.entry:	197	.entry:
198		198
199	DEBUGF 1,"Loading driver\n"	199	DEBUGF 1,"Loading driver\n"
200	stdcall RegService, my_service, service_proc	200	stdcall RegService, my_service, service_proc
201	ret	201	ret
202		202
203	.fail:	203	.fail:
204	.exit:	204	.exit:
205	xor eax, eax	205	xor eax, eax
206	ret	206	ret
207		207
208	endp	208	endp
209		209
210		210
211	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	211	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
212	;; ;;	212	;; ;;
213	;; proc SERVICE_PROC ;;	213	;; proc SERVICE_PROC ;;
214	;; ;;	214	;; ;;
215	;; (standard driver proc) ;;	215	;; (standard driver proc) ;;
216	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	216	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
217		217
218	align 4	218	align 4
219	proc service_proc stdcall, ioctl:dword	219	proc service_proc stdcall, ioctl:dword
220		220
221	mov edx, [ioctl]	221	mov edx, [ioctl]
222	mov eax, [IOCTL.io_code]	222	mov eax, [edx + IOCTL.io_code]
223		223
224	;------------------------------------------------------	224	;------------------------------------------------------
225		225
226	cmp eax, 0 ;SRV_GETVERSION	226	cmp eax, 0 ;SRV_GETVERSION
227	jne @F	227	jne @F
228		228
229	cmp [IOCTL.out_size], 4	229	cmp [edx + IOCTL.out_size], 4
230	jb .fail	230	jb .fail
231	mov eax, [IOCTL.output]	231	mov eax, [edx + IOCTL.output]
232	mov [eax], dword API_VERSION	232	mov [eax], dword API_VERSION
233		233
234	xor eax, eax	234	xor eax, eax
235	ret	235	ret
236		236
237	;------------------------------------------------------	237	;------------------------------------------------------
238	@@:	238	@@:
239	cmp eax, 1 ;SRV_HOOK	239	cmp eax, 1 ;SRV_HOOK
240	jne .fail	240	jne .fail
241		241
242	cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes	242	cmp [edx + IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
243	jb .fail	243	jb .fail
244		244
245	mov eax, [IOCTL.input]	245	mov eax, [edx + IOCTL.input]
246	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given	246	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
247	jne .fail ; other types arent supported for this card yet	247	jne .fail ; other types arent supported for this card yet
248		248
249	; check if the device is already listed	249	; check if the device is already listed
250		250
251	mov esi, device_list	251	mov esi, device_list
252	mov ecx, [devices]	252	mov ecx, [devices]
253	test ecx, ecx	253	test ecx, ecx
254	jz .firstdevice	254	jz .firstdevice
255		255
256	; mov eax, [IOCTL.input] ; get the pci bus and device numbers	256	; mov eax, [edx + IOCTL.input] ; get the pci bus and device numbers
257	mov ax , [eax+1] ;	257	mov ax , [eax+1] ;
258	.nextdevice:	258	.nextdevice:
259	mov ebx, [esi]	259	mov ebx, [esi]
260	cmp al, byte[device.pci_bus]	260	cmp al, byte[device.pci_bus]
261	jne @f	261	jne @f
262	cmp ah, byte[device.pci_dev]	262	cmp ah, byte[device.pci_dev]
263	je .find_devicenum ; Device is already loaded, let's find it's device number	263	je .find_devicenum ; Device is already loaded, let's find it's device number
264	@@:	264	@@:
265	add esi, 4	265	add esi, 4
266	loop .nextdevice	266	loop .nextdevice
267		267
268		268
269	; This device doesnt have its own eth_device structure yet, lets create one	269	; This device doesnt have its own eth_device structure yet, lets create one
270	.firstdevice:	270	.firstdevice:
271	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card	271	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
272	jae .fail	272	jae .fail
273		273
274	allocate_and_clear ebx, sizeof.device_struct, .fail ; Allocate the buffer for device structure	274	allocate_and_clear ebx, sizeof.device_struct, .fail ; Allocate the buffer for device structure
275		275
276	; Fill in the direct call addresses into the struct	276	; Fill in the direct call addresses into the struct
277		277
278	mov [device.reset], reset	278	mov [device.reset], reset
279	mov [device.transmit], transmit	279	mov [device.transmit], transmit
280	mov [device.unload], unload	280	mov [device.unload], unload
281	mov [device.name], my_service	281	mov [device.name], my_service
282		282
283	; save the pci bus and device numbers	283	; save the pci bus and device numbers
284		284
285	mov eax, [IOCTL.input]	285	mov eax, [edx + IOCTL.input]
286	movzx ecx, byte[eax+1]	286	movzx ecx, byte[eax+1]
287	mov [device.pci_bus], ecx	287	mov [device.pci_bus], ecx
288	movzx ecx, byte[eax+2]	288	movzx ecx, byte[eax+2]
289	mov [device.pci_dev], ecx	289	mov [device.pci_dev], ecx
290		290
291	; Now, it's time to find the base io addres of the PCI device	291	; Now, it's time to find the base io addres of the PCI device
292		292
293	PCI_find_io	293	PCI_find_io
294		294
295	; We've found the io address, find IRQ now	295	; We've found the io address, find IRQ now
296		296
297	PCI_find_irq	297	PCI_find_irq
298		298
299	DEBUGF 1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\	299	DEBUGF 1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
300	[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4	300	[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
301		301
302	; Ok, the eth_device structure is ready, let's probe the device	302	; Ok, the eth_device structure is ready, let's probe the device
303		303
304	pushf	304	pushf
305	cli ; disable ints until initialisation is done	305	cli ; disable ints until initialisation is done
306		306
307	call probe ; this function will output in eax	307	call probe ; this function will output in eax
308	test eax, eax	308	test eax, eax
309	jnz .err ; If an error occured, exit	309	jnz .err ; If an error occured, exit
310		310
311	mov eax, [devices] ; Add the device structure to our device list	311	mov eax, [devices] ; Add the device structure to our device list
312	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)	312	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)
313	inc [devices] ;	313	inc [devices] ;
314		314
315	popf	315	popf
316		316
317	mov [device.type], NET_TYPE_ETH	317	mov [device.type], NET_TYPE_ETH
318	call NetRegDev	318	call NetRegDev
319		319
320	cmp eax, -1	320	cmp eax, -1
321	je .err	321	je .err
322		322
323	ret	323	ret
324		324
325	; If the device was already loaded, find the device number and return it in eax	325	; If the device was already loaded, find the device number and return it in eax
326		326
327	.find_devicenum:	327	.find_devicenum:
328	DEBUGF 2,"Trying to find device number of already registered device\n"	328	DEBUGF 2,"Trying to find device number of already registered device\n"
329	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx	329	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
330	; into a device number in edi	330	; into a device number in edi
331	mov eax, edi ; Application wants it in eax instead	331	mov eax, edi ; Application wants it in eax instead
332	DEBUGF 2,"Kernel says: %u\n", eax	332	DEBUGF 2,"Kernel says: %u\n", eax
333	ret	333	ret
334		334
335	; If an error occured, remove all allocated data and exit (returning -1 in eax)	335	; If an error occured, remove all allocated data and exit (returning -1 in eax)
336		336
337	.err:	337	.err:
338	stdcall KernelFree, ebx	338	stdcall KernelFree, ebx
339		339
340	.fail:	340	.fail:
341	or eax, -1	341	or eax, -1
342	ret	342	ret
343		343
344	;------------------------------------------------------	344	;------------------------------------------------------
345	endp	345	endp
346		346
347		347
348		348
349		349
350		350
351	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	351	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
352	;; ;;	352	;; ;;
353	;; Actual Hardware dependent code starts here ;;	353	;; Actual Hardware dependent code starts here ;;
354	;; ;;	354	;; ;;
355	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	355	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
356		356
357		357
358	unload:	358	unload:
359	; TODO: (in this particular order)	359	; TODO: (in this particular order)
360	;	360	;
361	; - Stop the device	361	; - Stop the device
362	; - Detach int handler	362	; - Detach int handler
363	; - Remove device from local list (device_list)	363	; - Remove device from local list (device_list)
364	; - call unregister function in kernel	364	; - call unregister function in kernel
365	; - Remove all allocated structures and buffers the card used	365	; - Remove all allocated structures and buffers the card used
366		366
367	or eax,-1	367	or eax,-1
368		368
369	ret	369	ret
370		370
371		371
372	;-------------	372	;-------------
373	;	373	;
374	; Probe	374	; Probe
375	;	375	;
376	;-------------	376	;-------------
377		377
378	align 4	378	align 4
379	probe:	379	probe:
380		380
381	DEBUGF 1,"Probing\n"	381	DEBUGF 1,"Probing\n"
382		382
383	PCI_make_bus_master	383	PCI_make_bus_master
384		384
385	;---------------------------	385	;---------------------------
386	; First, identify the device	386	; First, identify the device
387		387
388	stdcall PciRead32, [device.pci_bus], [device.pci_dev], PCI_VENDOR_ID ; get device/vendor id	388	stdcall PciRead32, [device.pci_bus], [device.pci_dev], PCI_VENDOR_ID ; get device/vendor id
389		389
390	DEBUGF 1,"Vendor_id=0x%x\n", ax	390	DEBUGF 1,"Vendor_id=0x%x\n", ax
391		391
392	cmp ax, 0x8086	392	cmp ax, 0x8086
393	jne .notfound	393	jne .notfound
394	shr eax, 16	394	shr eax, 16
395		395
396	DEBUGF 1,"Device_id=0x%x\n", ax	396	DEBUGF 1,"Device_id=0x%x\n", ax
397		397
398	mov ecx, DEVICE_IDs	398	mov ecx, DEVICE_IDs
399	mov edi, device_id_list	399	mov edi, device_id_list
400	repne scasw	400	repne scasw
401	jne .notfound	401	jne .notfound
402	jmp .found	402	jmp .found
403		403
404	.notfound:	404	.notfound:
405	DEBUGF 2,"Unsupported device!\n"	405	DEBUGF 2,"Unsupported device!\n"
406	or eax, -1	406	or eax, -1
407	ret	407	ret
408		408
409	.found:	409	.found:
410		410
411	call ee_get_width	411	call ee_get_width
412	call MAC_read_eeprom	412	call MAC_read_eeprom
413		413
414	;;; TODO: detect phy	414	;;; TODO: detect phy
415		415
416		416
417		417
418	;----------	418	;----------
419	;	419	;
420	; Reset	420	; Reset
421	;	421	;
422	;----------	422	;----------
423		423
424	align 4	424	align 4
425	reset:	425	reset:
426		426
427	movzx eax, [device.irq_line]	427	movzx eax, [device.irq_line]
428	DEBUGF 1,"Attaching int handler to irq %x\n", eax:1	428	DEBUGF 1,"Attaching int handler to irq %x\n", eax:1
429	stdcall AttachIntHandler, eax, int_handler, dword 0	429	stdcall AttachIntHandler, eax, int_handler, dword 0
430	test eax, eax	430	test eax, eax
431	jnz @f	431	jnz @f
432	DEBUGF 2,"Could not attach int handler!\n"	432	DEBUGF 2,"Could not attach int handler!\n"
433	; or eax, -1	433	; or eax, -1
434	; ret	434	; ret
435	@@:	435	@@:
436		436
437	DEBUGF 1,"Resetting\n"	437	DEBUGF 1,"Resetting\n"
438		438
439	;---------------	439	;---------------
440	; reset the card	440	; reset the card
441		441
442	set_io 0	442	set_io 0
443	set_io reg_port	443	set_io reg_port
444	xor eax, eax ; Software Reset	444	xor eax, eax ; Software Reset
445	out dx, eax	445	out dx, eax
446		446
447	mov esi, 10	447	mov esi, 10
448	call Sleep ; Give the card time to warm up.	448	call Sleep ; Give the card time to warm up.
449		449
450	;---------------------------------	450	;---------------------------------
451	; Tell device where to store stats	451	; Tell device where to store stats
452		452
453	lea eax, [lstats]	453	lea eax, [lstats]
454	GetRealAddr	454	GetRealAddr
455	set_io 0	455	set_io 0
456	set_io reg_scb_ptr	456	set_io reg_scb_ptr
457	out dx, eax	457	out dx, eax
458		458
459	mov ax, INT_MASK + CU_STATSADDR	459	mov ax, INT_MASK + CU_STATSADDR
460	set_io reg_scb_cmd	460	set_io reg_scb_cmd
461	out dx, ax	461	out dx, ax
462	call cmd_wait	462	call cmd_wait
463		463
464	;-----------------	464	;-----------------
465	; setup RX	465	; setup RX
466		466
467	set_io reg_scb_ptr	467	set_io reg_scb_ptr
468	xor eax, eax	468	xor eax, eax
469	out dx, eax	469	out dx, eax
470		470
471	set_io reg_scb_cmd	471	set_io reg_scb_cmd
472	mov ax, INT_MASK + RX_ADDR_LOAD	472	mov ax, INT_MASK + RX_ADDR_LOAD
473	out dx, ax	473	out dx, ax
474	call cmd_wait	474	call cmd_wait
475		475
476	;-----------------------------	476	;-----------------------------
477	; Create RX and TX descriptors	477	; Create RX and TX descriptors
478		478
479	call create_ring	479	call create_ring
480		480
481	; RX start	481	; RX start
482		482
483	set_io 0	483	set_io 0
484	set_io reg_scb_ptr	484	set_io reg_scb_ptr
485	mov eax, [device.rx_desc]	485	mov eax, [device.rx_desc]
486	GetRealAddr	486	GetRealAddr
487	out dx, eax	487	out dx, eax
488		488
489	mov ax, INT_MASK + RX_START	489	mov ax, INT_MASK + RX_START
490	set_io reg_scb_cmd	490	set_io reg_scb_cmd
491	out dx, ax	491	out dx, ax
492	call cmd_wait	492	call cmd_wait
493		493
494	; Set-up TX	494	; Set-up TX
495		495
496	set_io reg_scb_ptr	496	set_io reg_scb_ptr
497	xor eax, eax	497	xor eax, eax
498	out dx, eax	498	out dx, eax
499		499
500	set_io reg_scb_cmd	500	set_io reg_scb_cmd

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/i8255x.asm – Rev 4467 → 4470