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


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

Subversion Repositories Kolibri OS

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