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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2015. 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   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
format PE DLL native
entry START
 
        CURRENT_API             = 0x0200
        COMPATIBLE_API          = 0x0100
        API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
 
        MAX_DEVICES             = 16
 
        TX_RING_SIZE            = 16
 
        DEBUG                   = 1
        __DEBUG__               = 1
        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
 
section '.flat' readable writable executable
 
include '../proc32.inc'
include '../struct.inc'
include '../macros.inc'
include '../fdo.inc'
include '../netdrv.inc'
 
; 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
 
CmdRxFlex       = 0x0008
 
reg_scb_status  = 0
reg_scb_cmd     = 2
reg_scb_ptr     = 4
reg_port        = 8
reg_eeprom      = 14
reg_mdi_ctrl    = 16
 
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
 
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
 
struct  rxfd
 
        status          dw ?
        command         dw ?
        link            dd ?
        rx_buf_addr     dd ?
        count           dw ?
        size            dw ?
        packet          rb 1500
 
ends
 
struct  txfd
 
        status          dw ?
        command         dw ?
        link            dd ?
        desc_addr       dd ?
        count           dd ?
 
        buf_addr        dd ?
        buf_size        dd ?
        virt_addr       dd ?
                        dd ?            ; alignment
 
ends
 
struc   confcmd {
 
        .status         dw ?
        .command        dw ?
        .link           dd ?
        .data           rb 64
 
}
 
struc   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 ?
 
}
 
struct  device          ETH_DEVICE
 
        io_addr         dd ?
        pci_bus         dd ?
        pci_dev         dd ?
        rx_desc         dd ?
        cur_tx          dd ?
        last_tx         dd ?
        ee_bus_width    db ?
        irq_line        db ?
 
        rb 0x100 - ($ and 0xff) ; align 256
        tx_ring         rb TX_RING_SIZE*sizeof.txfd
 
        rb 0x100 - ($ and 0xff) ; align 256
        confcmd         confcmd
 
        rb 0x100 - ($ and 0xff) ; align 256
        lstats          lstats
 
ends
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc START             ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc START c, state:dword
 
        cmp [state], 1
        jne .exit
 
  .entry:
 
        DEBUGF 1,"Loading driver\n"
        invoke  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[ebx + device.pci_bus]
        jne     @f
        cmp     ah, byte[ebx + device.pci_dev]
        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
       @@:
        add     esi, 4
        loop    .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, .fail      ; Allocate the buffer for device structure
 
; Fill in the direct call addresses into the struct
 
        mov     [ebx + device.reset], reset
        mov     [ebx + device.transmit], transmit
        mov     [ebx + device.unload], unload
        mov     [ebx + device.name], my_service
 
; save the pci bus and device numbers
 
        mov     eax, [edx + IOCTL.input]
        movzx   ecx, byte[eax+1]
        mov     [ebx + device.pci_bus], ecx
        movzx   ecx, byte[eax+2]
        mov     [ebx + device.pci_dev], ecx
 
; Now, it's time to find the base io addres of the PCI device
 
        stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]
        mov     [ebx + device.io_addr], eax
 
; We've found the io address, find IRQ now
 
        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
        mov     [ebx + device.irq_line], al
 
        DEBUGF  1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
        [ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4
 
; Ok, the eth_device structure is ready, let's probe the device
 
        pushf
        cli                     ; disable ints untilm 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     [ebx + device.type], NET_TYPE_ETH
        invoke  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"
        invoke  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:
        invoke  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"
 
; Make the device a bus master
        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
        or      al, PCI_CMD_MASTER
        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
 
;---------------------------
; First, identify the device
 
        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header.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, [ebx + device.irq_line]
        DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
        invoke  AttachIntHandler, eax, int_handler, ebx
        test    eax, eax
        jnz     @f
        DEBUGF  2,"Could not attach int handler!\n"
        or      eax, -1
        ret
  @@:
 
        DEBUGF  1,"Resetting\n"
 
;---------------
; reset the card
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_port
        xor     eax, eax        ; Software Reset
        out     dx, eax
 
        mov     esi, 10
        invoke  Sleep           ; Give the card time to warm up.
 
;---------------------------------
; Tell device where to store stats
 
        lea     eax, [ebx + device.lstats.tx_good_frames]      ; lstats
        invoke  GetPhysAddr
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_scb_ptr
        out     dx, eax
 
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, CU_STATSADDR or INT_MASK
        out     dx, ax
        call    cmd_wait
 
;------------------------
; setup RX base addr to 0
 
        set_io  [ebx + device.io_addr], reg_scb_ptr
        xor     eax, eax
        out     dx, eax
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, RX_ADDR_LOAD or INT_MASK
        out     dx, ax
        call    cmd_wait
 
;-----------------------------
; Create RX and TX descriptors
 
        call    init_rx_ring
        test    eax, eax
        jz      .error
 
        call    init_tx_ring
 
 
;---------
; Start RX
 
        DEBUGF  1, "Starting RX"
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_scb_ptr
        mov     eax, [ebx + device.rx_desc]
        invoke  GetPhysAddr
        add     eax, NET_BUFF.data
        out     dx, eax
 
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, RX_START or INT_MASK
        out     dx, ax
        call    cmd_wait
 
;----------
; Set-up TX
 
        set_io  [ebx + device.io_addr], reg_scb_ptr
        xor     eax, eax
        out     dx, eax
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, CU_CMD_BASE or INT_MASK
        out     dx, ax
        call    cmd_wait
 
;-------------------------
; Individual address setup
 
        mov     [ebx + device.confcmd.command], CmdIASetup + Cmdsuspend
        mov     [ebx + device.confcmd.status], 0
        lea     eax, [ebx + device.tx_ring]
        invoke  GetPhysAddr
        mov     [ebx + device.confcmd.link], eax
        lea     edi, [ebx + device.confcmd.data]
        lea     esi, [ebx + device.mac]
        movsd
        movsw
 
        set_io  [ebx + device.io_addr], reg_scb_ptr
        lea     eax, [ebx + device.confcmd.status]
        invoke  GetPhysAddr
        out     dx, eax
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, CU_START or INT_MASK
        out     dx, ax
        call    cmd_wait
 
;-------------
; Configure CU
 
        mov     [ebx + device.confcmd.command], CmdConfigure + Cmdsuspend
        mov     [ebx + device.confcmd.status], 0
        lea     eax, [ebx + device.confcmd.status]
        invoke  GetPhysAddr
        mov     [ebx + device.confcmd.link], eax
 
        mov     esi, confcmd_data
        lea     edi, [ebx + device.confcmd.data]
        mov     ecx, 22
        rep     movsb
 
        mov     byte[ebx + device.confcmd.data + 1], 0x88  ; fifo of 8 each
        mov     byte[ebx + device.confcmd.data + 4], 0
        mov     byte[ebx + device.confcmd.data + 5], 0x80
        mov     byte[ebx + device.confcmd.data + 15], 0x48
        mov     byte[ebx + device.confcmd.data + 19], 0x80
        mov     byte[ebx + device.confcmd.data + 21], 0x05
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        set_io  [ebx + device.io_addr], reg_scb_ptr
        lea     eax, [ebx + device.confcmd.status]
        invoke  GetPhysAddr
        out     dx, eax
 
 
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, CU_START                            ; expect Interrupts from now on
        out     dx, ax
        call    cmd_wait
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        DEBUGF  1,"Reset complete\n"
        mov     [ebx + device.mtu], 1514
 
; Set link state to unknown
        mov     [ebx + device.state], ETH_LINK_UNKNOWN
 
        xor     eax, eax        ; indicate that we have successfully reset the card
        ret
 
  .error:
        or      eax, -1
        ret
 
 
align 4
init_rx_ring:
 
        DEBUGF  1,"Creating ring\n"
 
;---------------------
; build rxfd structure
 
        invoke  NetAlloc, 2000
        test    eax, eax
        jz      .out_of_mem
        mov     [ebx + device.rx_desc], eax
        mov     esi, eax
        invoke  GetPhysAddr
        add     eax, NET_BUFF.data
        mov     [esi + sizeof.NET_BUFF + rxfd.status], 0x0000
        mov     [esi + sizeof.NET_BUFF + rxfd.command], 0x0000
        mov     [esi + sizeof.NET_BUFF + rxfd.link], eax
        mov     [esi + sizeof.NET_BUFF + rxfd.count], 0
        mov     [esi + sizeof.NET_BUFF + rxfd.size], 1528
 
        ret
 
  .out_of_mem:
 
        ret
 
 
 
 
align 4
init_tx_ring:
 
        DEBUGF  1,"Creating TX ring\n"
 
        lea     esi, [ebx + device.tx_ring]
        mov     eax, esi
        invoke  GetPhysAddr
        mov     ecx, TX_RING_SIZE
  .next_desc:
        mov     [esi + txfd.status], 0
        mov     [esi + txfd.command], 0
        lea     edx, [eax + txfd.buf_addr]
        mov     [esi + txfd.desc_addr], edx
        add     eax, sizeof.txfd
        mov     [esi + txfd.link], eax
        mov     [esi + txfd.count], 0x01208000          ; One buffer, 0x20 bytes of transmit threshold, end of frame
        add     esi, sizeof.txfd
        dec     ecx
        jnz     .next_desc
 
        lea     eax, [ebx + device.tx_ring]
        invoke  GetPhysAddr
        mov     dword[ebx + device.tx_ring + sizeof.txfd*(TX_RING_SIZE-1) + txfd.link], eax
 
        mov     [ebx + device.cur_tx], 0
        mov     [ebx + device.last_tx], 0
 
        ret
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                         ;;
;; Transmit                                ;;
;;                                         ;;
;; In: pointer to device structure in ebx  ;;
;;                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc transmit stdcall bufferptr
 
        pushf
        cli
 
        mov     esi, [bufferptr]
        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [esi + NET_BUFF.length]
        lea     eax, [esi + NET_BUFF.data]
        DEBUGF  1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
        [eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
        [eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
        [eax+13]:2,[eax+12]:2
 
        cmp     [esi + NET_BUFF.length], 1514
        ja      .fail
        cmp     [esi + NET_BUFF.length], 60
        jb      .fail
 
        ; Get current TX descriptor
        mov     edi, [ebx + device.cur_tx]
        mov     eax, sizeof.txfd
        mul     edi
        lea     edi, [ebx + device.tx_ring + eax]
 
        ; Check if current descriptor is free or still in use
        cmp     [edi + txfd.status], 0
        jne     .fail
 
        ; Fill in status and command values
        mov     [edi + txfd.status], 0
        mov     [edi + txfd.command], Cmdsuspend + CmdTx + CmdTxFlex ;;;+ 1 shl 15 ;;; EL bit
        mov     [edi + txfd.count], 0x01208000
 
        ; Fill in buffer address and size
        mov     [edi + txfd.virt_addr], esi
        mov     eax, esi
        add     eax, [esi + NET_BUFF.offset]
        push    edi
        invoke  GetPhysAddr
        pop     edi
        mov     [edi + txfd.buf_addr], eax
        mov     ecx, [esi + NET_BUFF.length]
        mov     [edi + txfd.buf_size], ecx
 
        ; Inform device of the new/updated transmit descriptor
        mov     eax, edi
        invoke  GetPhysAddr
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_scb_ptr
        out     dx, eax
 
        ; Start the transmit
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, CU_START
        out     dx, ax
 
 
        ; Update stats
        inc     [ebx + device.packets_tx]
        add     dword[ebx + device.bytes_tx], ecx
        adc     dword[ebx + device.bytes_tx + 4], 0
 
        ; Wait for command to complete
        call    cmd_wait
 
        inc     [ebx + device.cur_tx]
        and     [ebx + device.cur_tx], TX_RING_SIZE - 1
 
        DEBUGF  1,"Transmit OK\n"
        popf
        xor     eax, eax
        ret
 
  .fail:
        DEBUGF  2,"Transmit failed!\n"
        invoke  NetFree, [bufferptr]
        popf
        or      eax, -1
        ret
 
endp
 
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; 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  [ebx + device.io_addr], 0              ; reg_scb_status = 0
        set_io  [ebx + device.io_addr], 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, [ebx + device.rx_desc]
        cmp     [esi + sizeof.NET_BUFF + 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 + sizeof.NET_BUFF + rxfd.status]:4
 
        movzx   ecx, [esi + sizeof.NET_BUFF + rxfd.count]
        and     ecx, 0x3fff
 
        push    ebx
        push    .rx_loop
        push    esi
        mov     [esi + NET_BUFF.length], ecx
        mov     [esi + NET_BUFF.device], ebx
        mov     [esi + NET_BUFF.offset], NET_BUFF.data + rxfd.packet
 
; Update stats
        add     dword [ebx + device.bytes_rx], ecx
        adc     dword [ebx + device.bytes_rx + 4], 0
        inc     dword [ebx + device.packets_rx]
 
; allocate new descriptor
 
        invoke  NetAlloc, 2000
        mov     [ebx + device.rx_desc], eax
        mov     esi, eax
        invoke  GetPhysAddr
        add     eax, NET_BUFF.data
        mov     [esi + sizeof.NET_BUFF + rxfd.status], 0x0000
        mov     [esi + sizeof.NET_BUFF + rxfd.command], 0xc000    ; End of list + Suspend
        mov     [esi + sizeof.NET_BUFF + rxfd.link], eax
        mov     [esi + sizeof.NET_BUFF + rxfd.count], 0
        mov     [esi + sizeof.NET_BUFF + rxfd.size], 1528
 
; restart RX
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_scb_ptr
;        lea     eax, [ebx + device.rx_desc]
;        invoke  GetPhysAddr
        out     dx, eax
 
        set_io  [ebx + device.io_addr], reg_scb_cmd
        mov     ax, RX_START
        out     dx, ax
        call    cmd_wait
 
; And give packet to kernel
        jmp     [EthInput]
 
  .nodata:
        DEBUGF  1, "no more data\n"
        pop     ax
 
  .no_rx:
 
        test    ax, 1 shl 13
        jz      .no_tx
        DEBUGF  1, "Command completed\n"
 
        push    eax
  .loop_tx:
        mov     edi, [ebx + device.last_tx]
        mov     eax, sizeof.txfd
        mul     eax
        lea     edi, [ebx + device.tx_ring + eax]
 
        cmp     [edi + txfd.status], 0
        je      .tx_done
 
        cmp     [edi + txfd.virt_addr], 0
        je      .tx_done
 
        DEBUGF  1,"Freeing buffer 0x%x\n", [edi + txfd.virt_addr]
 
        push    [edi + txfd.virt_addr]
        mov     [edi + txfd.virt_addr], 0
        invoke  NetFree
 
        inc     [ebx + device.last_tx]
        and     [ebx + device.last_tx], TX_RING_SIZE - 1
 
        jmp     .loop_tx
  .tx_done:
        pop     eax
 
  .no_tx:
 
        and     ax, 00111100b
        cmp     ax, 00001000b
        jne     .fail
 
        DEBUGF  1, "out of resources!\n"
; Restart the RX
 
; allocate new descriptor
 
        invoke  KernelAlloc, 2000
        mov     [ebx + device.rx_desc], eax
        mov     esi, eax
        invoke  GetPhysAddr
        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  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_scb_ptr
;        lea     eax, [ebx + device.rx_desc]
;        invoke  GetPhysAddr
        out     dx, eax
 
        set_io  [ebx + device.io_addr], 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  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], 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, [ebx + device.ee_bus_width]
        shl     esi, cl
        or      esi, EE_READ shl 29
 
        movzx   ecx, [ebx + device.ee_bus_width]
        add     ecx, 3
 
        mov     al, EE_CS
        out     dx, al
        call    udelay
 
;-----------------------
; Write this to the chip
 
  .loop:
        mov     al, EE_CS + EE_SK
        shl     esi, 1
        jnc     @f
        or      al, EE_DI
       @@:
        out     dx, al
        call    udelay
 
        and     al, not EE_SK
        out     dx, al
        call    udelay
 
        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
        call    udelay
 
        in      al, dx
        test    al, EE_DO
        jz      @f
        inc     esi
       @@:
 
        mov     al, EE_CS
        out     dx, al
        call    udelay
 
        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  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], 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, [ebx + device.ee_bus_width]
        shl     esi, cl
        or      esi, EE_WRITE shl 29
 
        movzx   ecx, [ebx + 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
        call    udelay
 
        and     al, not EE_SK
        out     dx, al
        call    udelay
 
        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
        call    udelay
 
        and     al, not EE_SK
        out     dx, al
        call    udelay
 
        loop    .loop2
 
;-----------------------
; de-activate the eeprom
 
        xor     al, al
        out     dx, al
 
 
        ret
 
 
 
align 4
ee_get_width:
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_eeprom
 
        mov     al, EE_CS      ; activate eeprom
        out     dx, al
        call    udelay
 
        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
        call    udelay
 
        and     al, not EE_SK
        out     dx, al
        call    udelay
 
        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     [ebx + 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
 
 
; Wait a minimum of 2µs
udelay:
        pusha
        mov     esi, 1
        invoke  Sleep
        popa
 
        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  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_mdi_ctrl
        out     dx, eax
 
  .wait:
        call    udelay
        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  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], reg_mdi_ctrl
        out     dx, eax
 
  .wait:
        call    udelay
        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[ebx + device.mac], si
 
        mov     esi, 1
        call    ee_read
        mov     word[ebx + device.mac+2], si
 
        mov     esi, 2
        call    ee_read
        mov     word[ebx + device.mac+4], si
 
 
        ret
 
 
align 4
MAC_write:
 
;;;;
 
        ret
 
 
 
 
; End of code
 
 
data fixups
end data
 
include '../peimport.inc'
 
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
 
include_debug_strings                           ; All data wich FDO uses will be included here
 
align 4
devices         dd 0                              ; number of currently running devices
device_list     rd MAX_DEVICES                    ; This list contains all pointers to device structures the driver is handling

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

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/i8255x.asm – Rev 5522 → 5525