WebSVN – Kolibri OS – Diff – /kernel/branches/net/drivers/RTL8139.asm

         __DEBUG_LEVEL__         = 1
 include 'proc32.inc'
 include 'imports.inc'
-include 'fdo.inc'
-include '../struct.inc'
+include 'fdo.inc'
 include 'netdrv.inc'
 public START
         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
+        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
         IDX_RTL8100             = 4
         IDX_RTL8139D            = 5
         IDX_RTL8139D            = 6
         IDX_RTL8101             = 7
-        ISR_SERR                = 1 SHL 15
+        ISR_SERR                = 1 shl 15
-        ISR_TIMEOUT             = 1 SHL 14
+        ISR_TIMEOUT             = 1 shl 14
-        ISR_LENCHG              = 1 SHL 13
+        ISR_LENCHG              = 1 shl 13
-        ISR_FIFOOVW             = 1 SHL 6
+        ISR_FIFOOVW             = 1 shl 6
-        ISR_PUN                 = 1 SHL 5
+        ISR_PUN                 = 1 shl 5
-        ISR_RXOVW               = 1 SHL 4
+        ISR_RXOVW               = 1 shl 4
-        ISR_TER                 = 1 SHL 3
+        ISR_TER                 = 1 shl 3
-        ISR_TOK                 = 1 SHL 2
+        ISR_TOK                 = 1 shl 2
-        ISR_RER                 = 1 SHL 1
+        ISR_RER                 = 1 shl 1
-        ISR_ROK                 = 1 SHL 0
+        ISR_ROK                 = 1 shl 0
         INTERRUPT_MASK          = ISR_ROK or \
                                   ISR_RXOVW or \
                                   ISR_PUN or \
                                   ISR_FIFOOVW or \
                                   ISR_LENCHG or \
                                   ISR_TOK or \
                                   ISR_TER
-        TSR_OWN                 = 1 SHL 13
+        TSR_OWN                 = 1 shl 13
-        TSR_TUN                 = 1 SHL 14
+        TSR_TUN                 = 1 shl 14
-        TSR_TOK                 = 1 SHL 15
+        TSR_TOK                 = 1 shl 15
-        TSR_CDH                 = 1 SHL 28
+        TSR_CDH                 = 1 shl 28
-        TSR_OWC                 = 1 SHL 29
+        TSR_OWC                 = 1 shl 29
-        TSR_TABT                = 1 SHL 30
+        TSR_TABT                = 1 shl 30
-        TSR_CRS                 = 1 SHL 31
+        TSR_CRS                 = 1 shl 31
 virtual at ebx
 virtual at ebx
         device:
         mov     esi, device_list
         mov     ecx, [devices]
         test    ecx, ecx
         jz      .firstdevice
-        mov     ax , [eax+1]                            ; get the pci bus and device numbers
+        mov     ax, [eax+1]                             ; get the pci bus and device numbers
   .nextdevice:
         mov     ebx, [esi]
         cmp     al, byte[device.pci_bus]
         jne     @f
 ; Fill in the direct call addresses into the struct
-        mov     [device.reset], reset
-        mov     [device.transmit], transmit
-        mov     [device.get_MAC], read_mac
+        mov     [device.reset], reset
-        mov     [device.set_MAC], write_mac
+        mov     [device.transmit], transmit
         mov     [device.unload], unload
 ; We've found the io address, find IRQ now
         PCI_find_irq
-        DEBUGF  2, "Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
+        DEBUGF  2, "Hooking into device, dev:%x, bus:%x, irq:%x, I/O addr:%x\n",\
         DEBUGF  2, "Probing %s device\n", my_service
         PCI_make_bus_master
 ; get chip version
 ; get chip version
         set_io  0
         set_io  REG_TXCONFIG + 2
         in      ax, dx
         shr     ah, 2
+        shr     ax, 6
-        shr     ax, 6
+        and     al, 01111111b
         and     al, 01111111b
 ; now find it in our array
         mov     ecx, HW_VER_ARRAY_SIZE-1
   .chip_ver_loop:
         mov     [device.name], ecx
         DEBUGF  2, "Chip version: %s\n", ecx
 ; wake up the chip
 ; wake up the chip
         set_io  0
         set_io  REG_HLTCLK
         mov     al, 'R'         ; run the clock
-        out     dx, al
         out     dx, al
 ; unlock config and BMCR registers
 ; 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
+        mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
         out     dx, al
 ; enable power management
+; enable power management
+        set_io  REG_CONFIG1
+        in      al, dx
+        cmp     [device.hw_ver_id], IDX_RTL8139B
+        jae     .new_chip
-        set_io  REG_CONFIG1
+; wake up older chips
-        in      al, dx
+        and     al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
-        cmp     [device.hw_ver_id], IDX_RTL8139B
+        out     dx, al
-        jb      .old_chip
+        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
-        jmp     .finish_wake_up
-  .old_chip:
         out     dx, al
-; wake up older chips
         set_io  REG_CONFIG4
-        and     al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
+        in      al, dx
-        out     dx, al
+        and     al, not (1 shl BIT_LWPTN)
-  .finish_wake_up:
+        out     dx, al
 ;;   reset: Set up all registers and descriptors, clear some values
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 reset:
-        DEBUGF  2, "Resetting\n"
+        DEBUGF  2, "Reset\n"
 ; attach int handler
+; attach int handler
         movzx   eax, [device.irq_line]
-        DEBUGF  1, "Attaching int handler to irq %x, ", eax:1
+        DEBUGF  1, "Attaching int handler to irq %x\n", eax:1
         stdcall AttachIntHandler, eax, int_handler, dword 0
         test    eax, eax
         jnz     @f
         DEBUGF  1, "\nCould not attach int handler!\n"
 ;        or      eax, -1
 ;        ret
-       @@:
        @@:
 ; reset chip
 ; reset chip
         DEBUGF  1, "Resetting chip\n"
         set_io  0
         set_io  REG_COMMAND
-        mov     al , 1 shl BIT_RST
+        mov     al, 1 shl BIT_RST
-        out     dx , al
+        out     dx, al
-        mov     cx , 1000               ; wait no longer for the reset
+        mov     cx, 1000                ; wait no longer for the reset
   .wait_for_reset:
-        in      al , dx
+        in      al, dx
-        test    al , 1 shl BIT_RST
+        test    al, 1 shl BIT_RST
+        jz      .reset_completed        ; RST remains 1 during reset
-        jz      .reset_completed        ; RST remains 1 during reset
+        dec     cx
-        dec     cx
+        jns     .wait_for_reset
-        jns     .wait_for_reset
-  .reset_completed:
+        DEBUGF  1, "Reset timeout!\n"
   .reset_completed:
 ; unlock config and BMCR registers
 ; unlock config and BMCR registers
-        set_io  REG_9346CR
-        mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
+        set_io  REG_9346CR
-        out     dx, al
+        mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
         out     dx, al
 ; initialize multicast registers (no filtering)
 ; 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     eax, 0xffffffff
         set_io  REG_MAR0
-        mov     al, (1 shl BIT_RE) or (1 shl BIT_TE)
-        set_io  REG_COMMAND
+        out     dx, eax
-        out     dx, al
+        set_io  REG_MAR4
         out     dx, eax
-; Rxbuffer size, unlimited dma burst, no wrapping, no rx threshold
 ; accept broadcast packets, accept physical match packets
-        mov     ax, RX_CONFIG
+; Rxbuffer size, unlimited dma burst, no wrapping, no rx threshold
-        set_io  REG_RXCONFIG
+; accept broadcast packets, accept physical match packets
-        out     dx, ax
+        mov     ax, RX_CONFIG
         set_io  REG_RXCONFIG
-; 1024 bytes DMA burst, total retries = 16 + 8 * 16 = 144
+        out     dx, ax
-        mov     eax, (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0
+; 1024 bytes DMA burst, total retries = 16 + 8 * 16 = 144
-        set_io  REG_TXCONFIG
+        mov     eax, (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0
-        out     dx, eax
+        set_io  REG_TXCONFIG
-; enable auto negotiation
+        out     dx, eax
-        set_io  REG_BMCR
+; enable auto negotiation
-        in      ax, dx
+        set_io  REG_BMCR
-        or      ax, (1 shl BIT_ANE)
+        in      ax, dx
-        out     dx, ax
         or      ax, (1 shl BIT_ANE)
-; set auto negotiation advertisement
+        out     dx, ax
-        set_io  REG_ANAR
+; set auto negotiation advertisement
-        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)
+        set_io  REG_ANAR
-        out     dx, ax
+        in      ax, dx
-; lock config and BMCR registers
+        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
         xor     eax, eax
-        set_io  REG_9346CR
-        out     dx, al
+; lock config and BMCR registers
         xor     eax, eax
-; init RX/TX pointers
+        set_io  REG_9346CR
         out     dx, al
-        mov     [device.rx_data_offset], eax
         mov     [device.curr_tx_desc], al
 ; init RX/TX pointers
-;        set_io  REG_CAPR
+        mov     [device.rx_data_offset], eax
-;        out     dx, ax
         mov     [device.curr_tx_desc], al
-; clear packet/byte counters
+;        set_io  REG_CAPR
+;        out     dx, ax
         lea     edi, [device.bytes_tx]
-        mov     ecx, 6
+; clear packet/byte counters
-        rep     stosd
+        lea     edi, [device.bytes_tx]
         mov     ecx, 6
-; clear missing packet counter
+        rep     stosd
         set_io  REG_MPC
-        out     dx, eax
+; clear missing packet counter
-; set RxBuffer address, init RX buffer offset
+        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  2, "RX buffer virtual addr=0x%x\n", eax
-        mov     eax, [device.rx_buffer]
+        GetRealAddr
-        mov     dword[eax], 0
+        DEBUGF  2, "RX buffer real addr=0x%x\n", eax
-        DEBUGF  2, "RX buffer: %x\n", eax
+        set_io  REG_RBSTART
-        GetRealAddr
+        out     dx, eax
-        DEBUGF  2, "RX buffer: %x\n", eax
-        set_io  REG_RBSTART
+; Read MAC address
-        out     dx, eax
+        call    read_mac
 ; Read MAC address
 ; enable Rx/Tx
-        call    read_mac
+        set_io  0
 int_handler:
         DEBUGF  1, "\n%s int\n", my_service
 ; find pointer of device wich made IRQ occur
 ; 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
+        in      ax, dx                          ; Get interrupt status
-        out     dx, ax                              ; send it back to ACK
+        out     dx, ax                          ; send it back to ACK
         test    ax, ax
         jnz     .got_it
   .continue:
         add     esi, 4
         dec     ecx
         jnz     .nextdevice
   .nothing:
         push    ax
   .receive:
         set_io  0
         set_io  REG_COMMAND
-        in      al , dx
+        in      al, dx
-        test    al , BUFE                           ; test if RX buffer is empty
+        test    al, BUFE                        ; test if RX buffer is empty
-        jnz     .finish                             ;
+        jnz     .finish
         DEBUGF  1, "RX: "
         mov     eax, [device.rx_buffer]
         add     eax, [device.rx_data_offset]
-        test    byte [eax], (1 shl BIT_ROK)         ; check if packet is ok
+        test    byte [eax], (1 shl BIT_ROK)     ; check if packet is ok
-        jz      .reset_rx
+        jz      .reset_rx
 ; packet is ok, copy it
-        movzx   ecx, word [eax+2]                   ; packet length
+; packet is ok, copy it
         movzx   ecx, word [eax+2]               ; packet length
-        sub     ecx, 4                              ; don't copy CRC
+        sub     cx, 4                           ; don't copy CRC
 ; Update stats
         add     dword [device.bytes_rx], ecx
         adc     dword [device.bytes_rx + 4], 0
-        inc     dword [device.packets_rx]
+        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
+        stdcall KernelAlloc, ecx                ; Allocate a buffer to put packet into
         pop     ecx
-        test    eax, eax                            ; Test if we allocated succesfully
+        test    eax, eax                        ; Test if we allocated succesfully
         jz      .abort
-        mov     edi, eax                            ; Where we will copy too
+        mov     edi, eax                        ; Where we will copy too
   .nw:
         jz      .nd
         rep     movsd
   .nd:
-        jmp     Eth_input                           ; Send it to kernel
+        jmp     Eth_input                       ; Send it to kernel
   .abort:
         pop     eax ebx
-                                                    ; update eth_data_start_offset
+                                                ; update eth_data_start_offset
-        movzx   eax, word [eax+2]                   ; packet length
+        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
+        add     eax, 4+3                        ; packet header is 4 bytes long + dword alignment
-        and     eax, not 3                          ; dword alignment
+        and     eax, not 3                      ; dword alignment
         cmp     eax, RX_BUFFER_SIZE
         jb      .no_wrap
         DEBUGF  2, "Wrapping"
         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'
+        set_io  REG_CAPR                        ; update 'Current Address of Packet Read register'
-        sub     eax, 0x10                           ; value 0x10 is a constant for CAPR
+        sub     eax, 0x10                       ; value 0x10 is a constant for CAPR
         out     dx , ax
         jz      .no_fae_error
         DEBUGF  1, "\nFrame alignment error!\n"
   .no_fae_error:
         DEBUGF  1, "Reset RX\n"
-        in      al, dx                              ; read command register
+        in      al, dx                          ; read command register
-        push    ax
+        push    ax
-        and     al, not (1 shl BIT_RE)              ; Clear the RE bit
+        and     al, not (1 shl BIT_RE)          ; Clear the RE bit
-        out     dx, al
         out     dx, al
         pop     ax
-        out     dx, al                              ; write original command back
+        out     dx, al                          ; write original command back
-        add     edx, REG_RXCONFIG - REG_COMMAND     ; Restore RX configuration
+        add     edx, REG_RXCONFIG - REG_COMMAND         ; Restore RX configuration
         mov     ax, RX_CONFIG
         out     dx, ax
 ; Something about Cable changed ?
   @@:
         test    ax, ISR_LENCHG
         jz      .fail
         DEBUGF  2, "Cable changed!\n"
         call    cable
   .fail:
 ;;                     ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 cable:
-        DEBUGF  1, "Checking Cable status: "
+        DEBUGF  1, "Updating Cable status\n"
-        mov     edx, dword [device.io_addr]
+        set_io  0
-        add     edx, REG_MSR
+        set_io  REG_MSR
-        in      al , dx
+        in      al, dx
-;        test    al , 1 SHL 2     ; 0 = link ok 1 = link fail
+        test    al, 1 shl 2             ; 0 = link ok 1 = link fail
+        jnz     .notconnected
-;        jnz     .notconnected
+        test    al, 1 shl 3             ; 0 = 100 Mbps 1 = 10 Mbps
+        jnz     .10mbps
+  .100mbps:
-;        test    al , 1 SHL 3     ; 0 = 100 Mbps 1 = 10 Mbps
+        mov     [device.state], ETH_LINK_100M
+        call    NetLinkChanged
+        ret
+  .10mbps:
+        mov     [device.state], ETH_LINK_10M
-;        jnz     .10mbps
+        call    NetLinkChanged
+        ret
         shr     al, 2
-        and     al, 3
+  .notconnected:
 write_mac:      ; in: mac pushed onto stack (as 3 words)
         DEBUGF  2, "Writing MAC: "
 ; disable all in command registers
 ; disable all in command registers
         set_io  0
         set_io  REG_9346CR
         set_io  REG_ISR
         mov     eax, -1
         out     dx, ax
-; enable writing
 ; enable writing
         set_io  REG_9346CR
         mov     eax, REG_9346CR_WE
         out     dx, al
  ; write the mac ...
  ; 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
+        pop     ax
         out     dx, eax
 ; disable writing
 ; disable writing

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/drivers/RTL8139.asm @ 3346 – Rev 3205 → 3346