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

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/i8255x.asm – Rev 5561 → 5562