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

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/i8255x.asm – Rev 5194 → 5247