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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  RTL8029/ne2000 driver for KolibriOS                            ;;
;;                                                                 ;;
;;  based on RTL8029.asm driver for menuetos                       ;;
;;  and realtek8029.asm for SolarOS by Eugen Brasoveanu            ;;
;;                                                                 ;;
;;    Written by hidnplayr@kolibrios.org                           ;;
;;     with help from CleverMouse                                  ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format MS COFF
 
        API_VERSION             = 0x01000100
        DRIVER_VERSION          = 5
 
        MAX_DEVICES             = 16
 
        DEBUG                   = 1
        __DEBUG__               = 1
        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
 
include '../proc32.inc'
include '../imports.inc'
include '../fdo.inc'
include '../netdrv.inc'
 
virtual at ebx
 
        device:
 
        ETH_DEVICE
 
        .io_addr        dd ?
        .irq_line       db ?
        .pci_bus        dd ?
        .pci_dev        dd ?
 
        .flags          db ?
        .vendor         db ?
 
        .memsize        db ?
        .rx_start       db ?
        .tx_start       db ?
        .bmem           dd ?
        .rmem           dd ?
 
        .size = $ - device
 
end virtual
 
 
public START
public service_proc
public version
 
        P0_COMMAND              = 0x00
        P0_PSTART               = 0x01
        P0_PSTOP                = 0x02
        P0_BOUND                = 0x03
        P0_TSR                  = 0x04
        P0_TPSR                 = 0x04
        P0_TBCR0                = 0x05
        P0_TBCR1                = 0x06
        P0_ISR                  = 0x07
        P0_RSAR0                = 0x08
        P0_RSAR1                = 0x09
        P0_RBCR0                = 0x0A
        P0_RBCR1                = 0x0B
        P0_RSR                  = 0x0C
        P0_RCR                  = 0x0C
        P0_TCR                  = 0x0D
        P0_DCR                  = 0x0E
        P0_IMR                  = 0x0F
 
        P1_COMMAND              = 0x00
        P1_PAR0                 = 0x01
        P1_PAR1                 = 0x02
        P1_PAR2                 = 0x03
        P1_PAR3                 = 0x04
        P1_PAR4                 = 0x05
        P1_PAR5                 = 0x06
        P1_CURR                 = 0x07
        P1_MAR0                 = 0x08
 
        CMD_PS0                 = 0x00          ; Page 0 select
        CMD_PS1                 = 0x40          ; Page 1 select
        CMD_PS2                 = 0x80          ; Page 2 select
        CMD_RD2                 = 0x20          ; Remote DMA control
        CMD_RD1                 = 0x10
        CMD_RD0                 = 0x08
        CMD_TXP                 = 0x04          ; transmit packet
        CMD_STA                 = 0x02          ; start
        CMD_STP                 = 0x01          ; stop
 
        CMD_RDMA_READ           = 001b shl 3
        CMD_RDMA_WRITE          = 010b shl 3
        CMD_RDMA_SEND_PACKET    = 011b shl 3
        CMD_RDMA_ABORT          = 100b shl 3    ; really is 1xx, Abort/Complete Remote DMA
;        RDMA_MASK               = 111b shl 3    ; internal, mask
 
        RCR_MON                 = 0x20          ; monitor mode
 
        DCR_FT1                 = 0x40
        DCR_LS                  = 0x08          ; Loopback select
        DCR_WTS                 = 0x01          ; Word transfer select
 
        ISR_PRX                 = 0x01          ; successful recv
        ISR_PTX                 = 0x02          ; successful xmit
        ISR_RXE                 = 0x04          ; receive error
        ISR_TXE                 = 0x08          ; transmit error
        ISR_OVW                 = 0x10          ; Overflow
        ISR_CNT                 = 0x20          ; Counter overflow
        ISR_RDC                 = 0x40          ; Remote DMA complete
        ISR_RST                 = 0x80          ; reset
 
        IRQ_MASK                = ISR_PRX ;+ ISR_PTX ;+ ISR_RDC + ISR_PTX + ISR_TXE
 
        RSTAT_PRX               = 1 shl 0       ; successful recv
        RSTAT_CRC               = 1 shl 1       ; CRC error
        RSTAT_FAE               = 1 shl 2       ; Frame alignment error
        RSTAT_OVER              = 1 shl 3       ; FIFO overrun
 
        TXBUF_SIZE              = 6
        RXBUF_END               = 32
        PAGE_SIZE               = 256
 
        ETH_ZLEN                = 60
        ETH_FRAME_LEN           = 1514
 
        FLAG_PIO                = 1 shl 0
        FLAG_16BIT              = 1 shl 1
 
        VENDOR_NONE             = 0
        VENDOR_WD               = 1
        VENDOR_NOVELL           = 2
        VENDOR_3COM             = 3
 
        NE_ASIC                 = 0x10
        NE_RESET                = 0x0F          ; Used to reset card
        NE_DATA                 = 0x00          ; Used to read/write NIC mem
 
        MEM_8k                  = 32
        MEM_16k                 = 64
        MEM_32k                 = 128
 
        ISA_MAX_ADDR            = 0x400
 
 
 
section '.flat' code readable align 16
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; proc START
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
proc START stdcall, state:dword
 
        cmp     [state], 1
        jne     .exit
  .entry:
        DEBUGF  1, "Loading driver\n"
        stdcall RegService, my_service, service_proc
        ret
  .fail:
  .exit:
        xor     eax, eax
        ret
 
endp
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; proc SERVICE_PROC
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
proc service_proc stdcall, ioctl:dword
 
        mov     edx, [ioctl]
        mov     eax, [IOCTL.io_code]
 
;------------------------------------------------------
                       ;---------------
        cmp     eax, 0 ;SRV_GETVERSION
        jne     @F     ;---------------
 
        cmp     [IOCTL.out_size], 4
        jb      .fail
        mov     eax, [IOCTL.output]
        mov     [eax], dword API_VERSION
 
        xor     eax, eax
        ret
 
;------------------------------------------------------
  @@:                  ;---------
        cmp     eax, 1 ;SRV_HOOK
        jne     @F     ;---------
 
        DEBUGF  1, "Checking if device is already listed..\n"
 
        mov     eax, [IOCTL.input]
 
        cmp     [IOCTL.inp_size], 3
        jb      .fail
        cmp     byte [eax], 1
        je      .pci
 
        cmp     [IOCTL.inp_size], 4
        jb      .fail
        cmp     byte [eax], 0
        je      .isa
 
        jmp     .fail
 
  .pci:
 
; check if the device is already listed
 
        mov     esi, device_list
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .firstdevice_pci
 
        mov     ax, [eax+1]                             ; get the pci bus and device numbers
  .nextdevice:
        mov     ebx, [esi]
        cmp     al, byte[device.pci_bus]
        jne     @f
        cmp     ah, byte[device.pci_dev]
        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
       @@:
        add     esi, 4
        loop    .nextdevice
 
  .firstdevice_pci:
        call    create_new_struct
 
        mov     eax, [IOCTL.input]
        movzx   ecx, byte[eax+1]
        mov     [device.pci_bus], ecx
        movzx   ecx, byte[eax+2]
        mov     [device.pci_dev], ecx
 
; Now, it's time to find the base io addres of the PCI device
 
        PCI_find_io
 
; We've found the io address, find IRQ now
 
        PCI_find_irq
 
        jmp     .hook
 
  .isa:
 
        mov     esi, device_list
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .firstdevice_isa
        mov     al, [eax+3]
        movzx   edi, word [eax+1]
  .nextdevice_isa:
        mov     ebx, [esi]
        cmp     edi, [device.io_addr]
        jne     .maybenext
        cmp     al, [device.irq_line]
        je      find_device_num
  .maybenext:
        add     esi, 4
        loop    .nextdevice_isa
 
 
 
  .firstdevice_isa:
        call    create_new_struct
 
        mov     eax, [IOCTL.input]
        movzx   ecx, word [eax+1]
        mov     [device.io_addr], ecx
        mov     cl, [eax+3]
        mov     [device.irq_line], cl
 
  .hook:
 
        DEBUGF  1, "Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
 
        call    probe                                                   ; this function will output in eax
        test    eax, eax
        jnz     .err                                                    ; If an error occured, exit
 
        mov     eax, [devices]
        mov     [device_list+4*eax], ebx
        inc     [devices]
 
        mov     [device.type], NET_TYPE_ETH
        call    NetRegDev
 
        cmp     eax, -1
        jz      .err
        ret
 
 
; If the device was already loaded, find the device number and return it in eax
 
  .find_devicenum:
        DEBUGF  1, "Trying to find device number of already registered device\n"
        call    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  1, "Kernel says: %u\n", eax
        ret
 
  .err:
        DEBUGF  2, "Failed, removing device structure\n"
        stdcall KernelFree, ebx
 
        jmp     .fail
 
;------------------------------------------------------
  @@:
.fail:
        or      eax, -1
        ret
 
;------------------------------------------------------
endp
 
 
create_new_struct:
 
        cmp     [devices], MAX_DEVICES
        jae     .fail
 
        allocate_and_clear ebx, device.size, .fail      ; Allocate the buffer for device structure
 
        mov     [device.reset], reset
        mov     [device.transmit], transmit
        mov     [device.unload], unload
        mov     [device.name], my_service
 
        ret
 
  .fail:
        add     esp, 4                                  ; return to caller of 'hook'
        or      eax, -1
        ret
 
find_device_num:
 
        DEBUGF  1, "Trying to find device number of already registered device\n"
        mov     ebx, eax
        call    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  1, "Kernel says: %u\n", eax
        ret
 
 
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
;;                                                                        ;;
;;        Actual Hardware dependent code starts here                      ;;
;;                                                                        ;;
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 
 
unload:   ; TODO
        or      eax, -1
        ret
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;  probe: enables the device and clears the rx buffer
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
probe:
        mov     [device.vendor], VENDOR_NONE
        mov     [device.bmem], 0
 
        DEBUGF  1, "Trying 16-bit mode\n"
 
        mov     [device.flags], FLAG_16BIT + FLAG_PIO
        mov     [device.memsize], MEM_32k
        mov     [device.tx_start], 64
        mov     [device.rx_start], TXBUF_SIZE + 64
 
        set_io  0
        set_io  P0_DCR
        mov     al, DCR_WTS + DCR_FT1 + DCR_LS  ; word transfer select +
        out     dx, al
 
        set_io  P0_PSTART
        mov     al, MEM_16k
        out     dx, al
 
        set_io  P0_PSTOP
        mov     al, MEM_32k
        out     dx, al
 
        mov     esi, my_service
        mov     di, 16384
        mov     cx, 14
        call    PIO_write
 
        mov     si, 16384
        mov     cx, 14
        sub     esp, 16
        mov     edi, esp
        call    PIO_read
 
        mov     esi, esp
        add     esp, 16
        mov     edi, my_service
        mov     ecx, 13
        repe    cmpsb
        je      ep_set_vendor
 
        DEBUGF  1, "16-bit mode failed\n"
        DEBUGF  1, "Trying 8-bit mode\n"
 
        mov     [device.flags], FLAG_PIO
        mov     [device.memsize], MEM_16k
        mov     [device.tx_start], 32
        mov     [device.rx_start], TXBUF_SIZE + 32
 
        set_io  NE_ASIC + NE_RESET
        in      al, dx
        out     dx, al
 
        in      al, 0x84
 
        set_io  P0_COMMAND
        mov     al, CMD_RD2 + CMD_STP
        out     dx, al
 
        set_io  P0_RCR
        mov     al, RCR_MON
        out     dx, al
 
        set_io  P0_DCR
        mov     al, DCR_FT1 + DCR_LS
        out     dx, al
 
        set_io  P0_PSTART
        mov     al, MEM_8k
        out     dx, al
 
        set_io  P0_PSTOP
        mov     al, MEM_16k
        out     dx, al
 
        mov     esi, my_service
        mov     di, 8192
        mov     cx, 14
        call    PIO_write
 
        mov     si, 8192
        mov     cx, 14
        sub     esp, 16
        mov     edi, esp
        call    PIO_read
 
        mov     esi, my_service
        mov     edi, esp
        add     esp, 16
        mov     ecx, 13
        repe    cmpsb
        je      ep_set_vendor
 
        DEBUGF  2, "This is not a valid ne2000 device!\n"
        or      eax, -1
        ret
 
 
ep_set_vendor:
 
        DEBUGF  1, "Mode ok\n"
 
        cmp     [device.io_addr], ISA_MAX_ADDR
        jbe     .isa
 
        DEBUGF  1, "Card is using PCI bus\n"
 
        mov     [device.vendor], VENDOR_NOVELL  ;;; FIXME
        jmp     ep_check_have_vendor
 
  .isa:
        DEBUGF  1, "Card is using ISA bus\n"
 
        mov     [device.vendor], VENDOR_NOVELL
 
ep_check_have_vendor:
 
 
        mov     al, [device.vendor]
        cmp     al, VENDOR_NONE
;        je      exit
 
        cmp     al, VENDOR_3COM
        je      reset
 
        mov     eax, [device.bmem]
        mov     [device.rmem], eax
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;   reset: Place the chip into a virgin state
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
reset:
        DEBUGF  1, "Resetting device\n"
 
; attach int handler
        movzx   eax, [device.irq_line]
        DEBUGF  1, "Attaching int handler to irq %x\n", eax:1
        stdcall AttachIntHandler, eax, int_handler, dword 0
        test    eax, eax
        jnz     @f
        DEBUGF  2, "Could not attach int handler!\n"
;        or      eax, -1
;        ret
       @@:
 
; Stop card + DMA
        set_io  0
;        set_io  P0_COMMAND
        mov     al, CMD_PS0 + CMD_RDMA_ABORT + CMD_STP
        out     dx, al
 
; initialize DCR
        set_io  P0_DCR
        mov     al, DCR_FT1 + DCR_LS
        test    [device.flags], FLAG_16BIT
        jz      @f
        or      al, DCR_WTS                     ; word transfer select
      @@:
        out     dx, al
 
; clear remote bytes count
        set_io  P0_RBCR0
        xor     al, al
        out     dx, al
 
        set_io  P0_RBCR1
        out     dx, al
 
; initialize Receive configuration register (until all init is done)
        set_io  P0_RCR
        mov     al, 0x20        ; monitor mode
        out     dx, al
 
; transmit configuration register to monitor mode (until all ini is done)
        set_io  P0_TCR
        mov     al, 2           ; internal loopback
        out     dx, al
 
; clear interupt status
        set_io  P0_ISR
        mov     al, 0xff
        out     dx, al
 
; clear IRQ mask                        ;;;;; CHECKME ;;;;;
        set_io  P0_IMR
        xor     al, al
        out     dx, al
 
; set transmit pointer
        set_io  P0_TPSR
        mov     al, [device.tx_start]
        out     dx, al
 
; set pagestart pointer
        set_io  P0_PSTART
        mov     al, [device.rx_start]
        out     dx, al
 
; set pagestop pointer
        set_io  P0_PSTOP
        mov     al, [device.memsize]
        out     dx, al
 
; set boundary pointer
        set_io  P0_BOUND
        mov     al, [device.memsize]
        dec     al
        out     dx, al
 
; set curr pointer
        set_io  P0_COMMAND
        mov     al, CMD_PS1 ;+ CMD_RD2 + CMD_STP ; page 1, stop mode
        out     dx, al
 
        set_io  P1_CURR
        mov     al, [device.rx_start]
        out     dx, al
 
        set_io  P0_COMMAND
        mov     al, CMD_PS0 ;+ CMD_RD2 + CMD_STA ; go to page 0, start mode
        out     dx, al
 
; Read MAC address and set it to registers
        call    read_mac
        push    .macret
        sub     esp, 6
        lea     esi, [device.mac]
        mov     edi, esp
        movsd
        movsw
        jmp     write_mac
  .macret:
 
; set IRQ mask
        set_io  0
        set_io  P0_IMR
        mov     al, IRQ_MASK
        out     dx, al
 
; start mode
        set_io  P0_COMMAND
        mov     al, CMD_STA
        out     dx, al
 
; clear transmit control register
        set_io  P0_TCR
        xor     al, al                  ; no loopback
        out     dx, al
 
; set receive control register ;;;;
        set_io  P0_RCR
        mov     al, 4                   ; accept broadcast
        out     dx, al
 
; clear packet/byte counters
        xor     eax, eax
        lea     edi, [device.bytes_tx]
        mov     ecx, 6
        rep     stosd
 
; Set the mtu, kernel will be able to send now
        mov     [device.mtu], ETH_FRAME_LEN
 
; Set link state to unknown
        mov     [device.state], ETH_LINK_UNKOWN
 
; Indicate that we have successfully reset the card
        xor     eax, eax
        DEBUGF  1, "Done!\n"
 
        ret
 
 
 
;***************************************************************************
;   Function
;      transmit
; buffer in [esp+4], size in [esp+8], pointer to device struct in ebx
;***************************************************************************
 
align 4
transmit:
 
        mov     esi, [esp + 4]
        mov     ecx, [esp + 8]
        DEBUGF  1, "Transmitting packet, buffer:%x, size:%u\n",esi, ecx
        DEBUGF  1, "To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
        [esi+0]:2,[esi+1]:2,[esi+2]:2,[esi+3]:2,[esi+4]:2,[esi+5]:2,[esi+6]:2,[esi+7]:2,[esi+8]:2,[esi+9]:2,[esi+10]:2,[esi+11]:2,[esi+13]:2,[esi+12]:2
 
        cmp     ecx, ETH_FRAME_LEN
        ja      .err ; packet is too long
        cmp     ecx, ETH_ZLEN
        jb      .err ; packet is too short
 
        movzx   edi, [device.tx_start]
        shl     edi, 8
        push    cx
        call    PIO_write
        pop     cx
 
        set_io  0
;        set_io  P0_COMMAND
        mov     al, CMD_PS0 + CMD_RD2 + CMD_STA
        out     dx, al
 
        set_io  P0_TPSR
        mov     al, [device.tx_start]
        out     dx, al
 
        set_io  P0_TBCR0
        mov     al, cl
        out     dx, al
 
        set_io  P0_TBCR1
        mov     al, ch
        out     dx, al
 
        set_io  P0_COMMAND
        mov     al, CMD_PS0 + CMD_TXP + CMD_RD2 + CMD_STA
        out     dx, al
 
        DEBUGF  1, "Packet Sent!\n"
 
        inc     [device.packets_tx]
        mov     eax, [esp + 8]                   ; Get packet size in eax
 
        add     dword [device.bytes_tx], eax
        adc     dword [device.bytes_tx + 4], 0
 
        stdcall KernelFree, [esp+4]
        xor     eax, eax
        ret     8
 
  .err:
        DEBUGF  2, "Transmit error!\n"
 
 
        stdcall KernelFree, [esp+4]
        or      eax, -1
        ret     8
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Interrupt handler
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
int_handler:
 
        push    ebx esi edi
 
        DEBUGF  1, "INT\n"
 
; find pointer of device wich made INT occur
 
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .nothing
        mov     esi, device_list
  .nextdevice:
        mov     ebx, [esi]
 
        set_io  0
;        set_io  P0_COMMAND
        mov     al, CMD_PS0
        out     dx, al
 
        set_io  P0_ISR
        in      al, dx
        test    al, al
        jnz     .got_it
  .continue:
        add     esi, 4
        dec     ecx
        jnz     .nextdevice
  .nothing:
        pop     edi esi ebx
        xor     eax, eax
 
        ret
 
  .got_it:
 
        DEBUGF  1, "Device=%x status=%x\n", ebx, eax:2
 
        push    ebx
 
        test    al, ISR_PRX     ; packet received ok ?
        jz      .no_rx
 
        test    [device.flags], FLAG_PIO
        jz      .no_rx          ; FIXME: Only PIO mode supported for now
 
;
 
        pushd   .no_rx
 
; allocate a buffer
 
        stdcall KernelAlloc, ETH_FRAME_LEN
        test    eax, eax
        jz      .fail_2
        pushd   0
        push    eax
 
; read offset for current packet from device
 
        set_io  0
        set_io  P0_BOUND        ; boundary ptr is offset to next packet we need to read.
        in      al, dx
        inc     al
 
        cmp     al, [device.memsize]
        jb      @f
        mov     al, [device.rx_start]
       @@:
        mov     ch, al
 
        set_io  P0_COMMAND
        mov     al, CMD_PS1
        out     dx, al
 
        set_io  P1_CURR
        in      al, dx          ; get current page in cl
        mov     cl, al
 
        set_io  P1_COMMAND
        mov     al, CMD_PS0
        out     dx, al
 
        cmp     cl, [device.memsize]
        jb      @f
        mov     cl, [device.rx_start]
       @@:
 
        cmp     cl, ch
        je      .fail
 
        movzx   esi, ch                         ; we are using 256 byte pages
        shl     esi, 8                          ; esi now holds the offset for current packet
 
; Get packet header in eax
 
        sub     esp, 4                          ; reserve 4 bytes on stack to put packet header in
        mov     edi, esp
        mov     cx, 4
        call    PIO_read
 
        mov     ecx, [esp]                      ; ecx now contains packet header
 
; check if packet is ok
 
        test    ecx, RSTAT_PRX
        jz      .fail_3
 
; calculate packet length in ecx
 
        shr     ecx, 16
        sub     ecx, 4                          ; CRC doesnt count as data byte
        mov     [esp + 4 + 4], ecx
 
; check if packet size is ok
 
        cmp     ecx, ETH_ZLEN
        jb      .fail_3
        cmp     ecx, ETH_FRAME_LEN
        ja      .fail_3
 
; update stats
 
        DEBUGF  1, "Received %u bytes\n", ecx
 
        add     dword[device.bytes_rx], ecx
        adc     dword[device.bytes_rx + 4], 0
        inc     [device.packets_rx]
 
; update read and write pointers
 
        add     esi, 4
        mov     edi, [esp + 4]
 
; now check if we can read all data at once (if we cross the end boundary, we need to wrap back to the beginning)
 
        xor     eax, eax
        mov     ah, [device.memsize]
        sub     eax, esi
        cmp     ecx, eax                ; eax = number of bytes till end of buffer, ecx = bytes we need to read
        jbe     .no_wrap
 
; Read first part
 
        sub     ecx, eax
        push    ecx
        mov     ecx, eax
 
        call    PIO_read                ; Read the data
 
; update pointers
 
        add     edi, ecx
        pop     ecx
 
        movzx   esi, [device.rx_start]
        shl     esi, 8
 
; now read second part (or only part)
 
  .no_wrap:
        call    PIO_read                ; Read the data
 
; update boundary pointer
 
        pop     eax
        mov     al, ah
        cmp     al, [device.rx_start]
        jne     @f
        mov     al, [device.memsize]
       @@:
 
        set_io  0
        set_io  P0_BOUND
        dec     al
        out     dx, al
 
; now send the data to the kernel
 
        jmp     Eth_input
 
  .fail_3:
        add     esp, 4
  .fail:
        add     esp, 8
  .fail_2:
 
 
  .no_rx:
        pop     ebx
        DEBUGF  1, "done\n"
 
        set_io  0
        set_io  P0_ISR
        mov     al, 0xff
        out     dx, al
 
        pop     edi esi ebx
 
        ret
 
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; Write MAC address ;;
;;                   ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
write_mac:      ; in: mac on stack (6 bytes)
 
        DEBUGF  1, "Writing MAC\n"
 
        set_io  0
        mov     al, CMD_PS1; + CMD_RD2 + CMD_STP
        out     dx, al
 
        set_io  P1_PAR0
        mov     esi, esp
        mov     cx, 6
 @@:
        lodsb
        out     dx, al
        inc     dx
        loopw   @r
 
        add     esp, 6
 
; Notice this procedure does not ret, but continues to read_mac instead.
 
;;;;;;;;;;;;;;;;;;;;;;
;;                  ;;
;; Read MAC address ;;
;;                  ;;
;;;;;;;;;;;;;;;;;;;;;;
 
read_mac:
 
        DEBUGF  1, "Reading MAC\n"
 
        xor     esi, esi
        mov     cx, 16
        sub     esp, 16
        mov     edi, esp
        call    PIO_read
 
        mov     esi, esp
        add     esp, 16
        lea     edi, [device.mac]
        mov     ecx, 6
  .loop:
        movsb
        test    [device.flags], FLAG_16BIT
        jz      .8bit
        inc     esi
  .8bit:
        loop    .loop
 
        DEBUGF  1, "MAC=%x-%x-%x-%x-%x-%x\n",\
        [device.mac]:2,[device.mac+1]:2,[device.mac+2]:2,[device.mac+3]:2,[device.mac+4]:2,[device.mac+5]:2
 
        ret
 
 
;***************************************************************************
;
;   PIO_read
;
;   Description
;       Read a frame from the ethernet card via Programmed I/O
;      src in si
;      cnt in cx
;       dst in edi
;***************************************************************************
PIO_read:
 
        DEBUGF  1, "PIO Read from %x to %x, %u bytes ", si, edi, cx
 
; start DMA
        set_io  0
;        set_io  P0_COMMAND
        mov     al, CMD_RD2 + CMD_STA
        out     dx, al
 
; set length of data we're interested in
        set_io  P0_RBCR0
        mov     al, cl
        out     dx, al
 
        set_io  P0_RBCR1
        mov     al, ch
        out     dx, al
 
; set offset of what we want to read
        set_io  P0_RSAR0
        mov     ax, si
        out     dx, al
 
        set_io  P0_RSAR1
        shr     ax, 8
        out     dx, al
 
; start DMA read
        set_io  P0_COMMAND
        mov     al, CMD_RD0 + CMD_STA
        out     dx, al
 
        set_io  NE_ASIC
 
        test    [device.flags], FLAG_16BIT
        jz      .8bits
 
        DEBUGF  1, "(16-bit mode)\n"
 
        shr     cx, 1   ; note that if the number was odd, carry flag will be set
        pushf
 
  .16bits:
        in      ax, dx
        stosw
        loopw   .16bits
 
        inc     cx
        popf
        jnc     .done
        jmp     .8bits_
 
  .8bits:
        DEBUGF  1, "(8-bit mode)\n"
 
  .8bits_:
        in      al, dx
        stosb
        loopw   .8bits_
 
 
  .done:
;        set_io  0
;        set_io  P0_ISR
;
;  .dmawait:                             ; Wait for Remote DMA Complete
;        in      al, dx
;        test    al, ISR_RDC
;        jz      .dmawait
;        and     al, not ISR_RDC
;        out     dx, al                  ; clear the bit
 
        ret
 
 
 
 
;***************************************************************************
;
;   PIO_write
;
;   Description
;       writes a frame to the ethernet card via Programmed I/O
;      dst in di
;      cnt in cx
;       src in esi
;***************************************************************************
PIO_write:
 
        DEBUGF  1, "Eth PIO Write from %x to %x, %u bytes ", esi, di, cx
 
        set_io  0
;        set_io  P0_COMMAND
        mov     al, CMD_RD2 + CMD_STA
        out     dx, al
 
        set_io  P0_ISR
        mov     al, ISR_RDC
        out     dx, al
 
        set_io  P0_RBCR0
        mov     al, cl
        out     dx, al
 
        set_io  P0_RBCR1
        mov     al, ch
        out     dx, al
 
        mov     ax, di
        set_io  P0_RSAR0
        out     dx, al
        shr     ax, 8
        set_io  P0_RSAR1
        out     dx, al
 
        set_io  P0_COMMAND
        mov     al, CMD_RD1 + CMD_STA
        out     dx, al
 
        set_io  NE_ASIC
        test    [device.flags], FLAG_16BIT
        jz      .8_bit
 
        DEBUGF  1, "(16-bit mode)\n"
 
        shr     cx, 1   ; note that if the number was odd, carry flag will be set
        pushf           ; save the flags for later
 
  .16bit:
        lodsw
        out     dx, ax
        loopw   .16bit
 
        popf
        jnc     .done
        inc     cx
        jmp     .8_bit_
 
  .8_bit:
 
        DEBUGF  1, "(8-bit mode)\n"
 
  .8_bit_:
        lodsb
        out     dx, al
        loopw   .8_bit_
 
  .done:
;        set_io  0
;        set_io  P0_ISR
;  .dmawait:                             ; Wait for Remote DMA Complete
;        in      al, dx
;        test    al, ISR_RDC
;        jz      .dmawait
;        and     al, not ISR_RDC
;        out     dx, al                  ; clear the bit
 
        ret
 
 
 
;all initialized data place here
align 4
 
devices         dd 0
version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
my_service      db 'RTL8029/ne2000',0  ;max 16 chars include zero
 
;device_1        db 'Realtek 8029',0
;device_2        db 'Realtek 8019',0
;device_3        db 'Realtek 8019AS',0
;device_4        db 'ne2000',0
;device_5        db 'DP8390',0
 
include_debug_strings
 
section '.data' data readable writable align 16  ;place all uninitialized data place here
 
device_list     rd MAX_DEVICES

Rev 3856	Rev 4334
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2013. 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	;; RTL8029/ne2000 driver for KolibriOS ;;	6	;; RTL8029/ne2000 driver for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; based on RTL8029.asm driver for menuetos ;;	8	;; based on RTL8029.asm driver for menuetos ;;
9	;; and realtek8029.asm for SolarOS by Eugen Brasoveanu ;;	9	;; and realtek8029.asm for SolarOS by Eugen Brasoveanu ;;
10	;; ;;	10	;; ;;
11	;; Written by hidnplayr@kolibrios.org ;;	11	;; Written by hidnplayr@kolibrios.org ;;
12	;; with help from CleverMouse ;;	12	;; with help from CleverMouse ;;
13	;; ;;	13	;; ;;
14	;; GNU GENERAL PUBLIC LICENSE ;;	14	;; GNU GENERAL PUBLIC LICENSE ;;
15	;; Version 2, June 1991 ;;	15	;; Version 2, June 1991 ;;
16	;; ;;	16	;; ;;
17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18		18
19	format MS COFF	19	format MS COFF
20		20
21	API_VERSION = 0x01000100	21	API_VERSION = 0x01000100
22	DRIVER_VERSION = 5	22	DRIVER_VERSION = 5
23		23
24	MAX_DEVICES = 16	24	MAX_DEVICES = 16
25		25
26	DEBUG = 1	26	DEBUG = 1
27	__DEBUG__ = 1	27	__DEBUG__ = 1
28	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only	28	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only
29		29
30	include '../proc32.inc'	30	include '../proc32.inc'
31	include '../imports.inc'	31	include '../imports.inc'
32	include '../fdo.inc'	32	include '../fdo.inc'
33	include '../netdrv.inc'	33	include '../netdrv.inc'
34		34
35	virtual at ebx	35	virtual at ebx
36		36
37	device:	37	device:
38		38
39	ETH_DEVICE	39	ETH_DEVICE
40		40
41	.io_addr dd ?	41	.io_addr dd ?
42	.irq_line db ?	42	.irq_line db ?
43	.pci_bus dd ?	43	.pci_bus dd ?
44	.pci_dev dd ?	44	.pci_dev dd ?
45		45
46	.flags db ?	46	.flags db ?
47	.vendor db ?	47	.vendor db ?
48		48
49	.memsize db ?	49	.memsize db ?
50	.rx_start db ?	50	.rx_start db ?
51	.tx_start db ?	51	.tx_start db ?
52	.bmem dd ?	52	.bmem dd ?
53	.rmem dd ?	53	.rmem dd ?
54		54
55	.size = $ - device	55	.size = $ - device
56		56
57	end virtual	57	end virtual
58		58
59		59
60	public START	60	public START
61	public service_proc	61	public service_proc
62	public version	62	public version
63		63
64	P0_COMMAND = 0x00	64	P0_COMMAND = 0x00
65	P0_PSTART = 0x01	65	P0_PSTART = 0x01
66	P0_PSTOP = 0x02	66	P0_PSTOP = 0x02
67	P0_BOUND = 0x03	67	P0_BOUND = 0x03
68	P0_TSR = 0x04	68	P0_TSR = 0x04
69	P0_TPSR = 0x04	69	P0_TPSR = 0x04
70	P0_TBCR0 = 0x05	70	P0_TBCR0 = 0x05
71	P0_TBCR1 = 0x06	71	P0_TBCR1 = 0x06
72	P0_ISR = 0x07	72	P0_ISR = 0x07
73	P0_RSAR0 = 0x08	73	P0_RSAR0 = 0x08
74	P0_RSAR1 = 0x09	74	P0_RSAR1 = 0x09
75	P0_RBCR0 = 0x0A	75	P0_RBCR0 = 0x0A
76	P0_RBCR1 = 0x0B	76	P0_RBCR1 = 0x0B
77	P0_RSR = 0x0C	77	P0_RSR = 0x0C
78	P0_RCR = 0x0C	78	P0_RCR = 0x0C
79	P0_TCR = 0x0D	79	P0_TCR = 0x0D
80	P0_DCR = 0x0E	80	P0_DCR = 0x0E
81	P0_IMR = 0x0F	81	P0_IMR = 0x0F
82		82
83	P1_COMMAND = 0x00	83	P1_COMMAND = 0x00
84	P1_PAR0 = 0x01	84	P1_PAR0 = 0x01
85	P1_PAR1 = 0x02	85	P1_PAR1 = 0x02
86	P1_PAR2 = 0x03	86	P1_PAR2 = 0x03
87	P1_PAR3 = 0x04	87	P1_PAR3 = 0x04
88	P1_PAR4 = 0x05	88	P1_PAR4 = 0x05
89	P1_PAR5 = 0x06	89	P1_PAR5 = 0x06
90	P1_CURR = 0x07	90	P1_CURR = 0x07
91	P1_MAR0 = 0x08	91	P1_MAR0 = 0x08
92		92
93	CMD_PS0 = 0x00 ; Page 0 select	93	CMD_PS0 = 0x00 ; Page 0 select
94	CMD_PS1 = 0x40 ; Page 1 select	94	CMD_PS1 = 0x40 ; Page 1 select
95	CMD_PS2 = 0x80 ; Page 2 select	95	CMD_PS2 = 0x80 ; Page 2 select
96	CMD_RD2 = 0x20 ; Remote DMA control	96	CMD_RD2 = 0x20 ; Remote DMA control
97	CMD_RD1 = 0x10	97	CMD_RD1 = 0x10
98	CMD_RD0 = 0x08	98	CMD_RD0 = 0x08
99	CMD_TXP = 0x04 ; transmit packet	99	CMD_TXP = 0x04 ; transmit packet
100	CMD_STA = 0x02 ; start	100	CMD_STA = 0x02 ; start
101	CMD_STP = 0x01 ; stop	101	CMD_STP = 0x01 ; stop
102		102
103	CMD_RDMA_READ = 001b shl 3	103	CMD_RDMA_READ = 001b shl 3
104	CMD_RDMA_WRITE = 010b shl 3	104	CMD_RDMA_WRITE = 010b shl 3
105	CMD_RDMA_SEND_PACKET = 011b shl 3	105	CMD_RDMA_SEND_PACKET = 011b shl 3
106	CMD_RDMA_ABORT = 100b shl 3 ; really is 1xx, Abort/Complete Remote DMA	106	CMD_RDMA_ABORT = 100b shl 3 ; really is 1xx, Abort/Complete Remote DMA
107	; RDMA_MASK = 111b shl 3 ; internal, mask	107	; RDMA_MASK = 111b shl 3 ; internal, mask
108		108
109	RCR_MON = 0x20 ; monitor mode	109	RCR_MON = 0x20 ; monitor mode
110		110
111	DCR_FT1 = 0x40	111	DCR_FT1 = 0x40
112	DCR_LS = 0x08 ; Loopback select	112	DCR_LS = 0x08 ; Loopback select
113	DCR_WTS = 0x01 ; Word transfer select	113	DCR_WTS = 0x01 ; Word transfer select
114		114
115	ISR_PRX = 0x01 ; successful recv	115	ISR_PRX = 0x01 ; successful recv
116	ISR_PTX = 0x02 ; successful xmit	116	ISR_PTX = 0x02 ; successful xmit
117	ISR_RXE = 0x04 ; receive error	117	ISR_RXE = 0x04 ; receive error
118	ISR_TXE = 0x08 ; transmit error	118	ISR_TXE = 0x08 ; transmit error
119	ISR_OVW = 0x10 ; Overflow	119	ISR_OVW = 0x10 ; Overflow
120	ISR_CNT = 0x20 ; Counter overflow	120	ISR_CNT = 0x20 ; Counter overflow
121	ISR_RDC = 0x40 ; Remote DMA complete	121	ISR_RDC = 0x40 ; Remote DMA complete
122	ISR_RST = 0x80 ; reset	122	ISR_RST = 0x80 ; reset
123		123
124	IRQ_MASK = ISR_PRX ;+ ISR_PTX ;+ ISR_RDC + ISR_PTX + ISR_TXE	124	IRQ_MASK = ISR_PRX ;+ ISR_PTX ;+ ISR_RDC + ISR_PTX + ISR_TXE
125		125
126	RSTAT_PRX = 1 shl 0 ; successful recv	126	RSTAT_PRX = 1 shl 0 ; successful recv
127	RSTAT_CRC = 1 shl 1 ; CRC error	127	RSTAT_CRC = 1 shl 1 ; CRC error
128	RSTAT_FAE = 1 shl 2 ; Frame alignment error	128	RSTAT_FAE = 1 shl 2 ; Frame alignment error
129	RSTAT_OVER = 1 shl 3 ; FIFO overrun	129	RSTAT_OVER = 1 shl 3 ; FIFO overrun
130		130
131	TXBUF_SIZE = 6	131	TXBUF_SIZE = 6
132	RXBUF_END = 32	132	RXBUF_END = 32
133	PAGE_SIZE = 256	133	PAGE_SIZE = 256
134		134
135	ETH_ZLEN = 60	135	ETH_ZLEN = 60
136	ETH_FRAME_LEN = 1514	136	ETH_FRAME_LEN = 1514
137		137
138	FLAG_PIO = 1 shl 0	138	FLAG_PIO = 1 shl 0
139	FLAG_16BIT = 1 shl 1	139	FLAG_16BIT = 1 shl 1
140		140
141	VENDOR_NONE = 0	141	VENDOR_NONE = 0
142	VENDOR_WD = 1	142	VENDOR_WD = 1
143	VENDOR_NOVELL = 2	143	VENDOR_NOVELL = 2
144	VENDOR_3COM = 3	144	VENDOR_3COM = 3
145		145
146	NE_ASIC = 0x10	146	NE_ASIC = 0x10
147	NE_RESET = 0x0F ; Used to reset card	147	NE_RESET = 0x0F ; Used to reset card
148	NE_DATA = 0x00 ; Used to read/write NIC mem	148	NE_DATA = 0x00 ; Used to read/write NIC mem
149		149
150	MEM_8k = 32	150	MEM_8k = 32
151	MEM_16k = 64	151	MEM_16k = 64
152	MEM_32k = 128	152	MEM_32k = 128
153		153
154	ISA_MAX_ADDR = 0x400	154	ISA_MAX_ADDR = 0x400
155		155
156		156
157		157
158	section '.flat' code readable align 16	158	section '.flat' code readable align 16
159		159
160	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	160	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
161	;;	161	;;
162	;; proc START	162	;; proc START
163	;;	163	;;
164	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	164	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
165		165
166	align 4	166	align 4
167	proc START stdcall, state:dword	167	proc START stdcall, state:dword
168		168
169	cmp [state], 1	169	cmp [state], 1
170	jne .exit	170	jne .exit
171	.entry:	171	.entry:
172	DEBUGF 1, "Loading driver\n"	172	DEBUGF 1, "Loading driver\n"
173	stdcall RegService, my_service, service_proc	173	stdcall RegService, my_service, service_proc
174	ret	174	ret
175	.fail:	175	.fail:
176	.exit:	176	.exit:
177	xor eax, eax	177	xor eax, eax
178	ret	178	ret
179		179
180	endp	180	endp
181		181
182		182
183	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	183	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
184	;;	184	;;
185	;; proc SERVICE_PROC	185	;; proc SERVICE_PROC
186	;;	186	;;
187	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	187	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
188		188
189	align 4	189	align 4
190	proc service_proc stdcall, ioctl:dword	190	proc service_proc stdcall, ioctl:dword
191		191
192	mov edx, [ioctl]	192	mov edx, [ioctl]
193	mov eax, [IOCTL.io_code]	193	mov eax, [IOCTL.io_code]
194		194
195	;------------------------------------------------------	195	;------------------------------------------------------
196	;---------------	196	;---------------
197	cmp eax, 0 ;SRV_GETVERSION	197	cmp eax, 0 ;SRV_GETVERSION
198	jne @F ;---------------	198	jne @F ;---------------
199		199
200	cmp [IOCTL.out_size], 4	200	cmp [IOCTL.out_size], 4
201	jb .fail	201	jb .fail
202	mov eax, [IOCTL.output]	202	mov eax, [IOCTL.output]
203	mov [eax], dword API_VERSION	203	mov [eax], dword API_VERSION
204		204
205	xor eax, eax	205	xor eax, eax
206	ret	206	ret
207		207
208	;------------------------------------------------------	208	;------------------------------------------------------
209	@@: ;---------	209	@@: ;---------
210	cmp eax, 1 ;SRV_HOOK	210	cmp eax, 1 ;SRV_HOOK
211	jne @F ;---------	211	jne @F ;---------
212		212
213	DEBUGF 1, "Checking if device is already listed..\n"	213	DEBUGF 1, "Checking if device is already listed..\n"
214		214
215	mov eax, [IOCTL.input]	215	mov eax, [IOCTL.input]
216		216
217	cmp [IOCTL.inp_size], 3	217	cmp [IOCTL.inp_size], 3
218	jb .fail	218	jb .fail
219	cmp byte [eax], 1	219	cmp byte [eax], 1
220	je .pci	220	je .pci
221		221
222	cmp [IOCTL.inp_size], 4	222	cmp [IOCTL.inp_size], 4
223	jb .fail	223	jb .fail
224	cmp byte [eax], 0	224	cmp byte [eax], 0
225	je .isa	225	je .isa
226		226
227	jmp .fail	227	jmp .fail
228		228
229	.pci:	229	.pci:
230		230
231	; check if the device is already listed	231	; check if the device is already listed
232		232
233	mov esi, device_list	233	mov esi, device_list
234	mov ecx, [devices]	234	mov ecx, [devices]
235	test ecx, ecx	235	test ecx, ecx
236	jz .firstdevice_pci	236	jz .firstdevice_pci
237		237
238	mov ax, [eax+1] ; get the pci bus and device numbers	238	mov ax, [eax+1] ; get the pci bus and device numbers
239	.nextdevice:	239	.nextdevice:
240	mov ebx, [esi]	240	mov ebx, [esi]
241	cmp al, byte[device.pci_bus]	241	cmp al, byte[device.pci_bus]
242	jne @f	242	jne @f
243	cmp ah, byte[device.pci_dev]	243	cmp ah, byte[device.pci_dev]
244	je .find_devicenum ; Device is already loaded, let's find it's device number	244	je .find_devicenum ; Device is already loaded, let's find it's device number
245	@@:	245	@@:
246	add esi, 4	246	add esi, 4
247	loop .nextdevice	247	loop .nextdevice
248		248
249	.firstdevice_pci:	249	.firstdevice_pci:
250	call create_new_struct	250	call create_new_struct
251		251
252	mov eax, [IOCTL.input]	252	mov eax, [IOCTL.input]
253	movzx ecx, byte[eax+1]	253	movzx ecx, byte[eax+1]
254	mov [device.pci_bus], ecx	254	mov [device.pci_bus], ecx
255	movzx ecx, byte[eax+2]	255	movzx ecx, byte[eax+2]
256	mov [device.pci_dev], ecx	256	mov [device.pci_dev], ecx
257		257
258	; Now, it's time to find the base io addres of the PCI device	258	; Now, it's time to find the base io addres of the PCI device
259		259
260	PCI_find_io	260	PCI_find_io
261		261
262	; We've found the io address, find IRQ now	262	; We've found the io address, find IRQ now
263		263
264	PCI_find_irq	264	PCI_find_irq
265		265
266	jmp .hook	266	jmp .hook
267		267
268	.isa:	268	.isa:
269		269
270	mov esi, device_list	270	mov esi, device_list
271	mov ecx, [devices]	271	mov ecx, [devices]
272	test ecx, ecx	272	test ecx, ecx
273	jz .firstdevice_isa	273	jz .firstdevice_isa
274	mov al, [eax+3]	274	mov al, [eax+3]
275	movzx edi, word [eax+1]	275	movzx edi, word [eax+1]
276	.nextdevice_isa:	276	.nextdevice_isa:
277	mov ebx, [esi]	277	mov ebx, [esi]
278	cmp edi, [device.io_addr]	278	cmp edi, [device.io_addr]
279	jne .maybenext	279	jne .maybenext
280	cmp al, [device.irq_line]	280	cmp al, [device.irq_line]
281	je find_device_num	281	je find_device_num
282	.maybenext:	282	.maybenext:
283	add esi, 4	283	add esi, 4
284	loop .nextdevice_isa	284	loop .nextdevice_isa
285		285
286		286
287		287
288	.firstdevice_isa:	288	.firstdevice_isa:
289	call create_new_struct	289	call create_new_struct
290		290
291	mov eax, [IOCTL.input]	291	mov eax, [IOCTL.input]
292	movzx ecx, word [eax+1]	292	movzx ecx, word [eax+1]
293	mov [device.io_addr], ecx	293	mov [device.io_addr], ecx
294	mov cl, [eax+3]	294	mov cl, [eax+3]
295	mov [device.irq_line], cl	295	mov [device.irq_line], cl
296		296
297	.hook:	297	.hook:
298		298
299	DEBUGF 1, "Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\	299	DEBUGF 1, "Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
300	[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4	300	[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
301		301
302	call probe ; this function will output in eax	302	call probe ; this function will output in eax
303	test eax, eax	303	test eax, eax
304	jnz .err ; If an error occured, exit	304	jnz .err ; If an error occured, exit
305		305
306	mov eax, [devices]	306	mov eax, [devices]
307	mov [device_list+4*eax], ebx	307	mov [device_list+4*eax], ebx
308	inc [devices]	308	inc [devices]
309		309
310	mov [device.type], NET_TYPE_ETH	310	mov [device.type], NET_TYPE_ETH
311	call NetRegDev	311	call NetRegDev
312		312
313	cmp eax, -1	313	cmp eax, -1
314	jz .err	314	jz .err
315	ret	315	ret
316		316
317		317
318	; If the device was already loaded, find the device number and return it in eax	318	; If the device was already loaded, find the device number and return it in eax
319		319
320	.find_devicenum:	320	.find_devicenum:
321	DEBUGF 1, "Trying to find device number of already registered device\n"	321	DEBUGF 1, "Trying to find device number of already registered device\n"
322	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx	322	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
323	; into a device number in edi	323	; into a device number in edi
324	mov eax, edi ; Application wants it in eax instead	324	mov eax, edi ; Application wants it in eax instead
325	DEBUGF 1, "Kernel says: %u\n", eax	325	DEBUGF 1, "Kernel says: %u\n", eax
326	ret	326	ret
327		327
328	.err:	328	.err:
329	DEBUGF 2, "Failed, removing device structure\n"	329	DEBUGF 2, "Failed, removing device structure\n"
330	stdcall KernelFree, ebx	330	stdcall KernelFree, ebx
331		331
332	jmp .fail	332	jmp .fail
333		333
334	;------------------------------------------------------	334	;------------------------------------------------------
335	@@:	335	@@:
336	.fail:	336	.fail:
337	or eax, -1	337	or eax, -1
338	ret	338	ret
339		339
340	;------------------------------------------------------	340	;------------------------------------------------------
341	endp	341	endp
342		342
343		343
344	create_new_struct:	344	create_new_struct:
345		345
346	cmp [devices], MAX_DEVICES	346	cmp [devices], MAX_DEVICES
347	jae .fail	347	jae .fail
348		348
349	allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure	349	allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure
350		350
351	mov [device.reset], reset	351	mov [device.reset], reset
352	mov [device.transmit], transmit	352	mov [device.transmit], transmit
353	mov [device.unload], unload	353	mov [device.unload], unload
354	mov [device.name], my_service	354	mov [device.name], my_service
355		355
356	ret	356	ret
357		357
358	.fail:	358	.fail:
359	add esp, 4 ; return to caller of 'hook'	359	add esp, 4 ; return to caller of 'hook'
360	or eax, -1	360	or eax, -1
361	ret	361	ret
362		362
363	find_device_num:	363	find_device_num:
364		364
365	DEBUGF 1, "Trying to find device number of already registered device\n"	365	DEBUGF 1, "Trying to find device number of already registered device\n"
366	mov ebx, eax	366	mov ebx, eax
367	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx	367	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
368	; into a device number in edi	368	; into a device number in edi
369	mov eax, edi ; Application wants it in eax instead	369	mov eax, edi ; Application wants it in eax instead
370	DEBUGF 1, "Kernel says: %u\n", eax	370	DEBUGF 1, "Kernel says: %u\n", eax
371	ret	371	ret
372		372
373		373
374	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	374	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
375	;; ;;	375	;; ;;
376	;; Actual Hardware dependent code starts here ;;	376	;; Actual Hardware dependent code starts here ;;
377	;; ;;	377	;; ;;
378	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	378	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
379		379
380		380
381	unload: ; TODO	381	unload: ; TODO
382	or eax, -1	382	or eax, -1
383	ret	383	ret
384		384
385		385
386		386
387	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	387	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
388	;;	388	;;
389	;; probe: enables the device and clears the rx buffer	389	;; probe: enables the device and clears the rx buffer
390	;;	390	;;
391	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	391	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
392		392
393	probe:	393	probe:
394	mov [device.vendor], VENDOR_NONE	394	mov [device.vendor], VENDOR_NONE
395	mov [device.bmem], 0	395	mov [device.bmem], 0
396		396
397	DEBUGF 1, "Trying 16-bit mode\n"	397	DEBUGF 1, "Trying 16-bit mode\n"
398		398
399	mov [device.flags], FLAG_16BIT + FLAG_PIO	399	mov [device.flags], FLAG_16BIT + FLAG_PIO
400	mov [device.memsize], MEM_32k	400	mov [device.memsize], MEM_32k
401	mov [device.tx_start], 64	401	mov [device.tx_start], 64
402	mov [device.rx_start], TXBUF_SIZE + 64	402	mov [device.rx_start], TXBUF_SIZE + 64
403		403
404	set_io 0	404	set_io 0
405	set_io P0_DCR	405	set_io P0_DCR
406	mov al, DCR_WTS + DCR_FT1 + DCR_LS ; word transfer select +	406	mov al, DCR_WTS + DCR_FT1 + DCR_LS ; word transfer select +
407	out dx, al	407	out dx, al
408		408
409	set_io P0_PSTART	409	set_io P0_PSTART
410	mov al, MEM_16k	410	mov al, MEM_16k
411	out dx, al	411	out dx, al
412		412
413	set_io P0_PSTOP	413	set_io P0_PSTOP
414	mov al, MEM_32k	414	mov al, MEM_32k
415	out dx, al	415	out dx, al
416		416
417	mov esi, my_service	417	mov esi, my_service
418	mov di, 16384	418	mov di, 16384
419	mov cx, 14	419	mov cx, 14
420	call PIO_write	420	call PIO_write
421		421
422	mov si, 16384	422	mov si, 16384
423	mov cx, 14	423	mov cx, 14
424	sub esp, 16	424	sub esp, 16
425	mov edi, esp	425	mov edi, esp
426	call PIO_read	426	call PIO_read
427		427
428	mov esi, esp	428	mov esi, esp
429	add esp, 16	429	add esp, 16
430	mov edi, my_service	430	mov edi, my_service
431	mov ecx, 13	431	mov ecx, 13
432	repe cmpsb	432	repe cmpsb
433	je ep_set_vendor	433	je ep_set_vendor
434		434
435	DEBUGF 1, "16-bit mode failed\n"	435	DEBUGF 1, "16-bit mode failed\n"
436	DEBUGF 1, "Trying 8-bit mode\n"	436	DEBUGF 1, "Trying 8-bit mode\n"
437		437
438	mov [device.flags], FLAG_PIO	438	mov [device.flags], FLAG_PIO
439	mov [device.memsize], MEM_16k	439	mov [device.memsize], MEM_16k
440	mov [device.tx_start], 32	440	mov [device.tx_start], 32
441	mov [device.rx_start], TXBUF_SIZE + 32	441	mov [device.rx_start], TXBUF_SIZE + 32
442		442
443	set_io NE_ASIC + NE_RESET	443	set_io NE_ASIC + NE_RESET
444	in al, dx	444	in al, dx
445	out dx, al	445	out dx, al
446		446
447	in al, 0x84	447	in al, 0x84
448		448
449	set_io P0_COMMAND	449	set_io P0_COMMAND
450	mov al, CMD_RD2 + CMD_STP	450	mov al, CMD_RD2 + CMD_STP
451	out dx, al	451	out dx, al
452		452
453	set_io P0_RCR	453	set_io P0_RCR
454	mov al, RCR_MON	454	mov al, RCR_MON
455	out dx, al	455	out dx, al
456		456
457	set_io P0_DCR	457	set_io P0_DCR
458	mov al, DCR_FT1 + DCR_LS	458	mov al, DCR_FT1 + DCR_LS
459	out dx, al	459	out dx, al
460		460
461	set_io P0_PSTART	461	set_io P0_PSTART
462	mov al, MEM_8k	462	mov al, MEM_8k
463	out dx, al	463	out dx, al
464		464
465	set_io P0_PSTOP	465	set_io P0_PSTOP
466	mov al, MEM_16k	466	mov al, MEM_16k
467	out dx, al	467	out dx, al
468		468
469	mov esi, my_service	469	mov esi, my_service
470	mov di, 8192	470	mov di, 8192
471	mov cx, 14	471	mov cx, 14
472	call PIO_write	472	call PIO_write
473		473
474	mov si, 8192	474	mov si, 8192
475	mov cx, 14	475	mov cx, 14
476	sub esp, 16	476	sub esp, 16
477	mov edi, esp	477	mov edi, esp
478	call PIO_read	478	call PIO_read
479		479
480	mov esi, my_service	480	mov esi, my_service
481	mov edi, esp	481	mov edi, esp
482	add esp, 16	482	add esp, 16
483	mov ecx, 13	483	mov ecx, 13
484	repe cmpsb	484	repe cmpsb
485	je ep_set_vendor	485	je ep_set_vendor
486		486
487	DEBUGF 2, "This is not a valid ne2000 device!\n"	487	DEBUGF 2, "This is not a valid ne2000 device!\n"
488	or eax, -1	488	or eax, -1
489	ret	489	ret
490		490
491		491
492	ep_set_vendor:	492	ep_set_vendor:
493		493
494	DEBUGF 1, "Mode ok\n"	494	DEBUGF 1, "Mode ok\n"
495		495
496	cmp [device.io_addr], ISA_MAX_ADDR	496	cmp [device.io_addr], ISA_MAX_ADDR
497	jbe .isa	497	jbe .isa
498		498
499	DEBUGF 1, "Card is using PCI bus\n"	499	DEBUGF 1, "Card is using PCI bus\n"
500		500

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/RTL8029.asm – Rev 3856 → 4334