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

 ;; Broadcom's programmers's manual for the BCM57xx                 ;;
 ;; http://www.broadcom.com/collateral/pg/57XX-PG105-R.pdf          ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+format PE DLL native
-        ; TODO: make better use of the available descriptors
-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_LEVEL__         = 2
         DEBUG                   = 1
-        __DEBUG__               = 1
-        __DEBUG_LEVEL__         = 2
 section '.flat' readable writable executable
-include '../struct.inc'
-include '../macros.inc'
-include '../proc32.inc'
-include '../imports.inc'
-include '../fdo.inc'
+include '../proc32.inc'
+include '../struct.inc'
-include '../netdrv.inc'
+include '../macros.inc'
+include '../fdo.inc'
-public START
+include '../netdrv_pe.inc'
-public service_proc
-public version
+struct  device          ETH_DEVICE
-virtual at ebx
-        device:
+        mmio_addr       dd ?
-        ETH_DEVICE
+        pci_bus         dd ?
+        pci_dev         dd ?
-        .mmio_addr      dd ?
-        .pci_bus        dd ?
-        .pci_dev        dd ?
-        .irq_line       db ?
-        .cur_tx         dd ?
+        irq_line        db ?
-        .last_tx        dd ?
                         rb 0x100 - (($ - device) and 0xff)
-        .rx_desc        rd 256/8
+        cur_tx          dd ?
         last_tx         dd ?
                         rb 0x100 - (($ - device) and 0xff)
-        .tx_desc        rd 256/8
+        rb 0x100 - ($ and 0xff) ; align 256
         rx_desc         rd 256/8
-        sizeof.device_struct = $ - device
-end virtual
+        rb 0x100 - ($ and 0xff) ; align 256
+        tx_desc         rd 256/8
-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
 proc START c, reason:dword, cmdline:dword
   .entry:
-        DEBUGF  2,"Loading driver\n"
+        cmp     [reason], DRV_ENTRY
-        stdcall RegService, my_service, service_proc
+        jne     .fail
         ret
 ;        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
+        mov     [ebx + device.pci_dev], ecx
 ; Now, it's time to find the base mmio addres of the PCI device
-        PCI_find_mmio32
+        stdcall PCI_find_mmio32, [ebx + device.pci_bus], [ebx + device.pci_dev]
+; Create virtual mapping of the physical memory
 ; Create virtual mapping of the physical memory
+        push    1Bh             ; PG_SW+PG_NOCACHE
-        push    1Bh             ; PG_SW+PG_NOCACHE
+        push    10000h          ; size of the map
-        push    10000h          ; size of the map
+        push    eax
-        push    eax
+        invoke  MapIoMem
-        call    MapIoMem
+        mov     [ebx + device.mmio_addr], eax
         mov     [device.mmio_addr], eax
 ; We've found the mmio address, find IRQ now
 ; We've found the mmio 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
         DEBUGF  1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
-        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.mmio_addr]:8
+        [ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.mmio_addr]:8
 ; 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)
   .destroy:
         ; todo: reset device into virgin state
   .err:
-        stdcall KernelFree, ebx
+        invoke  KernelFree, ebx
 ;;                                                                        ;;
 ;;        Actual Hardware dependent code starts here                      ;;
 ;;                                                                        ;;
 ;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 align 4
 unload:
         ; TODO: (in this particular order)
+        ;
         ; - Stop the device
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
-;;  probe: enables the device (if it really is I8254X)
+;;  probe: enables the device (if it really is BCM57XX)
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-align 4
+probe:
+        DEBUGF  1,"Probe\n"
-probe:
-        DEBUGF  1,"Probe\n"
+; Make the device a bus master
         invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
-        PCI_make_bus_master
+        or      al, PCI_CMD_MASTER
         invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
-        ; TODO: validate the device
         ; TODO: validate the device
 align 4
 reset:
         DEBUGF  1,"Reset\n"
-        movzx   eax, [device.irq_line]
+        movzx   eax, [ebx + device.irq_line]
         DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
 align 4
 read_mac:
         DEBUGF  1,"Read MAC\n"
-        mov     esi, [device.mmio_addr]
+        mov     esi, [ebx + device.mmio_addr]
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
         movsd
         movsw
   .mac_ok:
         DEBUGF  1,"MAC = %x-%x-%x-%x-%x-%x\n",\
 ;; In: buffer pointer in [esp+4]           ;;
 ;;     size of buffer in [esp+8]           ;;
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+proc transmit stdcall bufferptr, buffersize
-align 4
+        pushf
-transmit:
+        cli
-        DEBUGF  2,"\nTransmitting 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  2,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
+        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], 1514
+        cmp     [buffersize], 1514
         ja      .fail
-        cmp     dword [esp + 8], 60
+        cmp     [buffersize], 60
+        jb      .fail
         jb      .fail
+; Update stats
+        inc     [ebx + device.packets_tx]
-; Update stats
+        mov     eax, [buffersize]
-        inc     [device.packets_tx]
+        add     dword[ebx + device.bytes_tx], eax
-        mov     eax, [esp + 8]
+        adc     dword[ebx + device.bytes_tx + 4], 0
-        add     dword [device.bytes_tx], eax
-        adc     dword [device.bytes_tx + 4], 0
+        DEBUGF  1,"Transmit OK\n"
+        popf
         xor     eax, eax
-        xor     eax, eax
+        ret
+  .fail:
-        ret     8
+        DEBUGF  2,"Transmit failed\n"
         invoke  KernelFree, [bufferptr]
-  .fail:
+        popf
 align 4
 int_handler:
         push    ebx esi edi
-        DEBUGF  1,"\n%s int\n", my_service
+        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]
-;        mov     edi, [device.mmio_addr]
+;        mov     edi, [ebx + device.mmio_addr]
 ;        mov     eax, [edi + REG_ICR]
+; End of code
-; End of code
-section '.data' data readable writable align 16
+data fixups
-align 4
+end data
+include '../peimport.inc'

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/bcm57xx.asm – Rev 4470 → 4663