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


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

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/i8255x.asm @ 6948 – Rev 6948 → 9232