WebSVN – Kolibri OS – Diff – /kernel/branches/net/drivers/RTL8139.asm

 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 format MS COFF
-	API_VERSION		equ 0x01000100
+        API_VERSION             equ 0x01000100
-	DRIVER_VERSION		equ 5
+        DRIVER_VERSION          equ 5
-	MAX_DEVICES		equ 16
+        MAX_DEVICES             equ 16
-	RBLEN			equ 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k
+        RBLEN                   equ 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k
-	DEBUG			equ 1
+        DEBUG                   equ 1
-	__DEBUG__		equ 1
+        __DEBUG__               equ 1
-	__DEBUG_LEVEL__ 	equ 2
+        __DEBUG_LEVEL__         equ 2
 include 'proc32.inc'
-	TSR_OWN 		equ 1 SHL 13
+        TSR_OWN                 equ 1 SHL 13
-	TSR_TUN 		equ 1 SHL 14
+        TSR_TUN                 equ 1 SHL 14
-	TSR_TOK 		equ 1 SHL 15
+        TSR_TOK                 equ 1 SHL 15
-	TSR_CDH 		equ 1 SHL 28
+        TSR_CDH                 equ 1 SHL 28
-	TSR_OWC 		equ 1 SHL 29
+        TSR_OWC                 equ 1 SHL 29
-	TSR_TABT		equ 1 SHL 30
+        TSR_TABT                equ 1 SHL 30
-	TSR_CRS 		equ 1 SHL 31
+        TSR_CRS                 equ 1 SHL 31
 virtual at ebx
-	device:
+        device:
-	ETH_DEVICE
+        ETH_DEVICE
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 proc START stdcall, state:dword
-	cmp [state], 1
+        cmp [state], 1
-	jne .exit
+        jne .exit
   .entry:
-	DEBUGF	2,"Loading rtl8139 driver\n"
+        DEBUGF  2,"Loading rtl8139 driver\n"
-	stdcall RegService, my_service, service_proc
+        stdcall RegService, my_service, service_proc
-	ret
+        ret
   .fail:
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 proc service_proc stdcall, ioctl:dword
-	mov	edx, [ioctl]
+        mov     edx, [ioctl]
-	mov	eax, [IOCTL.io_code]
+        mov     eax, [IOCTL.io_code]
 ;------------------------------------------------------
-	cmp	eax, 0 ;SRV_GETVERSION
+        cmp     eax, 0 ;SRV_GETVERSION
-	jne	@F
+        jne     @F
-	cmp	[IOCTL.out_size], 4
+        cmp     [IOCTL.out_size], 4
-	jl	.fail
+        jl      .fail
-	mov	eax, [IOCTL.output]
+        mov     eax, [IOCTL.output]
-	mov	[eax], dword API_VERSION
+        mov     [eax], dword API_VERSION
-	xor	eax, eax
+        xor     eax, eax
-	ret
+        ret
 ;------------------------------------------------------
   @@:
-	cmp	eax, 1 ;SRV_HOOK
+        cmp     eax, 1 ;SRV_HOOK
-	jne	.fail
+        jne     .fail
-	cmp	[IOCTL.inp_size], 3		  ; Data input must be at least 3 bytes
+        cmp     [IOCTL.inp_size], 3               ; Data input must be at least 3 bytes
-	jl	.fail
+        jl      .fail
-	mov	eax, [IOCTL.input]
+        mov     eax, [IOCTL.input]
-	cmp	byte [eax], 1				; 1 means device number and bus number (pci) are given
+        cmp     byte [eax], 1                           ; 1 means device number and bus number (pci) are given
-	jne	.fail					; other types arent supported for this card yet
+        jne     .fail                                   ; other types arent supported for this card yet
 ; check if the device is already listed
-	mov	esi, device_list
+        mov     esi, device_list
-	mov	ecx, [devices]
+        mov     ecx, [devices]
-	test	ecx, ecx
+        test    ecx, ecx
-	jz	.firstdevice
+        jz      .firstdevice
 ;        mov     eax, [IOCTL.input]                      ; get the pci bus and device numbers
-	mov	ax , [eax+1]				;
+        mov     ax , [eax+1]                            ;
   .nextdevice:
-	mov	ebx, [esi]
+        mov     ebx, [esi]
-	cmp	ax , word [device.pci_bus]		; compare with pci and device num in device list (notice the usage of word instead of byte)
+        cmp     ax , word [device.pci_bus]              ; compare with pci and device num in device list (notice the usage of word instead of byte)
-	je	.find_devicenum 			; Device is already loaded, let's find it's device number
+        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
-	add	esi, 4
+        add     esi, 4
-	loop	.nextdevice
+        loop    .nextdevice
 ; 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
+        cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
-	jge	.fail
+        jge     .fail
-	allocate_and_clear ebx, device.size, .fail	; Allocate the buffer for device structure
+        allocate_and_clear ebx, device.size, .fail      ; Allocate the buffer for device structure
 ; Fill in the direct call addresses into the struct
-	mov	[device.reset], reset
+        mov     [device.reset], reset
-	mov	[device.transmit], transmit
+        mov     [device.transmit], transmit
-	mov	[device.get_MAC], read_mac
+        mov     [device.get_MAC], read_mac
-	mov	[device.set_MAC], write_mac
+        mov     [device.set_MAC], write_mac
-	mov	[device.unload], unload
+        mov     [device.unload], unload
-	mov	[device.name], my_service
+        mov     [device.name], my_service
 ; save the pci bus and device numbers
-	mov	eax, [IOCTL.input]
+        mov     eax, [IOCTL.input]
-	mov	cl , [eax+1]
+        mov     cl , [eax+1]
-	mov	[device.pci_bus], cl
+        mov     [device.pci_bus], cl
-	mov	cl , [eax+2]
+        mov     cl , [eax+2]
-	mov	[device.pci_dev], cl
+        mov     [device.pci_dev], cl
 ; Now, it's time to find the base io addres of the PCI device
-	find_io [device.pci_bus], [device.pci_dev], [device.io_addr]
+        find_io [device.pci_bus], [device.pci_dev], [device.io_addr]
 ; We've found the io address, find IRQ now
-	find_irq [device.pci_bus], [device.pci_dev], [device.irq_line]
+        find_irq [device.pci_bus], [device.pci_dev], [device.irq_line]
-	DEBUGF	2,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
+        DEBUGF  2,"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
+        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
 ; Allocate the receive buffer
-	stdcall CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW
+        stdcall CreateRingBuffer, dword (RX_BUFFER_SIZE), dword PG_SW
-	test	eax, eax
+        test    eax, eax
-	jz	.err
+        jz      .err
-	mov	[device.rx_buffer], eax
+        mov     [device.rx_buffer], eax
 ; Ok, the eth_device structure is ready, let's probe the device
-	call	probe							; this function will output in eax
+        call    probe                                                   ; this function will output in eax
-	test	eax, eax
+        test    eax, eax
 ;;                                                                        ;;
 ;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 align 4
 unload:
-	; TODO: (in this particular order)
+        ; TODO: (in this particular order)
-	;
+        ;
-	; - Stop the device
+        ; - Stop the device
-	; - Detach int handler
+        ; - Detach int handler
-	; - Remove device from local list (RTL8139_LIST)
+        ; - Remove device from local list (RTL8139_LIST)
-	; - call unregister function in kernel
+        ; - call unregister function in kernel
-	; - Remove all allocated structures and buffers the card used
+        ; - Remove all allocated structures and buffers the card used
-	or	eax,-1
+        or      eax,-1
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 probe:
-	DEBUGF	2,"Probing rtl8139 device: "
+        DEBUGF  2,"Probing rtl8139 device: "
-	make_bus_master [device.pci_bus], [device.pci_dev]
+        make_bus_master [device.pci_bus], [device.pci_dev]
 ; get chip version
-	set_io	0
+        set_io  0
-	set_io	REG_TXCONFIG + 2
+        set_io  REG_TXCONFIG + 2
-	in	ax , dx
+        in      ax , dx
-	shr	ah , 2
+        shr     ah , 2
-	shr	ax , 6
+        shr     ax , 6
-	and	al , 01111111b
+        and     al , 01111111b
-	mov	ecx, HW_VER_ARRAY_SIZE-1
+        mov     ecx, HW_VER_ARRAY_SIZE-1
   .chip_ver_loop:
-	cmp	al , [hw_ver_array + ecx]
+        cmp     al , [hw_ver_array + ecx]
-	je	.chip_ver_found
+        je      .chip_ver_found
-	dec	ecx
+        dec     ecx
-	jns	.chip_ver_loop
+        jns     .chip_ver_loop
   .unknown:
-	mov	ecx, 8
+        mov     ecx, 8
   .chip_ver_found:
-	cmp	ecx, 8
+        cmp     ecx, 8
-	jg	.unknown
+        jg      .unknown
-	mov	[device.hw_ver_id], cl
+        mov     [device.hw_ver_id], cl
-	mov	ecx, [crosslist + ecx*4]
+        mov     ecx, [crosslist + ecx*4]
-	mov	[device.name], ecx
+        mov     [device.name], ecx
-	DEBUGF	2,"Chip version: %s\n", ecx
+        DEBUGF  2,"Chip version: %s\n", ecx
 ; wake up the chip
-	set_io	0
+        set_io  0
-	set_io	REG_HLTCLK
+        set_io  REG_HLTCLK
-	mov	al , 'R' ; run the clock
+        mov     al , 'R' ; run the clock
-	out	dx , al
+        out     dx , al
 ; unlock config and BMCR registers
-	set_io	REG_9346CR
+        set_io  REG_9346CR
-	mov	al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
+        mov     al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
-	out	dx , al
+        out     dx , al
 ; enable power management
-	set_io	REG_CONFIG1
+        set_io  REG_CONFIG1
-	in	al , dx
+        in      al , dx
-	cmp	[device.hw_ver_id], IDX_RTL8139B
+        cmp     [device.hw_ver_id], IDX_RTL8139B
-	jl	.old_chip
+        jl      .old_chip
 ; set LWAKE pin to active high (default value).
 ; it is for Wake-On-LAN functionality of some motherboards.
 ; this signal is used to inform the motherboard to execute a wake-up process.
 ; only at newer chips.
-	or	al , (1 shl BIT_PMEn)
+        or      al , (1 shl BIT_PMEn)
-	and	al , not (1 shl BIT_LWACT)
+        and     al , not (1 shl BIT_LWACT)
-	out	dx , al
+        out     dx , al
-	set_io	REG_CONFIG4
+        set_io  REG_CONFIG4
-	in	al , dx
+        in      al , dx
-	and	al , not (1 shl BIT_LWPTN)
+        and     al , not (1 shl BIT_LWPTN)
-	out	dx , al
+        out     dx , al
-	jmp	.finish_wake_up
+        jmp     .finish_wake_up
   .old_chip:
 ; wake up older chips
-	and	al , not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
+        and     al , not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
-	out	dx , al
+        out     dx , al
   .finish_wake_up:
 ; lock config and BMCR registers
-	xor	al , al
+        xor     al , al
-	set_io	0
+        set_io  0
-	set_io	REG_9346CR
+        set_io  REG_9346CR
-	out	dx , al
+        out     dx , al
-	DEBUGF	2,"done!\n"
+        DEBUGF  2,"done!\n"
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;;   reset: Set up all registers and descriptors, clear some values
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 reset:
-	DEBUGF	2,"Resetting rtl8139: "
+        DEBUGF  2,"Resetting rtl8139: "
 ; attach int handler
-	movzx	eax, [device.irq_line]
+        movzx   eax, [device.irq_line]
-	DEBUGF	1,"Attaching int handler to irq %x, ",eax:1
+        DEBUGF  1,"Attaching int handler to irq %x, ",eax:1
-	stdcall AttachIntHandler, eax, int_handler, dword 0
+        stdcall AttachIntHandler, eax, int_handler, dword 0
-	test	eax, eax
+        test    eax, eax
-	jnz	@f
+        jnz     @f
-	DEBUGF	1,"\nCould not attach int handler!\n"
+        DEBUGF  1,"\nCould not attach int handler!\n"
 ;        or      eax, -1
 ;        ret
        @@:
 ; reset chip
-	DEBUGF	1,"Resetting chip\n"
+        DEBUGF  1,"Resetting chip\n"
-	set_io	0
+        set_io  0
-	set_io	REG_COMMAND
+        set_io  REG_COMMAND
-	mov	al , 1 shl BIT_RST
+        mov     al , 1 shl BIT_RST
-	out	dx , al
+        out     dx , al
-	mov	cx , 1000		; wait no longer for the reset
+        mov     cx , 1000               ; wait no longer for the reset
   .wait_for_reset:
-	in	al , dx
+        in      al , dx
-	test	al , 1 shl BIT_RST
+        test    al , 1 shl BIT_RST
-	jz	.reset_completed	; RST remains 1 during reset
+        jz      .reset_completed        ; RST remains 1 during reset
-	dec	cx
+        dec     cx
-	jns	.wait_for_reset
+        jns     .wait_for_reset
   .reset_completed:
 ; unlock config and BMCR registers
-	set_io	REG_9346CR
+        set_io  REG_9346CR
-	mov	al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
+        mov     al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
-	out	dx , al
+        out     dx , al
 ; initialize multicast registers (no filtering)
-	mov	eax, 0xffffffff
+        mov     eax, 0xffffffff
-	set_io	REG_MAR0
+        set_io  REG_MAR0
-	out	dx , eax
+        out     dx , eax
-	set_io	REG_MAR4
+        set_io  REG_MAR4
-	out	dx , eax
+        out     dx , eax
 ; enable Rx/Tx
-	mov	al , (1 shl BIT_RE) or (1 shl BIT_TE)
+        mov     al , (1 shl BIT_RE) or (1 shl BIT_TE)
-	set_io	REG_COMMAND
+        set_io  REG_COMMAND
-	out	dx , al
+        out     dx , al
 ; Rxbuffer size, unlimited dma burst, no wrapping, no rx threshold
 ; accept broadcast packets, accept physical match packets
-	mov	ax , RX_CONFIG
+        mov     ax , RX_CONFIG
-	set_io	REG_RXCONFIG
+        set_io  REG_RXCONFIG
-	out	dx , ax
+        out     dx , ax
 ; 1024 bytes DMA burst, total retries = 16 + 8 * 16 = 144
-	mov	eax , (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0
+        mov     eax , (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0
-	set_io	REG_TXCONFIG
+        set_io  REG_TXCONFIG
-	out	dx , eax
+        out     dx , eax
 ; enable auto negotiation
-	set_io	REG_BMCR
+        set_io  REG_BMCR
-	in	ax , dx
+        in      ax , dx
-	or	ax , (1 shl BIT_ANE)
+        or      ax , (1 shl BIT_ANE)
-	out	dx , ax
+        out     dx , ax
 ; set auto negotiation advertisement
-	set_io	REG_ANAR
+        set_io  REG_ANAR
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 transmit:
-	DEBUGF	1,"\nTransmitting packet, buffer:%x, size:%u\n",[esp+4],[esp+8]
+        DEBUGF  1,"\nTransmitting packet, buffer:%x, size:%u\n",[esp+4],[esp+8]
-	mov	eax, [esp+4]
+        mov     eax, [esp+4]
-	DEBUGF	1,"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+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+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
-	[eax+13]:2,[eax+12]:2
+        [eax+13]:2,[eax+12]:2
-	cmp	dword [esp+8], MAX_ETH_FRAME_SIZE
+        cmp     dword [esp+8], MAX_ETH_FRAME_SIZE
-	jg	.fail
+        jg      .fail
-	cmp	dword [esp+8], 60
+        cmp     dword [esp+8], 60
-	jl	.fail
+        jl      .fail
 ; check if we own the current discriptor
-	set_io	0
+        set_io  0
-	set_io	REG_TSD0
+        set_io  REG_TSD0
-	movzx	ecx, [device.curr_tx_desc]
+        movzx   ecx, [device.curr_tx_desc]
-	shl	ecx, 2
+        shl     ecx, 2
-	add	edx, ecx
+        add     edx, ecx
-	in	eax, dx
+        in      eax, dx
-	test	eax, (1 shl BIT_OWN)
+        test    eax, (1 shl BIT_OWN)
-	jz	.wait_to_send
+        jz      .wait_to_send
   .send_packet:
 ; get next descriptor
-	inc	[device.curr_tx_desc]
+        inc     [device.curr_tx_desc]
-	and	[device.curr_tx_desc], NUM_TX_DESC-1
+        and     [device.curr_tx_desc], NUM_TX_DESC-1
 ; Update stats
-	inc	[device.packets_tx]
+        inc     [device.packets_tx]
-	mov	eax, [esp+8]
+        mov     eax, [esp+8]
-	add	dword [device.bytes_tx], eax
+        add     dword [device.bytes_tx], eax
-	adc	dword [device.bytes_tx + 4], 0
+        adc     dword [device.bytes_tx + 4], 0
 ; Set the buffer address
-	set_io	REG_TSAD0
+        set_io  REG_TSAD0
-	mov	eax, [esp+4]
+        mov     eax, [esp+4]
-	mov	[device.TX_DESC+ecx], eax
+        mov     [device.TX_DESC+ecx], eax
-	GetRealAddr
+        GetRealAddr
-	out	dx, eax
+        out     dx, eax
 ; And the size of the buffer
-	set_io	REG_TSD0
+        set_io  REG_TSD0
-	mov	eax, [esp+8]
+        mov     eax, [esp+8]
-	or	eax, (ERTXTH shl BIT_ERTXTH)	; Early threshold
+        or      eax, (ERTXTH shl BIT_ERTXTH)    ; Early threshold
-	out	dx, eax
+        out     dx, eax
-	DEBUGF	1,"Packet Sent!\n"
+        DEBUGF  1,"Packet Sent!\n"
-	xor	eax, eax
+        xor     eax, eax
-	ret	8
+        ret     8
   .wait_to_send:
-	DEBUGF	1,"Waiting for timeout\n"
+        DEBUGF  1,"Waiting for timeout\n"
-	push	edx
+        push    edx
-	mov	esi, 300
+        mov     esi, 300
-	stdcall Sleep
+        stdcall Sleep
-	pop	edx
+        pop     edx
-	in	ax, dx
+        in      ax, dx
-	test	ax, (1 shl BIT_OWN)
+        test    ax, (1 shl BIT_OWN)
-	jnz	.send_packet
+        jnz     .send_packet
+        pusha
-	pusha
+        call    reset                            ; if chip hung, reset it
 ;;                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 int_handler:
-	DEBUGF	1,"\nIRQ %x\n", eax:2			; no, you cant replace 'eax:2' with 'al', this must be a bug in FDO
+        DEBUGF  1,"\nIRQ %x\n", eax:2                   ; no, you cant replace 'eax:2' with 'al', this must be a bug in FDO
 ; find pointer of device wich made IRQ occur
-	mov	esi, device_list
+        mov     esi, device_list
-	mov	ecx, [devices]
+        mov     ecx, [devices]
-	test	ecx, ecx
+        test    ecx, ecx
-	jz	.fail
+        jz      .fail
 .nextdevice:
-	mov	ebx, dword [esi]
+        mov     ebx, dword [esi]
-	set_io	0
+        set_io  0
-	set_io	REG_ISR
+        set_io  REG_ISR
-	in	ax , dx
+        in      ax , dx
-	out	dx , ax 			    ; send it back to ACK
+        out     dx , ax                             ; send it back to ACK
-	add	esi, 4
+        add     esi, 4
-	test	ax , ax
+        test    ax , ax
-	jnz	.got_it
+        jnz     .got_it
-	dec	ecx
+        dec     ecx
-	jnz	.nextdevice
+        jnz     .nextdevice
-	ret					    ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
+        ret                                         ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
   .got_it:
 ; looks like we've found it!
 ; Lets found out why the irq occured then..
 ;----------------------------------------------------
 ; Received packet ok?
-	test	ax, ISR_ROK
+        test    ax, ISR_ROK
-	jz	@f
+        jz      @f
-	push	ax
+        push    ax
   .receive:
-	set_io	0
+        set_io  0
-	set_io	REG_COMMAND
+        set_io  REG_COMMAND
-	in	al , dx
+        in      al , dx
-	test	al , BUFE			    ; test if RX buffer is empty
+        test    al , BUFE                           ; test if RX buffer is empty
-	jnz	.finish 			    ;
+        jnz     .finish                             ;
-	DEBUGF	1,"RX: "
+        DEBUGF  1,"RX: "
-	mov	eax, [device.rx_buffer]
+        mov     eax, [device.rx_buffer]
-	add	eax, [device.rx_data_offset]
+        add     eax, [device.rx_data_offset]
-	test	byte [eax], (1 shl BIT_ROK)	    ; check if packet is ok
+        test    byte [eax], (1 shl BIT_ROK)         ; check if packet is ok
-	jz	.reset_rx
+        jz      .reset_rx
 ; packet is ok, copy it
-	movzx	ecx, word [eax+2]		    ; packet length
+        movzx   ecx, word [eax+2]                   ; packet length
-	sub	ecx, 4				    ; don't copy CRC
+        sub     ecx, 4                              ; don't copy CRC
 ; Update stats
-	add	dword [device.bytes_rx], ecx
+        add     dword [device.bytes_rx], ecx
-	adc	dword [device.bytes_rx + 4], 0
+        adc     dword [device.bytes_rx + 4], 0
-	inc	dword [device.packets_rx]
+        inc     dword [device.packets_rx]
-	DEBUGF	1,"Received %u bytes\n", ecx
+        DEBUGF  1,"Received %u bytes\n", ecx
-	push	ebx eax ecx
+        push    ebx eax ecx
-	stdcall KernelAlloc, ecx		    ; Allocate a buffer to put packet into
+        stdcall KernelAlloc, ecx                    ; Allocate a buffer to put packet into
-	pop	ecx
+        pop     ecx
-	test	eax, eax			    ; Test if we allocated succesfully
+        test    eax, eax                            ; Test if we allocated succesfully
-	jz	.abort
+        jz      .abort
-	mov	edi, eax			    ; Where we will copy too
+        mov     edi, eax                            ; Where we will copy too
-	mov	esi, [esp]			    ; The buffer we will copy from
+        mov     esi, [esp]                          ; The buffer we will copy from
-	add	esi, 4				    ; Dont copy CRC
+        add     esi, 4                              ; Dont copy CRC
-	push	dword .abort			    ; Kernel will return to this address after EthReceiver
+        push    dword .abort                        ; Kernel will return to this address after EthReceiver
-	push	ecx edi 			    ; Save buffer pointer and size, to pass to kernel
+        push    ecx edi                             ; Save buffer pointer and size, to pass to kernel
   .copy:
-	shr	ecx, 1
+        shr     ecx, 1
-	jnc	.nb
+        jnc     .nb
-	movsb
+        movsb
   .nb:
-	shr	ecx, 1
+        shr     ecx, 1
-	jnc	.nw
+        jnc     .nw
-	movsw
+        movsw
   .nw:
-	jz	.nd
+        jz      .nd
-	rep	movsd
+        rep     movsd
   .nd:
-	jmp	EthReceiver			    ; Send it to kernel
+        jmp     EthReceiver                         ; Send it to kernel
   .abort:
-	pop	eax ebx
+        pop     eax ebx
-						    ; update eth_data_start_offset
+                                                    ; update eth_data_start_offset
-	movzx	eax, word [eax+2]		    ; packet length
+        movzx   eax, word [eax+2]                   ; packet length
-	add	eax, [device.rx_data_offset]
+        add     eax, [device.rx_data_offset]
-	add	eax, 4+3			    ; packet header is 4 bytes long + dword alignment
+        add     eax, 4+3                            ; packet header is 4 bytes long + dword alignment
-	and	eax, not 3			    ; dword alignment
+        and     eax, not 3                          ; dword alignment
-	cmp	eax, RX_BUFFER_SIZE
+        cmp     eax, RX_BUFFER_SIZE
-	jl	.no_wrap
+        jl      .no_wrap
-	DEBUGF	2,"Wrapping"
+        DEBUGF  2,"Wrapping"
-	sub	eax, RX_BUFFER_SIZE
+        sub     eax, RX_BUFFER_SIZE
   .no_wrap:
-	mov	[device.rx_data_offset], eax
+        mov     [device.rx_data_offset], eax
-	DEBUGF	1,"New RX ptr: %d\n", eax
+        DEBUGF  1,"New RX ptr: %d\n", eax
-	set_io	0
+        set_io  0
-	set_io	REG_CAPR			    ; update 'Current Address of Packet Read register'
+        set_io  REG_CAPR                            ; update 'Current Address of Packet Read register'
-	sub	eax, 0x10			    ; value 0x10 is a constant for CAPR
+        sub     eax, 0x10                           ; value 0x10 is a constant for CAPR
-	out	dx , ax
+        out     dx , ax
-	jmp	.receive			    ; check for multiple packets
+        jmp     .receive                            ; check for multiple packets
   .reset_rx:
-	test	byte [eax], (1 shl BIT_CRC)
+        test    byte [eax], (1 shl BIT_CRC)
-	jz	.no_crc_error
+        jz      .no_crc_error
-	DEBUGF	2,"\nCRC error!\n"
+        DEBUGF  2,"\nCRC error!\n"
   .no_crc_error:
-	test	byte [eax], (1 shl BIT_FAE)
+        test    byte [eax], (1 shl BIT_FAE)
-	jz	.no_fae_error
+        jz      .no_fae_error
-	DEBUGF	1,"\nFrame alignment error!\n"
+        DEBUGF  1,"\nFrame alignment error!\n"
   .no_fae_error:
-	DEBUGF	1,"Reset RX\n"
+        DEBUGF  1,"Reset RX\n"
-	in	al , dx 			    ; read command register
+        in      al , dx                             ; read command register
-	push	ax
+        push    ax
-	and	al , not (1 shl BIT_RE) 	    ; Clear the RE bit
+        and     al , not (1 shl BIT_RE)             ; Clear the RE bit
-	out	dx , al
+        out     dx , al
 ;        jz      .nocsl
 ;        DEBUGF  2, "TX: Carrier Sense Lost!\n"
+;
 ;  .nocsl:
-	DEBUGF	1,"TX OK: free buffer %x\n", [device.TX_DESC+ecx]:8
+        DEBUGF  1,"TX OK: free buffer %x\n", [device.TX_DESC+ecx]:8
-	push	ecx ebx
+        push    ecx ebx
-	stdcall KernelFree, [device.TX_DESC+ecx]
+        stdcall KernelFree, [device.TX_DESC+ecx]
-	pop	ebx ecx
+        pop     ebx ecx
-	mov	[device.TX_DESC+ecx], 0
+        mov     [device.TX_DESC+ecx], 0
   .notthisone:
-	add	ecx, 4
+        add     ecx, 4
-	cmp	ecx, 16
+        cmp     ecx, 16
-	jl	.txdesloop
+        jl      .txdesloop
-	pop	ax
+        pop     ax
 ;----------------------------------------------------
 ; Rx buffer overflow ?
   @@:
-	test	ax, ISR_RXOVW
+        test    ax, ISR_RXOVW
-	jz	@f
+        jz      @f
-	push	ax
+        push    ax
-	DEBUGF	2,"RX-buffer overflow!\n"
+        DEBUGF  2,"RX-buffer overflow!\n"
-	set_io	0
+        set_io  0
-	set_io	REG_ISR
+        set_io  REG_ISR
-	mov	ax , ISR_FIFOOVW or ISR_RXOVW
+        mov     ax , ISR_FIFOOVW or ISR_RXOVW
-	out	dx , ax
+        out     dx , ax
-	pop	ax
+        pop     ax
 ;----------------------------------------------------
 ; Packet underrun?
   @@:
-	test	ax, ISR_PUN
+        test    ax, ISR_PUN
-	jz	@f
+        jz      @f
-	DEBUGF	2,"Packet underrun!\n"
+        DEBUGF  2,"Packet underrun!\n"
 ;----------------------------------------------------
 ; Receive FIFO overflow ?
   @@:
-	test	ax, ISR_FIFOOVW
+        test    ax, ISR_FIFOOVW
-	jz	@f
+        jz      @f
-	push	ax
+        push    ax
-	DEBUGF	2,"RX fifo overflow!\n"
+        DEBUGF  2,"RX fifo overflow!\n"
-	set_io	0
+        set_io  0
-	set_io	REG_ISR
+        set_io  REG_ISR
-	mov	ax , ISR_FIFOOVW or ISR_RXOVW
+        mov     ax , ISR_FIFOOVW or ISR_RXOVW
-	out	dx , ax
+        out     dx , ax
-	pop	ax
+        pop     ax
 ;;                     ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 cable:
-	DEBUGF	1,"Checking Cable status: "
+        DEBUGF  1,"Checking Cable status: "
-	mov	edx, dword [device.io_addr]
+        mov     edx, dword [device.io_addr]
-	add	edx, REG_MSR
+        add     edx, REG_MSR
-	in	al , dx
+        in      al , dx
 ;        test    al , 1 SHL 2     ; 0 = link ok 1 = link fail
 ;        jnz     .notconnected
 ;        test    al , 1 SHL 3     ; 0 = 100 Mbps 1 = 10 Mbps
 ;        jnz     .10mbps
-	shr	al, 2
+        shr     al, 2
 ;; Write MAC address ;;
 ;;                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;
 align 4
-write_mac:	; in: mac pushed onto stack (as 3 words)
+write_mac:      ; in: mac pushed onto stack (as 3 words)
-	DEBUGF	2,"Writing MAC: "
+        DEBUGF  2,"Writing MAC: "
 ; disable all in command registers
-	set_io	0
+        set_io  0
-	set_io	REG_9346CR
+        set_io  REG_9346CR
-	xor	eax, eax
+        xor     eax, eax
-	out	dx , al
+        out     dx , al
-	set_io	REG_IMR
+        set_io  REG_IMR
-	xor	eax, eax
+        xor     eax, eax
-	out	dx , ax
+        out     dx , ax
-	set_io	REG_ISR
+        set_io  REG_ISR
-	mov	eax, -1
+        mov     eax, -1
-	out	dx , ax
+        out     dx , ax
 ; enable writing
-	set_io	REG_9346CR
+        set_io  REG_9346CR
-	mov	eax, REG_9346CR_WE
+        mov     eax, REG_9346CR_WE
-	out	dx , al
+        out     dx , al
  ; write the mac ...
-	set_io	REG_IDR0
+        set_io  REG_IDR0
-	pop	eax
+        pop     eax
-	out	dx , eax
+        out     dx , eax
-	set_io	REG_IDR0+4
+        set_io  REG_IDR0+4
-	xor	eax, eax
+        xor     eax, eax
-	pop	ax
+        pop     ax
 ;; Read MAC address ;;
 ;;                  ;;
 ;;;;;;;;;;;;;;;;;;;;;;
 read_mac:
-	DEBUGF	2,"Reading MAC: "
+        DEBUGF  2,"Reading MAC: "
-	set_io	0
+        set_io  0
-	lea	edi, [device.mac]
+        lea     edi, [device.mac]
-	in	eax, dx
+        in      eax, dx
-	stosd
+        stosd
-	add	edx, 4
+        add     edx, 4
-	in	ax, dx
+        in      ax, dx
-	stosw
+        stosw
-	DEBUGF	2,"%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2
+        DEBUGF  2,"%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2
-	ret
+        ret
 ; End of code
 section '.data' data readable writable align 16 ; place all uninitialized data place here
-align 4 					; Place all initialised data here
+align 4                                         ; Place all initialised data here
-devices 	dd 0
+devices         dd 0
-version 	dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
+version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
-my_service	db 'RTL8139',0			  ; max 16 chars include zero
+my_service      db 'RTL8139',0                    ; max 16 chars include zero
-device_1	db 'Realtek 8139',0
+device_1        db 'Realtek 8139',0
-device_2	db 'Realtek 8139A',0
+device_2        db 'Realtek 8139A',0
-device_3	db 'Realtek 8139B',0
+device_3        db 'Realtek 8139B',0
-device_4	db 'Realtek 8139C',0
+device_4        db 'Realtek 8139C',0
-device_5	db 'Realtek 8100',0
+device_5        db 'Realtek 8100',0
-device_6	db 'Realtek 8139D',0
+device_6        db 'Realtek 8139D',0
-device_7	db 'Realtek 8139CP',0
+device_7        db 'Realtek 8139CP',0
-device_8	db 'Realtek 8101',0
+device_8        db 'Realtek 8101',0
-device_unknown	db 'Unknown RTL8139 clone', 0
+device_unknown  db 'Unknown RTL8139 clone', 0
 crosslist:
-	dd device_1
+        dd device_1
-	dd device_2
+        dd device_2
-	dd device_3
+        dd device_3
-	dd device_4
+        dd device_4
-	dd device_5
+        dd device_5
-	dd device_6
+        dd device_6
-	dd device_7
+        dd device_7
-	dd device_8
+        dd device_8
-	dd device_unknown
+        dd device_unknown
-hw_ver_array:			 ; This array is used by the probe routine to find out wich version of the RTL8139 we are working with
+hw_ver_array:                    ; This array is used by the probe routine to find out wich version of the RTL8139 we are working with
-	db VER_RTL8139
+        db VER_RTL8139
-	db VER_RTL8139A
+        db VER_RTL8139A
-	db VER_RTL8139B
+        db VER_RTL8139B

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/drivers/RTL8139.asm – Rev 1556 → 2387