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

 ;;  See file COPYING for details                                   ;;
 ;;                                                                 ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+format PE DLL native
+entry START
-format MS COFF
+	CURRENT_API		= 0x0200
-        API_VERSION             = 0x01000100
+	COMPATIBLE_API		= 0x0100
-        DRIVER_VERSION          = 5
 	API_VERSION		= (COMPATIBLE_API shl 16) + CURRENT_API
-        MAX_DEVICES             = 16
 	MAX_DEVICES		= 16
         DEBUG                   = 1
-        __DEBUG__               = 1
+	__DEBUG__		= 1
-        __DEBUG_LEVEL__         = 2
+	__DEBUG_LEVEL__ 	= 1	; 1 = all, 2 = errors only
-        TX_RING_SIZE            = 4
+	TX_RING_SIZE		= 4
-        RX_RING_SIZE            = 4
 	RX_RING_SIZE		= 4
         ; max time out delay time
-        W_MAX_TIMEOUT           = 0x0FFF
+	; max time out delay time
 	W_MAX_TIMEOUT		= 0x0FFF
-        ; Size of the in-memory receive ring.
-        RX_BUF_LEN_IDX          = 3     ; 0==8K, 1==16K, 2==32K, 3==64K
+	; Size of the in-memory receive ring.
-        RX_BUF_LEN              = (8192 shl RX_BUF_LEN_IDX)
+	RX_BUF_LEN_IDX		= 3	; 0==8K, 1==16K, 2==32K, 3==64K
+	; PCI Tuning Parameters
+	; Threshold is bytes transferred to chip before transmission starts.
 	TX_FIFO_THRESH		= 256	; In bytes, rounded down to 32 byte units.
         ; PCI Tuning Parameters
-        ;   Threshold is bytes transferred to chip before transmission starts.
-        TX_FIFO_THRESH          = 256   ; In bytes, rounded down to 32 byte units.
 	; The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024.
-        ; The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024.
+	RX_FIFO_THRESH		= 4	; Rx buffer level before first PCI transfer.
-        RX_FIFO_THRESH          = 4     ; Rx buffer level before first PCI xfer.
-        RX_DMA_BURST            = 4     ; Maximum PCI burst, '4' is 256 bytes
-        TX_DMA_BURST            = 4
 	RX_DMA_BURST		= 4	; Maximum PCI burst, '4' is 256 bytes
-include '../struct.inc'
+	TX_DMA_BURST		= 4
 include '../macros.inc'
-MIICR_MOUT              = 0x08
+MIICR_MOUT		= 0x08
-MIICR_MDO               = 0x04
+MIICR_MDO		= 0x04
-MIICR_MDI               = 0x02
+MIICR_MDI		= 0x02
-MIICR_MDC               = 0x01
+MIICR_MDC		= 0x01
 ; Bits in the EECSR register
-EECSR_EEPR              = 0x80    ; eeprom programed status, 73h means programed
+EECSR_EEPR		= 0x80	  ; eeprom programmed status, 73h means programmed
-EECSR_EMBP              = 0x40    ; eeprom embeded programming
+EECSR_EMBP		= 0x40	  ; eeprom embedded programming
-EECSR_AUTOLD            = 0x20    ; eeprom content reload
+EECSR_AUTOLD		= 0x20	  ; eeprom content reload
-EECSR_DPM               = 0x10    ; eeprom direct programming
+EECSR_DPM		= 0x10	  ; eeprom direct programming
-EECSR_CS                = 0x08    ; eeprom CS pin
+EECSR_CS		= 0x08	  ; eeprom CS pin
-EECSR_SK                = 0x04    ; eeprom SK pin
+EECSR_SK		= 0x04	  ; eeprom SK pin
-EECSR_DI                = 0x02    ; eeprom DI pin
+EECSR_DI		= 0x02	  ; eeprom DI pin
-BCR1_CTFT0              = 0x08
+BCR1_CTFT0		= 0x08
-BCR1_POT2               = 0x04
+BCR1_POT2		= 0x04
-BCR1_POT1               = 0x02
+BCR1_POT1		= 0x02
-BCR1_POT0               = 0x01
+BCR1_POT0		= 0x01
 ; Bits in the CFGA register
-CFGA_EELOAD             = 0x80    ; enable eeprom embeded and direct programming
+CFGA_EELOAD		= 0x80	  ; enable eeprom embedded and direct programming
-CFGA_JUMPER             = 0x40
+CFGA_JUMPER		= 0x40
-CFGA_MTGPIO             = 0x08
+CFGA_MTGPIO		= 0x08
-CFGA_T10EN              = 0x02
+CFGA_T10EN		= 0x02
-CFGA_AUTO               = 0x01
+CFGA_AUTO		= 0x01
 ; Bits in the CFGB register
-        IntrAbnormalSummary     = 0xC260
+	IntrAbnormalSummary	= 0xC260
-        IntrTxDescRace          = 0x080000        ; mapped from IntrStatus2
+	IntrTxDescRace		= 0x080000	  ; mapped from IntrStatus2
-        IntrTxErrSummary        = 0x082218
+	IntrTxErrSummary	= 0x082218
+	DEFAULT_INTR		= (IntrRxDone or IntrRxErr or IntrRxEmpty or IntrRxOverflow or IntrRxDropped or IntrRxNoBuf)
+	RX_BUF_LEN		= (8192 shl RX_BUF_LEN_IDX)
+struct	rx_head
+	status		dd ?
+	control 	dd ?
-DEFAULT_INTR  = (IntrRxDone or IntrRxErr or IntrRxEmpty or IntrRxOverflow or IntrRxDropped or IntrRxNoBuf)
+	buff_addr	dd ?	; address
-virtual at ebx
+	next_desc	dd ?	;
-        device:
-        ETH_DEVICE
-        .io_addr                dd ?
-        .pci_dev                dd ?
-        .pci_bus                dd ?
-        .revision               db ?
-        .irq_line               db ?
-        .chip_id                dw ?
-        .cur_rx                 dw ?
-        .cur_tx                 dw ?
-        .last_tx                dw ?
-                                rb 0x100-(($ - device) and 0xff)        ;        align 256
-        .tx_ring                rb tx_head.sizeof*TX_RING_SIZE
-                                rb 0x100-(($ - device) and 0xff)        ;        align 256
-        .rx_ring                rb rx_head.sizeof*RX_RING_SIZE
-        .size                   = $ - device
+	buff_addr_virt	dd ?
-end virtual
+			rd 3	; alignment
+ends
-virtual at 0
-        rx_head:
+struct	tx_head
-        .status         dd ?
+	status		dd ?
-        .control        dd ?
+	control 	dd ?
-        .buff_addr      dd ?    ; address
-        .next_desc      dd ?    ;
+	buff_addr	dd ?	; address
+	next_desc	dd ?	;
-        .buff_addr_virt dd ?
+	buff_addr_virt	dd ?
-                        rd 3    ; alignment
+			rd 3	; alignment
-        .sizeof:
+ends
-end virtual
+struct	device		ETH_DEVICE
+	io_addr 	dd ?
+	pci_dev 	dd ?
+	pci_bus 	dd ?
-virtual at 0
+	revision	db ?
-        tx_head:
+	irq_line	db ?
-        .status         dd ?
+	chip_id 	dw ?
+	cur_rx		dw ?
-        .control        dd ?
-        .buff_addr      dd ?    ; address
+	cur_tx		dw ?
-        .next_desc      dd ?    ;
+	last_tx 	dw ?
-        .buff_addr_virt dd ?
+	rb 0x100 - ($ and 0xff) ; align 256
-                        rd 3    ; alignment
+	tx_ring 	rb sizeof.tx_head*TX_RING_SIZE
         .sizeof:
-end virtual
+	rb 0x100 - ($ and 0xff) ; align 256
+	rx_ring 	rb sizeof.rx_head*RX_RING_SIZE
-section '.flat' code readable align 16
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ends
-;;                        ;;
 ;; proc START             ;;
-;;                        ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; (standard driver proc) ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                        ;;
 ;; proc START             ;;
-align 4
+;;                        ;;
 ;; proc SERVICE_PROC      ;;
 ;;                        ;;
 ;; (standard driver proc) ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 proc service_proc stdcall, ioctl:dword
-        cmp     [edx + IOCTL.inp_size], 3               ; Data input must be at least 3 bytes
+	cmp	[edx + IOCTL.inp_size], 3		; Data input must be at least 3 bytes
-        jb      .fail
+	jb	.fail
-        mov     eax, [edx + 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 aren't supported for this card yet
 ; check if the device is already listed
 ;        mov     eax, [edx + 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     al, byte[device.pci_bus]
+	cmp	al, byte[ebx + device.pci_bus]
-        jne     @f
+	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
+	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
+; This device doesn't 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
-        jae     .fail
+	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
 ; 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
-; save the pci bus and device numbers
 	mov	eax, [edx + IOCTL.input]
+	movzx	ecx, byte[eax+1]
-        mov     eax, [edx + IOCTL.input]
+	mov	[ebx + device.pci_bus], ecx
-        movzx   ecx, byte[eax+1]
+	movzx	ecx, byte[eax+2]
-        mov     [device.pci_bus], ecx
+	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 address 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
-        PCI_find_irq
+	mov	[ebx + device.irq_line], al
-        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]:4
 ; 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
-        jnz     .err                                                    ; If an error occured, exit
+	jnz	.err							; If an error occurred, exit
-        mov     eax, [devices]                                          ; Add the device structure to our device list
+	mov	eax, [devices]						; Add the device structure to our device list
-        mov     [device_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
+	mov	[device_list+4*eax], ebx				; (IRQ handler uses this list to find device)
-        inc     [devices]                                               ;
+	inc	[devices]						;
-        mov     [device.type], NET_TYPE_ETH
+	mov	[ebx + device.type], NET_TYPE_ETH
-        call    NetRegDev
+	invoke	NetRegDev
-        cmp     eax, -1
+	cmp	eax, -1
-        je      .destroy
+	je	.destroy
 ;;        Actual Hardware dependent code starts here                      ;;
 ;;                                                                        ;;
 ;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
+;-------
+;
+; PROBE
+;
-probe:
+;-------
+probe:
+	DEBUGF	1, "Probing\n"
-        mov     eax, [device.io_addr]
-        DEBUGF  1, "Probing card at 0x%x\n", eax
+; Make the device a bus master
+	invoke	PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
-; make the card a bus master
+	or	al, PCI_CMD_MASTER
-        PCI_make_bus_master
+	invoke	PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
 ; get device id
-        stdcall PciRead16, [device.pci_bus], [device.pci_dev], PCI_DEVICE_ID
+	invoke	PciRead16, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.device_id
-        mov     [device.chip_id], ax
+	mov	[ebx + device.chip_id], ax
-        mov     esi, chiplist
+	mov	esi, chiplist
   .loop:
-        cmp     word[esi+2], ax
+	cmp	word[esi+2], ax
-        je      .got_it
+	je	.got_it
-        add     esi, 8
+	add	esi, 8
-        cmp     esi, chiplist + 6*8
+	cmp	esi, chiplist + 6*8
-        jbe     .loop
+	jbe	.loop
-        DEBUGF  2, "Unknown chip: 0x%x, continueing anyway\n", ax
+	DEBUGF	2, "Unknown chip: 0x%x, continuing anyway\n", ax
-        jmp     .done
+	jmp	.done
+  .got_it:
-  .got_it:
+	mov	eax, dword[esi+4]
-        mov     eax, dword[esi+4]
+	mov	[ebx + device.name], eax
-        mov     [device.name], eax
+	DEBUGF	1, "Chip type = %s\n", eax
-        DEBUGF  1, "Chip type = %s\n", eax
+  .done:
   .done:
 ; get revision id.
-; get revision id.
+	invoke	PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.revision_id
-        PCI_find_rev
+	mov	[ebx + device.revision], al
-        movzx   eax, [device.revision]
+	movzx	eax, [ebx + device.revision]
-        DEBUGF  1, "Card revision = 0x%x\n", eax
+	DEBUGF	1, "Card revision = 0x%x\n", eax
 ; D-Link provided reset code (with comment additions)
-        cmp     al, 0x40
+	cmp	al, 0x40
-        jb      .below_x40
+	jb	.below_x40
-        mov     ax, [device.chip_id]
+	mov	ax, [ebx + device.chip_id]
-        DEBUGF  1, "Enabling Sticky Bit Workaround for Chip_id: 0x%x\n", ax
+	DEBUGF	1, "Enabling Sticky Bit Workaround for Chip_id: 0x%x\n", ax
-        ; clear sticky bit before reset & read ethernet address
+	; clear sticky bit before reset & read ethernet address
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  bySTICKHW
+	set_io	[ebx + device.io_addr], bySTICKHW
-        in      al, dx
+	in	al, dx
-        and     al, 0xFC
+	and	al, 0xFC
-        out     dx, al
+	out	dx, al
-        ; (bits written are cleared?)
+	; (bits written are cleared?)
-        ; disable force PME-enable
+	; disable force PME-enable
-        set_io  byWOLcgClr
+	set_io	[ebx + device.io_addr], byWOLcgClr
-        mov     al, 0x80
+	mov	al, 0x80
-        out     dx, al
+	out	dx, al
-        ; disable power-event config bit
+	; disable power-event config bit
-        mov     al, 0xFF
+	mov	al, 0xFF
-        out     dx, al
+	out	dx, al
-        ; clear power status (undocumented in vt6102 docs?)
+	; clear power status (undocumented in vt6102 docs?)
-        set_io  byPwrcsrClr
+	set_io	[ebx + device.io_addr], byPwrcsrClr
-        out     dx, al
+	out	dx, al
-        loop    .poll_again
+	loop	.poll_again
-        DEBUGF  1, "Soft reset timeout!\n"
+	DEBUGF	1, "Soft reset timeout!\n"
    @@:
 ; issue AUTOLoad in EECSR to reload eeprom
-        set_io  byEECSR
+	set_io	[ebx + device.io_addr], byEECSR
-        mov     al, 0x20
+	mov	al, 0x20
-        out     dx, al
+	out	dx, al
 ; if vt3065 delay after reset
-        cmp     [device.revision], 0x40
+	cmp	[ebx + device.revision], 0x40
-        jb      .not_vt3065
+	jb	.not_vt3065
-        ; delay 8ms to let MAC stable
+	; delay 10ms to let MAC stable
-        mov     esi, 8 ; 8ms
+	mov	esi, 1 ; 10ms
-        call    Sleep
+	invoke	Sleep
-        ; for 3065D, EEPROM reloaded will cause bit 0 in MAC_REG_CFGA
+	; for 3065D, EEPROM reloaded will cause bit 0 in MAC_REG_CFGA
-        ; turned on.  it makes MAC receive magic packet
+	; turned on.  it makes MAC receive magic packet
-        ; automatically. So, we turn it off. (D-Link)
+	; automatically. So, we turn it off. (D-Link)
-        set_io  byCFGA
+	set_io	[ebx + device.io_addr], byCFGA
-        in      al, dx
+	in	al, dx
-        and     al, 0xFE
+	and	al, 0xFE
-        out     dx, al
+	out	dx, al
-        ; turn on bit2 in PCI configuration register 0x53 , only for 3065
+	; turn on bit2 in PCI configuration register 0x53 , only for 3065
-        stdcall PciRead8, [device.pci_bus], [device.pci_dev], PCI_REG_MODE3
+	invoke	PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_REG_MODE3
-        or      al,  MODE3_MIION
+	or	al, MODE3_MIION
-        stdcall PciWrite8, [device.pci_bus], [device.pci_dev], PCI_REG_MODE3, eax
+	invoke	PciWrite8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_REG_MODE3, eax
   .not_vt3065:
-        DEBUGF  1, "Analyzing Media type, this may take several seconds"
+	DEBUGF	1, "Analyzing Media type, this may take several seconds"
-        mov     ecx, 5
-     .read_again:
+	mov	ecx, 5
-        DEBUGF  1, "."
+     .read_again:
-        mov     esi, 1
+	mov	esi, 1
-        call    Sleep
+	invoke	Sleep
-        stdcall ReadMII, 1
+	stdcall ReadMII, 1
-        test    eax, 0x0020
+	test	eax, 0x0020
-        jnz     .read_done
+	jnz	.read_done
-        loop    .read_again
+	loop	.read_again
-        DEBUGF  1, "timeout!\n"
+	DEBUGF	1, "timeout!\n"
      .read_done:
-        DEBUGF  1, " OK\n"
+	DEBUGF	1, "OK\n"
-if DEBUG
+if 0
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        DEBUGF  1, "link 0x%x\n", ax
+	DEBUGF	1, "link 0x%x\n", ax
 end if
 ; query MII to know LineSpeed, duplex mode
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  MIIStatus
+	set_io	[ebx + device.io_addr], MIIStatus
-        in      al, dx
+	in	al, dx
-        test    al, MIISR_SPEED
+	test	al, MIISR_SPEED
-        jz      .100mbps
+	jz	.100mbps
-        test    eax, 1
+	test	eax, 1
-        jz      .halfduplex
+	jz	.halfduplex
-        DEBUGF  1, "Fullduplex\n"
+	DEBUGF	1, "Fullduplex\n"
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byCR0
+	set_io	[ebx + device.io_addr], byCR0
-        mov     ax, CR_FDX
+	mov	ax, CR_FDX
-        out     dx, ax
+	out	dx, ax
-        jmp     @f
+	jmp	@f
     .halfduplex:
-        DEBUGF  1, "Halfduplex\n"
+	DEBUGF	1, "Halfduplex\n"
     @@:
 ; set MII 10 FULL ON, only apply in vt3043
-        cmp     [device.chip_id], 0x3043
+	cmp	[ebx + device.chip_id], 0x3043
-        jne     @f
+	jne	@f
-        stdcall WriteMII, 0x17, 1 shl 1, 1
+	stdcall WriteMII, 0x17, 1 shl 1, 1
     @@:
 ; turn on MII link change
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byMIICR
+	set_io	[ebx + device.io_addr], byMIICR
-        in      al, dx
+	in	al, dx
-        and     al, 0x7F
+	and	al, 0x7F
-        out     dx, al
+	out	dx, al
-        push    eax
+	push	eax
-        call    MIIDelay
+	call	MIIDelay
-        set_io  byMIIAD
+	set_io	[ebx + device.io_addr], byMIIAD
-        mov     al, 0x41
+	mov	al, 0x41
-        out     dx, al
+	out	dx, al
 reset:
-        DEBUGF  1, "reset\n"
+	DEBUGF	1, "reset\n"
-; attach int handler
 ; 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
+	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
+	test	eax, eax
-        jnz     @f
+	jnz	@f
-        DEBUGF  2,"\nCould not attach int handler!\n"
+	DEBUGF	2,"Could not attach int handler!\n"
-;        or      eax, -1
+	or	eax, -1
-;        ret
+	ret
        @@:
 ; Soft reset the chip.
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byCR0
+	set_io	[ebx + device.io_addr], byCR0
-        mov     ax, CR_SFRST
+	mov	ax, CR_SFRST
-        out     dx, ax
+	out	dx, ax
-        call    MIIDelay
+	call	MIIDelay
 ; Initialize rings
-        call    init_ring
+	call	init_ring
-; Setup Multicast
+; Set Multicast
-        call    set_rx_mode
+	call	set_rx_mode
 ; set TCR RCR threshold to store and forward
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byBCR0
+	set_io	[ebx + device.io_addr], byBCR0
-        mov     al, 0x3E
+	mov	al, 0x3E
-        out     dx, al
+	out	dx, al
-        set_io  byBCR1
+	set_io	[ebx + device.io_addr], byBCR1
-        mov     al, 0x38
+	mov	al, 0x38
-        out     dx, al
+	out	dx, al
-        set_io  byRCR
+	set_io	[ebx + device.io_addr], byRCR
-        mov     al, 0x2C
+	mov	al, 0x2C
-        out     dx, al
+	out	dx, al
-        set_io  byTCR
+	set_io	[ebx + device.io_addr], byTCR
-        mov     al, 0x60
+	mov	al, 0x60
-        out     dx, al
+	out	dx, al
 ; Set Fulldupex
-        call    QueryAuto
+	call	QueryAuto
-        test    eax, eax        ; full duplex?
+	test	eax, eax	; full duplex?
-        jz      @f
+	jz	@f
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byCFGD
+	set_io	[ebx + device.io_addr], byCFGD
-        mov     al, CFGD_CFDX
+	mov	al, CFGD_CFDX
-        out     dx, al
+	out	dx, al
-        set_io  byCR0
+	set_io	[ebx + device.io_addr], byCR0
-        mov     ax, CR_FDX
+	mov	ax, CR_FDX
-        out     dx, ax
+	out	dx, ax
     @@:
 ; ENABLE interrupts
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byIMR0
+	set_io	[ebx + device.io_addr], byIMR0
-        call    reset
+	call	reset
-        push    eax edx
+	push	eax edx
-        DEBUGF  1, "rhine disable\n"
+	DEBUGF	1, "rhine disable\n"
-        ; Switch to loopback mode to avoid hardware races.
+	; Switch to loopback mode to avoid hardware races.
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byTCR
+	set_io	[ebx + device.io_addr], byTCR
-        mov     al, 0x61
+	mov	al, 0x61
-        out     dx, al
+	out	dx, al
-        ; Stop the chip's Tx and Rx processes.
+	; Stop the chip's Tx and Rx processes.
-        set_io  byCR0
+	set_io	[ebx + device.io_addr], byCR0
-        mov     ax, CR_STOP
+	mov	ax, CR_STOP
-        out     dx, ax
+	out	dx, ax
 align 4
 reload_eeprom:
-        DEBUGF  1, "Reload eeprom\n"
+	DEBUGF	1, "Reload eeprom\n"
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byEECSR
+	set_io	[ebx + device.io_addr], byEECSR
-        mov     al, 0x20
+	mov	al, 0x20
-        out     dx, al
+	out	dx, al
-        ; Typically 2 cycles to reload.
+	; Typically 2 cycles to reload.
-        mov     ecx, 150
+	mov	ecx, 150
   .reload:
-        in      al, dx
+	in	al, dx
-        test    al, 0x20
+	test	al, 0x20
-        jz      @f
+	jz	@f
-        loop    .reload
+	loop	.reload
-        DEBUGF  1, "Reload timeout!\n"
+	DEBUGF	2, "Reload eeprom: timeout!\n"
+  @@:
-  @@:
+	ret
         ret
 ; Initialize the Rx and Tx rings, along with various 'dev' bits.
 align 4
 init_ring:
-        DEBUGF  1, "Init ring\n"
+	DEBUGF	1, "Init ring\n"
-        lea     edi, [device.rx_ring]
+	lea	edi, [ebx + device.rx_ring]
-        mov     eax, edi
+	mov	eax, edi
-        GetRealAddr
+	invoke	GetPhysAddr
-        mov     esi, eax
+	mov	esi, eax
-        push    esi
+	push	esi
-        mov     ecx, RX_RING_SIZE
+	mov	ecx, RX_RING_SIZE
    .rx_init:
-        add     esi, rx_head.sizeof
+	add	esi, sizeof.rx_head
-        mov     [edi + rx_head.status], RX_SBITS_OWN_BIT
+	mov	[edi + rx_head.status], RX_SBITS_OWN_BIT
-        mov     [edi + rx_head.control], PKT_BUF_SZ
+	mov	[edi + rx_head.control], PKT_BUF_SZ
-        push    ecx
+	push	ecx
-        stdcall KernelAlloc, PKT_BUF_SZ
+	invoke	KernelAlloc, PKT_BUF_SZ
-        pop     ecx
+	pop	ecx
-        mov     [edi + rx_head.buff_addr_virt], eax
+	mov	[edi + rx_head.buff_addr_virt], eax
-        GetRealAddr
+	invoke	GetPhysAddr
-        mov     [edi + rx_head.buff_addr], eax                        ; buffer ptr
+	mov	[edi + rx_head.buff_addr], eax			      ; buffer ptr
-        mov     [edi + rx_head.next_desc], esi                        ; next head
+	mov	[edi + rx_head.next_desc], esi			      ; next head
-        add     edi, rx_head.sizeof
+	add	edi, sizeof.rx_head
-        dec     ecx
+	dec	ecx
-        jnz     .rx_init
+	jnz	.rx_init
-        pop     [edi - rx_head.sizeof + rx_head.next_desc]            ; Mark the last entry as wrapping the ring.
+	pop	[edi - sizeof.rx_head + rx_head.next_desc]	      ; Mark the last entry as wrapping the ring.
-        lea     edi, [device.tx_ring]
+	lea	edi, [ebx + device.tx_ring]
-        mov     eax, edi
+	mov	eax, edi
-        GetRealAddr
+	invoke	GetPhysAddr
-        mov     esi, eax
+	mov	esi, eax
-        push    esi
+	push	esi
-        mov     ecx, TX_RING_SIZE
+	mov	ecx, TX_RING_SIZE
    .tx_init:
-        add     esi, tx_head.sizeof
+	add	esi, sizeof.tx_head
-        mov     [edi + tx_head.status], 0
+	mov	[edi + tx_head.status], 0
-        mov     [edi + tx_head.control], 0x00E08000
+	mov	[edi + tx_head.control], 0x00E08000
-        mov     [edi + tx_head.buff_addr], 0
+	mov	[edi + tx_head.buff_addr], 0
-        mov     [edi + tx_head.next_desc], esi
+	mov	[edi + tx_head.next_desc], esi
-        mov     [edi + tx_head.buff_addr_virt], 0
+	mov	[edi + tx_head.buff_addr_virt], 0
-        add     edi, tx_head.sizeof
+	add	edi, sizeof.tx_head
-        dec     ecx
+	dec	ecx
-        jnz     .tx_init
+	jnz	.tx_init
-        pop     [edi - tx_head.sizeof + tx_head.next_desc]              ; Mark the last entry as wrapping the ring.
+	pop	[edi - sizeof.tx_head + tx_head.next_desc]		; Mark the last entry as wrapping the ring.
 ; write Descriptors to MAC
-        lea     eax, [device.rx_ring]
+	lea	eax, [ebx + device.rx_ring]
-        GetRealAddr
+	invoke	GetPhysAddr
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  dwCurrentRxDescAddr
+	set_io	[ebx + device.io_addr], dwCurrentRxDescAddr
-        out     dx, eax
+	out	dx, eax
 ;        DEBUGF  1, "ReadMII Index=%x\n", [byMIIIndex]
-        push    esi ebx ecx edx
+	push	esi ebx ecx edx
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byMIIAD
+	set_io	[ebx + device.io_addr], byMIIAD
-        in      al, dx
+	in	al, dx
-        mov     bl, al
+	mov	bl, al
-        set_io  byMIICR
+	set_io	[ebx + device.io_addr], byMIICR
-        in      al, dx
+	in	al, dx
-        mov     bh, al
+	mov	bh, al
-        and     al, 0x7F
+	and	al, 0x7F
-        out     dx, al
+	out	dx, al
-        call    MIIDelay
+	call	MIIDelay
-        mov     al, byte [byMIIIndex]
+	mov	al, byte [byMIIIndex]
-        set_io  byMIIAD
+	set_io	[ebx + device.io_addr], byMIIAD
-        out     dx, al
+	out	dx, al
-        in      al, dx
+	in	al, dx
-        test    al, 0x40
+	test	al, 0x40
-        jz      @f
+	jz	@f
-        mov     esi, 10
+	mov	esi, 10
-        call    Sleep
+	invoke	Sleep
-        dec     ecx
+	dec	ecx
-        jnz     .read_again
+	jnz	.read_again
-        DEBUGF  1, "\nReadMII timeout!\n"
+	DEBUGF	2, "ReadMII: timeout!\n"
   @@:
-        call    MIIDelay
+	call	MIIDelay
-        set_io  byMIIAD
+	set_io	[ebx + device.io_addr], byMIIAD
-        in      ax, dx
+	in	ax, dx
-        push    eax
+	push	eax
-        mov     ax, bx
+	mov	ax, bx
-        set_io  byMIIAD
+	set_io	[ebx + device.io_addr], byMIIAD
-        out     dx, al
+	out	dx, al
-        shr     ax, 8
+	shr	ax, 8
-        set_io  byMIICR
+	set_io	[ebx + device.io_addr], byMIICR
-        out     dx, al
+	out	dx, al
-        call    MIIDelay
+	call	MIIDelay
+	pop	eax
 	and	eax, 0xFFFF
-        pop     eax
+	rol	ax, 8
         and     eax, 0xFFFF
-        rol     ax, 8           ;;;;; I dont know how or why but it seems needed...
+	pop	edx ecx ebx esi
+	ret
-        pop     edx ecx ebx esi
+endp
         ret
-endp
-proc    WriteMII stdcall, byMIISetByte:dword, byMIISetBit:dword, byMIIOP:dword
+proc	WriteMII stdcall, byMIISetByte:dword, byMIISetBit:dword, byMIIOP:dword
 ;        DEBUGF  1, "WriteMII SetByte=%x SetBit=%x OP=%x\n", [byMIISetByte], [byMIISetBit], [byMIIOP]
-        push    ebx eax ecx edx
+	push	ebx eax ecx edx
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byMIIAD
+	set_io	[ebx + device.io_addr], byMIIAD
-        in      al, dx
+	in	al, dx
-        mov     bl, al
+	mov	bl, al
-        set_io  byMIICR
+	set_io	[ebx + device.io_addr], byMIICR
-        in      al, dx
+	in	al, dx
-        in      al, dx
+	in	al, dx
-        test    al, 0x40
+	test	al, 0x40
-        jz      .done
+	jz	.done
-        mov     esi, 10
+	mov	esi, 10
-        call    Sleep
+	invoke	Sleep
-        dec     ecx
+	dec	ecx
-        jnz     .read_again0
+	jnz	.read_again0
-        DEBUGF  1, "WriteMII timeout 1\n"
+	DEBUGF	2, "WriteMII: timeout (1)\n"
   .done:
-        call    MIIDelay
+	call	MIIDelay
-        set_io  wMIIDATA
+	set_io	[ebx + device.io_addr], wMIIDATA
-        in      ax, dx
+	in	ax, dx
-        mov     ecx, [byMIISetBit]
+	mov	ecx, [byMIISetBit]
-        rol     cx, 8                   ;;;;;;;;;;;;;;;;; CHECKME
+	rol	cx, 8
-        cmp     byte [byMIIOP], 0
+	cmp	byte [byMIIOP], 0
-        jne     @f
+	jne	@f
-        not     ecx
+	not	ecx
-        and     ax, cx
+	and	ax, cx
-        jmp     .end_mascarad
+	jmp	.end_mascarad
      @@:
-        or      ax, cx
+	or	ax, cx
      .end_mascarad:
-        set_io  wMIIDATA
+	set_io	[ebx + device.io_addr], wMIIDATA
-        out     dx, ax
+	out	dx, ax
-        in      al, dx
+	in	al, dx
-        test    al, 0x20
+	test	al, 0x20
-        jz      @f
+	jz	@f
-        mov     esi, 10
+	mov	esi, 10
-        call    Sleep
+	invoke	Sleep
-        dec     ecx
+	dec	ecx
-        jnz     .read_again1
+	jnz	.read_again1
-        DEBUGF  1, "WriteMII timeout 2\n"
+	DEBUGF	2, "WriteMII timeout (2)\n"
     @@:
-        call    MIIDelay
+	call	MIIDelay
-        mov     ax, bx
+	mov	ax, bx
-        and     al, 0x7F
+	and	al, 0x7F
-        set_io  byMIIAD
+	set_io	[ebx + device.io_addr], byMIIAD
-        out     dx, al
+	out	dx, al
-        shr     ax, 8
+	shr	ax, 8
-        DEBUGF  1, "Set RX mode\n"
+	DEBUGF	1, "Set RX mode\n"
-        ; ! IFF_PROMISC
+	; ! IFF_PROMISC
-        mov     eax, 0xffffffff
+	mov	eax, 0xffffffff
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byMAR0
+	set_io	[ebx + device.io_addr], byMAR0
-        out     dx, eax
+	out	dx, eax
-        set_io  byMAR4
+	set_io	[ebx + device.io_addr], byMAR4
-        out     dx, eax
+	out	dx, eax
 ; Beware of PCI posted writes
 macro IOSYNC
+{
-        set_io  StationAddr
+	set_io	[ebx + device.io_addr], StationAddr
-        in      al, dx
+	in	al, dx
+}
 align 4
 read_mac:
-        lea     edi, [device.mac]
+	lea	edi, [ebx + device.mac]
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byPAR0
+	set_io	[ebx + device.io_addr], byPAR0
-        mov     ecx, 6
+	mov	ecx, 6
   .next:
-        in      al, dx
+	in	al, dx
-        stosb
+	stosb
 ;;     size of buffer in [esp+8]           ;;
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
+proc transmit stdcall bufferptr, buffersize
-transmit:
+	pushf
+	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",\
+	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], 1514
+	cmp	[buffersize], 1514
-        ja      .fail
+	ja	.fail
-        cmp     dword [esp+8], 60
+	cmp	[buffersize], 60
-        jb      .fail
+	jb	.fail
-        movzx   eax, [device.cur_tx]
+	movzx	eax, [ebx + device.cur_tx]
-        mov     ecx, tx_head.sizeof
+	mov	ecx, sizeof.tx_head
-        mul     ecx
+	mul	ecx
-        lea     edi, [device.tx_ring]
+	lea	edi, [ebx + device.tx_ring]
-        add     edi, eax
+	add	edi, eax
-        cmp     [edi + tx_head.buff_addr_virt], 0
+	cmp	[edi + tx_head.buff_addr_virt], 0
-        jne     .fail
+	jne	.fail
-        mov     eax, [esp+4]
+	mov	eax, [bufferptr]
-        mov     [edi + tx_head.buff_addr_virt], eax
+	mov	[edi + tx_head.buff_addr_virt], eax
-        GetRealAddr
+	invoke	GetPhysAddr
-        mov     [edi + tx_head.buff_addr], eax
+	mov	[edi + tx_head.buff_addr], eax
-        mov     ecx, [esp+8]
+	mov	ecx, [buffersize]
-        and     ecx, TX_CBITS_TX_BUF_SIZE
+	and	ecx, TX_CBITS_TX_BUF_SIZE
-        or      ecx,  0x00E08000
+	or	ecx,  0x00E08000
-        mov     [edi + tx_head.control], ecx
+	mov	[edi + tx_head.control], ecx
-        or      [edi + tx_head.status], TX_SBITS_OWN_BIT
+	or	[edi + tx_head.status], TX_SBITS_OWN_BIT
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  byCR1
+	set_io	[ebx + device.io_addr], byCR1
-        in      al, dx
+	in	al, dx
-        or      al, CR1_TDMD1
+	or	al, CR1_TDMD1
-        out     dx, al
+	out	dx, al
-        inc     [device.cur_tx]
+	inc	[ebx + device.cur_tx]
-        and     [device.cur_tx], TX_RING_SIZE-1
+	and	[ebx + device.cur_tx], TX_RING_SIZE-1
+	;outw(IMRShadow,byIMR0); ;
-        ;outw(IMRShadow,byIMR0); ;
+; Update stats
 	inc	[ebx + device.packets_tx]
-; Update stats
+	mov	ecx, [buffersize]
-        inc     [device.packets_tx]
+	add	dword [ebx + device.bytes_tx], ecx
-        mov     ecx, [esp+8]    ;;;;;
+	adc	dword [ebx + device.bytes_tx + 4], 0
-        add     dword [device.bytes_tx], ecx
-        adc     dword [device.bytes_tx + 4], 0
-        xor     eax, eax        ; Transmit succesfull
-        ret     8
+	DEBUGF	1,"Transmit OK\n"
+	popf
 	xor	eax, eax
-  .fail:
+	ret
-        push    ebx esi edi
+	push	ebx esi edi
-        DEBUGF  1,"INT\n"
+	DEBUGF	1,"INT\n"
-; Find pointer of device wich made IRQ occur
+; Find pointer of device which made IRQ occur
-        mov     ecx, [devices]
+	mov	ecx, [devices]
-        test    ecx, ecx
+	test	ecx, ecx
-        jz      .nothing
+	jz	.nothing
-        mov     esi, device_list
+	mov	esi, device_list
   .nextdevice:
-        mov     ebx, [esi]
+	mov	ebx, [esi]
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  IntrStatus
+	set_io	[ebx + device.io_addr], IntrStatus
-        push    ebx
+	push	ebx
   .more_RX:
-        pop     ebx
+	pop	ebx
-; Get the current descripter pointer
+; Get the current descriptor pointer
-        movzx   eax, [device.cur_rx]
+	movzx	eax, [ebx + device.cur_rx]
-        mov     ecx, rx_head.sizeof
+	mov	ecx, sizeof.rx_head
-        mul     ecx
+	mul	ecx
-        lea     edi, [device.rx_ring]
+	lea	edi, [ebx + device.rx_ring]
-        shr     ecx, 16
+	shr	ecx, 16
-        sub     ecx, 4  ; We dont want CRC
+	sub	ecx, 4	; We dont want CRC
 ; Update stats
-        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
-        inc     [device.packets_rx]
+	inc	[ebx + device.packets_rx]
-        push    [edi + rx_head.buff_addr_virt]
+	push	[edi + rx_head.buff_addr_virt]
 ; reset the RX descriptor
-        push    edi
+	push	edi
-        stdcall KernelAlloc, PKT_BUF_SZ
+	invoke	KernelAlloc, PKT_BUF_SZ
-        pop     edi
+	pop	edi
-        mov     [edi + rx_head.buff_addr_virt], eax
+	mov	[edi + rx_head.buff_addr_virt], eax
-        GetRealAddr
+	invoke	GetPhysAddr
-        mov     [edi + rx_head.buff_addr], eax
+	mov	[edi + rx_head.buff_addr], eax
-        mov     [edi + rx_head.status], RX_SBITS_OWN_BIT
+	mov	[edi + rx_head.status], RX_SBITS_OWN_BIT
 ; Use next descriptor next time
-        inc     [device.cur_rx]
+	inc	[ebx + device.cur_rx]
-        and     [device.cur_rx], RX_RING_SIZE - 1
+	and	[ebx + device.cur_rx], RX_RING_SIZE - 1
 ; At last, send packet to kernel
-        jmp     Eth_input
+	jmp	[Eth_input]
   .not_bit_own:
   .not_RX:
-        pop     ax
+	pop	ax
-        test    ax, IntrTxDone
+	test	ax, IntrTxDone
-        DEBUGF  1,"Freeing buffer 0x%x\n", [edi + tx_head.buff_addr_virt]
+	DEBUGF	1,"Freeing buffer 0x%x\n", [edi + tx_head.buff_addr_virt]
-        push    [edi + tx_head.buff_addr_virt]
+	push	[edi + tx_head.buff_addr_virt]
-        mov     [edi + tx_head.buff_addr_virt], 0
+	mov	[edi + tx_head.buff_addr_virt], 0
-        call    KernelFree
+	invoke	KernelFree
-        inc     [device.last_tx]
+	inc	[ebx + device.last_tx]
-        and     [device.last_tx], TX_RING_SIZE - 1
+	and	[ebx + device.last_tx], TX_RING_SIZE - 1
-        jmp     .loop_tx
+	jmp	.loop_tx
   .not_TX:
-        ; On Rhine-II, Bit 3 indicates Tx descriptor write-back race.
+	; On Rhine-II, Bit 3 indicates Tx descriptor write-back race.
 if 0
-        cmp     [device.chip_id], 0x3065 ;if (tp->chip_id == 0x3065)
+	cmp	[ebx + device.chip_id], 0x3065 ;if (tp->chip_id == 0x3065)
-        jne     @f
+	jne	@f
-        push    ax
+	push	ax
-        xor     eax, eax
+	xor	eax, eax
-        ; Acknowledge all of the current interrupt sources ASAP.
+	; Acknowledge all of the current interrupt sources ASAP.
-        xor     ecx, ecx
+	xor	ecx, ecx
-        test    eax, IntrTxDescRace
+	test	eax, IntrTxDescRace
-        jz      @f
+	jz	@f
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  IntrStatus2
+	set_io	[ebx + device.io_addr], IntrStatus2
-        push    ax
+	push	ax
-        mov     al, 0x08
+	mov	al, 0x08
-        out     dx, al
+	out	dx, al
-        pop     ax
+	pop	ax
     @@:
-        set_io  0
+	set_io	[ebx + device.io_addr], 0
-        set_io  IntrStatus
+	set_io	[ebx + device.io_addr], IntrStatus
-        out     dx, ax
+	out	dx, ax
-        IOSYNC
+	IOSYNC
+; End of code
-; End of code
-section '.data' data readable writable align 16 ; place all uninitialized data here
+data fixups
-align 4                                         ; Place all initialised data here
+end data
-devices         dd 0
+include '../peimport.inc'
 version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
-my_service      db 'RHINE',0                    ; max 16 chars including zero
+my_service	db 'RHINE',0			; max 16 chars including zero
 chiplist:
-                dd 0x30431106, rhine_3043;, RHINE_IOTYPE, RHINE_I_IOSIZE, CanHaveMII or ReqTxAlign or HasV1TxStat
+		dd 0x30431106, rhine_3043;, RHINE_IOTYPE, RHINE_I_IOSIZE, CanHaveMII or ReqTxAlign or HasV1TxStat
-                dd 0x61001106, rhine_6100;, RHINE_IOTYPE, RHINE_I_IOSIZE, CanHaveMII or ReqTxAlign or HasV1TxStat
+		dd 0x61001106, rhine_6100;, RHINE_IOTYPE, RHINE_I_IOSIZE, CanHaveMII or ReqTxAlign or HasV1TxStat
-                dd 0x30651106, rhine_6102;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL
+		dd 0x30651106, rhine_6102;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL
-                dd 0x31061106, rhine_6105;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL
+		dd 0x31061106, rhine_6105;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL
-                ; Duplicate entry, with 'M' features enabled.
+; Duplicate entry, with 'M' features enabled.
-                dd 0x31061106, rhine_6105;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL or HasIPChecksum or HasVLAN
+;                dd 0x31061106, rhine_6105;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL or HasIPChecksum or HasVLAN
-                dd 0x30531106, rhine_3053;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL
+		dd 0x30531106, rhine_3053;, RHINE_IOTYPE, RHINEII_IOSIZE, CanHaveMII or HasWOL
-                dd 0
+		dd 0
+rhine_3043	db "VIA VT3043 Rhine", 0
 rhine_6100	db "VIA VT86C100A Rhine", 0

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/rhine.asm – Rev 4470 → 4606