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

 ;;  Updates:                                                          ;;
 ;;    Revision Look up table and SIS635 Mac Address by Jarek Pelczar  ;;
 ;;                                                                    ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+format PE DLL native
+entry START
+        CURRENT_API             = 0x0200
+        COMPATIBLE_API          = 0x0100
-format MS COFF
+        API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
         NUM_RX_DESC             = 4             ; Number of RX descriptors
-        NUM_TX_DESC             = 4             ; Number of TX descriptors
-        RX_BUFF_SZ              = 1520          ; Buffer size for each Rx buffer
-        TX_BUFF_SZ              = 1516          ; Buffer size for each Tx buffer
-        MAX_ETH_FRAME_SIZE      = 1516
-        API_VERSION             = 0x01000100
+        NUM_TX_DESC             = 4             ; Number of TX descriptors
-        DRIVER_VERSION          = 5
         RX_BUFF_SZ              = 1520          ; Buffer size for each Rx buffer
-        MAX_DEVICES             = 16
         MAX_DEVICES             = 16
         DEBUG                   = 1
         __DEBUG__               = 1
 ; For SiS962 or SiS963, request the eeprom software access
         EEREQ           = 0x00000400
         EEDONE          = 0x00000200
         EEGNT           = 0x00000100
+section '.flat' readable writable executable
 include '../proc32.inc'
 include '../struct.inc'
-include '../macros.inc'
-include '../proc32.inc'
-include '../imports.inc'
+include '../macros.inc'
 include '../fdo.inc'
-include '../netdrv.inc'
-public START
-public version
-virtual at ebx
-        device:
-        ETH_DEVICE
-        .io_addr        dd ?
-        .pci_bus        dd ?
+include '../netdrv_pe.inc'
-        .pci_dev        dd ?
-        .irq_line       db ?
-        .cur_rx         db ?
-        .cur_tx         db ?
-        .last_tx        db ?
+struct  device          ETH_DEVICE
+        io_addr         dd ?
+        pci_bus         dd ?
+        pci_dev         dd ?
+        irq_line        db ?
+        cur_rx          db ?
+        cur_tx          db ?
+        last_tx         db ?
-        .pci_revision   db ?
+        pci_revision    db ?
-        .table_entries  db ?
+        table_entries   db ?
-        rb 2    ; alignment
-        .txd            rd (4 * NUM_TX_DESC)
-        .rxd            rd (4 * NUM_RX_DESC)
+        rb 0x100 - ($ and 0xff) ; align 256
         txd             rd (4 * NUM_TX_DESC)
-        .size = $ - device
+        rxd             rd (4 * NUM_RX_DESC)
         in      eax, dx
         in      eax, dx
         pop     eax
+}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                        ;;
+;; proc START             ;;
+;;                        ;;
+;; (standard driver proc) ;;
-section '.flat' code readable align 16
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; Driver entry point - register our service when the driver is loading.
+; TODO: add needed operations when unloading
-; Driver entry point - register our service when the driver is loading.
-; TODO: add needed operations when unloading
+proc START c, reason:dword, cmdline:dword
-START:
+        cmp     [reason], DRV_ENTRY
+        jne     .fail
-        cmp     dword [esp+4], 1
-        jne     .exit
+        DEBUGF  2,"Loading driver\n"
+        invoke  RegService, my_service, service_proc
-        stdcall RegService, my_service, service_proc
+        ret
         ret     4
-  .exit:
+  .fail:
+        xor     eax, eax
+        ret
+endp
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                        ;;
+;; proc SERVICE_PROC      ;;
+;;                        ;;
-        xor     eax, eax
+;; (standard driver proc) ;;
-        ret     4
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; Service procedure for the driver - handle all I/O requests for the driver.
-;        mov     eax, [edx + IOCTL.input]               ; get the pci bus and device numbers
+;        mov     eax, [edx + IOCTL.input]                ; get the pci bus and device numbers
-        mov     ax, [eax+1]                            ;
+        mov     ax, [eax+1]                             ;
   .nextdevice:
         mov     ebx, [esi]
-        cmp     al, byte[device.pci_bus]
+        cmp     al, byte[ebx + device.pci_bus]
         jne     @f
-        cmp     ah, byte[device.pci_dev]
+        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
 ; 4f. Check that we have place for new device.
         cmp     [devices], MAX_DEVICES
         jae     .fail
 ; 4g. Allocate memory for device descriptor and receive+transmit buffers.
 ; 4h. Zero the structure.
-        allocate_and_clear ebx, device.size, .fail
+        allocate_and_clear ebx, sizeof.device, .fail
 ; 4i. Save PCI coordinates
         mov     eax, [edx + IOCTL.input]
         movzx   ecx, byte[eax+1]
-        mov     [device.pci_bus], ecx
+        mov     [ebx + device.pci_bus], ecx
         movzx   ecx, byte[eax+2]
-        mov     [device.pci_dev], ecx
+        mov     [ebx + device.pci_dev], ecx
 ; 4j. Fill in the direct call addresses into the struct.
-        mov     [device.reset], reset
+        mov     [ebx + device.reset], reset
-        mov     [device.transmit], transmit
+        mov     [ebx + device.transmit], transmit
-        mov     [device.unload], unload
+        mov     [ebx + device.unload], unload
-        mov     [device.name], my_service
+        mov     [ebx + device.name], my_service
 ; 4k. Now, it's time to find the base io addres of the PCI device
 ; TODO: implement check if bus and dev exist on this machine
+; Now, it's time to find the base io addres of the PCI device
-; 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
-        PCI_find_io
+; We've found the io address, find IRQ now
-; We've found the io address, find IRQ now
+        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
-        PCI_find_irq
+        mov     [ebx + device.irq_line], al
         call    probe
         test    eax, eax
         jnz     .destroy
 ; 4n. If device was successfully initialized, register it for the kernel.
-        mov     [device.type], NET_TYPE_ETH
+        mov     [ebx + device.type], NET_TYPE_ETH
-        call    NetRegDev
+        invoke  NetRegDev
         cmp     eax, -1
         je      .destroy
         ret     4
 ; 5. If the device was already loaded, find the device number and return it in eax
   .find_devicenum:
   .destroy:
         dec     [devices]
         ; todo: reset device into virgin state
   .err:
-        stdcall KernelFree, ebx
+        invoke  KernelFree, ebx
   .fail:
 ;***************************************************************************
 align 4
 probe:
         DEBUGF  1, "Probe\n"
+; wake up device
-; wake up device   CHECKME
+; TODO: check capabilities pointer instead of using hardcoded offset.
-        stdcall PciWrite8, [device.pci_bus], [device.pci_dev], 0x40, 0
+        invoke  PciWrite8, [ebx + device.pci_bus], [ebx + device.pci_dev], 0x40, 0
+; Make the device a bus master
+        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
+        or      al, PCI_CMD_MASTER
-        PCI_make_bus_master
+        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
+; Adjust PCI latency to be at least 64
+        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.max_latency
+        cmp     al, 64
+        jae     @f
+        mov     al, 64
+        invoke  PciWrite8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.max_latency, eax
-        PCI_adjust_latency 64
+  @@:
 ; Get Card Revision
-        stdcall PciRead8, [device.pci_bus], [device.pci_dev], 0x08
+        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], 0x08
-        mov     [device.pci_revision], al       ; save the revision for later use
+        mov     [ebx + device.pci_revision], al         ; save the revision for later use
 ; Look up through the specific_table
         mov     esi, specific_table
   .tableloop:
-        cmp     dword [esi], 0                  ; Check if we reached end of the list
+        cmp     dword[esi], 0                           ; Check if we reached end of the list
         je      .notsupported
-        cmp     al, [esi]                       ; Check if revision is OK
+        cmp     al, [esi]                               ; Check if revision is OK
-        je      .ok
-        add     esi, 12                         ; Advance to next entry
+        je      .ok
-        jmp     .tableloop
         add     esi, 12                                 ; Advance to next entry
-  .ok:
+        jmp     .tableloop
+  .ok:
-        call     dword[esi + 4]                 ; "get MAC" function
+        call     dword[esi + 4]                         ; "get MAC" function
 ; Set table entries
-        mov      [device.table_entries], 16
+        mov      [ebx + device.table_entries], 16
-        cmp      [device.pci_revision], SIS635A_900_REV
+        cmp      [ebx + device.pci_revision], SIS635A_900_REV
         jae      @f
-        cmp      [device.pci_revision], SIS900B_900_REV
+        cmp      [ebx + device.pci_revision], SIS900B_900_REV
-        je       @f
-        mov      [device.table_entries], 8
+        je       @f
-       @@:
+        mov      [ebx + device.table_entries], 8
+       @@:
 ; TODO: Probe for mii transceiver
 ; TODO: Probe for mii transceiver
         jmp     reset
   .notsupported:
-        DEBUGF  1, "Device not supported\n"
+        DEBUGF  2, "Device not supported\n"
+        or      eax, -1
+        ret
+reset:
-        or      eax, -1
+        DEBUGF  1, "reset\n"
-        ret
+        movzx   eax, [ebx + device.irq_line]
+        invoke  AttachIntHandler, eax, int_handler, ebx
-reset:
+        test    eax, eax
         jnz     @f
-        DEBUGF  1, "reset\n"
+        DEBUGF  2,"Could not attach int handler!\n"
         or      eax, -1
-        movzx   eax, [device.irq_line]
+        ret
-        stdcall AttachIntHandler, eax, int_handler, 0
+       @@:
 ;--------------------------------------------
 ; Disable Interrupts and reset Receive Filter
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  ier
+        set_io  [ebx + device.io_addr], ier
         xor     eax, eax
         out     dx, eax
-        set_io  imr
+        set_io  [ebx + device.io_addr], imr
         out     dx, eax
-        set_io  rfcr
+        set_io  [ebx + device.io_addr], rfcr
         out     dx, eax
         DEBUGF  1, "status=%x\n", eax
 ;------------------------------------------------------
 ; Set Configuration Register depending on Card Revision
-        set_io  cfg
+        set_io  [ebx + device.io_addr], cfg
-        mov     eax, PESEL                      ; Configuration Register Bit
+        mov     eax, PESEL                              ; Configuration Register Bit
-        cmp     [device.pci_revision], SIS635A_900_REV
+        cmp     [ebx + device.pci_revision], SIS635A_900_REV
         je      .match
-        cmp     [device.pci_revision], SIS900B_900_REV ; Check card revision
+        cmp     [ebx + device.pci_revision], SIS900B_900_REV ; Check card revision
         jne     .done
-  .match:                                       ; Revision match
+  .match:                                               ; Revision match
-        or      eax, RND_CNT                    ; Configuration Register Bit
+        or      eax, RND_CNT                            ; Configuration Register Bit
   .done:
         out     dx, eax
         DEBUGF  1, "Initialising RX Filter\n"
 ; Get Receive Filter Control Register
-        set_io  rfcr
+        set_io  [ebx + device.io_addr], rfcr
 ; load MAC addr to filter data register
         xor     ecx, ecx
   .macloop:
         mov     eax, ecx
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  rfcr
+        set_io  [ebx + device.io_addr], rfcr
-        shl     eax, 16                                             ; high word of eax tells card which mac byte to write
+        shl     eax, 16                                 ; high word of eax tells card which mac byte to write
-        out     dx, eax                                             ;
+        out     dx, eax                                 ;
-        set_io  rfdr
+        set_io  [ebx + device.io_addr], rfdr
-        mov     ax, word [device.mac + ecx*2]                       ; Get Mac ID word
+        mov     ax, word [ebx + device.mac + ecx*2]     ; Get Mac ID word
-        out     dx, ax                                              ; Send Mac ID
+        out     dx, ax                                  ; Send Mac ID
-        inc     cl                                                  ; send next word
+        inc     cl                                      ; send next word
-        cmp     cl, 3                                               ; more to send?
+        cmp     cl, 3                                   ; more to send?
         jne     .macloop
 ; enable packet filtering
-        pop     eax                     ; old register value
+        pop     eax                                     ; old register value
-        set_io  rfcr
+        set_io  [ebx + device.io_addr], rfcr
-        or      eax, RFEN               ; enable filtering
+        or      eax, RFEN                               ; enable filtering
-        out     dx, eax                 ; set register
+        out     dx, eax                                 ; set register
         DEBUGF  1, "Initialising TX Descriptors\n"
         mov     ecx, NUM_TX_DESC
-        lea     esi, [device.txd]
+        lea     esi, [ebx + device.txd]
   .txdescloop:
-        lea     eax, [esi + 16]                 ; next ptr
+        lea     eax, [esi + 16]                         ; next ptr
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     dword [esi], eax                ; link to next desc
+        mov     dword[esi], eax                         ; link to next desc
-        mov     dword [esi + 4], 0              ; status field
+        mov     dword[esi + 4], 0                       ; status field
-        mov     dword [esi + 8], 0              ; ptr to buffer
+        mov     dword[esi + 8], 0                       ; ptr to buffer
         add     esi, 16
         dec     ecx
         jnz     .txdescloop
-        lea     eax, [device.txd]
+        lea     eax, [ebx + device.txd]
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     dword [esi - 16], eax           ; correct last descriptor link ptr
+        mov     dword[esi - 16], eax                    ; correct last descriptor link ptr
-        set_io  txdp                            ; TX Descriptor Pointer
+        set_io  [ebx + device.io_addr], txdp            ; TX Descriptor Pointer
-;        lea     eax, [device.txd]
+;        lea     eax, [ebx + device.txd]
-;        GetRealAddr
+;        invoke  GetPhysAddr
         out     dx, eax
-        mov     [device.cur_tx], 0              ; Set current tx descriptor to 0
+        mov     [ebx + device.cur_tx], 0                ; Set current tx descriptor to 0
-        mov     [device.last_tx], 0
+        mov     [ebx + device.last_tx], 0
         DEBUGF  1, "Initialising RX Descriptors\n"
         mov     ecx, NUM_RX_DESC
-        lea     esi, [device.rxd]
+        lea     esi, [ebx + device.rxd]
   .rxdescloop:
-        lea     eax, [esi + 16]                 ; next ptr
+        lea     eax, [esi + 16]                         ; next ptr
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     dword [esi], eax
-        mov     dword [esi + 4], RX_BUFF_SZ     ; size
+        mov     dword [esi + 4], RX_BUFF_SZ             ; size
         push    ecx esi
-        stdcall KernelAlloc, RX_BUFF_SZ
+        invoke  KernelAlloc, RX_BUFF_SZ
         pop     esi ecx
         test    eax, eax
         jz      .fail
-        mov     dword [esi + 12], eax           ; address
+        mov     dword [esi + 12], eax                   ; address
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     dword [esi + 8], eax            ; real address
+        mov     dword [esi + 8], eax                    ; real address
         add     esi, 16
         dec     ecx
         jnz     .rxdescloop
-        lea     eax, [device.rxd]
+        lea     eax, [ebx + device.rxd]
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     dword [esi - 16], eax           ; correct last descriptor link ptr
+        mov     dword [esi - 16], eax                   ; correct last descriptor link ptr
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  rxdp
+        set_io  [ebx + device.io_addr], rxdp
-;        lea     eax, [device.rxd]
+;        lea     eax, [ebx + device.rxd]
-;        GetRealAddr
+;        invoke  GetPhysAddr
         out     dx, eax
-        mov     [device.cur_rx], 0              ; Set current rx descriptor to 0
+        mov     [ebx + device.cur_rx], 0                ; Set current rx descriptor to 0
         DEBUGF  1, "setting RX mode\n"
         xor     cl, cl
   .rxfilterloop:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  rfcr                    ; Receive Filter Control Reg offset
+        set_io  [ebx + device.io_addr], rfcr            ; Receive Filter Control Reg offset
-        mov     eax, 4                  ; determine table entry
+        mov     eax, 4                                  ; determine table entry
         add     al, cl
         shl     eax, 16
-        out     dx, eax                 ; tell card which entry to modify
+        out     dx, eax                                 ; tell card which entry to modify
         set_io  rfdr                    ; Receive Filter Control Reg offset
-        mov     eax, 0xffff             ; entry value
+        set_io  [ebx + device.io_addr], rfdr            ; Receive Filter Control Reg offset
-        out     dx, ax                  ; write value to table in card
+        mov     eax, 0xffff                             ; entry value
+        out     dx, ax                                  ; write value to table in card
         inc     cl                      ; next entry
-        cmp     cl, [device.table_entries]
+        inc     cl                                      ; next entry
-        jb      .rxfilterloop
+        cmp     cl, [ebx + device.table_entries]
         jb      .rxfilterloop
         set_io  rfcr                    ; Receive Filter Control Register offset
-        mov     eax, RFAAB + RFAAM + RFAAP + RFEN
+        set_io  [ebx + device.io_addr], rfcr            ; Receive Filter Control Register offset
-        out     dx, eax
+        mov     eax, RFAAB + RFAAM + RFAAP + RFEN
         out     dx, eax
         set_io  rxcfg                   ; Receive Config Register offset
-        mov     eax, ATX + RX_DMA + 2   ; 0x2 : RX Drain Threshold = 8*8=64 bytes
+        set_io  [ebx + device.io_addr], rxcfg           ; Receive Config Register offset
-        out     dx, eax
+        mov     eax, ATX + RX_DMA + 2                   ; 0x2 : RX Drain Threshold = 8*8=64 bytes
+        out     dx, eax
         DEBUGF  1, "setting TX mode\n"
         DEBUGF  1, "setting TX mode\n"
         set_io  txcfg                   ; Transmit config Register offset
-        mov     eax, ATP + HBI + CSI + TX_DMA + 0x120
+        set_io  [ebx + device.io_addr], txcfg           ; Transmit config Register offset
-                                        ; TX Fill threshold = 0x100
+        mov     eax, ATP + HBI + CSI + TX_DMA + 0x120   ; TX Fill threshold = 0x100
-                                        ; TX Drain Threshold = 0x20
+                                                        ; TX Drain Threshold = 0x20
 ; Return 0 is EAX = failure
+;
 ;***************************************************************************
 align 4
 SIS960_get_mac_addr:
-        DEBUGF  1, "SIS960 - get mac: "
+        DEBUGF  1, "SIS960 - get mac:\n"
 ;-------------------------------
 ; Send Request for eeprom access
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  mear            ; Eeprom access register
+        set_io  [ebx + device.io_addr], mear            ; Eeprom access register
-        mov     eax, EEREQ      ; Request access to eeprom
+        mov     eax, EEREQ                              ; Request access to eeprom
-        out     dx, eax         ; Send request
+        out     dx, eax                                 ; Send request
-        in      eax, dx         ; get eeprom status
+        in      eax, dx                                 ; get eeprom status
-        test    eax, EEGNT      ; see if eeprom access granted flag is set
+        test    eax, EEGNT                              ; see if eeprom access granted flag is set
-        jnz     .got_access     ; if it is, go access the eeprom
+        jnz     .got_access                             ; if it is, go access the eeprom
-        loop    .loop           ; else keep waiting
+        loop    .loop                                   ; else keep waiting
-        DEBUGF  1, "Access to EEprom failed!\n", 0
+        DEBUGF  2, "Access to EEprom failed!\n", 0
-        set_io  mear            ; Eeprom access register
+        set_io  [ebx + device.io_addr], mear            ; Eeprom access register
-        mov     eax, EEDONE     ; tell eeprom we are done
+        mov     eax, EEDONE                             ; tell eeprom we are done
         out     dx, eax
-        mov     eax, EEPROMMACAddr      ; Base Mac Address
+        mov     eax, EEPROMMACAddr                      ; Base Mac Address
-        add     eax, ecx                ; Current Mac Byte Offset
+        add     eax, ecx                                ; Current Mac Byte Offset
         push    ecx
-        call    read_eeprom             ; try to read 16 bits
+        call    read_eeprom                             ; try to read 16 bits
         pop     ecx
-        mov     word [device.mac+ecx*2], ax     ; save 16 bits to the MAC ID varible
+        mov     word [ebx + device.mac+ecx*2], ax       ; save 16 bits to the MAC ID varible
-        dec     ecx                     ; one less word to read
+        dec     ecx                                     ; one less word to read
-        jns     .read_loop              ; if more read more
+        jns     .read_loop                              ; if more read more
-        mov     eax, 1                  ; return non-zero indicating success
+        mov     eax, 1                                  ; return non-zero indicating success
+        DEBUGF  1,"%x-%x-%x-%x-%x-%x\n",\
-        DEBUGF  2,"%x-%x-%x-%x-%x-%x\n",[device.mac]:2,[device.mac+1]:2,[device.mac+2]:2,[device.mac+3]:2,[device.mac+4]:2,[device.mac+5]:2
+        [ebx + device.mac]:2,[ebx + device.mac+1]:2,[ebx + device.mac+2]:2,[ebx + device.mac+3]:2,[ebx + device.mac+4]:2,[ebx + device.mac+5]:2
 ;-------------------------------------
 ; Tell EEPROM We are Done Accessing It
   .done:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  mear            ; Eeprom access register
+        set_io  [ebx + device.io_addr], mear            ; Eeprom access register
-        mov     eax, EEDONE     ; tell eeprom we are done
+        mov     eax, EEDONE                             ; tell eeprom we are done
 ; Older SiS900 and friends, use EEPROM to store MAC address.
+;
 ;***************************************************************************
 align 4
 SIS900_get_mac_addr:
-        DEBUGF  1, "SIS900 - get mac: "
+        DEBUGF  1, "SIS900 - get mac:\n"
 ;------------------------------------
 ; check to see if we have sane EEPROM
-        mov     eax, EEPROMMACAddr      ; Base Mac Address
+        mov     eax, EEPROMMACAddr                      ; Base Mac Address
-        add     eax, ecx                ; Current Mac Byte Offset
+        add     eax, ecx                                ; Current Mac Byte Offset
         push    ecx
-        call    read_eeprom             ; try to read 16 bits
+        call    read_eeprom                             ; try to read 16 bits
         pop     ecx
-        mov     word [device.mac+ecx*2], ax     ; save 16 bits to the MAC ID storage
+        mov     word [ebx + device.mac+ecx*2], ax       ; save 16 bits to the MAC ID storage
-        dec     ecx                             ; one less word to read
+        dec     ecx                                     ; one less word to read
-        jns     .loop                           ; if more read more
+        jns     .loop                                   ; if more read more
+        DEBUGF  1,"%x-%x-%x-%x-%x-%x\n",\
-        DEBUGF  2,"%x-%x-%x-%x-%x-%x\n",[device.mac]:2,[device.mac+1]:2,[device.mac+2]:2,[device.mac+3]:2,[device.mac+4]:2,[device.mac+5]:2
+        [ebx + device.mac]:2,[ebx + device.mac+1]:2,[ebx + device.mac+2]:2,[ebx + device.mac+3]:2,[ebx + device.mac+4]:2,[ebx + device.mac+5]:2
 ; Get_Mac_SIS635_900_REV: - Get MAC address for model 635
+;
 ;***************************************************************************
 align 4
 Get_Mac_SIS635_900_REV:
-        DEBUGF  1, "SIS635 - get mac: "
+        DEBUGF  1, "SIS635 - get mac:\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  rfcr
+        set_io  [ebx + device.io_addr], rfcr
         in      eax, dx
         mov     esi, eax
-        set_io  cr
+        set_io  [ebx + device.io_addr], cr
         or      eax, RELOAD
         out     dx, eax
         xor     eax, eax
         out     dx, eax
 ;-----------------------------------------------
 ; Disable packet filtering before setting filter
-        set_io  rfcr
+        set_io  [ebx + device.io_addr], rfcr
         mov     eax, esi
         and     eax, not RFEN
         out     dx, eax
 ;---------------------------------
 ; Load MAC to filter data register
         xor     ecx, ecx
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
   .loop:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  rfcr
+        set_io  [ebx + device.io_addr], rfcr
         mov     eax, ecx
         shl     eax, RFADDR_shift
         out     dx, eax
-        set_io  rfdr
+        set_io  [ebx + device.io_addr], rfdr
         in      ax, dx
         stosw
         inc     ecx
+        cmp     ecx, 3
-        cmp     ecx, 3
+        jb      .loop
         jb      .loop
 ;------------------------
-;------------------------
+; Enable packet filtering
+;
 ;***************************************************************************
 align 4
 read_eeprom:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  mear
+        set_io  [ebx + device.io_addr], mear
-        xor     eax, eax              ; start send
+        xor     eax, eax                                ; start send
 align 4
 write_mac:
 ;         size of buffer in [esp+8]
 ;         pointer to device structure in ebx
+;
 ;***************************************************************************
 align 4
+proc transmit stdcall bufferptr, buffersize
+        pushf
-transmit:
+        cli
-        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n",[esp+4],[esp+8]
+        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
-        mov     eax, [esp+4]
+        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     dword [esp + 8], MAX_ETH_FRAME_SIZE
+        cmp     [buffersize], 1514
-        ja      .error
+        ja      .fail
-        cmp     dword [esp + 8], 60
+        cmp     [buffersize], 60
-        jb      .error
+        jb      .fail
-        movzx   ecx, [device.cur_tx]
+        movzx   ecx, [ebx + device.cur_tx]
-        shl     ecx, 4                  ; *16
+        shl     ecx, 4                                  ; *16
-        lea     ecx, [device.txd + ecx]
+        lea     ecx, [ebx + device.txd + ecx]
-        test    dword [ecx + 4], 0x80000000     ; card owns descriptor ?
+        test    dword[ecx + 4], 0x80000000              ; card owns descriptor ?
-        jnz     .error
+        jnz     .fail
-        mov     eax, [esp + 4]
+        mov     eax, [bufferptr]
-        mov     dword [ecx + 12], eax
+        mov     dword[ecx + 12], eax
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     dword [ecx + 8], eax    ; buffer address
+        mov     dword[ecx + 8], eax                     ; buffer address
-        mov     eax, [esp + 8]
+        mov     eax, [buffersize]
         and     eax, DSIZE
-        or      eax, 0x80000000         ; card owns descriptor
+        or      eax, 0x80000000                         ; card owns descriptor
-        mov     dword [ecx + 4], eax    ; status field
+        mov     dword[ecx + 4], eax                     ; status field
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  cr
+        set_io  [ebx + device.io_addr], cr
         in      eax, dx
-        or      eax, TxENA              ; Enable the transmit state machine
+        or      eax, TxENA                              ; Enable the transmit state machine
         out     dx, eax
-        inc     [device.cur_tx]
-        and     [device.cur_tx], NUM_TX_DESC-1
+        inc     [ebx + device.cur_tx]
+        and     [ebx + device.cur_tx], NUM_TX_DESC-1
 ; update stats
-        mov     ecx, [esp + 8]
+        mov     ecx, [buffersize]
-        inc     [device.packets_tx]
+        inc     [ebx + device.packets_tx]
-        add     dword [device.bytes_tx], ecx
+        add     dword [ebx + device.bytes_tx], ecx
+        adc     dword [ebx + device.bytes_tx + 4], 0
         adc     dword [device.bytes_tx + 4], 0
+        DEBUGF  1,"Transmit OK\n"
+        popf
+        xor     eax, eax
-  .finish:
+        ret
         DEBUGF  1,"Packet sent!\n"
-        xor     eax, eax
+  .fail:
 align 4
 int_handler:
         push    ebx esi edi
-        DEBUGF  1,"\n%s int\n", my_service
+        DEBUGF  1,"INT\n"
 ; find pointer of device which made IRQ occur
         mov     ecx, [devices]
         test    ecx, ecx
         jz      .nothing
         mov     esi, device_list
   .nextdevice:
         mov     ebx, [esi]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  isr
+        set_io  [ebx + device.io_addr], isr
         ret
   .got_it:
-        DEBUGF  1,"Device: %x Status: %x ", ebx, ax
+        DEBUGF  1,"Device: %x Status: %x\n", ebx, ax
         test    ax, RxOK
         jz      .no_rx_
         push    ax
   .rx_loop:
 ;-----------
 ; Get Status
-        and     ecx, DSIZE                      ; get packet size minus CRC
+        and     ecx, DSIZE                              ; get packet size minus CRC
-        sub     ecx, CRC_SIZE                   ; make sure packet contains data
+        sub     ecx, CRC_SIZE                           ; make sure packet contains data
         jbe     .error_size
 ; update statistics
-        inc     dword [device.packets_rx]
+        inc     dword [ebx + device.packets_rx]
-        add     dword [device.bytes_rx], ecx
+        add     dword [ebx + device.bytes_rx], ecx
-        adc     dword [device.bytes_rx + 4], 0
+        adc     dword [ebx + device.bytes_rx + 4], 0
         push    ebx
         push    .return
-        push    ecx                             ; packet size
+        push    ecx                                     ; packet size
-        pushd   [device.rxd + eax + 12]         ; packet ptr
+        pushd   [ebx + device.rxd + eax + 12]           ; packet ptr
         DEBUGF  1, "Packet received OK\n"
-        jmp     Eth_input
+        jmp     [Eth_input]
   .return:
         pop     ebx
 ; Reset status, allow ethernet card access to descriptor
-        stdcall KernelAlloc, RX_BUFF_SZ
+        invoke  KernelAlloc, RX_BUFF_SZ
         test    eax, eax
         jz      .fail
-        movzx   ecx, [device.cur_rx]
+        movzx   ecx, [ebx + device.cur_rx]
-        shl     ecx, 4                          ; *16
+        shl     ecx, 4                                  ; *16
-        lea     ecx, [device.rxd + ecx]
+        lea     ecx, [ebx + device.rxd + ecx]
         mov     dword [ecx + 12], eax
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     dword [ecx + 8], eax
         mov     dword [ecx + 4], RX_BUFF_SZ
-        inc     [device.cur_rx]                         ; get next descriptor
+        inc     [ebx + device.cur_rx]                   ; get next descriptor
-        and     [device.cur_rx], NUM_RX_DESC-1          ; only 4 descriptors 0-3
+        and     [ebx + device.cur_rx], NUM_RX_DESC-1    ; only 4 descriptors 0-3
         jmp     .rx_loop
   .no_rx:
         jz      .no_tx
         DEBUGF  1, "TX ok!\n"
   .tx_loop:
-        movzx   ecx, [device.last_tx]
+        movzx   ecx, [ebx + device.last_tx]
         shl     ecx, 4                  ; *16
-        lea     ecx, [device.txd + ecx]
+        lea     ecx, [ebx + device.txd + ecx]
-        test    dword [ecx + 4], 0x80000000   ; card owns descr
+        test    dword[ecx + 4], 0x80000000              ; card owns descr
         jnz     .no_tx
-        cmp     dword [ecx + 12], 0
+        cmp     dword[ecx + 12], 0
         je      .no_tx
         DEBUGF  1, "Freeing packet = %x\n", [ecx + 12]:8
-        push    dword [ecx + 12]
+        push    dword[ecx + 12]
-        mov     dword [ecx + 12], 0
+        mov     dword[ecx + 12], 0
-        call    KernelFree
+        invoke  KernelFree
-        inc     [device.last_tx]
+        inc     [ebx + device.last_tx]
         ret
         ret
   .error_status:
-        DEBUGF  1, "Packet error: %x\n", ecx
+        DEBUGF  2, "Packet error: %x\n", ecx
         jmp     .fail
   .error_size:
+        DEBUGF  2, "Packet too large/small\n"
-        DEBUGF  1, "Packet too large/small\n"
+        jmp     .fail
-        jmp     .fail
 ; End of code
     dd SIS635A_900_REV, Get_Mac_SIS635_900_REV, 0
     dd SIS900_960_REV, SIS960_get_mac_addr, 0
     dd SIS900B_900_REV, SIS900_get_mac_addr, 0
-    dd 0                                        ; end of list
+    dd 0                                                ; end of list
-version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
-my_service      db 'SIS900',0                  ; max 16 chars include zero
-include_debug_strings                          ; All data wich FDO uses will be included here
+include_debug_strings                                   ; All data wich FDO uses will be included here
-section '.data' data readable writable align 16; place all uninitialized data place here
+align 4

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/sis900.asm – Rev 4470 → 5006