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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2014. 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 '../struct.inc'
include '../macros.inc'
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, [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     @F     ;---------
 
        DEBUGF  1, "Checking if device is already listed..\n"
 
        mov     eax, [edx + IOCTL.input]
 
        cmp     [edx + IOCTL.inp_size], 3
        jb      .fail
        cmp     byte [eax], 1
        je      .pci
 
        cmp     [edx + 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, [edx + 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, [edx + 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
 
 
 
; place all initialized data here
align 4
 
devices         dd 0
version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
my_service      db 'RTL8029',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 here
 
device_list     rd MAX_DEVICES

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

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/RTL8029.asm – Rev 4627 → 4629