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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2014. 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 MS COFF
 
        API_VERSION             = 0x01000100
        DRIVER_VERSION          = 5
 
        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__               = 1
        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
 
include '../proc32.inc'
include '../imports.inc'
include '../fdo.inc'
include '../netdrv.inc'
 
public START
public service_proc
public version
 
        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
        MAX_ETH_FRAME_SIZE      = 1514
        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
 
 
virtual at ebx
 
        device:
 
        ETH_DEVICE
 
        .rx_buffer      dd ?
 
        .rx_data_offset dd ?
        .io_addr        dd ?
 
        .curr_tx_desc   db ?
        .pci_bus        dd ?
        .pci_dev        dd ?
        .irq_line       db ?
        .hw_ver_id      db ?
 
                        db ?    ; align 4
        .TX_DESC        rd NUM_TX_DESC
 
        .size = $ - device
 
end virtual
 
 
 
section '.flat' code readable align 16
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc START             ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
proc START stdcall, state:dword
 
        cmp     [state], 1
        jne     .exit
 
  .entry:
 
        DEBUGF  2, "Loading driver\n"
        stdcall RegService, my_service, service_proc
        ret
 
  .fail:
  .exit:
        xor     eax, eax
        ret
 
endp
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc SERVICE_PROC      ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
proc service_proc stdcall, ioctl:dword
 
        mov     edx, [ioctl]
        mov     eax, [IOCTL.io_code]
 
;------------------------------------------------------
 
        cmp     eax, 0 ;SRV_GETVERSION
        jne     @F
 
        cmp     [IOCTL.out_size], 4
        jb      .fail
        mov     eax, [IOCTL.output]
        mov     [eax], dword API_VERSION
 
        xor     eax, eax
        ret
 
;------------------------------------------------------
  @@:
        cmp     eax, 1 ;SRV_HOOK
        jne     .fail
 
        cmp     [IOCTL.inp_size], 3                     ; Data input must be at least 3 bytes
        jb      .fail
 
        mov     eax, [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[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
 
 
; 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, device.size, .fail      ; Allocate the buffer for device structure
 
; Fill in the direct call addresses into the struct
 
        mov     [device.reset], reset
        mov     [device.transmit], transmit
        mov     [device.unload], unload
        mov     [device.name], my_service
 
; save the pci bus and device numbers
 
        mov     eax, [IOCTL.input]
        movzx   ecx, byte[eax+1]
        mov     [device.pci_bus], ecx
        movzx   ecx, byte[eax+2]
        mov     [device.pci_dev], ecx
 
; Now, it's time to find the base io addres of the PCI device
 
        PCI_find_io
 
; We've found the io address, find IRQ now
 
        PCI_find_irq
 
        DEBUGF  1, "Hooking into device, dev:%x, bus:%x, irq:%x, I/O addr:%x\n",\
        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
 
; Allocate the receive buffer
 
        stdcall CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW
        test    eax, eax
        jz      .err
        mov     [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     [device.type], NET_TYPE_ETH
        call    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"
        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
 
; 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"
        stdcall KernelFree, [device.rx_buffer]
        stdcall 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"
 
        PCI_make_bus_master
 
; get chip version
        set_io  0
        set_io  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     [device.hw_ver_id], cl
 
        mov     ecx, [crosslist+ecx*4]
        mov     [device.name], ecx
 
        DEBUGF  1, "Chip version: %s\n", ecx
 
; wake up the chip
        set_io  0
        set_io  REG_HLTCLK
        mov     al, 'R'         ; run the clock
        out     dx, al
 
; unlock config and BMCR registers
        set_io  REG_9346CR
        mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
        out     dx, al
 
; enable power management
        set_io  REG_CONFIG1
        in      al, dx
        cmp     [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  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  0
        set_io  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, [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
       @@:
 
; reset chip
        DEBUGF  1, "Resetting chip\n"
        set_io  0
        set_io  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  0
        set_io  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  REG_MAR0
        out     dx, eax
        set_io  REG_MAR4
        out     dx, eax
 
; enable Rx/Tx
        mov     al, (1 shl BIT_RE) or (1 shl BIT_TE)
        set_io  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  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  REG_TXCONFIG
        out     dx, eax
 
; enable auto negotiation
        set_io  REG_BMCR
        in      ax, dx
        or      ax, (1 shl BIT_ANE)
        out     dx, ax
 
; set auto negotiation advertisement
        set_io  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  REG_9346CR
        out     dx, al
 
; init RX/TX pointers
        mov     [device.rx_data_offset], eax
        mov     [device.curr_tx_desc], al
;        set_io  REG_CAPR
;        out     dx, ax
 
; clear packet/byte counters
        lea     edi, [device.bytes_tx]
        mov     ecx, 6
        rep     stosd
 
; clear missing packet counter
        set_io  REG_MPC
        out     dx, eax
 
; set RxBuffer address, init RX buffer offset
        mov     eax, [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
        GetRealAddr
        DEBUGF  1, "RX buffer physical addr=0x%x\n", eax
        set_io  REG_RBSTART
        out     dx, eax
 
; enable interrupts
        set_io  0
        set_io  REG_IMR
        mov     ax, INTERRUPT_MASK
        out     dx, ax
 
; Set the mtu, kernel will be able to send now
        mov     [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  ;;
;;                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
transmit:
        DEBUGF  1, "Transmitting packet, buffer:%x, size:%u\n", [esp+4], [esp+8]
        mov     eax, [esp+4]
        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     dword [esp+8], MAX_ETH_FRAME_SIZE
        ja      .fail
        cmp     dword [esp+8], 60
        jb      .fail
 
; check if we own the current discriptor
        set_io  0
        set_io  REG_TSD0
        movzx   ecx, [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     [device.curr_tx_desc]
        and     [device.curr_tx_desc], NUM_TX_DESC-1
 
; Update stats
        inc     [device.packets_tx]
        mov     eax, [esp+8]
        add     dword [device.bytes_tx], eax
        adc     dword [device.bytes_tx+4], 0
 
; Set the buffer address
        set_io  REG_TSAD0
        mov     eax, [esp+4]
        mov     [device.TX_DESC+ecx], eax
        GetRealAddr
        out     dx, eax
 
; And the size of the buffer
        set_io  REG_TSD0
        mov     eax, [esp+8]
        or      eax, (ERTXTH shl BIT_ERTXTH)    ; Early threshold
        out     dx, eax
 
        DEBUGF  1, "Packet Sent!\n"
        xor     eax, eax
        ret     8
 
  .wait_to_send:
        DEBUGF  1, "Waiting for timeout\n"
 
        push    edx
        mov     esi, 30
        stdcall 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"
        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 IRQ occur
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .nothing
        mov     esi, device_list
  .nextdevice:
        mov     ebx, [esi]
 
        set_io  0
        set_io  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  0
        set_io  REG_COMMAND
        in      al, dx
        test    al, BUFE                        ; test if RX buffer is empty
        jnz     .finish
 
        DEBUGF  1, "RX:\n"
 
        mov     eax, [device.rx_buffer]
        add     eax, [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 [device.bytes_rx], ecx
        adc     dword [device.bytes_rx + 4], 0
        inc     [device.packets_rx]
 
        DEBUGF  1, "Received %u bytes\n", ecx
 
        push    ebx eax ecx
        stdcall 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, [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     [device.rx_data_offset], eax
        DEBUGF  1, "New RX ptr: %d\n", eax
 
        set_io  0
        set_io  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  0
        set_io  REG_TSD0
        add     edx, ecx
        in      eax, dx
 
        test    eax, TSR_OWN                    ; DMA operation completed
        jz      .notthisone
 
        cmp     [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", [device.TX_DESC+ecx]:8
        push    ecx ebx
        stdcall KernelFree, [device.TX_DESC+ecx]
        pop     ebx ecx
        mov     [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  0
        set_io  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  0
        set_io  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  0
        set_io  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     [device.state], ETH_LINK_100M
        call    NetLinkChanged
        DEBUGF  2, "link changed to 100 mbit\n"
 
        ret
 
  .10mbps:
        mov     [device.state], ETH_LINK_10M
        call    NetLinkChanged
        DEBUGF  2, "link changed to 10 mbit\n"
 
        ret
 
  .notconnected:
        mov     [device.state], ETH_LINK_DOWN
        call    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  0
        set_io  REG_9346CR
        xor     eax, eax
        out     dx, al
 
        set_io  REG_IMR
        xor     eax, eax
        out     dx, ax
 
        set_io  REG_ISR
        mov     eax, -1
        out     dx, ax
 
; enable writing
        set_io  REG_9346CR
        mov     eax, REG_9346CR_WE
        out     dx, al
 
 ; write the mac ...
        set_io  REG_IDR0
        pop     eax
        out     dx, eax
 
        set_io  REG_IDR0+4
        xor     eax, eax
        pop     ax
        out     dx, eax
 
; disable writing
        set_io  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  0
        lea     edi, [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
 
section '.data' data readable writable align 16 ; place all uninitialized data place here
align 4                                         ; Place all initialised data here
 
devices         dd 0
version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
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
 
device_list     rd MAX_DEVICES                   ; This list contains all pointers to device structures the driver is handling

Rev 3858	Rev 4449
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2013. 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	;; 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 MS COFF	18	format MS COFF
19		19
20	API_VERSION = 0x01000100	20	API_VERSION = 0x01000100
21	DRIVER_VERSION = 5	21	DRIVER_VERSION = 5
22		22
23	MAX_DEVICES = 16	23	MAX_DEVICES = 16
24		24
25	RBLEN = 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k	25	RBLEN = 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k
26		26
27	TXRR = 8 ; total retries = 16+(TXRR*16)	27	TXRR = 8 ; total retries = 16+(TXRR*16)
28	TX_MXDMA = 6 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=2048	28	TX_MXDMA = 6 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=2048
29	ERTXTH = 8 ; in unit of 32 bytes e.g:(8*32)=256	29	ERTXTH = 8 ; in unit of 32 bytes e.g:(8*32)=256
30	RX_MXDMA = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=unlimited	30	RX_MXDMA = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=unlimited
31	RXFTH = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=no threshold	31	RXFTH = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=no threshold
32		32
33	DEBUG = 1	33	DEBUG = 1
34	__DEBUG__ = 1	34	__DEBUG__ = 1
35	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only	35	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only
36		36
37	include '../proc32.inc'	37	include '../proc32.inc'
38	include '../imports.inc'	38	include '../imports.inc'
39	include '../fdo.inc'	39	include '../fdo.inc'
40	include '../netdrv.inc'	40	include '../netdrv.inc'
41		41
42	public START	42	public START
43	public service_proc	43	public service_proc
44	public version	44	public version
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	MAX_ETH_FRAME_SIZE = 1514	138	MAX_ETH_FRAME_SIZE = 1514
139	NUM_TX_DESC = 4 ; not user selectable	139	NUM_TX_DESC = 4 ; not user selectable
140		140
141	EE_93C46_REG_ETH_ID = 7 ; MAC offset	141	EE_93C46_REG_ETH_ID = 7 ; MAC offset
142	EE_93C46_READ_CMD = (6 shl 6) ; 110b + 6bit address	142	EE_93C46_READ_CMD = (6 shl 6) ; 110b + 6bit address
143	EE_93C56_READ_CMD = (6 shl 8) ; 110b + 8bit address	143	EE_93C56_READ_CMD = (6 shl 8) ; 110b + 8bit address
144	EE_93C46_CMD_LENGTH = 9 ; start bit + cmd + 6bit address	144	EE_93C46_CMD_LENGTH = 9 ; start bit + cmd + 6bit address
145	EE_93C56_CMD_LENGTH = 11 ; start bit + cmd + 8bit ddress	145	EE_93C56_CMD_LENGTH = 11 ; start bit + cmd + 8bit ddress
146		146
147	VER_RTL8139 = 1100000b	147	VER_RTL8139 = 1100000b
148	VER_RTL8139A = 1110000b	148	VER_RTL8139A = 1110000b
149	VER_RTL8139AG = 1110100b	149	VER_RTL8139AG = 1110100b
150	VER_RTL8139B = 1111000b	150	VER_RTL8139B = 1111000b
151	VER_RTL8130 = VER_RTL8139B	151	VER_RTL8130 = VER_RTL8139B
152	VER_RTL8139C = 1110100b	152	VER_RTL8139C = 1110100b
153	VER_RTL8100 = 1111010b	153	VER_RTL8100 = 1111010b
154	VER_RTL8100B = 1110101b	154	VER_RTL8100B = 1110101b
155	VER_RTL8139D = VER_RTL8100B	155	VER_RTL8139D = VER_RTL8100B
156	VER_RTL8139CP = 1110110b	156	VER_RTL8139CP = 1110110b
157	VER_RTL8101 = 1110111b	157	VER_RTL8101 = 1110111b
158		158
159	IDX_RTL8139 = 0	159	IDX_RTL8139 = 0
160	IDX_RTL8139A = 1	160	IDX_RTL8139A = 1
161	IDX_RTL8139B = 2	161	IDX_RTL8139B = 2
162	IDX_RTL8139C = 3	162	IDX_RTL8139C = 3
163	IDX_RTL8100 = 4	163	IDX_RTL8100 = 4
164	IDX_RTL8139D = 5	164	IDX_RTL8139D = 5
165	IDX_RTL8139D = 6	165	IDX_RTL8139D = 6
166	IDX_RTL8101 = 7	166	IDX_RTL8101 = 7
167		167
168	ISR_SERR = 1 shl 15	168	ISR_SERR = 1 shl 15
169	ISR_TIMEOUT = 1 shl 14	169	ISR_TIMEOUT = 1 shl 14
170	ISR_LENCHG = 1 shl 13	170	ISR_LENCHG = 1 shl 13
171	ISR_FIFOOVW = 1 shl 6	171	ISR_FIFOOVW = 1 shl 6
172	ISR_PUN = 1 shl 5	172	ISR_PUN = 1 shl 5
173	ISR_RXOVW = 1 shl 4	173	ISR_RXOVW = 1 shl 4
174	ISR_TER = 1 shl 3	174	ISR_TER = 1 shl 3
175	ISR_TOK = 1 shl 2	175	ISR_TOK = 1 shl 2
176	ISR_RER = 1 shl 1	176	ISR_RER = 1 shl 1
177	ISR_ROK = 1 shl 0	177	ISR_ROK = 1 shl 0
178		178
179	INTERRUPT_MASK = ISR_ROK or \	179	INTERRUPT_MASK = ISR_ROK or \
180	ISR_RER or \	180	ISR_RER or \
181	ISR_TOK or \	181	ISR_TOK or \
182	ISR_TER or \	182	ISR_TER or \
183	ISR_RXOVW or \	183	ISR_RXOVW or \
184	ISR_PUN or \	184	ISR_PUN or \
185	ISR_FIFOOVW or \	185	ISR_FIFOOVW or \
186	ISR_LENCHG or \	186	ISR_LENCHG or \
187	ISR_TIMEOUT or \	187	ISR_TIMEOUT or \
188	ISR_SERR	188	ISR_SERR
189		189
190		190
191		191
192	TSR_OWN = 1 shl 13	192	TSR_OWN = 1 shl 13
193	TSR_TUN = 1 shl 14	193	TSR_TUN = 1 shl 14
194	TSR_TOK = 1 shl 15	194	TSR_TOK = 1 shl 15
195		195
196	TSR_CDH = 1 shl 28	196	TSR_CDH = 1 shl 28
197	TSR_OWC = 1 shl 29	197	TSR_OWC = 1 shl 29
198	TSR_TABT = 1 shl 30	198	TSR_TABT = 1 shl 30
199	TSR_CRS = 1 shl 31	199	TSR_CRS = 1 shl 31
200		200
201		201
202	virtual at ebx	202	virtual at ebx
203		203
204	device:	204	device:
205		205
206	ETH_DEVICE	206	ETH_DEVICE
207		207
208	.rx_buffer dd ?	208	.rx_buffer dd ?
209		209
210	.rx_data_offset dd ?	210	.rx_data_offset dd ?
211	.io_addr dd ?	211	.io_addr dd ?
212		212
213	.curr_tx_desc db ?	213	.curr_tx_desc db ?
214	.pci_bus dd ?	214	.pci_bus dd ?
215	.pci_dev dd ?	215	.pci_dev dd ?
216	.irq_line db ?	216	.irq_line db ?
217	.hw_ver_id db ?	217	.hw_ver_id db ?
218		218
219	db ? ; align 4	219	db ? ; align 4
220	.TX_DESC rd NUM_TX_DESC	220	.TX_DESC rd NUM_TX_DESC
221		221
222	.size = $ - device	222	.size = $ - device
223		223
224	end virtual	224	end virtual
225		225
226		226
227		227
228	section '.flat' code readable align 16	228	section '.flat' code readable align 16
229		229
230	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	230	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
231	;; ;;	231	;; ;;
232	;; proc START ;;	232	;; proc START ;;
233	;; ;;	233	;; ;;
234	;; (standard driver proc) ;;	234	;; (standard driver proc) ;;
235	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	235	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
236		236
237	align 4	237	align 4
238	proc START stdcall, state:dword	238	proc START stdcall, state:dword
239		239
240	cmp [state], 1	240	cmp [state], 1
241	jne .exit	241	jne .exit
242		242
243	.entry:	243	.entry:
244		244
245	DEBUGF 1, "Loading driver\n"	245	DEBUGF 2, "Loading driver\n"
246	stdcall RegService, my_service, service_proc	246	stdcall RegService, my_service, service_proc
247	ret	247	ret
248		248
249	.fail:	249	.fail:
250	.exit:	250	.exit:
251	xor eax, eax	251	xor eax, eax
252	ret	252	ret
253		253
254	endp	254	endp
255		255
256		256
257	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	257	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
258	;; ;;	258	;; ;;
259	;; proc SERVICE_PROC ;;	259	;; proc SERVICE_PROC ;;
260	;; ;;	260	;; ;;
261	;; (standard driver proc) ;;	261	;; (standard driver proc) ;;
262	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	262	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
263		263
264	align 4	264	align 4
265	proc service_proc stdcall, ioctl:dword	265	proc service_proc stdcall, ioctl:dword
266		266
267	mov edx, [ioctl]	267	mov edx, [ioctl]
268	mov eax, [IOCTL.io_code]	268	mov eax, [IOCTL.io_code]
269		269
270	;------------------------------------------------------	270	;------------------------------------------------------
271		271
272	cmp eax, 0 ;SRV_GETVERSION	272	cmp eax, 0 ;SRV_GETVERSION
273	jne @F	273	jne @F
274		274
275	cmp [IOCTL.out_size], 4	275	cmp [IOCTL.out_size], 4
276	jb .fail	276	jb .fail
277	mov eax, [IOCTL.output]	277	mov eax, [IOCTL.output]
278	mov [eax], dword API_VERSION	278	mov [eax], dword API_VERSION
279		279
280	xor eax, eax	280	xor eax, eax
281	ret	281	ret
282		282
283	;------------------------------------------------------	283	;------------------------------------------------------
284	@@:	284	@@:
285	cmp eax, 1 ;SRV_HOOK	285	cmp eax, 1 ;SRV_HOOK
286	jne .fail	286	jne .fail
287		287
288	cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes	288	cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
289	jb .fail	289	jb .fail
290		290
291	mov eax, [IOCTL.input]	291	mov eax, [IOCTL.input]
292	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given	292	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
293	jne .fail ; other types arent supported for this card yet	293	jne .fail ; other types arent supported for this card yet
294		294
295	; check if the device is already listed	295	; check if the device is already listed
296		296
297	mov esi, device_list	297	mov esi, device_list
298	mov ecx, [devices]	298	mov ecx, [devices]
299	test ecx, ecx	299	test ecx, ecx
300	jz .firstdevice	300	jz .firstdevice
301		301
302	mov ax, [eax+1] ; get the pci bus and device numbers	302	mov ax, [eax+1] ; get the pci bus and device numbers
303	.nextdevice:	303	.nextdevice:
304	mov ebx, [esi]	304	mov ebx, [esi]
305	cmp al, byte[device.pci_bus]	305	cmp al, byte[device.pci_bus]
306	jne @f	306	jne @f
307	cmp ah, byte[device.pci_dev]	307	cmp ah, byte[device.pci_dev]
308	je .find_devicenum ; Device is already loaded, let's find it's device number	308	je .find_devicenum ; Device is already loaded, let's find it's device number
309	@@:	309	@@:
310	add esi, 4	310	add esi, 4
311	loop .nextdevice	311	loop .nextdevice
312		312
313		313
314	; This device doesnt have its own eth_device structure yet, lets create one	314	; This device doesnt have its own eth_device structure yet, lets create one
315	.firstdevice:	315	.firstdevice:
316	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card	316	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
317	jae .fail	317	jae .fail
318		318
319	allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure	319	allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure
320		320
321	; Fill in the direct call addresses into the struct	321	; Fill in the direct call addresses into the struct
322		322
323	mov [device.reset], reset	323	mov [device.reset], reset
324	mov [device.transmit], transmit	324	mov [device.transmit], transmit
325	mov [device.unload], unload	325	mov [device.unload], unload
326	mov [device.name], my_service	326	mov [device.name], my_service
327		327
328	; save the pci bus and device numbers	328	; save the pci bus and device numbers
329		329
330	mov eax, [IOCTL.input]	330	mov eax, [IOCTL.input]
331	movzx ecx, byte[eax+1]	331	movzx ecx, byte[eax+1]
332	mov [device.pci_bus], ecx	332	mov [device.pci_bus], ecx
333	movzx ecx, byte[eax+2]	333	movzx ecx, byte[eax+2]
334	mov [device.pci_dev], ecx	334	mov [device.pci_dev], ecx
335		335
336	; Now, it's time to find the base io addres of the PCI device	336	; Now, it's time to find the base io addres of the PCI device
337		337
338	PCI_find_io	338	PCI_find_io
339		339
340	; We've found the io address, find IRQ now	340	; We've found the io address, find IRQ now
341		341
342	PCI_find_irq	342	PCI_find_irq
343		343
344	DEBUGF 1, "Hooking into device, dev:%x, bus:%x, irq:%x, I/O addr:%x\n",\	344	DEBUGF 1, "Hooking into device, dev:%x, bus:%x, irq:%x, I/O addr:%x\n",\
345	[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4	345	[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
346		346
347	; Allocate the receive buffer	347	; Allocate the receive buffer
348		348
349	stdcall CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW	349	stdcall CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW
350	test eax, eax	350	test eax, eax
351	jz .err	351	jz .err
352	mov [device.rx_buffer], eax	352	mov [device.rx_buffer], eax
353		353
354	; Ok, the eth_device structure is ready, let's probe the device	354	; Ok, the eth_device structure is ready, let's probe the device
355		355
356	call probe ; this function will output in eax	356	call probe ; this function will output in eax
357	test eax, eax	357	test eax, eax
358	jnz .err ; If an error occured, exit	358	jnz .err ; If an error occured, exit
359		359
360	mov eax, [devices] ; Add the device structure to our device list	360	mov eax, [devices] ; Add the device structure to our device list
361	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)	361	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)
362	inc [devices] ;	362	inc [devices] ;
363		363
364	call reset	364	call reset
365	test eax, eax	365	test eax, eax
366	jnz .destroy	366	jnz .destroy
367		367
368	mov [device.type], NET_TYPE_ETH	368	mov [device.type], NET_TYPE_ETH
369	call NetRegDev	369	call NetRegDev
370		370
371	cmp eax, -1	371	cmp eax, -1
372	je .destroy	372	je .destroy
373		373
374	ret	374	ret
375		375
376	; If the device was already loaded, find the device number and return it in eax	376	; If the device was already loaded, find the device number and return it in eax
377		377
378	.find_devicenum:	378	.find_devicenum:
379	DEBUGF 1, "Trying to find device number of already registered device\n"	379	DEBUGF 1, "Trying to find device number of already registered device\n"
380	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx	380	call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
381	; into a device number in edi	381	; into a device number in edi
382	mov eax, edi ; Application wants it in eax instead	382	mov eax, edi ; Application wants it in eax instead
383	DEBUGF 1, "Kernel says: %u\n", eax	383	DEBUGF 1, "Kernel says: %u\n", eax
384	ret	384	ret
385		385
386	; If an error occured, remove all allocated data and exit (returning -1 in eax)	386	; If an error occured, remove all allocated data and exit (returning -1 in eax)
387		387
388	.destroy:	388	.destroy:
389	; todo: unregister device from device_list	389	; todo: unregister device from device_list
390	; todo: reset device into virgin state	390	; todo: reset device into virgin state
391		391
392	.err:	392	.err:
393	DEBUGF 2, "Error, removing all data !\n"	393	DEBUGF 2, "Error, removing all data !\n"
394	stdcall KernelFree, [device.rx_buffer]	394	stdcall KernelFree, [device.rx_buffer]
395	stdcall KernelFree, ebx	395	stdcall KernelFree, ebx
396		396
397	.fail:	397	.fail:
398	or eax, -1	398	or eax, -1
399	ret	399	ret
400		400
401	;------------------------------------------------------	401	;------------------------------------------------------
402	endp	402	endp
403		403
404		404
405	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	405	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
406	;; ;;	406	;; ;;
407	;; Actual Hardware dependent code starts here ;;	407	;; Actual Hardware dependent code starts here ;;
408	;; ;;	408	;; ;;
409	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	409	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
410		410
411	align 4	411	align 4
412	unload:	412	unload:
413	; TODO: (in this particular order)	413	; TODO: (in this particular order)
414	;	414	;
415	; - Stop the device	415	; - Stop the device
416	; - Detach int handler	416	; - Detach int handler
417	; - Remove device from local list (RTL8139_LIST)	417	; - Remove device from local list (RTL8139_LIST)
418	; - call unregister function in kernel	418	; - call unregister function in kernel
419	; - Remove all allocated structures and buffers the card used	419	; - Remove all allocated structures and buffers the card used
420		420
421	or eax, -1	421	or eax, -1
422		422
423	ret	423	ret
424		424
425		425
426	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	426	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
427	;;	427	;;
428	;; probe: enables the device (if it really is RTL8139)	428	;; probe: enables the device (if it really is RTL8139)
429	;;	429	;;
430	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	430	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
431		431
432	align 4	432	align 4
433	probe:	433	probe:
434	DEBUGF 1, "Probing\n"	434	DEBUGF 1, "Probing\n"
435		435
436	PCI_make_bus_master	436	PCI_make_bus_master
437		437
438	; get chip version	438	; get chip version
439	set_io 0	439	set_io 0
440	set_io REG_TXCONFIG + 2	440	set_io REG_TXCONFIG + 2
441	in ax, dx	441	in ax, dx
442	shr ah, 2	442	shr ah, 2
443	shr ax, 6	443	shr ax, 6
444	and al, 01111111b	444	and al, 01111111b
445		445
446	; now find it in our array	446	; now find it in our array
447	mov ecx, HW_VER_ARRAY_SIZE-1	447	mov ecx, HW_VER_ARRAY_SIZE-1
448	.chip_ver_loop:	448	.chip_ver_loop:
449	cmp al, [hw_ver_array + ecx]	449	cmp al, [hw_ver_array + ecx]
450	je .chip_ver_found	450	je .chip_ver_found
451	dec ecx	451	dec ecx
452	jns .chip_ver_loop	452	jns .chip_ver_loop
453	.unknown:	453	.unknown:
454	mov ecx, 8	454	mov ecx, 8
455	.chip_ver_found:	455	.chip_ver_found:
456	cmp ecx, 8	456	cmp ecx, 8
457	ja .unknown	457	ja .unknown
458		458
459	mov [device.hw_ver_id], cl	459	mov [device.hw_ver_id], cl
460		460
461	mov ecx, [crosslist+ecx*4]	461	mov ecx, [crosslist+ecx*4]
462	mov [device.name], ecx	462	mov [device.name], ecx
463		463
464	DEBUGF 1, "Chip version: %s\n", ecx	464	DEBUGF 1, "Chip version: %s\n", ecx
465		465
466	; wake up the chip	466	; wake up the chip
467	set_io 0	467	set_io 0
468	set_io REG_HLTCLK	468	set_io REG_HLTCLK
469	mov al, 'R' ; run the clock	469	mov al, 'R' ; run the clock
470	out dx, al	470	out dx, al
471		471
472	; unlock config and BMCR registers	472	; unlock config and BMCR registers
473	set_io REG_9346CR	473	set_io REG_9346CR
474	mov al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)	474	mov al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
475	out dx, al	475	out dx, al
476		476
477	; enable power management	477	; enable power management
478	set_io REG_CONFIG1	478	set_io REG_CONFIG1
479	in al, dx	479	in al, dx
480	cmp [device.hw_ver_id], IDX_RTL8139B	480	cmp [device.hw_ver_id], IDX_RTL8139B
481	jae .new_chip	481	jae .new_chip
482	; wake up older chips	482	; wake up older chips
483	and al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))	483	and al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
484	out dx, al	484	out dx, al
485	jmp .finish_wake_up	485	jmp .finish_wake_up
486		486
487	; set LWAKE pin to active high (default value).	487	; set LWAKE pin to active high (default value).
488	; it is for Wake-On-LAN functionality of some motherboards.	488	; it is for Wake-On-LAN functionality of some motherboards.
489	; this signal is used to inform the motherboard to execute a wake-up process.	489	; this signal is used to inform the motherboard to execute a wake-up process.
490	; only at newer chips.	490	; only at newer chips.
491	.new_chip:	491	.new_chip:
492	or al, (1 shl BIT_PMEn)	492	or al, (1 shl BIT_PMEn)
493	and al, not (1 shl BIT_LWACT)	493	and al, not (1 shl BIT_LWACT)
494	out dx, al	494	out dx, al
495		495
496	set_io REG_CONFIG4	496	set_io REG_CONFIG4
497	in al, dx	497	in al, dx
498	and al, not (1 shl BIT_LWPTN)	498	and al, not (1 shl BIT_LWPTN)
499	out dx, al	499	out dx, al
500		500

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/RTL8139.asm – Rev 3858 → 4449