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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  Realtek 8139 driver for KolibriOS                              ;;
;;                                                                 ;;
;;  based on RTL8139.asm driver for menuetos                       ;;
;;  and realtek8139.asm for SolarOS by Eugen Brasoveanu            ;;
;;                                                                 ;;
;;    Written by hidnplayr@kolibrios.org                           ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format PE DLL native
entry START
 
        CURRENT_API             = 0x0200
        COMPATIBLE_API          = 0x0100
        API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
 
        MAX_DEVICES             = 16
 
        RBLEN                   = 3     ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k
 
        TXRR                    = 8     ; total retries = 16+(TXRR*16)
        TX_MXDMA                = 6     ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=2048
        ERTXTH                  = 8     ; in unit of 32 bytes e.g:(8*32)=256
        RX_MXDMA                = 7     ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=unlimited
        RXFTH                   = 7     ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=no threshold
 
        __DEBUG__               = 1
        __DEBUG_LEVEL__         = 2     ; 1 = verbose, 2 = errors only
 
section '.flat' readable writable executable
 
include '../proc32.inc'
include '../struct.inc'
include '../macros.inc'
include '../fdo.inc'
include '../netdrv.inc'
 
        REG_IDR0                = 0x00
        REG_MAR0                = 0x08 ; multicast filter register 0
        REG_MAR4                = 0x0c ; multicast filter register 4
        REG_TSD0                = 0x10 ; transmit status of descriptor
        REG_TSAD0               = 0x20 ; transmit start address of descriptor
        REG_RBSTART             = 0x30 ; RxBuffer start address
        REG_COMMAND             = 0x37 ; command register
        REG_CAPR                = 0x38 ; current address of packet read (word) R/W
        REG_IMR                 = 0x3c ; interrupt mask register
        REG_ISR                 = 0x3e ; interrupt status register
        REG_TXCONFIG            = 0x40 ; transmit configuration register
        REG_RXCONFIG            = 0x44 ; receive configuration register 0
        REG_MPC                 = 0x4c ; missed packet counter
        REG_9346CR              = 0x50 ; serial eeprom 93C46 command register
        REG_CONFIG1             = 0x52 ; configuration register 1
        REG_MSR                 = 0x58
        REG_CONFIG4             = 0x5a ; configuration register 4
        REG_HLTCLK              = 0x5b ; undocumented halt clock register
        REG_BMCR                = 0x62 ; basic mode control register
        REG_ANAR                = 0x66 ; auto negotiation advertisement register
        REG_9346CR_WE           = 11b shl 6
 
        BIT_RUNT                = 4 ; total packet length < 64 bytes
        BIT_LONG                = 3 ; total packet length > 4k
        BIT_CRC                 = 2 ; crc error occured
        BIT_FAE                 = 1 ; frame alignment error occured
        BIT_ROK                 = 0 ; received packet is ok
 
        BIT_RST                 = 4 ; reset bit
        BIT_RE                  = 3 ; receiver enabled
        BIT_TE                  = 2 ; transmitter enabled
        BUFE                    = 1 ; rx buffer is empty, no packet stored
 
        BIT_ISR_TOK             = 2 ; transmit ok
        BIT_ISR_RER             = 1 ; receive error interrupt
        BIT_ISR_ROK             = 0 ; receive ok
 
        BIT_TX_MXDMA            = 8 ; Max DMA burst size per Tx DMA burst
        BIT_TXRR                = 4 ; Tx Retry count 16+(TXRR*16)
 
        BIT_RXFTH               = 13 ; Rx fifo threshold
        BIT_RBLEN               = 11 ; Ring buffer length indicator
        BIT_RX_MXDMA            = 8 ; Max DMA burst size per Rx DMA burst
        BIT_NOWRAP              = 7 ; transfered data wrapping
        BIT_9356SEL             = 6 ; eeprom selector 9346/9356
        BIT_AER                 = 5 ; accept error packets
        BIT_AR                  = 4 ; accept runt packets
        BIT_AB                  = 3 ; accept broadcast packets
        BIT_AM                  = 2 ; accept multicast packets
        BIT_APM                 = 1 ; accept physical match packets
        BIT_AAP                 = 0 ; accept all packets
 
        BIT_93C46_EEM1          = 7 ; RTL8139 eeprom operating mode1
        BIT_93C46_EEM0          = 6 ; RTL8139 eeprom operating mode0
        BIT_93C46_EECS          = 3 ; chip select
        BIT_93C46_EESK          = 2 ; serial data clock
        BIT_93C46_EEDI          = 1 ; serial data input
        BIT_93C46_EEDO          = 0 ; serial data output
 
        BIT_LWACT               = 4 ; see REG_CONFIG1
        BIT_SLEEP               = 1 ; sleep bit at older chips
        BIT_PWRDWN              = 0 ; power down bit at older chips
        BIT_PMEn                = 0 ; power management enabled
 
        BIT_LWPTN               = 2 ; see REG_CONFIG4
 
        BIT_ERTXTH              = 16 ; early TX threshold
        BIT_TOK                 = 15 ; transmit ok
        BIT_OWN                 = 13 ; tx DMA operation is completed
 
        BIT_ANE                 = 12 ; auto negotiation enable
 
        BIT_TXFD                = 8 ; 100base-T full duplex
        BIT_TX                  = 7 ; 100base-T
        BIT_10FD                = 6 ; 10base-T full duplex
        BIT_10                  = 5 ; 10base-T
        BIT_SELECTOR            = 0 ; binary encoded selector CSMA/CD=00001
 
        BIT_IFG1                = 25
        BIT_IFG0                = 24
 
        RX_CONFIG               = (RBLEN shl BIT_RBLEN) or \
                                  (RX_MXDMA shl BIT_RX_MXDMA) or \
                                  (1 shl BIT_NOWRAP) or \
                                  (RXFTH shl BIT_RXFTH) or\
                                  (1 shl BIT_AB) or \                   ; Accept broadcast packets
                                  (1 shl BIT_APM) or \                  ; Accept physical match packets
                                  (1 shl BIT_AER) or \                  ; Accept error packets
                                  (1 shl BIT_AR) or \                   ; Accept Runt packets (smaller then 64 bytes)
                                  (1 shl BIT_AM)                        ; Accept multicast packets
 
        RX_BUFFER_SIZE          = (8192 shl RBLEN);+16+1500
        NUM_TX_DESC             = 4                                     ; not user selectable
 
        EE_93C46_REG_ETH_ID     = 7 ; MAC offset
        EE_93C46_READ_CMD       = (6 shl 6) ; 110b + 6bit address
        EE_93C56_READ_CMD       = (6 shl 8) ; 110b + 8bit address
        EE_93C46_CMD_LENGTH     = 9  ; start bit + cmd + 6bit address
        EE_93C56_CMD_LENGTH     = 11 ; start bit + cmd + 8bit ddress
 
        VER_RTL8139             = 1100000b
        VER_RTL8139A            = 1110000b
        VER_RTL8139AG           = 1110100b
        VER_RTL8139B            = 1111000b
        VER_RTL8130             = VER_RTL8139B
        VER_RTL8139C            = 1110100b
        VER_RTL8100             = 1111010b
        VER_RTL8100B            = 1110101b
        VER_RTL8139D            = VER_RTL8100B
        VER_RTL8139CP           = 1110110b
        VER_RTL8101             = 1110111b
 
        IDX_RTL8139             = 0
        IDX_RTL8139A            = 1
        IDX_RTL8139B            = 2
        IDX_RTL8139C            = 3
        IDX_RTL8100             = 4
        IDX_RTL8139D            = 5
        IDX_RTL8139D            = 6
        IDX_RTL8101             = 7
 
        ISR_SERR                = 1 shl 15
        ISR_TIMEOUT             = 1 shl 14
        ISR_LENCHG              = 1 shl 13
        ISR_FIFOOVW             = 1 shl 6
        ISR_PUN                 = 1 shl 5
        ISR_RXOVW               = 1 shl 4
        ISR_TER                 = 1 shl 3
        ISR_TOK                 = 1 shl 2
        ISR_RER                 = 1 shl 1
        ISR_ROK                 = 1 shl 0
 
        INTERRUPT_MASK          = ISR_ROK or \
                                  ISR_RER or \
                                  ISR_TOK or \
                                  ISR_TER or \
                                  ISR_RXOVW or \
                                  ISR_PUN or \
                                  ISR_FIFOOVW or \
                                  ISR_LENCHG or \
                                  ISR_TIMEOUT or \
                                  ISR_SERR
 
        TSR_OWN                 = 1 shl 13
        TSR_TUN                 = 1 shl 14
        TSR_TOK                 = 1 shl 15
 
        TSR_CDH                 = 1 shl 28
        TSR_OWC                 = 1 shl 29
        TSR_TABT                = 1 shl 30
        TSR_CRS                 = 1 shl 31
 
 
struct  device          ETH_DEVICE
 
        io_addr         dd ?
        pci_bus         dd ?
        pci_dev         dd ?
        irq_line        db ?
                        rb 3    ; align 4
 
        rx_buffer       dd ?
        rx_data_offset  dd ?
        curr_tx_desc    db ?
        hw_ver_id       db ?
                        rb 2    ; align 4
 
        TX_DESC         rd NUM_TX_DESC
 
ends
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc START             ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc START c, reason:dword, cmdline:dword
 
        cmp     [reason], DRV_ENTRY
        jne     .fail
 
        DEBUGF  2,"Loading driver\n"
        invoke  RegService, my_service, service_proc
        ret
 
  .fail:
        xor     eax, eax
        ret
 
endp
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc SERVICE_PROC      ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc service_proc stdcall, ioctl:dword
 
        mov     edx, [ioctl]
        mov     eax, [edx + IOCTL.io_code]
 
;------------------------------------------------------
 
        cmp     eax, 0 ;SRV_GETVERSION
        jne     @F
 
        cmp     [edx + IOCTL.out_size], 4
        jb      .fail
        mov     eax, [edx + IOCTL.output]
        mov     [eax], dword API_VERSION
 
        xor     eax, eax
        ret
 
;------------------------------------------------------
  @@:
        cmp     eax, 1 ;SRV_HOOK
        jne     .fail
 
        cmp     [edx + IOCTL.inp_size], 3               ; Data input must be at least 3 bytes
        jb      .fail
 
        mov     eax, [edx + IOCTL.input]
        cmp     byte [eax], 1                           ; 1 means device number and bus number (pci) are given
        jne     .fail                                   ; other types arent supported for this card yet
 
; check if the device is already listed
 
        mov     esi, device_list
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .firstdevice
 
        mov     ax, [eax+1]                             ; get the pci bus and device numbers
  .nextdevice:
        mov     ebx, [esi]
        cmp     al, byte[ebx + device.pci_bus]
        jne     @f
        cmp     ah, byte[ebx + device.pci_dev]
        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
       @@:
        add     esi, 4
        loop    .nextdevice
 
 
; This device doesnt have its own eth_device structure yet, lets create one
  .firstdevice:
        cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
        jae     .fail
 
        allocate_and_clear ebx, sizeof.device, .fail      ; Allocate the buffer for device structure
 
; Fill in the direct call addresses into the struct
 
        mov     [ebx + device.reset], reset
        mov     [ebx + device.transmit], transmit
        mov     [ebx + device.unload], unload
        mov     [ebx + device.name], my_service
 
; save the pci bus and device numbers
 
        mov     eax, [edx + IOCTL.input]
        movzx   ecx, byte[eax+1]
        mov     [ebx + device.pci_bus], ecx
        movzx   ecx, byte[eax+2]
        mov     [ebx + device.pci_dev], ecx
 
; Now, it's time to find the base io addres of the PCI device
 
        stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]
        mov     [ebx + device.io_addr], eax
 
; We've found the io address, find IRQ now
 
        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
        mov     [ebx + device.irq_line], al
 
        DEBUGF  1, "Hooking into device, dev:%x, bus:%x, irq:%x, I/O addr:%x\n",\
        [ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4
 
; Allocate the receive buffer
 
        invoke  CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW
        test    eax, eax
        jz      .err
        mov     [ebx + device.rx_buffer], eax
 
; Ok, the eth_device structure is ready, let's probe the device
 
        call    probe                                                   ; this function will output in eax
        test    eax, eax
        jnz     .err                                                    ; If an error occured, exit
 
        mov     eax, [devices]                                          ; Add the device structure to our device list
        mov     [device_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
        inc     [devices]                                               ;
 
        call    reset
        test    eax, eax
        jnz     .destroy
 
        mov     [ebx + device.type], NET_TYPE_ETH
        invoke  NetRegDev
 
        cmp     eax, -1
        je      .destroy
 
        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"
        invoke  NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx
                                                                        ; into a device number in edi
        mov     eax, edi                                                ; Application wants it in eax instead
        DEBUGF  1, "Kernel says: %u\n", eax
        ret
 
; If an error occured, remove all allocated data and exit (returning -1 in eax)
 
  .destroy:
        ; todo: unregister device from device_list
        ; todo: reset device into virgin state
 
  .err:
        DEBUGF  2, "Error, removing all data !\n"
        invoke  KernelFree, [ebx + device.rx_buffer]
        invoke  KernelFree, ebx
 
  .fail:
        or      eax, -1
        ret
 
;------------------------------------------------------
endp
 
 
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
;;                                                                        ;;
;;        Actual Hardware dependent code starts here                      ;;
;;                                                                        ;;
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 
align 4
unload:
        ; TODO: (in this particular order)
        ;
        ; - Stop the device
        ; - Detach int handler
        ; - Remove device from local list (RTL8139_LIST)
        ; - call unregister function in kernel
        ; - Remove all allocated structures and buffers the card used
 
        or      eax, -1
 
ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;  probe: enables the device (if it really is RTL8139)
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
probe:
        DEBUGF  1, "Probing\n"
 
; Make the device a bus master
        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
        or      al, PCI_CMD_MASTER
        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
 
; get chip version
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_TXCONFIG + 2
        in      ax, dx
        shr     ah, 2
        shr     ax, 6
        and     al, 01111111b
 
; now find it in our array
        mov     ecx, HW_VER_ARRAY_SIZE-1
  .chip_ver_loop:
        cmp     al, [hw_ver_array + ecx]
        je      .chip_ver_found
        dec     ecx
        jns     .chip_ver_loop
  .unknown:
        mov     ecx, 8
  .chip_ver_found:
        cmp     ecx, 8
        ja      .unknown
 
        mov     [ebx + device.hw_ver_id], cl
 
        mov     ecx, [crosslist+ecx*4]
        mov     [ebx + device.name], ecx
 
        DEBUGF  1, "Chip version: %s\n", ecx
 
; wake up the chip
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_HLTCLK
        mov     al, 'R'         ; run the clock
        out     dx, al
 
; unlock config and BMCR registers
        set_io  [ebx + device.io_addr], REG_9346CR
        mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
        out     dx, al
 
; enable power management
        set_io  [ebx + device.io_addr], REG_CONFIG1
        in      al, dx
        cmp     [ebx + device.hw_ver_id], IDX_RTL8139B
        jae     .new_chip
; wake up older chips
        and     al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
        out     dx, al
        jmp     .finish_wake_up
 
; set LWAKE pin to active high (default value).
; it is for Wake-On-LAN functionality of some motherboards.
; this signal is used to inform the motherboard to execute a wake-up process.
; only at newer chips.
  .new_chip:
        or      al, (1 shl BIT_PMEn)
        and     al, not (1 shl BIT_LWACT)
        out     dx, al
 
        set_io  [ebx + device.io_addr], REG_CONFIG4
        in      al, dx
        and     al, not (1 shl BIT_LWPTN)
        out     dx, al
 
; lock config and BMCR registers
  .finish_wake_up:
        xor     al, al
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_9346CR
        out     dx, al
        DEBUGF  1, "probing done!\n"
 
        xor     eax, eax
 
        ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;   reset: Set up all registers and descriptors, clear some values
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
reset:
        DEBUGF  1, "Reset\n"
 
; attach int handler
        movzx   eax, [ebx + device.irq_line]
        DEBUGF  1, "Attaching int handler to irq %x\n", eax:1
        invoke  AttachIntHandler, eax, int_handler, ebx
        test    eax, eax
        jnz     @f
        DEBUGF  2, "Could not attach int handler!\n"
        or      eax, -1
        ret
       @@:
 
; reset chip
        DEBUGF  1, "Resetting chip\n"
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_COMMAND
        mov     al, 1 shl BIT_RST
        out     dx, al
        mov     cx, 1000                ; wait no longer for the reset
  .wait_for_reset:
        in      al, dx
        test    al, 1 shl BIT_RST
        jz      .reset_completed        ; RST remains 1 during reset
        dec     cx
        jns     .wait_for_reset
        DEBUGF  2, "Reset timeout!\n"
  .reset_completed:
 
; Read MAC address
        call    read_mac
 
; unlock config and BMCR registers
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_9346CR
        mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
        out     dx, al
 
; initialize multicast registers (no filtering)
        mov     eax, 0xffffffff
        set_io  [ebx + device.io_addr], REG_MAR0
        out     dx, eax
        set_io  [ebx + device.io_addr], REG_MAR4
        out     dx, eax
 
; enable Rx/Tx
        mov     al, (1 shl BIT_RE) or (1 shl BIT_TE)
        set_io  [ebx + device.io_addr], REG_COMMAND
        out     dx, al
 
; Rxbuffer size, unlimited dma burst, no wrapping, no rx threshold
; accept broadcast packets, accept physical match packets
        mov     eax, RX_CONFIG
        set_io  [ebx + device.io_addr], REG_RXCONFIG
        out     dx, eax
 
; 1024 bytes DMA burst, total retries = 16 + 8 * 16 = 144
        mov     eax, (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0
        set_io  [ebx + device.io_addr], REG_TXCONFIG
        out     dx, eax
 
; enable auto negotiation
        set_io  [ebx + device.io_addr], REG_BMCR
        in      ax, dx
        or      ax, (1 shl BIT_ANE)
        out     dx, ax
 
; set auto negotiation advertisement
        set_io  [ebx + device.io_addr], REG_ANAR
        in      ax, dx
        or      ax, (1 shl BIT_SELECTOR) or (1 shl BIT_10) or (1 shl BIT_10FD) or (1 shl BIT_TX) or (1 shl BIT_TXFD)
        out     dx, ax
 
; lock config and BMCR registers
        xor     eax, eax
        set_io  [ebx + device.io_addr], REG_9346CR
        out     dx, al
 
; init RX/TX pointers
        mov     [ebx + device.rx_data_offset], eax
        mov     [ebx + device.curr_tx_desc], al
;        set_io  [ebx + device.io_addr], REG_CAPR
;        out     dx, ax
 
; clear packet/byte counters
        lea     edi, [ebx + device.bytes_tx]
        mov     ecx, 6
        rep     stosd
 
; clear missing packet counter
        set_io  [ebx + device.io_addr], REG_MPC
        out     dx, eax
 
; set RxBuffer address, init RX buffer offset
        mov     eax, [ebx + device.rx_buffer]
        mov     dword[eax], 0                   ; clear receive flags for first packet (really needed??)
        DEBUGF  1, "RX buffer virtual addr=0x%x\n", eax
        invoke  GetPhysAddr
        DEBUGF  1, "RX buffer physical addr=0x%x\n", eax
        set_io  [ebx + device.io_addr], REG_RBSTART
        out     dx, eax
 
; enable interrupts
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_IMR
        mov     ax, INTERRUPT_MASK
        out     dx, ax
 
; Set the mtu, kernel will be able to send now
        mov     [ebx + device.mtu], 1514
 
        call    cable
 
; Indicate that we have successfully reset the card
        xor     eax, eax
        ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                         ;;
;; Transmit                                ;;
;;                                         ;;
;; In: buffer pointer in [esp+4]           ;;
;;     size of buffer in [esp+8]           ;;
;;     pointer to device structure in ebx  ;;
;;                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc transmit stdcall bufferptr, buffersize
 
        pushf
        cli
 
        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
        mov     eax, [bufferptr]
        DEBUGF  1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
        [eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
        [eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
        [eax+13]:2,[eax+12]:2
 
        cmp     [buffersize], 1514
        ja      .fail
        cmp     [buffersize], 60
        jb      .fail
 
; check if we own the current discriptor
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_TSD0
        movzx   ecx, [ebx + device.curr_tx_desc]
        shl     ecx, 2
        add     edx, ecx
        in      eax, dx
        test    eax, (1 shl BIT_OWN)
        jz      .wait_to_send
 
  .send_packet:
; get next descriptor
        inc     [ebx + device.curr_tx_desc]
        and     [ebx + device.curr_tx_desc], NUM_TX_DESC-1
 
; Update stats
        inc     [ebx + device.packets_tx]
        mov     eax, [buffersize]
        add     dword [ebx + device.bytes_tx], eax
        adc     dword [ebx + device.bytes_tx+4], 0
 
; Set the buffer address
        set_io  [ebx + device.io_addr], REG_TSAD0
        mov     eax, [bufferptr]
        mov     [ebx + device.TX_DESC+ecx], eax
        invoke  GetPhysAddr
        out     dx, eax
 
; And the size of the buffer
        set_io  [ebx + device.io_addr], REG_TSD0
        mov     eax, [buffersize]
        or      eax, (ERTXTH shl BIT_ERTXTH)    ; Early threshold
        out     dx, eax
 
        DEBUGF  1, "Packet Sent!\n"
        popf
        xor     eax, eax
        ret
 
  .wait_to_send:
        DEBUGF  1, "Waiting for timeout\n"
 
        push    edx
        mov     esi, 30
        invoke  Sleep
        pop     edx
 
        in      ax, dx
        test    ax, (1 shl BIT_OWN)
        jnz     .send_packet
 
        pusha
        call    reset                            ; if chip hung, reset it
        popa
 
        jmp     .send_packet
 
  .fail:
        DEBUGF  2, "transmit failed!\n"
        invoke  KernelFree, [bufferptr]
        popf
        or      eax, -1
        ret
 
endp
 
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; Interrupt handler ;;
;;                   ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
int_handler:
 
        push    ebx esi edi
 
        DEBUGF  1, "INT\n"
 
; find pointer of device wich made IRQ occur
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .nothing
        mov     esi, device_list
  .nextdevice:
        mov     ebx, [esi]
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_ISR
        in      ax, dx                          ; Get interrupt status
        out     dx, ax                          ; send it back to ACK
        test    ax, ax
        jnz     .got_it
  .continue:
        add     esi, 4
        dec     ecx
        jnz     .nextdevice
  .nothing:
        pop     edi esi ebx
        xor     eax, eax
 
        ret                                     ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
 
  .got_it:
 
        DEBUGF  1, "Device: %x Status: %x\n", ebx, ax
 
;----------------------------------------------------
; Received packet ok?
 
        test    ax, ISR_ROK
        jz      @f
        push    ax
 
  .receive:
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_COMMAND
        in      al, dx
        test    al, BUFE                        ; test if RX buffer is empty
        jnz     .finish
 
        DEBUGF  1, "RX:\n"
 
        mov     eax, [ebx + device.rx_buffer]
        add     eax, [ebx + device.rx_data_offset]
        test    byte [eax], (1 shl BIT_ROK)     ; check if packet is ok
        jz      .reset_rx
 
; packet is ok, copy it
        movzx   ecx, word [eax+2]               ; packet length
        sub     cx, 4                           ; don't copy CRC
 
; Update stats
        add     dword [ebx + device.bytes_rx], ecx
        adc     dword [ebx + device.bytes_rx + 4], 0
        inc     [ebx + device.packets_rx]
 
        DEBUGF  1, "Received %u bytes\n", ecx
 
        push    ebx eax ecx
        invoke  KernelAlloc, ecx                ; Allocate a buffer to put packet into
        pop     ecx
        test    eax, eax                        ; Test if we allocated succesfully
        jz      .abort
 
        mov     edi, eax                        ; Where we will copy too
 
        mov     esi, [esp]                      ; The buffer we will copy from
        add     esi, 4                          ; Dont copy CRC
 
        push    dword .abort                    ; Kernel will return to this address after EthReceiver
        push    ecx edi                         ; Save buffer pointer and size, to pass to kernel
 
  .copy:
        shr     ecx, 1
        jnc     .nb
        movsb
  .nb:
        shr     ecx, 1
        jnc     .nw
        movsw
  .nw:
        jz      .nd
        rep     movsd
  .nd:
 
        jmp     [Eth_input]                     ; Send it to kernel
 
  .abort:
        pop     eax ebx
                                                ; update eth_data_start_offset
        movzx   eax, word [eax+2]               ; packet length
        add     eax, [ebx + device.rx_data_offset]
        add     eax, 4+3                        ; packet header is 4 bytes long + dword alignment
        and     eax, not 3                      ; dword alignment
 
        cmp     eax, RX_BUFFER_SIZE
        jb      .no_wrap
        DEBUGF  1, "Wrapping\n"
        sub     eax, RX_BUFFER_SIZE
  .no_wrap:
        mov     [ebx + device.rx_data_offset], eax
        DEBUGF  1, "New RX ptr: %d\n", eax
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_CAPR                        ; update 'Current Address of Packet Read register'
        sub     eax, 0x10                       ; value 0x10 is a constant for CAPR
        out     dx, ax
 
        jmp     .receive                        ; check for multiple packets
 
  .reset_rx:
        test    byte [eax], (1 shl BIT_CRC)
        jz      .no_crc_error
        DEBUGF  2, "RX: CRC error!\n"
 
  .no_crc_error:
        test    byte [eax], (1 shl BIT_FAE)
        jz      .no_fae_error
        DEBUGF  2, "RX: Frame alignment error!\n"
 
  .no_fae_error:
        DEBUGF  1, "Reset RX\n"
        in      al, dx                          ; read command register
        push    ax
        and     al, not (1 shl BIT_RE)          ; Clear the RE bit
        out     dx, al
        pop     ax
        out     dx, al                          ; write original command back
 
        add     edx, REG_RXCONFIG - REG_COMMAND         ; Restore RX configuration
        mov     ax, RX_CONFIG
        out     dx, ax
 
  .finish:
        pop     ax
 
;----------------------------------------------------
; Transmit ok / Transmit error
  @@:
        test    ax, ISR_TOK + ISR_TER
        jz      @f
 
        DEBUGF  1, "Transmit done!\n"
 
        push    ax
        mov     ecx, (NUM_TX_DESC-1)*4
  .txdescloop:
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_TSD0
        add     edx, ecx
        in      eax, dx
 
        test    eax, TSR_OWN                    ; DMA operation completed
        jz      .notthisone
 
        cmp     [ebx + device.TX_DESC+ecx], 0
        je      .notthisone
 
        DEBUGF  1, "TSD: 0x%x\n", eax
 
        test    eax, TSR_TUN
        jz      .no_bun
        DEBUGF  2, "TX: FIFO Buffer underrun!\n"
 
  .no_bun:
        test    eax, TSR_OWC
        jz      .no_owc
        DEBUGF  2, "TX: OWC!\n"
 
  .no_owc:
        test    eax, TSR_TABT
        jz      .no_tabt
        DEBUGF  2, "TX: TABT!\n"
 
  .no_tabt:
        test    eax, TSR_CRS
        jz      .no_csl
        DEBUGF  2, "TX: Carrier Sense Lost!\n"
 
  .no_csl:
        test    eax, TSR_TOK
        jz      .no_tok
        DEBUGF  1, "TX: Transmit OK!\n"
 
  .no_tok:
        DEBUGF  1, "free transmit buffer 0x%x\n", [ebx + device.TX_DESC+ecx]:8
        push    ecx ebx
        invoke  KernelFree, [ebx + device.TX_DESC+ecx]
        pop     ebx ecx
        mov     [ebx + device.TX_DESC+ecx], 0
 
  .notthisone:
        sub     ecx, 4
        jae     .txdescloop
        pop     ax
 
;----------------------------------------------------
; Rx buffer overflow ?
  @@:
        test    ax, ISR_RXOVW
        jz      @f
 
        push    ax
        DEBUGF  2, "RX:buffer overflow!\n"
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_ISR
        mov     ax, ISR_FIFOOVW or ISR_RXOVW
        out     dx, ax
        pop     ax
 
;----------------------------------------------------
; Packet underrun?
  @@:
        test    ax, ISR_PUN
        jz      @f
 
        DEBUGF  1, "Packet underrun or link changed!\n"
 
        call    cable
 
;----------------------------------------------------
; Receive FIFO overflow ?
  @@:
        test    ax, ISR_FIFOOVW
        jz      @f
 
        push    ax
        DEBUGF  2, "RX fifo overflow!\n"
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_ISR
        mov     ax, ISR_FIFOOVW or ISR_RXOVW
        out     dx, ax
        pop     ax
 
;----------------------------------------------------
; cable length changed ?
  @@:
        test    ax, ISR_LENCHG
        jz      .fail
 
        DEBUGF  2, "Cable length changed!\n"
 
        call    cable
 
  .fail:
        pop     edi esi ebx
        xor     eax, eax
        inc     eax
 
        ret
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;
;;                     ;;
;; Update Cable status ;;
;;                     ;;
;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
cable:
        DEBUGF  1, "Checking link status:\n"
 
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_MSR
        in      al, dx
 
        test    al, 1 shl 2             ; 0 = link ok 1 = link fail
        jnz     .notconnected
 
        test    al, 1 shl 3             ; 0 = 100 Mbps 1 = 10 Mbps
        jnz     .10mbps
 
  .100mbps:
        mov     [ebx + device.state], ETH_LINK_100M
        invoke  NetLinkChanged
        DEBUGF  2, "link changed to 100 mbit\n"
 
        ret
 
  .10mbps:
        mov     [ebx + device.state], ETH_LINK_10M
        invoke  NetLinkChanged
        DEBUGF  2, "link changed to 10 mbit\n"
 
        ret
 
  .notconnected:
        mov     [ebx + device.state], ETH_LINK_DOWN
        invoke  NetLinkChanged
        DEBUGF  2, "no link\n"
 
        ret
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; Write MAC address ;;
;;                   ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
write_mac:      ; in: mac pushed onto stack (as 3 words)
 
        DEBUGF  1, "Writing MAC\n"
 
; disable all in command registers
        set_io  [ebx + device.io_addr], 0
        set_io  [ebx + device.io_addr], REG_9346CR
        xor     eax, eax
        out     dx, al
 
        set_io  [ebx + device.io_addr], REG_IMR
        xor     eax, eax
        out     dx, ax
 
        set_io  [ebx + device.io_addr], REG_ISR
        mov     eax, -1
        out     dx, ax
 
; enable writing
        set_io  [ebx + device.io_addr], REG_9346CR
        mov     eax, REG_9346CR_WE
        out     dx, al
 
 ; write the mac ...
        set_io  [ebx + device.io_addr], REG_IDR0
        pop     eax
        out     dx, eax
 
        set_io  [ebx + device.io_addr], REG_IDR0+4
        xor     eax, eax
        pop     ax
        out     dx, eax
 
; disable writing
        set_io  [ebx + device.io_addr], REG_9346CR
        xor     eax, eax
        out     dx, al
 
        DEBUGF  1, "MAC write ok!\n"
 
; Notice this procedure does not ret, but continues to read_mac instead.
 
 
;;;;;;;;;;;;;;;;;;;;;;
;;                  ;;
;; Read MAC address ;;
;;                  ;;
;;;;;;;;;;;;;;;;;;;;;;
 
read_mac:
        DEBUGF  1, "Reading MAC:\n"
 
        set_io  [ebx + device.io_addr], 0
        lea     edi, [ebx + device.mac]
        in      eax, dx
        stosd
        add     edx, 4
        in      ax, dx
        stosw
 
        DEBUGF  1, "%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2
 
        ret
 
 
; End of code
 
data fixups
end data
 
include '../peimport.inc'
 
my_service      db 'RTL8139',0                    ; max 16 chars include zero
 
device_1        db 'Realtek 8139',0
device_2        db 'Realtek 8139A',0
device_3        db 'Realtek 8139B',0
device_4        db 'Realtek 8139C',0
device_5        db 'Realtek 8100',0
device_6        db 'Realtek 8139D',0
device_7        db 'Realtek 8139CP',0
device_8        db 'Realtek 8101',0
device_unknown  db 'Unknown RTL8139 clone', 0
 
crosslist:
        dd device_1
        dd device_2
        dd device_3
        dd device_4
        dd device_5
        dd device_6
        dd device_7
        dd device_8
        dd device_unknown
 
hw_ver_array:                    ; This array is used by the probe routine to find out wich version of the RTL8139 we are working with
        db VER_RTL8139
        db VER_RTL8139A
        db VER_RTL8139B
        db VER_RTL8139C
        db VER_RTL8100
        db VER_RTL8139D
        db VER_RTL8139CP
        db VER_RTL8101
        db 0
 
HW_VER_ARRAY_SIZE = $-hw_ver_array
 
include_debug_strings                           ; All data wich FDO uses will be included here
 
align 4
devices         dd 0
device_list     rd MAX_DEVICES                   ; This list contains all pointers to device structures the driver is handling

Rev 5127	Rev 5363
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; Realtek 8139 driver for KolibriOS ;;	6	;; Realtek 8139 driver for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; based on RTL8139.asm driver for menuetos ;;	8	;; based on RTL8139.asm driver for menuetos ;;
9	;; and realtek8139.asm for SolarOS by Eugen Brasoveanu ;;	9	;; and realtek8139.asm for SolarOS by Eugen Brasoveanu ;;
10	;; ;;	10	;; ;;
11	;; Written by hidnplayr@kolibrios.org ;;	11	;; Written by hidnplayr@kolibrios.org ;;
12	;; ;;	12	;; ;;
13	;; GNU GENERAL PUBLIC LICENSE ;;	13	;; GNU GENERAL PUBLIC LICENSE ;;
14	;; Version 2, June 1991 ;;	14	;; Version 2, June 1991 ;;
15	;; ;;	15	;; ;;
16	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	16	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
17		17
18	format PE DLL native	18	format PE DLL native
19	entry START	19	entry START
20		20
21	CURRENT_API = 0x0200	21	CURRENT_API = 0x0200
22	COMPATIBLE_API = 0x0100	22	COMPATIBLE_API = 0x0100
23	API_VERSION = (COMPATIBLE_API shl 16) + CURRENT_API	23	API_VERSION = (COMPATIBLE_API shl 16) + CURRENT_API
24		24
25	MAX_DEVICES = 16	25	MAX_DEVICES = 16
26		26
27	RBLEN = 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k	27	RBLEN = 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k
28		28
29	TXRR = 8 ; total retries = 16+(TXRR*16)	29	TXRR = 8 ; total retries = 16+(TXRR*16)
30	TX_MXDMA = 6 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=2048	30	TX_MXDMA = 6 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=2048
31	ERTXTH = 8 ; in unit of 32 bytes e.g:(8*32)=256	31	ERTXTH = 8 ; in unit of 32 bytes e.g:(8*32)=256
32	RX_MXDMA = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=unlimited	32	RX_MXDMA = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=unlimited
33	RXFTH = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=no threshold	33	RXFTH = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=no threshold
34		34
35	__DEBUG__ = 1	35	__DEBUG__ = 1
36	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only	36	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only
37		37
38	section '.flat' readable writable executable	38	section '.flat' readable writable executable
39		39
40	include '../proc32.inc'	40	include '../proc32.inc'
41	include '../struct.inc'	41	include '../struct.inc'
42	include '../macros.inc'	42	include '../macros.inc'
43	include '../fdo.inc'	43	include '../fdo.inc'
44	include '../netdrv.inc'	44	include '../netdrv.inc'
45		45
46	REG_IDR0 = 0x00	46	REG_IDR0 = 0x00
47	REG_MAR0 = 0x08 ; multicast filter register 0	47	REG_MAR0 = 0x08 ; multicast filter register 0
48	REG_MAR4 = 0x0c ; multicast filter register 4	48	REG_MAR4 = 0x0c ; multicast filter register 4
49	REG_TSD0 = 0x10 ; transmit status of descriptor	49	REG_TSD0 = 0x10 ; transmit status of descriptor
50	REG_TSAD0 = 0x20 ; transmit start address of descriptor	50	REG_TSAD0 = 0x20 ; transmit start address of descriptor
51	REG_RBSTART = 0x30 ; RxBuffer start address	51	REG_RBSTART = 0x30 ; RxBuffer start address
52	REG_COMMAND = 0x37 ; command register	52	REG_COMMAND = 0x37 ; command register
53	REG_CAPR = 0x38 ; current address of packet read (word) R/W	53	REG_CAPR = 0x38 ; current address of packet read (word) R/W
54	REG_IMR = 0x3c ; interrupt mask register	54	REG_IMR = 0x3c ; interrupt mask register
55	REG_ISR = 0x3e ; interrupt status register	55	REG_ISR = 0x3e ; interrupt status register
56	REG_TXCONFIG = 0x40 ; transmit configuration register	56	REG_TXCONFIG = 0x40 ; transmit configuration register
57	REG_RXCONFIG = 0x44 ; receive configuration register 0	57	REG_RXCONFIG = 0x44 ; receive configuration register 0
58	REG_MPC = 0x4c ; missed packet counter	58	REG_MPC = 0x4c ; missed packet counter
59	REG_9346CR = 0x50 ; serial eeprom 93C46 command register	59	REG_9346CR = 0x50 ; serial eeprom 93C46 command register
60	REG_CONFIG1 = 0x52 ; configuration register 1	60	REG_CONFIG1 = 0x52 ; configuration register 1
61	REG_MSR = 0x58	61	REG_MSR = 0x58
62	REG_CONFIG4 = 0x5a ; configuration register 4	62	REG_CONFIG4 = 0x5a ; configuration register 4
63	REG_HLTCLK = 0x5b ; undocumented halt clock register	63	REG_HLTCLK = 0x5b ; undocumented halt clock register
64	REG_BMCR = 0x62 ; basic mode control register	64	REG_BMCR = 0x62 ; basic mode control register
65	REG_ANAR = 0x66 ; auto negotiation advertisement register	65	REG_ANAR = 0x66 ; auto negotiation advertisement register
66	REG_9346CR_WE = 11b shl 6	66	REG_9346CR_WE = 11b shl 6
67		67
68	BIT_RUNT = 4 ; total packet length < 64 bytes	68	BIT_RUNT = 4 ; total packet length < 64 bytes
69	BIT_LONG = 3 ; total packet length > 4k	69	BIT_LONG = 3 ; total packet length > 4k
70	BIT_CRC = 2 ; crc error occured	70	BIT_CRC = 2 ; crc error occured
71	BIT_FAE = 1 ; frame alignment error occured	71	BIT_FAE = 1 ; frame alignment error occured
72	BIT_ROK = 0 ; received packet is ok	72	BIT_ROK = 0 ; received packet is ok
73		73
74	BIT_RST = 4 ; reset bit	74	BIT_RST = 4 ; reset bit
75	BIT_RE = 3 ; receiver enabled	75	BIT_RE = 3 ; receiver enabled
76	BIT_TE = 2 ; transmitter enabled	76	BIT_TE = 2 ; transmitter enabled
77	BUFE = 1 ; rx buffer is empty, no packet stored	77	BUFE = 1 ; rx buffer is empty, no packet stored
78		78
79	BIT_ISR_TOK = 2 ; transmit ok	79	BIT_ISR_TOK = 2 ; transmit ok
80	BIT_ISR_RER = 1 ; receive error interrupt	80	BIT_ISR_RER = 1 ; receive error interrupt
81	BIT_ISR_ROK = 0 ; receive ok	81	BIT_ISR_ROK = 0 ; receive ok
82		82
83	BIT_TX_MXDMA = 8 ; Max DMA burst size per Tx DMA burst	83	BIT_TX_MXDMA = 8 ; Max DMA burst size per Tx DMA burst
84	BIT_TXRR = 4 ; Tx Retry count 16+(TXRR*16)	84	BIT_TXRR = 4 ; Tx Retry count 16+(TXRR*16)
85		85
86	BIT_RXFTH = 13 ; Rx fifo threshold	86	BIT_RXFTH = 13 ; Rx fifo threshold
87	BIT_RBLEN = 11 ; Ring buffer length indicator	87	BIT_RBLEN = 11 ; Ring buffer length indicator
88	BIT_RX_MXDMA = 8 ; Max DMA burst size per Rx DMA burst	88	BIT_RX_MXDMA = 8 ; Max DMA burst size per Rx DMA burst
89	BIT_NOWRAP = 7 ; transfered data wrapping	89	BIT_NOWRAP = 7 ; transfered data wrapping
90	BIT_9356SEL = 6 ; eeprom selector 9346/9356	90	BIT_9356SEL = 6 ; eeprom selector 9346/9356
91	BIT_AER = 5 ; accept error packets	91	BIT_AER = 5 ; accept error packets
92	BIT_AR = 4 ; accept runt packets	92	BIT_AR = 4 ; accept runt packets
93	BIT_AB = 3 ; accept broadcast packets	93	BIT_AB = 3 ; accept broadcast packets
94	BIT_AM = 2 ; accept multicast packets	94	BIT_AM = 2 ; accept multicast packets
95	BIT_APM = 1 ; accept physical match packets	95	BIT_APM = 1 ; accept physical match packets
96	BIT_AAP = 0 ; accept all packets	96	BIT_AAP = 0 ; accept all packets
97		97
98	BIT_93C46_EEM1 = 7 ; RTL8139 eeprom operating mode1	98	BIT_93C46_EEM1 = 7 ; RTL8139 eeprom operating mode1
99	BIT_93C46_EEM0 = 6 ; RTL8139 eeprom operating mode0	99	BIT_93C46_EEM0 = 6 ; RTL8139 eeprom operating mode0
100	BIT_93C46_EECS = 3 ; chip select	100	BIT_93C46_EECS = 3 ; chip select
101	BIT_93C46_EESK = 2 ; serial data clock	101	BIT_93C46_EESK = 2 ; serial data clock
102	BIT_93C46_EEDI = 1 ; serial data input	102	BIT_93C46_EEDI = 1 ; serial data input
103	BIT_93C46_EEDO = 0 ; serial data output	103	BIT_93C46_EEDO = 0 ; serial data output
104		104
105	BIT_LWACT = 4 ; see REG_CONFIG1	105	BIT_LWACT = 4 ; see REG_CONFIG1
106	BIT_SLEEP = 1 ; sleep bit at older chips	106	BIT_SLEEP = 1 ; sleep bit at older chips
107	BIT_PWRDWN = 0 ; power down bit at older chips	107	BIT_PWRDWN = 0 ; power down bit at older chips
108	BIT_PMEn = 0 ; power management enabled	108	BIT_PMEn = 0 ; power management enabled
109		109
110	BIT_LWPTN = 2 ; see REG_CONFIG4	110	BIT_LWPTN = 2 ; see REG_CONFIG4
111		111
112	BIT_ERTXTH = 16 ; early TX threshold	112	BIT_ERTXTH = 16 ; early TX threshold
113	BIT_TOK = 15 ; transmit ok	113	BIT_TOK = 15 ; transmit ok
114	BIT_OWN = 13 ; tx DMA operation is completed	114	BIT_OWN = 13 ; tx DMA operation is completed
115		115
116	BIT_ANE = 12 ; auto negotiation enable	116	BIT_ANE = 12 ; auto negotiation enable
117		117
118	BIT_TXFD = 8 ; 100base-T full duplex	118	BIT_TXFD = 8 ; 100base-T full duplex
119	BIT_TX = 7 ; 100base-T	119	BIT_TX = 7 ; 100base-T
120	BIT_10FD = 6 ; 10base-T full duplex	120	BIT_10FD = 6 ; 10base-T full duplex
121	BIT_10 = 5 ; 10base-T	121	BIT_10 = 5 ; 10base-T
122	BIT_SELECTOR = 0 ; binary encoded selector CSMA/CD=00001	122	BIT_SELECTOR = 0 ; binary encoded selector CSMA/CD=00001
123		123
124	BIT_IFG1 = 25	124	BIT_IFG1 = 25
125	BIT_IFG0 = 24	125	BIT_IFG0 = 24
126		126
127	RX_CONFIG = (RBLEN shl BIT_RBLEN) or \	127	RX_CONFIG = (RBLEN shl BIT_RBLEN) or \
128	(RX_MXDMA shl BIT_RX_MXDMA) or \	128	(RX_MXDMA shl BIT_RX_MXDMA) or \
129	(1 shl BIT_NOWRAP) or \	129	(1 shl BIT_NOWRAP) or \
130	(RXFTH shl BIT_RXFTH) or\	130	(RXFTH shl BIT_RXFTH) or\
131	(1 shl BIT_AB) or \ ; Accept broadcast packets	131	(1 shl BIT_AB) or \ ; Accept broadcast packets
132	(1 shl BIT_APM) or \ ; Accept physical match packets	132	(1 shl BIT_APM) or \ ; Accept physical match packets
133	(1 shl BIT_AER) or \ ; Accept error packets	133	(1 shl BIT_AER) or \ ; Accept error packets
134	(1 shl BIT_AR) or \ ; Accept Runt packets (smaller then 64 bytes)	134	(1 shl BIT_AR) or \ ; Accept Runt packets (smaller then 64 bytes)
135	(1 shl BIT_AM) ; Accept multicast packets	135	(1 shl BIT_AM) ; Accept multicast packets
136		136
137	RX_BUFFER_SIZE = (8192 shl RBLEN);+16+1500	137	RX_BUFFER_SIZE = (8192 shl RBLEN);+16+1500
138	NUM_TX_DESC = 4 ; not user selectable	138	NUM_TX_DESC = 4 ; not user selectable
139		139
140	EE_93C46_REG_ETH_ID = 7 ; MAC offset	140	EE_93C46_REG_ETH_ID = 7 ; MAC offset
141	EE_93C46_READ_CMD = (6 shl 6) ; 110b + 6bit address	141	EE_93C46_READ_CMD = (6 shl 6) ; 110b + 6bit address
142	EE_93C56_READ_CMD = (6 shl 8) ; 110b + 8bit address	142	EE_93C56_READ_CMD = (6 shl 8) ; 110b + 8bit address
143	EE_93C46_CMD_LENGTH = 9 ; start bit + cmd + 6bit address	143	EE_93C46_CMD_LENGTH = 9 ; start bit + cmd + 6bit address
144	EE_93C56_CMD_LENGTH = 11 ; start bit + cmd + 8bit ddress	144	EE_93C56_CMD_LENGTH = 11 ; start bit + cmd + 8bit ddress
145		145
146	VER_RTL8139 = 1100000b	146	VER_RTL8139 = 1100000b
147	VER_RTL8139A = 1110000b	147	VER_RTL8139A = 1110000b
148	VER_RTL8139AG = 1110100b	148	VER_RTL8139AG = 1110100b
149	VER_RTL8139B = 1111000b	149	VER_RTL8139B = 1111000b
150	VER_RTL8130 = VER_RTL8139B	150	VER_RTL8130 = VER_RTL8139B
151	VER_RTL8139C = 1110100b	151	VER_RTL8139C = 1110100b
152	VER_RTL8100 = 1111010b	152	VER_RTL8100 = 1111010b
153	VER_RTL8100B = 1110101b	153	VER_RTL8100B = 1110101b
154	VER_RTL8139D = VER_RTL8100B	154	VER_RTL8139D = VER_RTL8100B
155	VER_RTL8139CP = 1110110b	155	VER_RTL8139CP = 1110110b
156	VER_RTL8101 = 1110111b	156	VER_RTL8101 = 1110111b
157		157
158	IDX_RTL8139 = 0	158	IDX_RTL8139 = 0
159	IDX_RTL8139A = 1	159	IDX_RTL8139A = 1
160	IDX_RTL8139B = 2	160	IDX_RTL8139B = 2
161	IDX_RTL8139C = 3	161	IDX_RTL8139C = 3
162	IDX_RTL8100 = 4	162	IDX_RTL8100 = 4
163	IDX_RTL8139D = 5	163	IDX_RTL8139D = 5
164	IDX_RTL8139D = 6	164	IDX_RTL8139D = 6
165	IDX_RTL8101 = 7	165	IDX_RTL8101 = 7
166		166
167	ISR_SERR = 1 shl 15	167	ISR_SERR = 1 shl 15
168	ISR_TIMEOUT = 1 shl 14	168	ISR_TIMEOUT = 1 shl 14
169	ISR_LENCHG = 1 shl 13	169	ISR_LENCHG = 1 shl 13
170	ISR_FIFOOVW = 1 shl 6	170	ISR_FIFOOVW = 1 shl 6
171	ISR_PUN = 1 shl 5	171	ISR_PUN = 1 shl 5
172	ISR_RXOVW = 1 shl 4	172	ISR_RXOVW = 1 shl 4
173	ISR_TER = 1 shl 3	173	ISR_TER = 1 shl 3
174	ISR_TOK = 1 shl 2	174	ISR_TOK = 1 shl 2
175	ISR_RER = 1 shl 1	175	ISR_RER = 1 shl 1
176	ISR_ROK = 1 shl 0	176	ISR_ROK = 1 shl 0
177		177
178	INTERRUPT_MASK = ISR_ROK or \	178	INTERRUPT_MASK = ISR_ROK or \
179	ISR_RER or \	179	ISR_RER or \
180	ISR_TOK or \	180	ISR_TOK or \
181	ISR_TER or \	181	ISR_TER or \
182	ISR_RXOVW or \	182	ISR_RXOVW or \
183	ISR_PUN or \	183	ISR_PUN or \
184	ISR_FIFOOVW or \	184	ISR_FIFOOVW or \
185	ISR_LENCHG or \	185	ISR_LENCHG or \
186	ISR_TIMEOUT or \	186	ISR_TIMEOUT or \
187	ISR_SERR	187	ISR_SERR
188		188
189	TSR_OWN = 1 shl 13	189	TSR_OWN = 1 shl 13
190	TSR_TUN = 1 shl 14	190	TSR_TUN = 1 shl 14
191	TSR_TOK = 1 shl 15	191	TSR_TOK = 1 shl 15
192		192
193	TSR_CDH = 1 shl 28	193	TSR_CDH = 1 shl 28
194	TSR_OWC = 1 shl 29	194	TSR_OWC = 1 shl 29
195	TSR_TABT = 1 shl 30	195	TSR_TABT = 1 shl 30
196	TSR_CRS = 1 shl 31	196	TSR_CRS = 1 shl 31
197		197
198		198
199	struct device ETH_DEVICE	199	struct device ETH_DEVICE
200		200
201	io_addr dd ?	201	io_addr dd ?
202	pci_bus dd ?	202	pci_bus dd ?
203	pci_dev dd ?	203	pci_dev dd ?
204	irq_line db ?	204	irq_line db ?
205	rb 3 ; align 4	205	rb 3 ; align 4
206		206
207	rx_buffer dd ?	207	rx_buffer dd ?
208	rx_data_offset dd ?	208	rx_data_offset dd ?
209	curr_tx_desc db ?	209	curr_tx_desc db ?
210	hw_ver_id db ?	210	hw_ver_id db ?
211	rb 2 ; align 4	211	rb 2 ; align 4
212		212
213	TX_DESC rd NUM_TX_DESC	213	TX_DESC rd NUM_TX_DESC
214		214
215	ends	215	ends
216		216
217		217
218	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	218	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
219	;; ;;	219	;; ;;
220	;; proc START ;;	220	;; proc START ;;
221	;; ;;	221	;; ;;
222	;; (standard driver proc) ;;	222	;; (standard driver proc) ;;
223	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	223	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
224		224
225	proc START c, reason:dword, cmdline:dword	225	proc START c, reason:dword, cmdline:dword
226		226
227	cmp [reason], DRV_ENTRY	227	cmp [reason], DRV_ENTRY
228	jne .fail	228	jne .fail
229		229
230	DEBUGF 2,"Loading driver\n"	230	DEBUGF 2,"Loading driver\n"
231	invoke RegService, my_service, service_proc	231	invoke RegService, my_service, service_proc
232	ret	232	ret
233		233
234	.fail:	234	.fail:
235	xor eax, eax	235	xor eax, eax
236	ret	236	ret
237		237
238	endp	238	endp
239		239
240		240
241	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	241	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
242	;; ;;	242	;; ;;
243	;; proc SERVICE_PROC ;;	243	;; proc SERVICE_PROC ;;
244	;; ;;	244	;; ;;
245	;; (standard driver proc) ;;	245	;; (standard driver proc) ;;
246	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	246	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
247		247
248	proc service_proc stdcall, ioctl:dword	248	proc service_proc stdcall, ioctl:dword
249		249
250	mov edx, [ioctl]	250	mov edx, [ioctl]
251	mov eax, [edx + IOCTL.io_code]	251	mov eax, [edx + IOCTL.io_code]
252		252
253	;------------------------------------------------------	253	;------------------------------------------------------
254		254
255	cmp eax, 0 ;SRV_GETVERSION	255	cmp eax, 0 ;SRV_GETVERSION
256	jne @F	256	jne @F
257		257
258	cmp [edx + IOCTL.out_size], 4	258	cmp [edx + IOCTL.out_size], 4
259	jb .fail	259	jb .fail
260	mov eax, [edx + IOCTL.output]	260	mov eax, [edx + IOCTL.output]
261	mov [eax], dword API_VERSION	261	mov [eax], dword API_VERSION
262		262
263	xor eax, eax	263	xor eax, eax
264	ret	264	ret
265		265
266	;------------------------------------------------------	266	;------------------------------------------------------
267	@@:	267	@@:
268	cmp eax, 1 ;SRV_HOOK	268	cmp eax, 1 ;SRV_HOOK
269	jne .fail	269	jne .fail
270		270
271	cmp [edx + IOCTL.inp_size], 3 ; Data input must be at least 3 bytes	271	cmp [edx + IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
272	jb .fail	272	jb .fail
273		273
274	mov eax, [edx + IOCTL.input]	274	mov eax, [edx + IOCTL.input]
275	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given	275	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
276	jne .fail ; other types arent supported for this card yet	276	jne .fail ; other types arent supported for this card yet
277		277
278	; check if the device is already listed	278	; check if the device is already listed
279		279
280	mov esi, device_list	280	mov esi, device_list
281	mov ecx, [devices]	281	mov ecx, [devices]
282	test ecx, ecx	282	test ecx, ecx
283	jz .firstdevice	283	jz .firstdevice
284		284
285	mov ax, [eax+1] ; get the pci bus and device numbers	285	mov ax, [eax+1] ; get the pci bus and device numbers
286	.nextdevice:	286	.nextdevice:
287	mov ebx, [esi]	287	mov ebx, [esi]
288	cmp al, byte[ebx + device.pci_bus]	288	cmp al, byte[ebx + device.pci_bus]
289	jne @f	289	jne @f
290	cmp ah, byte[ebx + device.pci_dev]	290	cmp ah, byte[ebx + device.pci_dev]
291	je .find_devicenum ; Device is already loaded, let's find it's device number	291	je .find_devicenum ; Device is already loaded, let's find it's device number
292	@@:	292	@@:
293	add esi, 4	293	add esi, 4
294	loop .nextdevice	294	loop .nextdevice
295		295
296		296
297	; This device doesnt have its own eth_device structure yet, lets create one	297	; This device doesnt have its own eth_device structure yet, lets create one
298	.firstdevice:	298	.firstdevice:
299	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card	299	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
300	jae .fail	300	jae .fail
301		301
302	allocate_and_clear ebx, sizeof.device, .fail ; Allocate the buffer for device structure	302	allocate_and_clear ebx, sizeof.device, .fail ; Allocate the buffer for device structure
303		303
304	; Fill in the direct call addresses into the struct	304	; Fill in the direct call addresses into the struct
305		305
306	mov [ebx + device.reset], reset	306	mov [ebx + device.reset], reset
307	mov [ebx + device.transmit], transmit	307	mov [ebx + device.transmit], transmit
308	mov [ebx + device.unload], unload	308	mov [ebx + device.unload], unload
309	mov [ebx + device.name], my_service	309	mov [ebx + device.name], my_service
310		310
311	; save the pci bus and device numbers	311	; save the pci bus and device numbers
312		312
313	mov eax, [edx + IOCTL.input]	313	mov eax, [edx + IOCTL.input]
314	movzx ecx, byte[eax+1]	314	movzx ecx, byte[eax+1]
315	mov [ebx + device.pci_bus], ecx	315	mov [ebx + device.pci_bus], ecx
316	movzx ecx, byte[eax+2]	316	movzx ecx, byte[eax+2]
317	mov [ebx + device.pci_dev], ecx	317	mov [ebx + device.pci_dev], ecx
318		318
319	; Now, it's time to find the base io addres of the PCI device	319	; Now, it's time to find the base io addres of the PCI device
320		320
321	stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]	321	stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]
322	mov [ebx + device.io_addr], eax	322	mov [ebx + device.io_addr], eax
323		323
324	; We've found the io address, find IRQ now	324	; We've found the io address, find IRQ now
325		325
326	invoke PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line	326	invoke PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
327	mov [ebx + device.irq_line], al	327	mov [ebx + device.irq_line], al
328		328
329	DEBUGF 1, "Hooking into device, dev:%x, bus:%x, irq:%x, I/O addr:%x\n",\	329	DEBUGF 1, "Hooking into device, dev:%x, bus:%x, irq:%x, I/O addr:%x\n",\
330	[ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4	330	[ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4
331		331
332	; Allocate the receive buffer	332	; Allocate the receive buffer
333		333
334	invoke CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW	334	invoke CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW
335	test eax, eax	335	test eax, eax
336	jz .err	336	jz .err
337	mov [ebx + device.rx_buffer], eax	337	mov [ebx + device.rx_buffer], eax
338		338
339	; Ok, the eth_device structure is ready, let's probe the device	339	; Ok, the eth_device structure is ready, let's probe the device
340		340
341	call probe ; this function will output in eax	341	call probe ; this function will output in eax
342	test eax, eax	342	test eax, eax
343	jnz .err ; If an error occured, exit	343	jnz .err ; If an error occured, exit
344		344
345	mov eax, [devices] ; Add the device structure to our device list	345	mov eax, [devices] ; Add the device structure to our device list
346	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)	346	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)
347	inc [devices] ;	347	inc [devices] ;
348		348
349	call reset	349	call reset
350	test eax, eax	350	test eax, eax
351	jnz .destroy	351	jnz .destroy
352		352
353	mov [ebx + device.type], NET_TYPE_ETH	353	mov [ebx + device.type], NET_TYPE_ETH
354	invoke NetRegDev	354	invoke NetRegDev
355		355
356	cmp eax, -1	356	cmp eax, -1
357	je .destroy	357	je .destroy
358		358
359	ret	359	ret
360		360
361	; If the device was already loaded, find the device number and return it in eax	361	; If the device was already loaded, find the device number and return it in eax
362		362
363	.find_devicenum:	363	.find_devicenum:
364	DEBUGF 1, "Trying to find device number of already registered device\n"	364	DEBUGF 1, "Trying to find device number of already registered device\n"
365	invoke NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx	365	invoke NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
366	; into a device number in edi	366	; into a device number in edi
367	mov eax, edi ; Application wants it in eax instead	367	mov eax, edi ; Application wants it in eax instead
368	DEBUGF 1, "Kernel says: %u\n", eax	368	DEBUGF 1, "Kernel says: %u\n", eax
369	ret	369	ret
370		370
371	; If an error occured, remove all allocated data and exit (returning -1 in eax)	371	; If an error occured, remove all allocated data and exit (returning -1 in eax)
372		372
373	.destroy:	373	.destroy:
374	; todo: unregister device from device_list	374	; todo: unregister device from device_list
375	; todo: reset device into virgin state	375	; todo: reset device into virgin state
376		376
377	.err:	377	.err:
378	DEBUGF 2, "Error, removing all data !\n"	378	DEBUGF 2, "Error, removing all data !\n"
379	invoke KernelFree, [ebx + device.rx_buffer]	379	invoke KernelFree, [ebx + device.rx_buffer]
380	invoke KernelFree, ebx	380	invoke KernelFree, ebx
381		381
382	.fail:	382	.fail:
383	or eax, -1	383	or eax, -1
384	ret	384	ret
385		385
386	;------------------------------------------------------	386	;------------------------------------------------------
387	endp	387	endp
388		388
389		389
390	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	390	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
391	;; ;;	391	;; ;;
392	;; Actual Hardware dependent code starts here ;;	392	;; Actual Hardware dependent code starts here ;;
393	;; ;;	393	;; ;;
394	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	394	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
395		395
396	align 4	396	align 4
397	unload:	397	unload:
398	; TODO: (in this particular order)	398	; TODO: (in this particular order)
399	;	399	;
400	; - Stop the device	400	; - Stop the device
401	; - Detach int handler	401	; - Detach int handler
402	; - Remove device from local list (RTL8139_LIST)	402	; - Remove device from local list (RTL8139_LIST)
403	; - call unregister function in kernel	403	; - call unregister function in kernel
404	; - Remove all allocated structures and buffers the card used	404	; - Remove all allocated structures and buffers the card used
405		405
406	or eax, -1	406	or eax, -1
407		407
408	ret	408	ret
409		409
410		410
411	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	411	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
412	;;	412	;;
413	;; probe: enables the device (if it really is RTL8139)	413	;; probe: enables the device (if it really is RTL8139)
414	;;	414	;;
415	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	415	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
416		416
417	align 4	417	align 4
418	probe:	418	probe:
419	DEBUGF 1, "Probing\n"	419	DEBUGF 1, "Probing\n"
420		420
421	; Make the device a bus master	421	; Make the device a bus master
422	invoke PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command	422	invoke PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
423	or al, PCI_CMD_MASTER	423	or al, PCI_CMD_MASTER
424	invoke PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax	424	invoke PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
425		425
426	; get chip version	426	; get chip version
427	set_io [ebx + device.io_addr], 0	427	set_io [ebx + device.io_addr], 0
428	set_io [ebx + device.io_addr], REG_TXCONFIG + 2	428	set_io [ebx + device.io_addr], REG_TXCONFIG + 2
429	in ax, dx	429	in ax, dx
430	shr ah, 2	430	shr ah, 2
431	shr ax, 6	431	shr ax, 6
432	and al, 01111111b	432	and al, 01111111b
433		433
434	; now find it in our array	434	; now find it in our array
435	mov ecx, HW_VER_ARRAY_SIZE-1	435	mov ecx, HW_VER_ARRAY_SIZE-1
436	.chip_ver_loop:	436	.chip_ver_loop:
437	cmp al, [hw_ver_array + ecx]	437	cmp al, [hw_ver_array + ecx]
438	je .chip_ver_found	438	je .chip_ver_found
439	dec ecx	439	dec ecx
440	jns .chip_ver_loop	440	jns .chip_ver_loop
441	.unknown:	441	.unknown:
442	mov ecx, 8	442	mov ecx, 8
443	.chip_ver_found:	443	.chip_ver_found:
444	cmp ecx, 8	444	cmp ecx, 8
445	ja .unknown	445	ja .unknown
446		446
447	mov [ebx + device.hw_ver_id], cl	447	mov [ebx + device.hw_ver_id], cl
448		448
449	mov ecx, [crosslist+ecx*4]	449	mov ecx, [crosslist+ecx*4]
450	mov [ebx + device.name], ecx	450	mov [ebx + device.name], ecx
451		451
452	DEBUGF 1, "Chip version: %s\n", ecx	452	DEBUGF 1, "Chip version: %s\n", ecx
453		453
454	; wake up the chip	454	; wake up the chip
455	set_io [ebx + device.io_addr], 0	455	set_io [ebx + device.io_addr], 0
456	set_io [ebx + device.io_addr], REG_HLTCLK	456	set_io [ebx + device.io_addr], REG_HLTCLK
457	mov al, 'R' ; run the clock	457	mov al, 'R' ; run the clock
458	out dx, al	458	out dx, al
459		459
460	; unlock config and BMCR registers	460	; unlock config and BMCR registers
461	set_io [ebx + device.io_addr], REG_9346CR	461	set_io [ebx + device.io_addr], REG_9346CR
462	mov al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)	462	mov al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
463	out dx, al	463	out dx, al
464		464
465	; enable power management	465	; enable power management
466	set_io [ebx + device.io_addr], REG_CONFIG1	466	set_io [ebx + device.io_addr], REG_CONFIG1
467	in al, dx	467	in al, dx
468	cmp [ebx + device.hw_ver_id], IDX_RTL8139B	468	cmp [ebx + device.hw_ver_id], IDX_RTL8139B
469	jae .new_chip	469	jae .new_chip
470	; wake up older chips	470	; wake up older chips
471	and al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))	471	and al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
472	out dx, al	472	out dx, al
473	jmp .finish_wake_up	473	jmp .finish_wake_up
474		474
475	; set LWAKE pin to active high (default value).	475	; set LWAKE pin to active high (default value).
476	; it is for Wake-On-LAN functionality of some motherboards.	476	; it is for Wake-On-LAN functionality of some motherboards.
477	; this signal is used to inform the motherboard to execute a wake-up process.	477	; this signal is used to inform the motherboard to execute a wake-up process.
478	; only at newer chips.	478	; only at newer chips.
479	.new_chip:	479	.new_chip:
480	or al, (1 shl BIT_PMEn)	480	or al, (1 shl BIT_PMEn)
481	and al, not (1 shl BIT_LWACT)	481	and al, not (1 shl BIT_LWACT)
482	out dx, al	482	out dx, al
483		483
484	set_io [ebx + device.io_addr], REG_CONFIG4	484	set_io [ebx + device.io_addr], REG_CONFIG4
485	in al, dx	485	in al, dx
486	and al, not (1 shl BIT_LWPTN)	486	and al, not (1 shl BIT_LWPTN)
487	out dx, al	487	out dx, al
488		488
489	; lock config and BMCR registers	489	; lock config and BMCR registers
490	.finish_wake_up:	490	.finish_wake_up:
491	xor al, al	491	xor al, al
492	set_io [ebx + device.io_addr], 0	492	set_io [ebx + device.io_addr], 0
493	set_io [ebx + device.io_addr], REG_9346CR	493	set_io [ebx + device.io_addr], REG_9346CR
494	out dx, al	494	out dx, al
495	DEBUGF 1, "probing done!\n"	495	DEBUGF 1, "probing done!\n"
496		496
497	xor eax, eax	497	xor eax, eax
498		498
499	ret	499	ret
500		500

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/RTL8139.asm – Rev 5127 → 5363