WebSVN – Kolibri OS – Diff – /drivers/ethernet/RTL8029.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
+        DEBUG                   = 1
         __DEBUG__               = 1
-        DEBUG                   = 1
+        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
         __DEBUG__               = 1
-        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
 section '.flat' readable writable executable
-include '../struct.inc'
-include '../macros.inc'
-include '../proc32.inc'
-include '../imports.inc'
-include '../fdo.inc'
-include '../netdrv.inc'
-virtual at ebx
-        device:
+include '../struct.inc'
-        ETH_DEVICE
+include '../macros.inc'
+include '../proc32.inc'
+include '../fdo.inc'
+include '../netdrv_pe.inc'
-        .io_addr        dd ?
-        .irq_line       db ?
-        .pci_bus        dd ?
-        .pci_dev        dd ?
+struct  device          ETH_DEVICE
-        .flags          db ?
+        io_addr         dd ?
+        irq_line        db ?
+        pci_bus         dd ?
+        pci_dev         dd ?
-        .vendor         db ?
-        .memsize        db ?
-        .rx_start       db ?
-        .tx_start       db ?
-        .bmem           dd ?
-        .rmem           dd ?
+        flags           db ?
         vendor          db ?
         .size = $ - device
         memsize         db ?
+        ISA_MAX_ADDR            = 0x400
-        ISA_MAX_ADDR            = 0x400
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                        ;;
-section '.flat' code readable align 16
+;; proc START             ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                        ;;
-;;
+;; (standard driver proc) ;;
-;; proc START
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-align 4
-proc START stdcall, state:dword
+proc START c, reason:dword, cmdline:dword
         cmp     [reason], DRV_ENTRY
-        cmp     [state], 1
-        jne     .exit
+        jne     .fail
   .entry:
-        DEBUGF  1, "Loading driver\n"
+        DEBUGF  2,"Loading driver\n"
-        stdcall RegService, my_service, service_proc
+        invoke  RegService, my_service, service_proc
         ret
-  .fail:
+  .fail:
-  .exit:
+        xor     eax, eax
-        xor     eax, eax
+        ret
         ret
 endp
 endp
         jz      .firstdevice_pci
         mov     ax, [eax+1]                             ; get the pci bus and device numbers
   .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
   .firstdevice_pci:
         call    create_new_struct
         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]
-        movzx   ecx, byte[eax+2]
+        mov     [ebx + device.pci_dev], ecx
         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]
-        PCI_find_io
+        mov     [ebx + device.io_addr], eax
 ; We've found the io address, find IRQ now
         jz      .firstdevice_isa
         movzx   edi, word [eax+1]
         mov     al, [eax+3]
   .nextdevice_isa:
         mov     ebx, [esi]
-        cmp     edi, [device.io_addr]
+        cmp     edi, [ebx + device.io_addr]
         jne     .maybenext
-        cmp     al, [device.irq_line]
+        cmp     al, [ebx + device.irq_line]
         je      find_device_num
   .maybenext:
         add     esi, 4
         loop    .nextdevice_isa
   .firstdevice_isa:
         call    create_new_struct
         mov     eax, [edx + IOCTL.input]
         movzx   ecx, word[eax+1]
-        mov     [device.io_addr], ecx
+        mov     [ebx + device.io_addr], ecx
         mov     cl, [eax+3]
-        mov     [device.irq_line], cl
+        mov     [ebx + device.irq_line], cl
   .hook:
+  .hook:
-        DEBUGF  1, "Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
+        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.io_addr]:4
+        [ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:8
+        call    probe                                                   ; this function will output in eax
+        test    eax, eax
-        call    probe                                                   ; this function will output in eax
+        jnz     .err                                                    ; If an error occured, exit
         test    eax, eax
-        jnz     .err                                                    ; If an error occured, exit
+        DEBUGF  2,"Initialised OK\n"
         mov     eax, [devices]
         mov     [device_list+4*eax], ebx
         inc     [devices]
-        mov     [device.type], NET_TYPE_ETH
+        mov     [ebx + device.type], NET_TYPE_ETH
-        call    NetRegDev
+        invoke  NetRegDev
         cmp     eax, -1
         jz      .err
         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"
-        call    NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx
+        invoke  NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx
                                                                         ; into a device number in edi
 create_new_struct:
         cmp     [devices], MAX_DEVICES
         jae     .fail
-        allocate_and_clear ebx, device.size, .fail      ; Allocate the buffer for device structure
+        allocate_and_clear ebx, sizeof.device, .fail    ; Allocate the buffer for device structure
-        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
 find_device_num:
         DEBUGF  1, "Trying to find device number of already registered device\n"
         mov     ebx, eax
-        call    NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx
+        invoke  NetPtrToNum                             ; This kernel procedure converts a pointer to device struct in ebx
-                                                                        ; into a device number in edi
+                                                        ; into a device number in edi
-        mov     eax, edi                                                ; Application wants it in eax instead
+        mov     eax, edi                                ; Application wants it in eax instead
 ;;  probe: enables the device and clears the rx buffer
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 probe:
-        mov     [device.vendor], VENDOR_NONE
+        mov     [ebx + device.vendor], VENDOR_NONE
-        mov     [device.bmem], 0
+        mov     [ebx + device.bmem], 0
         DEBUGF  1, "Trying 16-bit mode\n"
-        mov     [device.flags], FLAG_16BIT + FLAG_PIO
+        mov     [ebx + device.flags], FLAG_16BIT + FLAG_PIO
-        mov     [device.memsize], MEM_32k
+        mov     [ebx + device.memsize], MEM_32k
-        mov     [device.tx_start], 64
+        mov     [ebx + device.tx_start], 64
-        mov     [device.rx_start], TXBUF_SIZE + 64
+        mov     [ebx + device.rx_start], TXBUF_SIZE + 64
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  P0_DCR
+        set_io  [ebx + device.io_addr], P0_DCR
         mov     al, DCR_WTS + DCR_FT1 + DCR_LS  ; word transfer select +
         out     dx, al
-        set_io  P0_PSTART
+        set_io  [ebx + device.io_addr], P0_PSTART
         mov     al, MEM_16k
         out     dx, al
         je      ep_set_vendor
         DEBUGF  1, "16-bit mode failed\n"
         DEBUGF  1, "Trying 8-bit mode\n"
-        mov     [device.flags], FLAG_PIO
+        mov     [ebx + device.flags], FLAG_PIO
-        mov     [device.memsize], MEM_16k
+        mov     [ebx + device.memsize], MEM_16k
-        mov     [device.tx_start], 32
+        mov     [ebx + device.tx_start], 32
-        mov     [device.rx_start], TXBUF_SIZE + 32
+        mov     [ebx + device.rx_start], TXBUF_SIZE + 32
-        set_io  NE_ASIC + NE_RESET
+        set_io  [ebx + device.io_addr], NE_ASIC + NE_RESET
         in      al, dx
         out     dx, al
         in      al, 0x84
-        set_io  P0_COMMAND
+        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_RD2 + CMD_STP
         out     dx, al
-        set_io  P0_RCR
+        set_io  [ebx + device.io_addr], P0_RCR
         mov     al, RCR_MON
         out     dx, al
-        set_io  P0_DCR
+        set_io  [ebx + device.io_addr], P0_DCR
         mov     al, DCR_FT1 + DCR_LS
         out     dx, al
 ep_set_vendor:
         DEBUGF  1, "Mode ok\n"
-        cmp     [device.io_addr], ISA_MAX_ADDR
+        cmp     [ebx + device.io_addr], ISA_MAX_ADDR
         jbe     .isa
         DEBUGF  1, "Card is using PCI bus\n"
-        mov     [device.vendor], VENDOR_NOVELL  ;;; FIXME
+        mov     [ebx + device.vendor], VENDOR_NOVELL  ;;; FIXME
         jmp     ep_check_have_vendor
   .isa:
         DEBUGF  1, "Card is using ISA bus\n"
-        mov     [device.vendor], VENDOR_NOVELL
+        mov     [ebx + device.vendor], VENDOR_NOVELL
 ep_check_have_vendor:
-        mov     al, [device.vendor]
+        mov     al, [ebx + device.vendor]
 reset:
         DEBUGF  1, "Resetting device\n"
 ; attach int handler
-        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
        @@:
 ; Stop card + DMA
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-;        set_io  P0_COMMAND
+;        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_PS0 + CMD_RDMA_ABORT + CMD_STP
         out     dx, al
 ; initialize DCR
-        set_io  P0_DCR
+        set_io  [ebx + device.io_addr], P0_DCR
         mov     al, DCR_FT1 + DCR_LS
-        test    [device.flags], FLAG_16BIT
+        test    [ebx + device.flags], FLAG_16BIT
         jz      @f
         or      al, DCR_WTS                     ; word transfer select
       @@:
         out     dx, al
 ; clear remote bytes count
-        set_io  P0_RBCR0
+        set_io  [ebx + device.io_addr], P0_RBCR0
         xor     al, al
         out     dx, al
-        set_io  P0_RBCR1
+        set_io  [ebx + device.io_addr], P0_RBCR1
         out     dx, al
 ; initialize Receive configuration register (until all init is done)
-        set_io  P0_RCR
+        set_io  [ebx + device.io_addr], P0_RCR
         mov     al, 0x20        ; monitor mode
         out     dx, al
 ; transmit configuration register to monitor mode (until all ini is done)
-        set_io  P0_TCR
+        set_io  [ebx + device.io_addr], P0_TCR
         mov     al, 2           ; internal loopback
         out     dx, al
 ; clear interupt status
-        set_io  P0_ISR
+        set_io  [ebx + device.io_addr], P0_ISR
         mov     al, 0xff
         out     dx, al
 ; clear IRQ mask                        ;;;;; CHECKME ;;;;;
-        set_io  P0_IMR
+        set_io  [ebx + device.io_addr], P0_IMR
         xor     al, al
         out     dx, al
 ; set transmit pointer
-        set_io  P0_TPSR
+        set_io  [ebx + device.io_addr], P0_TPSR
-        mov     al, [device.tx_start]
+        mov     al, [ebx + device.tx_start]
         out     dx, al
 ; set pagestart pointer
-        set_io  P0_PSTART
+        set_io  [ebx + device.io_addr], P0_PSTART
-        mov     al, [device.rx_start]
+        mov     al, [ebx + device.rx_start]
         out     dx, al
 ; set pagestop pointer
-        set_io  P0_PSTOP
+        set_io  [ebx + device.io_addr], P0_PSTOP
-        mov     al, [device.memsize]
+        mov     al, [ebx + device.memsize]
         out     dx, al
 ; set boundary pointer
-        set_io  P0_BOUND
+        set_io  [ebx + device.io_addr], P0_BOUND
-        mov     al, [device.memsize]
+        mov     al, [ebx + device.memsize]
         dec     al
         out     dx, al
 ; set curr pointer
-        set_io  P0_COMMAND
+        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_PS1 ;+ CMD_RD2 + CMD_STP ; page 1, stop mode
         out     dx, al
-        set_io  P1_CURR
+        set_io  [ebx + device.io_addr], P1_CURR
-        mov     al, [device.rx_start]
+        mov     al, [ebx + device.rx_start]
         out     dx, al
-        set_io  P0_COMMAND
+        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_PS0 ;+ CMD_RD2 + CMD_STA ; go to page 0, start mode
         out     dx, al
 ; Read MAC address and set it to registers
         call    read_mac
         push    .macret
         sub     esp, 6
-        lea     esi, [device.mac]
+        lea     esi, [ebx + device.mac]
         mov     edi, esp
         movsd
         movsw
         jmp     write_mac
   .macret:
 ; set IRQ mask
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  P0_IMR
+        set_io  [ebx + device.io_addr], P0_IMR
         mov     al, IRQ_MASK
         out     dx, al
 ; start mode
-        set_io  P0_COMMAND
+        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_STA
         out     dx, al
 ;   Function
 ;      transmit
 ; buffer in [esp+4], size in [esp+8], pointer to device struct in ebx
 ;***************************************************************************
+proc transmit stdcall buffer_ptr, buffer_size
-align 4
+        pushf
-transmit:
+        cli
-        mov     esi, [esp + 4]
+        mov     esi, [buffer_ptr]
-        mov     ecx, [esp + 8]
+        mov     ecx, [buffer_size]
-        DEBUGF  1, "Transmitting packet, buffer:%x, size:%u\n",esi, ecx
+        DEBUGF  1, "Transmitting packet, buffer:%x, size:%u\n", esi, ecx
         DEBUGF  1, "To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
         [esi+0]:2,[esi+1]:2,[esi+2]:2,[esi+3]:2,[esi+4]:2,[esi+5]:2,[esi+6]:2,[esi+7]:2,[esi+8]:2,[esi+9]:2,[esi+10]:2,[esi+11]:2,[esi+13]:2,[esi+12]:2
         cmp     ecx, ETH_FRAME_LEN
-        ja      .err ; packet is too long
+        ja      .err            ; packet is too long
         cmp     ecx, ETH_ZLEN
-        jb      .err ; packet is too short
+        jb      .err            ; packet is too short
-        movzx   edi, [device.tx_start]
+        movzx   edi, [ebx + device.tx_start]
         shl     edi, 8
         push    cx
         call    PIO_write
         pop     cx
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-;        set_io  P0_COMMAND
+;        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_PS0 + CMD_RD2 + CMD_STA
         out     dx, al
-        set_io  P0_TPSR
+        set_io  [ebx + device.io_addr], P0_TPSR
-        mov     al, [device.tx_start]
+        mov     al, [ebx + device.tx_start]
         out     dx, al
-        set_io  P0_TBCR0
+        set_io  [ebx + device.io_addr], P0_TBCR0
         mov     al, cl
         out     dx, al
-        set_io  P0_TBCR1
+        set_io  [ebx + device.io_addr], P0_TBCR1
-        mov     al, ch
-        out     dx, al
+        mov     al, ch
+        out     dx, al
-        set_io  P0_COMMAND
+        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_PS0 + CMD_TXP + CMD_RD2 + CMD_STA
         out     dx, al
         DEBUGF  1, "Packet Sent!\n"
+        inc     [ebx + device.packets_tx]
-        inc     [device.packets_tx]
+        mov     eax, [buffer_size]
-        mov     eax, [esp + 8]                   ; Get packet size in eax
+        add     dword[ebx + device.bytes_tx], eax
+        adc     dword[ebx + device.bytes_tx + 4], 0
         invoke  KernelFree, [buffer_ptr]
-        add     dword [device.bytes_tx], eax
+        popf
 align 4
 int_handler:
         push    ebx esi edi
         push    ebx esi edi
         DEBUGF  1, "INT\n"
         jz      .nothing
         mov     esi, device_list
   .nextdevice:
         mov     ebx, [esi]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-;        set_io  P0_COMMAND
+;        set_io  [ebx + device.io_addr], P0_COMMAND
         mov     al, CMD_PS0
         out     dx, al
-        set_io  P0_ISR
+        set_io  [ebx + device.io_addr], P0_ISR
         in      al, dx
         test    al, al
         jnz     .got_it
         xor     eax, eax
         ret
   .got_it:
   .got_it:
         DEBUGF  1, "Device=%x status=%x\n", ebx, eax:2
         push    ebx
-        test    al, ISR_PRX     ; packet received ok ?
+  .rx_loop:
-        jz      .no_rx
+        test    al, ISR_PRX     ; packet received ok ?
-        test    [device.flags], FLAG_PIO
-        jz      .no_rx          ; FIXME: Only PIO mode supported for now
         jz      .no_rx
-        pushd   .no_rx
+        test    [ebx + device.flags], FLAG_PIO
         jz      .no_rx          ; FIXME: Only PIO mode supported for now
-; allocate a buffer
+; allocate a buffer
+        invoke  KernelAlloc, ETH_FRAME_LEN
+        test    eax, eax
+        jz      .rx_fail_2
         stdcall KernelAlloc, ETH_FRAME_LEN
-        test    eax, eax
+; Push return address and packet ptr to stack
-        jz      .fail_2
-        pushd   0
+        pushd   .no_rx
-        push    eax
+        pushd   0               ; Reserve some space for the packet size
         push    eax
 ; read offset for current packet from device
-        set_io  0
+; read offset for current packet from device
-        set_io  P0_BOUND        ; boundary ptr is offset to next packet we need to read.
+        set_io  [ebx + device.io_addr], 0
-        in      al, dx
+        set_io  [ebx + device.io_addr], P0_BOUND        ; boundary ptr is offset to next packet we need to read.
-        inc     al
+        in      al, dx
         inc     al
-        cmp     al, [device.memsize]
+        cmp     al, [ebx + device.memsize]
         jb      @f
-        mov     al, [device.rx_start]
+        mov     al, [ebx + device.rx_start]
-       @@:
-        mov     ch, al
+       @@:
         mov     ch, al
         set_io  P0_COMMAND
-        mov     al, CMD_PS1
+        set_io  [ebx + device.io_addr], P0_COMMAND
-        out     dx, al
+        mov     al, CMD_PS1
         out     dx, al
-        set_io  P1_CURR
+        set_io  [ebx + device.io_addr], P1_CURR
-        in      al, dx          ; get current page in cl
+        in      al, dx                          ; get current page in cl
         mov     cl, al
-        set_io  P1_COMMAND
+        set_io  [ebx + device.io_addr], P1_COMMAND
         mov     al, CMD_PS0
-        out     dx, al
         out     dx, al
         cmp     cl, [device.memsize]
-        jb      @f
+        cmp     cl, [ebx + device.memsize]
-        mov     cl, [device.rx_start]
-       @@:
+        jb      @f
         mov     cl, [ebx + device.rx_start]
-        cmp     cl, ch
+       @@:
         je      .fail
-        movzx   esi, ch                         ; we are using 256 byte pages
+        cmp     cl, ch
-        shl     esi, 8                          ; esi now holds the offset for current packet
+        je      .rx_fail
-; Get packet header in eax
+        movzx   esi, ch                         ; we are using 256 byte pages
+        shl     esi, 8                          ; esi now holds the offset for current packet
         sub     esp, 4                          ; reserve 4 bytes on stack to put packet header in
-        mov     edi, esp
-        mov     cx, 4
+; Get packet header in ecx
-        call    PIO_read
+        push    ecx                             ; reserve 4 bytes on stack to put packet header in
+        mov     edi, esp
-        mov     ecx, [esp]                      ; ecx now contains packet header
+        mov     cx, 4
-; check if packet is ok
+        call    PIO_read
+        mov     ecx, [esp]
         test    ecx, RSTAT_PRX
-        jz      .fail_3
+; check if packet is ok
         test    ecx, RSTAT_PRX
-; calculate packet length in ecx
         jz      .rx_fail_3
-        shr     ecx, 16
-        sub     ecx, 4                          ; CRC doesnt count as data byte
-        mov     [esp + 4 + 4], ecx
+; calculate packet length in ecx
+        shr     ecx, 16
-; check if packet size is ok
+        sub     ecx, 4                          ; CRC doesnt count as data byte
-        cmp     ecx, ETH_ZLEN
+        mov     [esp + 8], ecx
         jb      .fail_3
-        cmp     ecx, ETH_FRAME_LEN
+; check if packet size is ok
-        ja      .fail_3
         cmp     ecx, ETH_ZLEN
-; update stats
+        jb      .rx_fail_3
         cmp     ecx, ETH_FRAME_LEN
-        DEBUGF  1, "Received %u bytes\n", ecx
+        ja      .rx_fail_3
-        add     dword[device.bytes_rx], ecx
+; update stats
-        adc     dword[device.bytes_rx + 4], 0
-        inc     [device.packets_rx]
+        DEBUGF  1, "Received %u bytes\n", ecx
         add     dword[ebx + device.bytes_rx], ecx
-; update read and write pointers
+        adc     dword[ebx + device.bytes_rx + 4], 0
-        add     esi, 4
+        inc     [ebx + device.packets_rx]
-        mov     edi, [esp + 4]
-; now check if we can read all data at once (if we cross the end boundary, we need to wrap back to the beginning)
+; update read and write pointers
         add     esi, 4
-        xor     eax, eax
-        mov     ah, [device.memsize]
+        mov     edi, [esp + 4]
         sub     eax, esi
-        cmp     ecx, eax                ; eax = number of bytes till end of buffer, ecx = bytes we need to read
+; now check if we can read all data at once (if we cross the end boundary, we need to wrap back to the beginning)
-        jbe     .no_wrap
         xor     eax, eax
-; Read first part
+        mov     ah, [ebx + device.memsize]
         sub     eax, esi
-        sub     ecx, eax
-        push    ecx
+        cmp     ecx, eax                ; eax = number of bytes till end of buffer, ecx = bytes we need to read
-        mov     ecx, eax
+        jbe     .no_wrap
-        call    PIO_read                ; Read the data
+; Read first part
+        sub     ecx, eax
-; update pointers
+        push    ecx
-        add     edi, ecx
+        mov     ecx, eax
-        pop     ecx
+        call    PIO_read                ; Read the data
-        movzx   esi, [device.rx_start]
+; update pointers for second read
-        shl     esi, 8
+        add     edi, ecx
+        pop     ecx
-; now read second part (or only part)
+        movzx   esi, [ebx + device.rx_start]
-  .no_wrap:
+        shl     esi, 8
-        call    PIO_read                ; Read the data
+; now read second part (or only part)
-; update boundary pointer
+  .no_wrap:
-        pop     eax
+        call    PIO_read                ; Read the data
         mov     al, ah
-        cmp     al, [device.rx_start]
+; update boundary pointer
-        jne     @f
+        pop     eax
-        mov     al, [device.memsize]
+        mov     al, ah
-       @@:
+        cmp     al, [ebx + device.rx_start]
         jne     @f
-        set_io  0
+        mov     al, [ebx + device.memsize]
-        set_io  P0_BOUND
+       @@:
-        dec     al
+        set_io  [ebx + device.io_addr], 0
-        out     dx, al
-; now send the data to the kernel
         set_io  [ebx + device.io_addr], P0_BOUND
-        jmp     Eth_input
+        dec     al
         out     dx, al
   .fail_3:
-        add     esp, 4
+; now send the data to the kernel
 align 4
 write_mac:      ; in: mac on stack (6 bytes)
         DEBUGF  1, "Writing MAC\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         mov     al, CMD_PS1; + CMD_RD2 + CMD_STP
         out     dx, al
-        set_io  P1_PAR0
+        set_io  [ebx + device.io_addr], P1_PAR0
         mov     esi, esp
         mov     cx, 6
         mov     edi, esp
         call    PIO_read
         mov     esi, esp
         add     esp, 16
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
         mov     ecx, 6
   .loop:
         movsb
-        test    [device.flags], FLAG_16BIT
+        test    [ebx + device.flags], FLAG_16BIT
         jz      .8bit
         inc     esi
   .8bit:
-        loop    .loop
         loop    .loop
         DEBUGF  1, "MAC=%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
 ;***************************************************************************
 PIO_read:
         DEBUGF  1, "PIO Read from %x to %x, %u bytes ", si, edi, cx
-; start DMA
+; stop DMA + start
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-;        set_io  P0_COMMAND
+;        set_io  [ebx + device.io_addr], P0_COMMAND
+        mov     al, CMD_RD2 + CMD_STA
+        out     dx, al
+; Request confirmation of end of DMA transfer
+        set_io  [ebx + device.io_addr], P0_ISR
-        mov     al, CMD_RD2 + CMD_STA
+        mov     al, ISR_RDC
         out     dx, al
 ; set length of data we're interested in
-        set_io  P0_RBCR0
-        mov     al, cl
+        set_io  [ebx + device.io_addr], P0_RBCR0
-        out     dx, al
+        mov     al, cl
         out     dx, al
-        set_io  P0_RBCR1
+        set_io  [ebx + device.io_addr], P0_RBCR1
         mov     al, ch
         out     dx, al
-; set offset of what we want to read
-        set_io  P0_RSAR0
+; set offset of what we want to read
-        mov     ax, si
+        set_io  [ebx + device.io_addr], P0_RSAR0
-        out     dx, al
+        mov     ax, si
         out     dx, al
-        set_io  P0_RSAR1
+        set_io  [ebx + device.io_addr], P0_RSAR1
         shr     ax, 8
         out     dx, al
-; start DMA read
-        set_io  P0_COMMAND
+; start DMA read
-        mov     al, CMD_RD0 + CMD_STA
+        set_io  [ebx + device.io_addr], P0_COMMAND
-        out     dx, al
         mov     al, CMD_RD0 + CMD_STA
-        set_io  NE_ASIC
         out     dx, al
         test    [device.flags], FLAG_16BIT
-        jz      .8bits
         set_io  [ebx + device.io_addr], NE_ASIC
-        DEBUGF  1, "(16-bit mode)\n"
+        test    [ebx + device.flags], FLAG_16BIT
         jz      .8bits
-        shr     cx, 1   ; note that if the number was odd, carry flag will be set
+        DEBUGF  1, "(16-bit mode)\n"
-        pushf
-  .16bits:
+        shr     cx, 1   ; note that if the number was odd, carry flag will be set
-        in      ax, dx
+        pushf
+  .16bits:
+        in      ax, dx
         stosw
         loopw   .16bits
         popf
-        inc     cx
-        popf
+        jnc     wait_dma_done
-        jnc     .done
+        in      al, dx
-        jmp     .8bits_
+        stosb
         jmp     wait_dma_done
-  .8bits:
-        DEBUGF  1, "(8-bit mode)\n"
-  .8bits_:
-        in      al, dx
-        stosb
-        loopw   .8bits_
-  .done:
-;        set_io  0
-;        set_io  P0_ISR
-;
-;  .dmawait:                             ; Wait for Remote DMA Complete
-;        in      al, dx
+  .8bits:
 ;***************************************************************************
 PIO_write:
+        DEBUGF  1, "Eth PIO Write from %x to %x, %u bytes ", esi, di, cx
-        DEBUGF  1, "Eth PIO Write from %x to %x, %u bytes ", esi, di, cx
+; Stop DMA + start
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-;        set_io  P0_COMMAND
+;        set_io  [ebx + device.io_addr], P0_COMMAND
+        mov     al, CMD_RD2 + CMD_STA
-        mov     al, CMD_RD2 + CMD_STA
+        out     dx, al
         out     dx, al
 ; Request confirmation of end of DMA transfer
+        set_io  [ebx + device.io_addr], P0_ISR
-        set_io  P0_ISR
+        mov     al, ISR_RDC
-        mov     al, ISR_RDC
+        out     dx, al
         out     dx, al
-        set_io  P0_RBCR0
+; Program number of bytes we want to write
-        mov     al, cl
+        set_io  [ebx + device.io_addr], P0_RBCR0
-        out     dx, al
+        mov     al, cl
+        out     dx, al
         set_io  [ebx + device.io_addr], P0_RBCR1
-        set_io  P0_RBCR1
+        mov     al, ch
-        mov     al, ch
+        out     dx, al
         out     dx, al
+; Program where we want to write
         mov     ax, di
+        set_io  [ebx + device.io_addr], P0_RSAR0
-        set_io  P0_RSAR0
+        out     dx, al
-        out     dx, al
+        shr     ax, 8
-        shr     ax, 8
+        set_io  [ebx + device.io_addr], P0_RSAR1
-        set_io  P0_RSAR1
+        out     dx, al
-        out     dx, al
 ; Set the DMA to write
-        set_io  P0_COMMAND
-        mov     al, CMD_RD1 + CMD_STA
+        set_io  [ebx + device.io_addr], P0_COMMAND
-        out     dx, al
         mov     al, CMD_RD1 + CMD_STA
-        set_io  NE_ASIC
+        out     dx, al
-        test    [device.flags], FLAG_16BIT
         jz      .8_bit
         set_io  [ebx + device.io_addr], NE_ASIC
-        DEBUGF  1, "(16-bit mode)\n"
+        test    [ebx + device.flags], FLAG_16BIT
         jz      .8_bit
-        shr     cx, 1   ; note that if the number was odd, carry flag will be set
-        pushf           ; save the flags for later
+        DEBUGF  1, "(16-bit mode)\n"
+        shr     cx, 1   ; note that if the number was odd, carry flag will be set
+        pushf           ; save the flags for later
   .16bit:
         lodsw
         out     dx, ax
-        loopw   .16bit
         loopw   .16bit
-        popf
-        jnc     .done
+        popf
-        inc     cx
+        jnc     wait_dma_done
-        jmp     .8_bit_
+        lodsb
         out     dx, al
+        jmp     wait_dma_done
+  .8_bit:
+        DEBUGF  1, "(8-bit mode)\n"
+  .8_bit_:
-  .8_bit:
+        lodsb
-        DEBUGF  1, "(8-bit mode)\n"
+        out     dx, al
+        loopw   .8_bit_
-  .8_bit_:
+        jmp     wait_dma_done
-        lodsb
-        out     dx, al
         loopw   .8_bit_
 wait_dma_done:
   .done:
-;        set_io  0
-;        set_io  P0_ISR
+        set_io  [ebx + device.io_addr], 0
-;  .dmawait:                             ; Wait for Remote DMA Complete
-;        in      al, dx
-;        test    al, ISR_RDC
-;        jz      .dmawait
+        set_io  [ebx + device.io_addr], P0_ISR
-;        and     al, not ISR_RDC
+  .dmawait:
-;        out     dx, al                  ; clear the bit
+        in      al, dx
+        test    al, ISR_RDC             ; Remote DMA Complete
+        jz      .dmawait
-        ret
+;        and     al, not ISR_RDC
+;        out     dx, al                  ; clear the bit
+        ret
+; End of code
-; place all initialized data here

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/RTL8029.asm – Rev 4974 → 5005