WebSVN – Kolibri OS – Diff – /drivers/ethernet/dec21x4x.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
-        RX_DES_COUNT            = 4     ; no of RX descriptors, must be power of 2
-        RX_BUFF_SIZE            = 2048  ; size of buffer for each descriptor, must be multiple of 4 and <= 2048 TDES1_TBS1_MASK
         RX_DES_COUNT            = 4     ; no of RX descriptors, must be power of 2
-        TX_DES_COUNT            = 4     ; no of TX descriptors, must be power of 2
+        RX_BUFF_SIZE            = 2048  ; size of buffer for each descriptor, must be multiple of 4 and <= 2048 TDES1_TBS1_MASK
+        TX_DES_COUNT            = 4     ; no of TX descriptors, must be power of 2
+        TX_BUFF_SIZE            = 2048  ; size of buffer for each descriptor, used for memory allocation only
         TX_BUFF_SIZE            = 2048  ; size of buffer for each descriptor, used for memory allocation only
         __DEBUG__               = 1
-        DEBUG                   = 1
-        __DEBUG__               = 1
+        __DEBUG_LEVEL__         = 2     ; 1 = verbose, 2 = errors only
-        __DEBUG_LEVEL__         = 2
-include '../struct.inc'
-include '../macros.inc'
-include '../proc32.inc'
-include '../imports.inc'
-include '../fdo.inc'
-include '../netdrv.inc'
-public START
-public service_proc
-public version
-virtual at ebx
-        device:
-        ETH_DEVICE
-        .rx_p_des         dd ?  ; descriptors ring with received packets
-        .tx_p_des         dd ?  ; descriptors ring with 'to transmit' packets
-        .tx_free_des      dd ?  ; Tx descriptors available
-        .tx_wr_des        dd ?  ; Tx current descriptor to write data to
-        .tx_rd_des        dd ?  ; Tx current descriptor to read TX completion
-        .rx_crt_des       dd ?  ; Rx current descriptor
-        .io_addr          dd ?
-        .pci_bus          dd ?
+section '.flat' readable writable executable
         .pci_dev          dd ?
-        .irq_line         db ?
+include '../proc32.inc'
 include '../struct.inc'
 CSR7_AI                 = 1 shl 15      ; Abnormal Interrupt Summary Enable (enables CSR5<0,3,7,8,9,10,13>)
 CSR7_NI                 = 1 shl 16      ; Normal Interrup Enable (enables CSR5<0,2,6,11,14>)
 CSR7_DEFAULT            = CSR7_TI + CSR7_TS + CSR7_RI + CSR7_RS + CSR7_TU + CSR7_TJ + CSR7_UN + \
-                                        CSR7_RU + CSR7_RW + CSR7_FBE + CSR7_AI + CSR7_NI
-;----------- descriptor structure ---------------------
-struc   DES {
-        .status         dd ?    ; bit 31 is 'own' and rest is 'status'
-        .length         dd ?    ; control bits + bytes-count buffer 1 + bytes-count buffer 2
-        .buffer1        dd ?    ; pointer to buffer1
-        .buffer2        dd ?    ; pointer to buffer2 or in this case to next descriptor, as we use a chained structure
-        .virtaddr       dd ?
-        .size = 64              ; 64, for alignment purposes
-}
-virtual at 0
-        DES DES
-end virtual
                                         CSR7_RU + CSR7_RW + CSR7_FBE + CSR7_AI + CSR7_NI
 ;common to Rx and Tx
 DES0_OWN                = 1 shl 31              ; if set, the NIC controls the descriptor, otherwise driver 'owns' the descriptors
 TDES1_FT1               = 1 shl 28              ; Filtering type 1
 TDES1_FS                = 1 shl 29              ; First segment - buffer is first segment of frame
 TDES1_LS                = 1 shl 30              ; Last segment
 TDES1_IC                = 1 shl 31              ; Interupt on completion (CSR5<0>=1) valid when TDES1<30>=1
+RX_MEM_TOTAL_SIZE       = RX_DES_COUNT*(sizeof.DES+RX_BUFF_SIZE)
+TX_MEM_TOTAL_SIZE       = TX_DES_COUNT*(sizeof.DES+TX_BUFF_SIZE)
+struct  device          ETH_DEVICE
+        rx_p_des        dd ?    ; descriptors ring with received packets
-MAX_ETH_FRAME_SIZE      = 1514
+        tx_p_des        dd ?    ; descriptors ring with 'to transmit' packets
+        tx_free_des     dd ?    ; Tx descriptors available
+        tx_wr_des       dd ?    ; Tx current descriptor to write data to
+        tx_rd_des       dd ?    ; Tx current descriptor to read TX completion
+        rx_crt_des      dd ?    ; Rx current descriptor
+        io_addr         dd ?
+        pci_bus         dd ?
+        pci_dev         dd ?
+        irq_line        db ?
+ends
+;----------- descriptor structure ---------------------
+struct  DES
+        status          dd ?    ; bit 31 is 'own' and rest is 'status'
+        length          dd ?    ; control bits + bytes-count buffer 1 + bytes-count buffer 2
+        buffer1         dd ?    ; pointer to buffer1
+        buffer2         dd ?    ; pointer to buffer2 or in this case to next descriptor, as we use a chained structure
+        virtaddr        dd ?
-RX_MEM_TOTAL_SIZE       = RX_DES_COUNT*(DES.size+RX_BUFF_SIZE)
+        rb 0x40 - ($ and 0x3f)  ; align 64
-TX_MEM_TOTAL_SIZE       = TX_DES_COUNT*(DES.size+TX_BUFF_SIZE)
+ends
 ;=============================================================================
         and     eax, not (a_bit)
         out     dx, eax
+}
 section '.flat' code readable align 16
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                        ;;
 ;; proc START             ;;
 ;;                        ;;
-;; (standard driver proc) ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; (standard driver proc) ;;
-align 4
-proc START stdcall, state:dword
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-        cmp [state], 1
+proc START c, reason:dword, cmdline:dword
-        jne .exit
         cmp     [reason], DRV_ENTRY
-  .entry:
+        jne     .fail
         DEBUGF  2,"Loading %s driver\n", my_service
-        stdcall RegService, my_service, service_proc
+        DEBUGF  2,"Loading driver\n"
-        ret
+        invoke  RegService, my_service, service_proc
 ;        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     @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
   .firstdevice:
         cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
         jae     .fail
         push    edx
-        stdcall KernelAlloc, dword device.size          ; Allocate the buffer for eth_device structure
+        invoke  KernelAlloc, sizeof.device              ; Allocate the buffer for eth_device structure
         pop     edx
         test    eax, eax
         jz      .fail
         mov     ebx, eax                                ; ebx is always used as a pointer to the structure (in driver, but also in kernel code)
 ; 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]
-        movzx   ecx, byte[eax+1]
+        mov     [ebx + device.pci_bus], ecx
-        mov     [device.pci_bus], ecx
+        movzx   ecx, byte[eax+2]
+        mov     [ebx + device.pci_dev], 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
-; 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
         call    probe                                                   ; this function will output in eax
         test    eax, eax
         jnz     .err2                                                   ; If an error occured, exit
-        mov     [device.type], NET_TYPE_ETH
+        mov     [ebx + device.type], NET_TYPE_ETH
-        call    NetRegDev
+        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:
   .err2:
         dec     [devices]
   .err:
         DEBUGF  2,"removing device structure\n"
-        stdcall KernelFree, [device.rx_p_des]
+        invoke  KernelFree, [ebx + device.rx_p_des]
-        stdcall KernelFree, [device.tx_p_des]
+        invoke  KernelFree, [ebx + device.tx_p_des]
-        stdcall KernelFree, ebx
+        invoke  KernelFree, ebx
 ret
 macro status {
-        set_io  CSR5
+        set_io  [ebx + device.io_addr], CSR5
 align 4
 probe:
         DEBUGF  2,"Probing dec21x4x device: "
+; Make the device a bus master
+        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
+        or      al, PCI_CMD_MASTER
+        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
         PCI_make_bus_master
 ; Check the vendor/device ID
-        stdcall PciRead32, [device.pci_bus], [device.pci_dev], 0                                ; get device/vendor id
+        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], 0                                ; get device/vendor id
         DEBUGF  1,"Vendor id: 0x%x\n", ax
   .supported_device2:
         ; wake up the 21143
         xor     eax, eax
-        stdcall PciWrite32, [device.pci_bus], [device.pci_dev], 0x40, eax
+        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], 0x40, eax
         DEBUGF  2,"Resetting dec21x4x\n"
 ;-----------------------------------------------------------
 ; board software reset - if fails, dont do nothing else
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         status
-        set_io  CSR0
+        set_io  [ebx + device.io_addr], CSR0
         mov     eax, CSR0_RESET
         out     dx, eax
 ; wait at least 50 PCI cycles
         mov     esi, 1000
-        call    Sleep
+        invoke  Sleep
 ;-----------
 ; setup CSR0
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         status
-        set_io  CSR0
+        set_io  [ebx + device.io_addr], CSR0
         mov     eax, CSR0_DEFAULT
         out     dx, eax
 ; wait at least 50 PCI cycles
         mov     esi, 1000
-        call    Sleep
+        invoke  Sleep
 ;-----------------------------------
 ; Read mac from eeprom to driver ram
         call    read_mac_eeprom
 ;--------------------------------
 ; insert irq handler on given irq
-        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
         test    eax, eax
         jnz     @f
         DEBUGF  2,"Could not attach int handler!\n"
-;        or      eax, -1
+        or      eax, -1
-;        ret
+        ret
   @@:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         status
         call    init_ring
 ;--------------------------------------------
 ; setup CSR3 & CSR4 (pointers to descriptors)
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         status
-        set_io  CSR3
+        set_io  [ebx + device.io_addr], CSR3
-        mov     eax, [device.rx_p_des]
+        mov     eax, [ebx + device.rx_p_des]
-        GetRealAddr
+        invoke  GetPhysAddr
         DEBUGF  1,"RX descriptor base address: %x\n", eax
         out     dx, eax
-        set_io  CSR4
+        set_io  [ebx + device.io_addr], CSR4
-        mov     eax, [device.tx_p_des]
+        mov     eax, [ebx + device.tx_p_des]
-        GetRealAddr
+        invoke  GetPhysAddr
         DEBUGF  1,"TX descriptor base address: %x\n", eax
         out     dx, eax
 ;-------------------------------------------------------
 ; setup interrupt mask register -expect IRQs from now on
         status
         DEBUGF  1,"Enabling interrupts\n"
-        set_io  CSR7
+        set_io  [ebx + device.io_addr], CSR7
         mov     eax, CSR7_DEFAULT
         out     dx, eax
         status
 ;----------
 ; enable RX
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         status
         DEBUGF  1,"Enable RX\n"
-        set_io  CSR6
+        set_io  [ebx + device.io_addr], CSR6
 init_ring:
 ;------------------------------------------
 ; Setup RX descriptors (use chained method)
-        mov     eax, [device.rx_p_des]
+        mov     eax, [ebx + device.rx_p_des]
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     edx, eax
         push    eax
-        lea     esi, [eax + RX_DES_COUNT*(DES.size)]    ; jump over RX descriptors
+        lea     esi, [eax + RX_DES_COUNT*(sizeof.DES)]  ; jump over RX descriptors
-        mov     eax, [device.rx_p_des]
+        mov     eax, [ebx + device.rx_p_des]
-        add     eax, RX_DES_COUNT*(DES.size)            ; jump over RX descriptors
+        add     eax, RX_DES_COUNT*(sizeof.DES)          ; jump over RX descriptors
-        mov     edi, [device.rx_p_des]
+        mov     edi, [ebx + device.rx_p_des]
         mov     ecx, RX_DES_COUNT
   .loop_rx_des:
-        add     edx, DES.size
+        add     edx, sizeof.DES
         mov     [edi + DES.status], DES0_OWN            ; hardware owns buffer
         mov     [edi + DES.length], 1984 + RDES1_RCH    ; only size of first buffer, chained buffers
         mov     [edi + DES.buffer1], esi                ; hw buffer address
         mov     [edi + DES.buffer2], edx                ; pointer to next descriptor
         mov     [edi + DES.virtaddr], eax               ; virtual buffer address
         DEBUGF  1,"RX desc: buff addr: %x, next desc: %x, real buff addr: %x, real descr addr: %x \n", esi, edx, eax, edi
         add     esi, RX_BUFF_SIZE
         add     eax, RX_BUFF_SIZE
-        add     edi, DES.size
+        add     edi, sizeof.DES
-        dec     ecx
-        jnz     .loop_rx_des
+        dec     ecx
+        jnz     .loop_rx_des
 ; set last descriptor as LAST
-        sub     edi, DES.size
+; set last descriptor as LAST
-        or      [edi + DES.length], RDES1_RER           ; EndOfRing
+        or      [edi - sizeof.DES + DES.length], RDES1_RER      ; EndOfRing
-        pop     [edi + DES.buffer2]                     ; point it to the first descriptor
+        pop     [edi - sizeof.DES + DES.buffer2]                ; point it to the first descriptor
 ;---------------------
 ; Setup TX descriptors
-        mov     eax, [device.tx_p_des]
+        mov     eax, [ebx + device.tx_p_des]
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     edx, eax
         push    eax
-        lea     esi, [eax + TX_DES_COUNT*(DES.size)]    ; jump over TX descriptors
+        lea     esi, [eax + TX_DES_COUNT*(sizeof.DES)]  ; jump over TX descriptors
-        mov     eax, [device.tx_p_des]
+        mov     eax, [ebx + device.tx_p_des]
-        add     eax, TX_DES_COUNT*(DES.size)            ; jump over TX descriptors
+        add     eax, TX_DES_COUNT*(sizeof.DES)          ; jump over TX descriptors
-        mov     edi, [device.tx_p_des]
+        mov     edi, [ebx + device.tx_p_des]
         mov     ecx, TX_DES_COUNT
   .loop_tx_des:
-        add     edx, DES.size
+        add     edx, sizeof.DES
         mov     [edi + DES.status], 0                   ; owned by driver
         mov     [edi + DES.length], TDES1_TCH           ; chained method
         mov     [edi + DES.buffer1], esi                ; pointer to buffer
         mov     [edi + DES.buffer2], edx                ; pointer to next descr
         mov     [edi + DES.virtaddr], eax
         DEBUGF  1,"TX desc: buff addr: %x, next desc: %x, virt buff addr: %x, virt descr addr: %x \n", esi, edx, eax, edi
-        add     esi, TX_BUFF_SIZE
-        add     eax, TX_BUFF_SIZE
+        add     esi, TX_BUFF_SIZE
-        add     edi, DES.size
+        add     eax, TX_BUFF_SIZE
-        dec     ecx
+        add     edi, sizeof.DES
-        jnz     .loop_tx_des
+        dec     ecx
+        jnz     .loop_tx_des
-; set last descriptor as LAST
-        sub     edi, DES.size
+; set last descriptor as LAST
-        or      [edi + DES.length], TDES1_TER           ; EndOfRing
+        or      [edi - sizeof.DES + DES.length], TDES1_TER      ; EndOfRing
-        pop     [edi + DES.buffer2]                     ; point it to the first descriptor
+        pop     [edi - sizeof.DES + DES.buffer2]                ; point it to the first descriptor
         DEBUGF  1,"Sending setup packet\n"
 ; if no descriptors available, out
         mov     ecx, 1000
 @@loop_wait_desc:
-        cmp     [device.tx_free_des], 0
+        cmp     [ebx + device.tx_free_des], 0
         jne     @f
         dec     ecx
         jnz     @@loop_wait_desc
         mov     eax, -1
         ret
       @@:
 ; go to current send descriptor
-        mov     edi, [device.tx_p_des]
+        mov     edi, [ebx + device.tx_p_des]
-        mov     eax, [device.tx_wr_des]
+        mov     eax, [ebx + device.tx_wr_des]
         DEBUGF  1,"Got free descriptor: %u (%x)", eax, edi
-        mov     edx, DES.size
+        mov     edx, sizeof.DES
         mul     edx
         add     edi, eax
         DEBUGF  1,"=>%x\n",  edi
 ; if NOT sending FIRST setup packet, must set current descriptor to 0 size for both buffers,
 ;  and go to next descriptor for real setup packet...            ;; TODO: check if 2 descriptors are available
-;       cmp     [device.tx_packets], 0
+;       cmp     [ebx + device.tx_packets], 0
 ;       je      .first
 ;
 ;       and     [edi+DES.des1], 0
 ;       mov     [edi+DES.des0], DES0_OWN
 ;
 ; go to next descriptor
-;        inc     [device.tx_wr_des]
+;        inc     [ebx + device.tx_wr_des]
-;        and     [device.tx_wr_des], TX_DES_COUNT-1
+;        and     [ebx + device.tx_wr_des], TX_DES_COUNT-1
+;
 ; dec free descriptors count
-;        cmp     [device.tx_free_des], 0
+;        cmp     [ebx + device.tx_free_des], 0
 ;        jz      @f
-;        dec     [device.tx_free_des]
+;        dec     [ebx + device.tx_free_des]
 ;       @@:
+;
 ;       ; recompute pointer to current descriptor
-;       mov     edi, [device.tx_p_des]
+;       mov     edi, [ebx + device.tx_p_des]
-;       mov     eax, [device.tx_wr_des]
+;       mov     eax, [ebx + device.tx_wr_des]
 ;       mov     edx, DES.size
 ;       mul     edx
 ;       add     edi, eax
   .first:
         push    edi
 ; copy setup packet to current descriptor
         DEBUGF  1,"length: %x\n", [edi + DES.length]:8
         DEBUGF  1,"buffer1: %x\n", [edi + DES.buffer1]:8
         DEBUGF  1,"buffer2: %x\n", [edi + DES.buffer2]:8
 ; go to next descriptor
-        inc     [device.tx_wr_des]
+        inc     [ebx + device.tx_wr_des]
-        and     [device.tx_wr_des], TX_DES_COUNT-1
+        and     [ebx + device.tx_wr_des], TX_DES_COUNT-1
 ; dec free descriptors count
-        cmp     [device.tx_free_des], 0
+        cmp     [ebx + device.tx_free_des], 0
         jz      @f
-        dec     [device.tx_free_des]
+        dec     [ebx + device.tx_free_des]
        @@:
 ; start tx
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         status
-        set_io  CSR6
+        set_io  [ebx + device.io_addr], CSR6
         in      eax, dx
         test    eax, CSR6_ST            ; if NOT started, start now
         jnz     .already_started
         or      eax, CSR6_ST
         DEBUGF  1,"Starting TX\n"
         jmp     .do_it
   .already_started:
                                         ; if already started, issue a Transmit Poll command
-        set_io  CSR1
+        set_io  [ebx + device.io_addr], CSR1
         xor     eax, eax
         DEBUGF  1,"Issuing transmit poll command\n"
 ;;     size of buffer in [esp+8]           ;;
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+proc transmit stdcall bufferptr, buffersize
-align 4
+        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
-        ja      .fail
+        cmp     [buffersize], 1514
         ja      .fail
-        cmp     [device.tx_free_des], 0
+        cmp     [buffersize], 60
-        je      .fail
+        jb      .fail
 ;--------------------------
 ; copy packet to crt buffer
-        mov     eax, [device.tx_wr_des]
+        mov     eax, [ebx + device.tx_wr_des]
-        mov     edx, DES.size
+        mov     edx, sizeof.DES
         mul     edx
-        add     eax, [device.tx_p_des]
+        add     eax, [ebx + device.tx_p_des]
-        mov     edi, [eax + DES.virtaddr]                 ; pointer to buffer
+        mov     edi, [eax + DES.virtaddr]               ; pointer to buffer
-        mov     esi, [esp+4]
+        mov     esi, [bufferptr]
-        mov     ecx, [esp+8]
+        mov     ecx, [buffersize]
         DEBUGF  1,"copying %u bytes from %x to %x\n", ecx, esi, edi
         rep     movsb
 ; set packet size
         mov     ecx, [eax+DES.length]
         and     ecx, TDES1_TER                          ; preserve 'End of Ring' bit
-        or      ecx, [esp+8]                            ; set size
+        or      ecx, [buffersize]                       ; set size
         or      ecx, TDES1_FS or TDES1_LS or TDES1_IC or TDES1_TCH    ; first descr, last descr, interrupt on complete, chained modus
-        mov     [eax+DES.length], ecx
+        mov     [eax + DES.length], ecx
 ; set descriptor info
-        mov     [eax+DES.status], DES0_OWN                ; say it is now owned by the 21x4x
+        mov     [eax + DES.status], DES0_OWN            ; say it is now owned by the 21x4x
 ; start tx
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         status
-        set_io  CSR6
+        set_io  [ebx + device.io_addr], CSR6
         in      eax, dx
         test    eax, CSR6_ST            ; if NOT started, start now
         jnz     .already_started
         or      eax, CSR6_ST
         DEBUGF  1,"Starting TX\n"
-        jmp     .do_it
-  .already_started:
+        jmp     .do_it
-                                        ; if already started, issues a Transmit Poll command
+  .already_started:
-        set_io  CSR1
+                                        ; if already started, issues a Transmit Poll command
-        mov     eax, -1
+        set_io  [ebx + device.io_addr], CSR1
-  .do_it:
+        mov     eax, -1
-        out     dx , eax
+  .do_it:
+        out     dx , eax
 ; Update stats
+; Update stats
-        inc     [device.packets_tx]
+        inc     [ebx + device.packets_tx]
-        mov     eax, [esp+8]
+        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
+; go to next descriptor
+        inc     [ebx + device.tx_wr_des]
-; go to next descriptor
+        and     [ebx + device.tx_wr_des], TX_DES_COUNT-1
-        inc     [device.tx_wr_des]
-        and     [device.tx_wr_des], TX_DES_COUNT-1
 ; dec free descriptors count
-; dec free descriptors count
+        test    [ebx + device.tx_free_des], -1
-        test    [device.tx_free_des], -1
+        jz      .end
+        dec     [ebx + device.tx_free_des]
-        jz      .end
+  .end:
-        dec     [device.tx_free_des]
+        status
-  .end:
+        DEBUGF  1,"transmit ok\n"
-        status
+        invoke  KernelFree, [bufferptr]
         popf
-        DEBUGF  1,"transmit ok\n"
+        xor     eax, eax
         jz      .nothing
         mov     esi, device_list
   .nextdevice:
         mov     ebx, [esi]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  CSR5
+        set_io  [ebx + device.io_addr], CSR5
         in      ax, dx
         test    ax, ax
         out     dx, ax                                  ; send it back to ACK
         jnz     .got_it
         push    ax esi ecx
         DEBUGF 1,"TX ok!\n"
         ; go to current descriptor
-        mov     edi, [device.tx_p_des]
+        mov     edi, [ebx + device.tx_p_des]
-        mov     eax, [device.tx_rd_des]
+        mov     eax, [ebx + device.tx_rd_des]
-        mov     edx, DES.size
+        mov     edx, sizeof.DES
         mul     edx
         add     edi, eax
       .loop_tx:
       .not_setup_packet:
         DEBUGF  1,"packet status: %x\n", eax
         ; next descriptor
-        add     edi, DES.size
+        add     edi, sizeof.DES
-        inc     [device.tx_rd_des]
+        inc     [ebx + device.tx_rd_des]
-        and     [device.tx_rd_des], TX_DES_COUNT-1
+        and     [ebx + device.tx_rd_des], TX_DES_COUNT-1
         ; inc free desc
-        inc     [device.tx_free_des]
+        inc     [ebx + device.tx_free_des]
-        cmp     [device.tx_free_des], TX_DES_COUNT
+        cmp     [ebx + device.tx_free_des], TX_DES_COUNT
         jbe     @f
-        mov     [device.tx_free_des], TX_DES_COUNT
+        mov     [ebx + device.tx_free_des], TX_DES_COUNT
         push    ebx
   .rx_loop:
         pop     ebx
         ; get current descriptor
-        mov     edi, [device.rx_p_des]
+        mov     edi, [ebx + device.rx_p_des]
-        mov     eax, [device.rx_crt_des]
+        mov     eax, [ebx + device.rx_crt_des]
-        mov     edx, DES.size
+        mov     edx, sizeof.DES
         mul     edx
         add     edi, eax
         sub     ecx, 4                                  ; crc, we dont need it
         DEBUGF  1,"Received packet!, size=%u, addr:%x\n", ecx, esi
         push    esi edi ecx
-        stdcall KernelAlloc, ecx                        ; Allocate a buffer to put packet into
+        invoke  KernelAlloc, ecx                        ; Allocate a buffer to put packet into
         pop     ecx edi esi
         test    eax, eax
         jz      .fail
         push    ebx
         push    dword .rx_loop
         push    ecx eax
         mov     edi, eax
 ; update statistics
-        inc     [device.packets_rx]
+        inc     [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
   .nw:
         rep     movsd
         mov     [edi + DES.status], DES0_OWN            ; free descriptor
-        inc     [device.rx_crt_des]                     ; next descriptor
+        inc     [ebx + device.rx_crt_des]                     ; next descriptor
-        and     [device.rx_crt_des], RX_DES_COUNT-1
+        and     [ebx + device.rx_crt_des], RX_DES_COUNT-1
-        jmp     Eth_input
+        jmp     [Eth_input]
         DEBUGF  2,"Writing MAC: "
 ; write data into driver cache
         mov     esi, esp
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
         movsd
         movsw
 align 4
 read_mac_eeprom:
         DEBUGF 1,"Read_mac_eeprom\n"
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
         mov     esi, 20/2               ; read words, start address is 20
      .loop:
         push    esi edi
         DEBUGF 1,"SROM_GetWidth\n"
         call    SROM_Idle
         call    SROM_EnterAccessMode
-;        set_io  0
+;        set_io  [ebx + device.io_addr], 0
-;        set_io  CSR9
+;        set_io  [ebx + device.io_addr], CSR9
 align 4
 SROM_EnterAccessMode:
         DEBUGF 1,"SROM_EnterAccessMode\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  CSR9
+        set_io  [ebx + device.io_addr], CSR9
         mov     eax, CSR9_SR
         out     dx, eax
         DEBUGF 1,"SROM_Idle\n"
         call    SROM_EnterAccessMode
-;        set_io  0
+;        set_io  [ebx + device.io_addr], 0
-;        set_io  CSR9
+;        set_io  [ebx + device.io_addr], CSR9
 align 4
 SROM_Read_Word:
         DEBUGF 1,"SROM_Read_word at: %x result: ", esi
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  CSR9
+        set_io  [ebx + device.io_addr], CSR9
 ; enter access mode
         shl     edx, 5
         or      esi, edx
         or      esi, 0xf6 shl 10
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  CSR9
+        set_io  [ebx + device.io_addr], CSR9
 ;    if (tp->chip_id == LC82C168) {
         or      edi, 0x5002 shl 16
         shl     edx, 23
         or      edi, edx
         mov     di, ax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  CSR9
+        set_io  [ebx + device.io_addr], CSR9
 ;    if (tp->chip_id == LC82C168) {
 ;        int i = 1000;
         ret
+; End of code
-; End of code
+data fixups
-align 4                                         ; Place all initialised data here
+end data
-devices       dd 0
-version       dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
+include '../peimport.inc'
 my_service    db 'DEC21X4X',0                    ; max 16 chars include zero

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/dec21x4x.asm – Rev 4470 → 5046