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

 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+format PE DLL native
-format MS COFF
+entry START
+        CURRENT_API             = 0x0200
-        API_VERSION             = 0x01000100
+        COMPATIBLE_API          = 0x0100
-        DRIVER_VERSION          = 5
         API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
         MAX_DEVICES             = 16
         MAX_DEVICES             = 16
         DEBUG                   = 1
         __DEBUG__               = 1
+        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
+        MAX_PKT_SIZE            = 4096          ; Maximum packet size
         __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
         RX_RING_SIZE            = 8             ; Must be a power of 2, and minimum 8
-        MAX_PKT_SIZE            = 4096          ; Maximum packet size
-        RX_RING_SIZE            = 8             ; Must be a power of 2, and minimum 8
+        TX_RING_SIZE            = 8             ; Must be a power of 2, and minimum 8
-        TX_RING_SIZE            = 8             ; Must be a power of 2, and minimum 8
-include '../struct.inc'
-include '../macros.inc'
-include '../proc32.inc'
-include '../imports.inc'
-include '../fdo.inc'
-include '../netdrv.inc'
+section '.flat' readable writable executable
-public START
+include '../proc32.inc'
-public service_proc
+include '../struct.inc'
 RXDESC_VP               = 0x00000008 ; Packet is 802.1Q
 RXDESC_IXSM             = 0x00000004 ; Ignore cksum indication
 RXDESC_EOP              = 0x00000002 ; End Of Packet
 RXDESC_DD               = 0x00000001 ; Descriptor Done
-virtual at ebx
-        device:
-        ETH_DEVICE
+struct  device          ETH_DEVICE
-        .mmio_addr      dd ?
+        mmio_addr       dd ?
-        .pci_bus        dd ?
+        pci_bus         dd ?
-        .pci_dev        dd ?
+        pci_dev         dd ?
-        .irq_line       db ?
+        irq_line        db ?
-        .cur_rx         dd ?
+        cur_rx          dd ?
-        .cur_tx         dd ?
-        .last_tx        dd ?
+        cur_tx          dd ?
-                        rb 0x100 - (($ - device) and 0xff)      ; align 256
+        last_tx         dd ?
-        .rx_desc        rb RX_RING_SIZE*sizeof.RDESC*2
-                        rb 0x100 - (($ - device) and 0xff)      ; align 256
-        .tx_desc        rb TX_RING_SIZE*sizeof.TDESC*2
+        rb 0x100 - ($ and 0xff) ; align 256
-        sizeof.device_struct = $ - device
+        rx_desc         rb RX_RING_SIZE*sizeof.RDESC*2
-end virtual
+        rb 0x100 - ($ and 0xff) ; align 256
         tx_desc         rb TX_RING_SIZE*sizeof.TDESC*2
-section '.flat' code readable align 16
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                        ;;
+ends
-;; proc START             ;;
-;;                        ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; (standard driver proc) ;;
+;;                        ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; proc START             ;;
 ;;                        ;;
-align 4
-proc START stdcall, state:dword
+;; (standard driver proc) ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
         cmp [state], 1
-        jne .exit
-  .entry:
+proc START stdcall, reason:dword, cmdline:dword
-        DEBUGF  1,"Loading driver\n"
+        cmp     [reason], DRV_ENTRY
-        stdcall RegService, my_service, service_proc
+        jne     .fail
         ret
         jne     @F
         cmp     [edx + IOCTL.out_size], 4
         jb      .fail
         mov     eax, [edx + IOCTL.output]
-        mov     [eax], dword API_VERSION
+        mov     dword[eax], API_VERSION
         xor     eax, eax
-;        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]                             ;
   .nextdevice:
         mov     ebx, [esi]
-        cmp     al, byte [device.pci_bus]
+        cmp     al, byte[ebx + device.pci_bus]
         jne     .next
-        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
   .next:
         add     esi, 4
 ; This device doesnt have its own eth_device structure yet, lets create one
   .firstdevice:
         cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
         jae     .fail
-        allocate_and_clear ebx, sizeof.device_struct, .fail      ; Allocate the buffer for device structure
+        allocate_and_clear ebx, sizeof.device, .fail    ; Allocate the buffer for device structure
 ; 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
 ; save the pci bus and device numbers
         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
-; Now, it's time to find the base mmio addres of the PCI device
+        mov     [ebx + device.pci_dev], ecx
         PCI_find_mmio32
+; Now, it's time to find the base mmio addres of the PCI device
-; Create virtual mapping of the physical memory
+        stdcall PCI_find_mmio32, [ebx + device.pci_bus], [ebx + device.pci_dev] ; returns in eax
-        push    1Bh             ; PG_SW+PG_NOCACHE
+; Create virtual mapping of the physical memory
         push    10000h          ; size of the map
-        push    eax
+        invoke  MapIoMem, eax, 10000h, PG_SW+PG_NOCACHE
-        call    MapIoMem
+        mov     [ebx + device.mmio_addr], eax
-        mov     [device_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
+        mov     [device_list+4*eax], ebx                ; (IRQ handler uses this list to find device)
-        inc     [devices]                                               ;
+        inc     [devices]                               ;
         call    start_i8254x
-        mov     [device.type], NET_TYPE_ETH
-        call    NetRegDev
+        mov     [ebx + device.type], NET_TYPE_ETH
         invoke  NetRegDev
         cmp     eax, -1
         je      .destroy
         ret
 ; If the device was already loaded, find the device number and return it in eax
   .find_devicenum:
         DEBUGF  1,"Trying to find device number of already registered device\n"
   .destroy:
         ; todo: reset device into virgin state
   .err:
-        stdcall KernelFree, ebx
+        invoke  KernelFree, ebx
 align 4
 probe:
         DEBUGF  1,"Probe\n"
+; Make the device a bus master
+        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
         or      al, PCI_CMD_MASTER
-        PCI_make_bus_master
+        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
         ; TODO: validate the device
         call    read_mac
-        movzx   eax, [device.irq_line]
+        movzx   eax, [ebx + device.irq_line]
         DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
-        stdcall AttachIntHandler, eax, int_handler, dword 0
+        invoke  AttachIntHandler, eax, int_handler, ebx
 reset_dontstart:
         DEBUGF  1,"Reset\n"
-        mov     esi, [device.mmio_addr]
+        mov     esi, [ebx + device.mmio_addr]
         or      dword[esi + REG_CTRL], CTRL_RST         ; reset device
   .loop:
         push    esi
         xor     esi, esi
         inc     esi
-        call    Sleep
+        invoke  Sleep
 align 4
 init_rx:
-        lea     edi, [device.rx_desc]
+        lea     edi, [ebx + device.rx_desc]
         mov     ecx, RX_RING_SIZE
   .loop:
         push    ecx
         push    edi
-        stdcall KernelAlloc, MAX_PKT_SIZE
+        invoke  KernelAlloc, MAX_PKT_SIZE
         DEBUGF  1,"RX buffer: 0x%x\n", eax
         pop     edi
         mov     dword[edi + RX_RING_SIZE*sizeof.RDESC], eax
         push    edi
-        GetRealAddr
+        invoke  GetPhysAddr
         pop     edi
         mov     [edi + RDESC.addr_l], eax
         mov     [edi + RDESC.addr_h], 0
         mov     [edi + RDESC.status_l], 0
         mov     [edi + RDESC.status_h], 0
         add     edi, sizeof.RDESC
         pop     ecx
         dec     ecx
         jnz     .loop
-        mov     [device.cur_rx], 0
+        mov     [ebx + device.cur_rx], 0
-        lea     eax, [device.rx_desc]
+        lea     eax, [ebx + device.rx_desc]
-        GetRealAddr
+        invoke  GetPhysAddr
 align 4
 init_tx:
-        lea     edi, [device.tx_desc]
+        lea     edi, [ebx + device.tx_desc]
         mov     ecx, TX_RING_SIZE
   .loop:
         mov     [edi + TDESC.addr_l], eax
         mov     [edi + TDESC.addr_h], 0
         mov     [edi + TDESC.length_cso_cmd], 0
         mov     [edi + TDESC.status], 0
         add     edi, sizeof.TDESC
         dec     ecx
         jnz     .loop
-        mov     [device.cur_tx], 0
+        mov     [ebx + device.cur_tx], 0
-        mov     [device.last_tx], 0
+        mov     [ebx + device.last_tx], 0
-        lea     eax, [device.tx_desc]
+        lea     eax, [ebx + device.tx_desc]
-        GetRealAddr
+        invoke  GetPhysAddr
 reset:
         call    reset_dontstart
 start_i8254x:
-        mov     esi, [device.mmio_addr]
+        mov     esi, [ebx + device.mmio_addr]
         or      dword[esi + REG_RCTL], RCTL_EN          ; Enable the receiver
         xor     eax, eax
         mov     [esi + REG_RDTR], eax                   ; Clear the Receive Delay Timer Register
         mov     [esi + REG_RADV], eax                   ; Clear the Receive Interrupt Absolute Delay Timer
         mov     [esi + REG_RSRPD], eax                  ; Clear the Receive Small Packet Detect Interrupt
         mov     dword[esi + REG_IMS], 0x1F6DC           ; Enable interrupt types
         mov     eax, [esi + REG_ICR]                    ; Clear pending interrupts
 align 4
 read_mac:
         DEBUGF  1,"Read MAC\n"
-        mov     esi, [device.mmio_addr]
+        mov     esi, [ebx + device.mmio_addr]
         mov     eax, [esi+0x5400]                       ; RAL
         test    eax, eax
         jz      .try_eeprom
-        mov     dword[device.mac], eax
+        mov     dword[ebx + device.mac], eax
         mov     eax, [esi+0x5404]                       ; RAH
-        mov     word[device.mac+4], ax
+        mov     word[ebx + device.mac+4], ax
         jmp     .mac_ok
   .try_eeprom:
         mov     dword[esi+0x14], 0x00000001
         mov     eax, [esi+0x14]
         shr     eax, 16
-        mov     word[device.mac], ax
+        mov     word[ebx + device.mac], ax
         mov     dword[esi+0x14], 0x00000101
         mov     eax, [esi+0x14]
         shr     eax, 16
+        mov     word[ebx + device.mac+2], ax
-        mov     word[device.mac+2], ax
         mov     dword[esi+0x14], 0x00000201
-        mov     dword[esi+0x14], 0x00000201
+        mov     eax, [esi+0x14]
         ja      .fail
         cmp     [buffersize], 60
         jb      .fail
 ; Program the descriptor (use legacy mode)
-        mov     edi, [device.cur_tx]
+        mov     edi, [ebx + device.cur_tx]
         DEBUGF  1, "Using TX desc: %u\n", edi
         shl     edi, 4                                          ; edi = edi * sizeof.TDESC
-        lea     edi, [device.tx_desc + edi]
+        lea     edi, [ebx + device.tx_desc + edi]
         mov     dword[edi + TX_RING_SIZE*sizeof.TDESC], eax     ; Store the data location (for driver)
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     [edi + TDESC.addr_l], eax                       ; Data location (for hardware)
         mov     [edi + TDESC.addr_h], 0
         mov     ecx, [buffersize]
         or      ecx, TXDESC_EOP + TXDESC_IFCS + TXDESC_RS
         mov     [edi + TDESC.length_cso_cmd], ecx
         mov     [edi + TDESC.status], 0
-; Tell i8254x wich descriptor(s) we programmed
+; Tell i8254x wich descriptor(s) we programmed, by moving the tail
-        mov     edi, [device.mmio_addr]
+        mov     edi, [ebx + device.mmio_addr]
-        mov     eax, [device.cur_tx]
+        mov     eax, [ebx + device.cur_tx]
         inc     eax
         and     eax, TX_RING_SIZE-1
-        mov     [device.cur_tx], eax
+        mov     [ebx + device.cur_tx], eax
         mov     dword[edi + REG_TDT], eax                        ; TDT - Transmit Descriptor Tail
 ; Update stats
-        inc     [device.packets_tx]
+        inc     [ebx + device.packets_tx]
         mov     eax, [buffersize]
-        add     dword[device.bytes_tx], eax
+        add     dword[ebx + device.bytes_tx], eax
-        adc     dword[device.bytes_tx + 4], 0
+        adc     dword[ebx + device.bytes_tx + 4], 0
         popf
         xor     eax, eax
         ret
   .fail:
         test    ecx, ecx
         jz      .nothing
         mov     esi, device_list
   .nextdevice:
         mov     ebx, [esi]
-        mov     edi, [device.mmio_addr]
+        mov     edi, [ebx + device.mmio_addr]
         mov     eax, [edi + REG_ICR]
         test    eax, eax
         jnz     .got_it
   .continue:
         add     esi, 4
         xor     eax, eax
         ret
   .got_it:
   .got_it:
         DEBUGF  1,"Device: %x Status: %x\n", ebx, eax
         push    eax ebx
   .retaddr:
         pop     ebx eax
 ; Get last descriptor addr
-        mov     esi, [device.cur_rx]
+        mov     esi, [ebx + device.cur_rx]
         shl     esi, 4                                  ; esi = esi * sizeof.RDESC
-        lea     esi, [device.rx_desc + esi]
+        lea     esi, [ebx + device.rx_desc + esi]
         cmp     byte[esi + RDESC.status_h], 0           ; Check status field
         je      .no_rx
         DEBUGF  1,"got %u bytes\n", ecx
         push    ecx
         push    dword[esi + RX_RING_SIZE*sizeof.RDESC]  ; Get packet pointer
 ; Update stats
-        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
-        inc     [device.packets_rx]
+        inc     [ebx + device.packets_rx]
 ; Allocate new descriptor
         push    esi
-        stdcall KernelAlloc, MAX_PKT_SIZE
+        invoke  KernelAlloc, MAX_PKT_SIZE
         pop     esi
         mov     dword[esi + RX_RING_SIZE*sizeof.RDESC], eax
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     [esi + RDESC.addr_l], eax
         mov     [esi + RDESC.status_l], 0
         mov     [esi + RDESC.status_h], 0
 ; Move the receive descriptor tail
-        mov     esi, [device.mmio_addr]
+        mov     esi, [ebx + device.mmio_addr]
-        mov     eax, [device.cur_rx]
+        mov     eax, [ebx + device.cur_rx]
         mov     [esi + REG_RDT], eax
 ; Move to next rx desc
-        inc     [device.cur_rx]
+        inc     [ebx + device.cur_rx]
-        and     [device.cur_rx], RX_RING_SIZE-1
+        and     [ebx + device.cur_rx], RX_RING_SIZE-1
         jz      .no_tx
         DEBUGF  1,"Transmit done\n"
   .txdesc_loop:
-        mov     edi, [device.last_tx]
+        mov     edi, [ebx + device.last_tx]
         shl     edi, 4                                  ; edi = edi * sizeof.TDESC
-        lea     edi, [device.tx_desc + edi]
+        lea     edi, [ebx + device.tx_desc + edi]
         test    [edi + TDESC.status], TXDESC_DD         ; Descriptor done?
         jz      .no_tx
         cmp     dword[edi + TX_RING_SIZE*sizeof.TDESC], 0
         je      .no_tx
         DEBUGF  1,"Cleaning up TX desc: 0x%x\n", edi
         push    ebx
         push    dword[edi + TX_RING_SIZE*sizeof.TDESC]
         mov     dword[edi + TX_RING_SIZE*sizeof.TDESC], 0
-        call    KernelFree
+        invoke  KernelFree
         pop     ebx
-        inc     [device.last_tx]
+        inc     [ebx + device.last_tx]
-        and     [device.last_tx], TX_RING_SIZE-1
+        and     [ebx + device.last_tx], TX_RING_SIZE-1
-        jmp     .txdesc_loop
         jmp     .txdesc_loop
   .no_tx:
-        pop     edi esi ebx
+  .no_tx:
-        xor     eax, eax
+        pop     edi esi ebx
-        inc     eax
+        xor     eax, eax
-        ret
+        inc     eax
+        ret

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/i8254x.asm – Rev 4521 → 4522