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

 	API_VERSION		equ 0x01000100
 	DEBUG			equ 1
 	__DEBUG__		equ 1
-	__DEBUG_LEVEL__ 	equ 1
+	__DEBUG_LEVEL__ 	equ 2
+include 'proc32.inc'
-include 'proc32.inc'
+include 'imports.inc'
-include 'imports.inc'
+include 'fdo.inc'
-include 'fdo.inc'
+include 'netdrv.inc'
 OS_BASE 	equ 0;
 new_app_base	equ 0x60400000
-PROC_BASE	equ OS_BASE+0x0080000
-public START
-public service_proc
-public version
-struc IOCTL {
-      .handle		dd ?
-      .io_code		dd ?
-      .input		dd ?
-      .inp_size 	dd ?
-      .output		dd ?
-      .out_size 	dd ?
+PROC_BASE	equ OS_BASE+0x0080000
 public START
-virtual at 0
+public service_proc
       .curr_tx_desc	db ?
       .pci_bus		db ?
       .pci_dev		db ?
       .irq_line 	db ?
       .hw_ver_id	db ?
-      .size:
+      .size = $ - device
 }
-virtual at 0
+virtual at ebx
-  device ETH_DEVICE
-end virtual
-; PCI Bus defines
-	PCI_HEADER_TYPE 		equ	0x0e  ;8 bit
-	PCI_BASE_ADDRESS_0		equ	0x10  ;32 bit
-	PCI_BASE_ADDRESS_5		equ	0x24  ;32 bits
-	PCI_BASE_ADDRESS_SPACE_IO	equ	0x01
-	PCI_VENDOR_ID			equ	0x00  ;16 bit
+  device ETH_DEVICE
-	PCI_BASE_ADDRESS_IO_MASK	equ	0xFFFFFFFC
+end virtual
 	RX_CONFIG		equ (RBLEN shl BIT_RBLEN) or \
 				    (RX_MXDMA shl BIT_RX_MXDMA) or \
 				    (1 shl BIT_NOWRAP) or \
 				    (RXFTH shl BIT_RXFTH) or\
-				    (1 shl BIT_AB) or \
+				    (1 shl BIT_AB) or \ 		; Accept broadcast packets
-				    (1 shl BIT_APM) or \
+				    (1 shl BIT_APM) or \		; Accept physical match packets
-				    (1 shl BIT_AER) or \
+				    (1 shl BIT_AER) or \		; Accept error packets
-				    (1 shl BIT_AR) or \
+				    (1 shl BIT_AR) or \ 		; Accept Runt packets (smaller then 64 bytes)
-				    (1 shl BIT_AM)
+				    (1 shl BIT_AM)			; Accept multicast packets
-	RX_BUFFER_SIZE		equ (8192 shl RBLEN)
+	RX_BUFFER_SIZE		equ (8192 shl RBLEN);+16
 	MAX_ETH_FRAME_SIZE	equ 1516 ; exactly 1514 wthout CRC
 	NUM_TX_DESC		equ 4
 	cmp [state], 1
 	jne .exit
   .entry:
-	DEBUGF 1,"Loading rtl8139 driver\n"
+	DEBUGF	2,"Loading rtl8139 driver\n"
 	stdcall RegService, my_service, service_proc
 	ret
 align 4
 proc service_proc stdcall, ioctl:dword
+	mov	edx, [ioctl]
 	mov	eax, [IOCTL.io_code]
+=======
-	mov	edx, [ioctl]
+	mov	eax, [edx+IOCTL.io_code]
-	mov	eax, [edx+IOCTL.io_code]
+>>>>>>> .r1471
 ;------------------------------------------------------
 	cmp	eax, 0 ;SRV_GETVERSION
 	jne	@F
-	cmp	[edx+IOCTL.out_size], 4
+	cmp	[IOCTL.out_size], 4
 	jl	.fail
-	mov	eax, [edx+IOCTL.output]
+	mov	eax, [IOCTL.output]
 	mov	[eax], dword API_VERSION
 	xor	eax, eax
 	ret
 ;------------------------------------------------------
   @@:
 	cmp	eax, 1 ;SRV_HOOK
 	jne	.fail
-	cmp	[edx + 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
+	mov	eax, [IOCTL.input]
-	mov	eax, [edx + 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
 ; check if the device is already listed
+	mov	esi, RTL8139_LIST
-	mov	esi, RTL8139_LIST
+	mov	ecx, [RTL8139_DEV]
+	test	ecx, ecx
-	mov	ecx, [RTL8139_DEV]
+	jz	.firstdevice
 	test	ecx, ecx
-	jz	.firstdevice
+;        mov     eax, [IOCTL.input]                      ; get the pci bus and device numbers
-;        mov     eax, [edx+IOCTL.input]                  ; get the pci bus and device numbers
+	mov	ax , [eax+1]				;
 	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	dword [ebx+device.reset], reset
+	mov	dword [device.reset], reset
-	mov	dword [ebx+device.transmit], transmit
+	mov	dword [device.transmit], transmit
-	mov	dword [ebx+device.get_MAC], read_mac
+	mov	dword [device.get_MAC], read_mac
-	mov	dword [ebx+device.set_MAC], write_mac
+	mov	dword [device.set_MAC], write_mac
-	mov	dword [ebx+device.unload], unload
+	mov	dword [device.unload], unload
-	mov	dword [ebx+device.name], my_service
+	mov	dword [device.name], my_service
 ; save the pci bus and device numbers
-	mov	eax, [edx+IOCTL.input]
+	mov	eax, [IOCTL.input]
 	mov	cl , [eax+1]
-	mov	[ebx+device.pci_bus], cl
+	mov	[device.pci_bus], cl
-	mov	cl , [eax+2]
-	mov	[ebx+device.pci_dev], cl
-; Now, it's time to find the base io addres of the PCI device
-; TODO: implement check if bus and dev exist on this machine
-	mov	edx, PCI_BASE_ADDRESS_0
-  .reg_check:
-	movzx	eax, byte [ebx+device.pci_bus]
-	movzx	ecx, byte [ebx+device.pci_dev]
-	push	edx ecx
-	stdcall PciRead16, eax ,ecx ,edx
-	pop	ecx edx
+	mov	cl , [eax+2]
-	mov	[ebx+device.io_addr], eax
-	and	eax, PCI_BASE_ADDRESS_IO_MASK
-	test	eax, eax
-	jz	.inc_reg
-	mov	eax, [ebx+device.io_addr]
-	and	eax, PCI_BASE_ADDRESS_SPACE_IO
-	test	eax, eax
-	jz	.inc_reg
-	mov	eax, [ebx+device.io_addr]
-	and	eax, PCI_BASE_ADDRESS_IO_MASK
-	mov	[ebx+device.io_addr], eax
-	jmp	.got_io
-  .inc_reg:
+	mov	[device.pci_dev], cl
-	add	edx, 4
-	cmp	edx, PCI_BASE_ADDRESS_5
+; Now, it's time to find the base io addres of the PCI device
-	jbe	.reg_check
+; TODO: implement check if bus and dev exist on this machine
-  .got_io:
+	find_io [device.pci_bus], [device.pci_dev], [device.io_addr]
-; We've found the io address, find IRQ now
-	movzx	eax, byte [ebx+device.pci_bus]
-	movzx	ecx, byte [ebx+device.pci_dev]
+; We've found the io address, find IRQ now
-	push	ebx
-	stdcall PciRead8, eax ,ecx ,0x3c				; 0x3c is the offset where irq can be found
-	pop	ebx
-	mov	byte [ebx+device.irq_line], al
-	DEBUGF	1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
-	[ebx+device.pci_dev]:1,[ebx+device.pci_bus]:1,[ebx+device.irq_line]:1,[ebx+device.io_addr]:4
-; Allocate the Receive buffer
-	stdcall KernelAlloc, dword (RX_BUFFER_SIZE+MAX_ETH_FRAME_SIZE)
-	test	eax, eax
-	jz	.err
-	mov	[ebx+device.rx_buffer], eax				; Save the address to it into the device struct
+	movzx	eax, byte [device.pci_bus]
-; Now, Clear the allocated buffer
-	cld
-	mov	edi, eax
-	mov	ecx, (RX_BUFFER_SIZE)/4 				; divide by 4 because we are going to use DWORD
-	xor	eax, eax
-	rep	stosd
+	movzx	ecx, byte [device.pci_dev]
-; Allocate the Transmit Buffer
-	stdcall KernelAlloc, dword (TX_BUF_SIZE*NUM_TX_DESC)
+	push	ebx
-	test	eax, eax
+	stdcall PciRead8, eax ,ecx ,0x3c				; 0x3c is the offset where irq can be found
-	jz	.err
+	pop	ebx
 	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"
+	DEBUGF	2,"Trying to find device number of already registered device\n"
 	mov	ebx, eax
 	call	EthStruc2Dev						; This kernel procedure converts a pointer to device struct in ebx
 									; into a device number in edi
 	mov	eax, edi						; Application wants it in eax instead
-	DEBUGF	1,"Kernel says: %u\n", eax
+	DEBUGF	2,"Kernel says: %u\n", eax
 	ret
 ; If an error occured, remove all allocated data and exit (returning -1 in eax)
   .destroy:
 	; todo: reset device into virgin state
   .err:
 align 4
 probe:
-	DEBUGF	2,"Probing rtl8139 device: "
-; enable the device
+	DEBUGF	2,"Probing rtl8139 device: "
-	movzx	eax, byte [ebx+device.pci_bus]
-	movzx	ecx, byte [ebx+device.pci_dev]
-	stdcall PciRead32, eax ,ecx ,PCI_REG_CMD
-	mov	cx , ax
-	or	cl , (1 shl PCI_BIT_MASTER) or (1 shl PCI_BIT_PIO)
-	and	cl , not (1 shl PCI_BIT_MMIO)
-	movzx	eax, byte [ebx+device.pci_bus]
 	movzx	edx, byte [ebx+device.pci_dev]
-	stdcall PciWrite32, eax ,edx ,PCI_REG_CMD, ecx
+	make_bus_master [device.pci_bus], [device.pci_dev]
 ; get chip version
-	mov	edx, [ebx+device.io_addr]
+	set_io	0
-	add	edx, REG_TXCONFIG + 2
+	set_io	REG_TXCONFIG + 2
 	in	ax , dx
 	je	.chip_ver_found
 	dec	ecx
 	jns	.chip_ver_loop
 	xor	cl , cl ; default RTL8139
   .chip_ver_found:
-	mov	[ebx+device.hw_ver_id], cl
+	mov	[device.hw_ver_id], cl
 	shl	ecx, 2
-	add	ecx, name_crosslist
+	add	ecx, crosslist
 	mov	ecx, [ecx]
-	mov	dword [ebx+device.name], ecx
+	mov	[device.name], ecx
-	DEBUGF	1,"Chip version: %s\n",ecx
+	DEBUGF	2,"Chip version: %s\n",ecx
 ; wake up the chip
-	mov	edx, [ebx+device.io_addr]
+	set_io	0
-	add	edx, REG_HLTCLK
+	set_io	REG_HLTCLK
 	mov	al , 'R' ; run the clock
 	out	dx , al
 ; unlock config and BMCR registers
-	add	edx, REG_9346CR - REG_HLTCLK
+	set_io	REG_9346CR
 	mov	al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
 	out	dx , al
 ; enable power management
-	add	edx, REG_CONFIG1 - REG_9346CR
+	set_io	REG_CONFIG1
 	in	al , dx
-	cmp	byte [ebx+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).
-; set LWAKE pin to active high (default value).
+; it is for Wake-On-LAN functionality of some motherboards.
-; 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.
 ; this signal is used to inform the motherboard to execute a wake-up process.
-; only at newer chips.
+	or	al , (1 shl BIT_PMEn)
 	and	al , not (1 shl BIT_LWACT)
   .finish_wake_up:
 ; lock config and BMCR registers
 	xor	al , al
-	mov	edx, [ebx+device.io_addr]
+	set_io	0
-	add	edx, REG_9346CR
+	set_io	REG_9346CR
 	out	dx , al
 reset:
 	DEBUGF	2,"Resetting rtl8139: "
 ; attach int handler
-	movzx	eax, [ebx+device.irq_line]
+	movzx	eax, [device.irq_line]
 	DEBUGF	1,"Attaching int handler to irq %x, ",eax:1
 	stdcall AttachIntHandler, eax, int_handler, dword 0
 	test	eax, eax
   @@:
 ; reset chip
 	DEBUGF	1,"Resetting chip\n"
-	mov	edx, [ebx+device.io_addr]
+	set_io	0
-	add	edx, REG_COMMAND
+	set_io	REG_COMMAND
 	mov	al , 1 shl BIT_RST
 	out	dx , al
 	mov	cx , 1000		; wait no longer for the reset
 	jns	.wait_for_reset
   .reset_completed:
-; unlock config and BMCR registers
+; unlock config and BMCR registers
 	mov	edx, [ebx+device.io_addr]
-	add	edx, REG_9346CR
+	set_io	REG_9346CR
 	mov	al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
 	out	dx , al
 ; initialize multicast registers (no filtering)
 	mov	eax, 0xffffffff
-	add	edx, REG_MAR0 - REG_9346CR
+	set_io	REG_MAR0
 	out	dx , eax
-	add	edx, REG_MAR4 - REG_MAR0
+	set_io	REG_MAR4
 	out	dx , eax
 ; enable Rx/Tx
 	mov	al , (1 shl BIT_RE) or (1 shl BIT_TE)
-	add	edx, REG_COMMAND - REG_MAR4
+	set_io	REG_COMMAND
+	out	dx , al
 	out	dx , al
 ; 32k Rxbuffer, unlimited dma burst, no wrapping, no rx threshold
-; 32k Rxbuffer, unlimited dma burst, no wrapping, no rx threshold
+; accept broadcast packets, accept physical match packets
 ; accept broadcast packets, accept physical match packets
 	mov	ax , RX_CONFIG
-	mov	ax , RX_CONFIG
+	set_io	REG_RXCONFIG
-	add	edx, REG_RXCONFIG - REG_COMMAND
+	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
-	add	edx, REG_TXCONFIG - REG_RXCONFIG
+	set_io	REG_TXCONFIG
 	out	dx , eax
 ; enable auto negotiation
-	add	edx, REG_BMCR - REG_TXCONFIG
+	set_io	REG_BMCR
 	in	ax , dx
 	or	ax , (1 shl BIT_ANE)
 	out	dx , ax
 ; set auto negotiation advertisement
-	add	edx, REG_ANAR - REG_BMCR
+	set_io	REG_ANAR
 	in	ax , dx
 	or	ax , (1 shl BIT_SELECTOR) or (1 shl BIT_10) or (1 shl BIT_10FD) or (1 shl BIT_TX) or (1 shl BIT_TXFD)
 	out	dx , ax
 ; lock config and BMCR registers
 	xor	eax, eax
-	add	edx, REG_9346CR - REG_ANAR
+	set_io	REG_9346CR
 	out	dx , al
 ; init RX/TX pointers
-	mov	[ebx+device.rx_data_offset], eax
+	mov	[device.rx_data_offset], eax
-	mov	[ebx+device.curr_tx_desc], al
+	mov	[device.curr_tx_desc], al
 ; clear packet/byte counters
-	lea	edi, [ebx+device.bytes_tx] ; TODO: check if destroying edi, ecx doesnt harm anything
+	lea	edi, [device.bytes_tx]
 	mov	ecx, 6
 	rep	stosd
 ; clear missing packet counter
-	add	edx, REG_MPC - REG_9346CR
+	set_io	REG_MPC
 	out	dx , eax
 ; Set up the 4 Txbuffer descriptors
 	jg	.finish 			; packet is too long
 	cmp	dword [esp+8], 60
 	jl	.finish 			; packet is too short
 ; check descriptor
-;        DEBUGF  1,"Checking descriptor, "
+	DEBUGF	1,"Checking descriptor, "
-	movzx	ecx, [ebx+device.curr_tx_desc]
+	movzx	ecx, [device.curr_tx_desc]
-	mov	edx, [ebx+device.io_addr]
+	mov	edx, [device.io_addr]
 	lea	edx, [edx+ecx*4+REG_TSD0]
 	in	ax, dx
 	test	ax, 0x1fff ; or no size given
 	jz	.send_packet
 	and	ax, (1 shl BIT_TOK) or (1 shl BIT_OWN)
 	cmp	ax, (1 shl BIT_TOK) or (1 shl BIT_OWN)
 	jz	.send_packet
 ; wait for timeout
-;        DEBUGF  1,"Waiting for timeout, "
+	DEBUGF	1,"Waiting for timeout, "
 	push	edx ebx 			 ; TODO : rtl8139 internal timer should be used instead
 	jz	.send_packet			 ; if chip hung, reset it
 	push	dx
 	call	reset				 ; reset the card
 	pop	dx
 .send_packet:
-;        DEBUGF  1,"Sending packet, "
+	DEBUGF	1,"Sending packet, "
 	push	edx
-	movzx	eax, [ebx+device.curr_tx_desc]	 ; calculate the current tx_buffer address
+	movzx	eax, [device.curr_tx_desc]   ; calculate the current tx_buffer address
 	mov	edx, TX_BUF_SIZE ;MAX_ETH_FRAME_SIZE          ;
 	mul	edx				 ;
-	mov	edi, [ebx+device.tx_buffer]	 ;
+	mov	edi, [device.tx_buffer]      ;
 	add	edi, eax			 ; Store it in edi
 	pop	edx
 	rep	movsd				 ;
 	mov	ecx, [esp+8]			 ;
 	and	ecx, 3				 ;
 	rep	movsb				 ;
-	inc	[ebx+device.packets_tx] 	 ;
+	inc	[device.packets_tx]	     ;
 	mov	eax, [esp+8]			 ; Get packet size in eax
-	add	dword [ebx + device.bytes_tx], eax
+	add	dword [device.bytes_tx], eax
-	adc	dword [ebx + device.bytes_tx + 4], 0
+	adc	dword [device.bytes_tx + 4], 0
 ;        or      eax, (ERTXTH shl BIT_ERTXTH)     ; Set descriptor size and the early tx treshold into the correct Transmission status register (TSD0, TSD1, TSD2 or TSD3)
 	out	dx , eax			 ;
 ; get next descriptor 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, ...
-	inc	[ebx+device.curr_tx_desc]
+	inc	[device.curr_tx_desc]
-	and	[ebx+device.curr_tx_desc], 3
+	and	[device.curr_tx_desc], 3
 	mov	esi, RTL8139_LIST
 	mov	ecx, [RTL8139_DEV]
 .nextdevice:
 	mov	ebx, dword [esi]
-	mov	edx, dword [ebx+device.io_addr]     ; get IRQ reason
+	set_io	0
-	add	edx, REG_ISR
+	set_io	REG_ISR
 	in	ax , dx
 	out	dx , ax 			    ; send it back to ACK
 	test	ax, ISR_ROK
 	jz	@f
 	push	ax
   .receive:
-	mov	edx, dword [ebx+device.io_addr]     ; get IRQ reason
+	set_io	0
-	add	edx, REG_COMMAND		    ;
+	set_io	REG_COMMAND
-	in	al , dx 			    ;
+	in	al , dx
 	test	al , BUFE			    ; test if RX buffer is empty
 	jnz	.finish 			    ;
-	DEBUGF	2,"RX: "
+	DEBUGF	1,"RX: "
-	mov	eax, dword [ebx+device.rx_buffer]
+	mov	eax, [device.rx_buffer]
+	add	eax, [device.rx_data_offset]
-	add	eax, dword [ebx+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
+; packet is ok, copy it
-	jz	.reset_rx
+	movzx	ecx, word [eax+2]		    ; packet length
-						    ; packet is ok, copy it
-	movzx	ecx, word [eax+2]		    ; packet length
+; Update stats
+	add	dword [device.bytes_rx], ecx
-	add	dword [ebx + device.bytes_rx], ecx  ; Update stats
+	adc	dword [device.bytes_rx + 4], 0
+	inc	dword [device.packets_rx]
 	adc	dword [ebx + device.bytes_rx + 4], 0
-	inc	dword [ebx + device.packets_rx]     ;
+	sub	ecx, 4				    ; don't copy CRC
 	sub	ecx, 4				    ; don't copy CRC
 	DEBUGF	1,"Received %u bytes\n", 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
+	test	eax, eax			    ; Test if we allocated succesfully
-	pop	ecx
+	jz	.abort
 	test	eax, eax			    ; Test if we allocated succesfully
 	jz	.abort				    ;
 	mov	edi, eax			    ; Where we will copy too
-	mov	edi, eax			    ; Set up registers to copy the packet
+	mov	esi, [esp]			    ; The buffer we will copy from
-	mov	esi, [esp]			    ;
+	add	esi, 4				    ; Dont copy CRC
-	add	esi, 4				    ; Dont copy CRC
+	push	dword .abort			    ; Kernel will return to this address after EthReceiver
+	push	ecx edi 			    ; Save buffer pointer and size, to pass to kernel
-	push	dword .abort			    ; Kernel will return to this address after EthReceiver
+  .copy:
+	shr	ecx, 1
+	jnc	.nb
-	push	ecx edi 			    ; Save buffer pointer and size, to pass to kernel
+	movsb
+  .nb:
 	shr	ecx, 1
+	jnc	.nw
-	shr	ecx, 2
+	movsw
-	cld
+  .nw:
-	rep	movsd				    ; copy the dwords
+	jz	.nd
-	mov	ecx, [esp+4]
+	rep	movsd
-	and	ecx, 3
+  .nd:
 	rep	movsb				    ; copy the rest bytes
 	jmp	EthReceiver			    ; Send it to kernel
 	jmp	EthReceiver			    ; Send it to kernel
   .abort:
+	pop	eax ebx
-  .abort:
+						    ; update eth_data_start_offset
-	pop	eax ebx
+	movzx	eax, word [eax+2]		    ; packet length
-						    ; update eth_data_start_offset
+	add	eax, [device.rx_data_offset]
-	movzx	eax, word [eax+2]		    ; packet length
+	add	eax, 4+3			    ; packet header is 4 bytes long + dword alignment
-	add	eax, [ebx+device.rx_data_offset]
+	and	eax, not 3			    ; dword alignment
-	add	eax, 4+3			    ; packet header is 4 bytes long + 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"
   @@:
 	test	ax, ISR_TER
 	jz	@f
 	push	ax
-	cmp	[ebx+device.curr_tx_desc], 4
+	cmp	[device.curr_tx_desc], 4
 	jz	.notxd
-	mov	edx, [ebx+device.io_addr]
+	set_io	0
-	movzx	ecx, [ebx+device.curr_tx_desc]
+	movzx	ecx, [device.curr_tx_desc]
 	lea	edx, [edx+ecx*4+REG_TSD0]
 	in	eax, dx
   .notxd:
 	test	eax, TSR_TUN
 	jz	.nobun
-	DEBUGF	1, "TX: FIFO Buffer underrun!\n"
+	DEBUGF	2, "TX: FIFO Buffer underrun!\n"
   .nobun:
 	test	eax, TSR_OWC
 	jz	.noowc
-	DEBUGF	1, "TX: OWC!\n"
+	DEBUGF	2, "TX: OWC!\n"
   .noowc:
 	test	eax, TSR_TABT
 	jz	.notabt
-	DEBUGF	1, "TX: TABT!\n"
+	DEBUGF	2, "TX: TABT!\n"
   .notabt:
 	test	eax, TSR_CRS
   @@:
 	test	ax, ISR_TOK
 	jz	@f
-	DEBUGF	1, "TX: Transmit OK (desc: %u)\n", [ebx+device.curr_tx_desc]:1
+	DEBUGF	1, "TX: Transmit OK (desc: %u)\n", [device.curr_tx_desc]:1
 ;----------------------------------------------------
 ; Rx buffer overflow ?
   @@:
 	test	ax, ISR_RXOVW
 	jz	@f
 	push	ax
-	DEBUGF	1,"RX-buffer overflow!\n"
+	DEBUGF	2,"RX-buffer overflow!\n"
   @@:
 	test	ax, ISR_PUN
 	jz	@f
-	DEBUGF	1,"Packet underrun!\n"
+	DEBUGF	2,"Packet underrun!\n"
 	jz	@f
 	push	ax
 	DEBUGF	2,"RX fifo overflox!\n"
-	mov	edx, [ebx+device.io_addr]
+	mov	edx, [device.io_addr]
 	add	edx, REG_ISR
 	mov	ax , ISR_FIFOOVW or ISR_RXOVW
 ; If none of the above events happened, just exit clearing int
   .fail:
 align 4
 cable:
 	DEBUGF	1,"Checking Cable status: "
-	mov	edx, dword [ebx+device.io_addr]
+	mov	edx, dword [device.io_addr]
 	add	edx, REG_MSR
 	in	al , dx
 ;        jnz     .10mbps
 	shr	al, 2
 	and	al, 3
-	mov	byte [ebx+device.mode+3], al
+	mov	byte [device.mode+3], al
 ;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 write_mac:	; in: mac pushed onto stack (as 3 words)
-	DEBUGF	1,"Writing MAC: "
+	DEBUGF	2,"Writing MAC: "
 ; disable all in command registers
-	mov	edx, [ebx+device.io_addr]
+	set_io	0
-	add	edx, REG_9346CR
+	set_io	REG_9346CR
 	xor	eax, eax
 	out	dx , al
-	add	edx, REG_IMR - REG_9346CR
+	set_io	REG_IMR
 	xor	eax, eax
-	out	dx , ax
+	out	dx , ax
 	add	edx, REG_ISR - REG_IMR
-	mov	eax, -1
+	set_io	REG_ISR
-	out	dx , ax
+	mov	eax, -1
+	out	dx , ax
 ; enable writing
 ; enable writing
-	add	edx, REG_9346CR - REG_ISR
+	set_io	REG_9346CR
 	mov	eax, REG_9346CR_WE
 	out	dx , al
  ; write the mac ...
-	add	edx, REG_IDR0 - REG_9346CR
+	set_io	REG_IDR0
 	pop	eax
 	out	dx , eax
 ;; Read MAC address ;;
 ;;                  ;;
 ;;;;;;;;;;;;;;;;;;;;;;
 read_mac:
-	DEBUGF	1,"Reading MAC: "
+	DEBUGF	2,"Reading MAC: "
-	mov	edx, [ebx + device.io_addr]
+	set_io	0
-	lea	edi, [ebx + device.mac]
+	lea	edi, [device.mac]
 	in	eax, dx
 	stosd
 	add	edx, 4
 	in	ax, dx
 	stosw
 align 4
 read_eeprom:
 	DEBUGF	2,"Reading eeprom, "
-	mov	edx, [ebx+device.io_addr]
+	set_io	0
 	push	ebx
 	movzx	ebx, al
-	add	edx, REG_RXCONFIG
+	set_io	REG_RXCONFIG
 	in	al, dx
 	test	al, (1 shl BIT_9356SEL)
 	jz	.type_93c46
 .type_93c46:
 	and	bl, 00111111b
 	or	bx, EE_93C46_READ_CMD		; it contains start bit
 	mov	cx, EE_93C46_CMD_LENGTH-1	; cmd_loop counter
 .read_eeprom:
-	add	edx, REG_9346CR - REG_RXCONFIG
+	set_io	REG_9346CR
 ;       mov     al, (1 shl BIT_93C46_EEM1)
 ;       out     dx, al
 	mov	al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EECS) ; wake up the eeprom
 	out	dx, al
 .cmd_loop:
 device_5      db 'Realtek 8100',0
 device_6      db 'Realtek 8139D',0
 device_7      db 'Realtek 8139CP',0
 device_8      db 'Realtek 8101',0
-name_crosslist dd device_1
+crosslist     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

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/drivers/RTL8139.asm – Rev 1377 → 1472