WebSVN – Kolibri OS – Diff – /drivers/unfinished/bcm57xx.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  Broadcom NetXtreme 57xx driver for KolibriOS                   ;;
;;                                                                 ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;; Broadcom's programmers's manual for the BCM57xx                 ;;
;; http://www.broadcom.com/collateral/pg/57XX-PG105-R.pdf          ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format PE DLL native
entry START
 
        CURRENT_API             = 0x0200
        COMPATIBLE_API          = 0x0100
        API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
 
        MAX_DEVICES             = 16
 
        __DEBUG__               = 1
        __DEBUG_LEVEL__         = 2
 
section '.flat' readable writable executable
 
include '../proc32.inc'
include '../struct.inc'
include '../macros.inc'
include '../fdo.inc'
include '../netdrv.inc'
 
struct  device          ETH_DEVICE
 
        mmio_addr       dd ?
        pci_bus         dd ?
        pci_dev         dd ?
        irq_line        db ?
 
        cur_tx          dd ?
        last_tx         dd ?
 
        rb 0x100 - ($ and 0xff) ; align 256
        rx_desc         rd 256/8
 
        rb 0x100 - ($ and 0xff) ; align 256
        tx_desc         rd 256/8
 
ends
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc START             ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc START c, reason:dword, cmdline:dword
 
        cmp     [reason], DRV_ENTRY
        jne     .fail
 
        DEBUGF  1,"Loading driver\n"
        invoke  RegService, my_service, service_proc
        ret
 
  .fail:
        xor     eax, eax
        ret
 
endp
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc SERVICE_PROC      ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc service_proc stdcall, ioctl:dword
 
        mov     edx, [ioctl]
        mov     eax, [edx + IOCTL.io_code]
 
;------------------------------------------------------
 
        cmp     eax, 0 ;SRV_GETVERSION
        jne     @F
 
        cmp     [edx + IOCTL.out_size], 4
        jb      .fail
        mov     eax, [edx + 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
        jb      .fail
 
        mov     eax, [edx + IOCTL.input]
        cmp     byte [eax], 1                           ; 1 means device number and bus number (pci) are given
        jne     .fail                                   ; other types arent supported for this card yet
 
; check if the device is already listed
 
        mov     esi, device_list
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .firstdevice
 
;        mov     eax, [edx + IOCTL.input]                      ; get the pci bus and device numbers
        mov     ax, [eax+1]                             ;
  .nextdevice:
        mov     ebx, [esi]
        cmp     al, byte [ebx + device.pci_bus]
        jne     .next
        cmp     ah, byte [ebx + device.pci_dev]
        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
  .next:
        add     esi, 4
        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
        jae     .fail
 
        allocate_and_clear ebx, sizeof.device, .fail      ; Allocate the buffer for device structure
 
; Fill in the direct call addresses into the struct
 
        mov     [ebx + device.reset], reset
        mov     [ebx + device.transmit], transmit
        mov     [ebx + device.unload], unload
        mov     [ebx + device.name], my_service
 
; save the pci bus and device numbers
 
        mov     eax, [edx + IOCTL.input]
        movzx   ecx, byte [eax+1]
        mov     [ebx + device.pci_bus], ecx
        movzx   ecx, byte [eax+2]
        mov     [ebx + device.pci_dev], ecx
 
; Now, it's time to find the base mmio addres of the PCI device
 
        stdcall PCI_find_mmio32, [ebx + device.pci_bus], [ebx + device.pci_dev]
 
; Create virtual mapping of the physical memory
 
        push    1Bh             ; PG_SW+PG_NOCACHE
        push    10000h          ; size of the map
        push    eax
        invoke  MapIoMem
        mov     [ebx + device.mmio_addr], eax
 
; We've found the mmio address, find IRQ now
 
        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
        mov     [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.mmio_addr]:8
 
; Ok, the eth_device structure is ready, let's probe the device
        call    probe                                                   ; this function will output in eax
        test    eax, eax
        jnz     .err                                                    ; If an error occured, exit
 
        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)
        inc     [devices]                                               ;
 
        mov     [ebx + device.type], NET_TYPE_ETH
        invoke  NetRegDev
 
        cmp     eax, -1
        je      .destroy
 
        ret
 
; If the device was already loaded, find the device number and return it in eax
 
  .find_devicenum:
        DEBUGF  1,"Trying to find device number of already registered device\n"
        invoke  NetPtrToNum                                             ; 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
        ret
 
; If an error occured, remove all allocated data and exit (returning -1 in eax)
 
  .destroy:
        ; todo: reset device into virgin state
 
  .err:
        invoke  KernelFree, ebx
 
  .fail:
        or      eax, -1
        ret
 
;------------------------------------------------------
endp
 
 
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
;;                                                                        ;;
;;        Actual Hardware dependent code starts here                      ;;
;;                                                                        ;;
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 
unload:
        ; TODO: (in this particular order)
        ;
        ; - Stop the device
        ; - Detach int handler
        ; - Remove device from local list (device_list)
        ; - call unregister function in kernel
        ; - Remove all allocated structures and buffers the card used
 
        or      eax, -1
 
ret
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;  probe: enables the device (if it really is BCM57XX)
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
probe:
 
        DEBUGF  1,"Probe\n"
 
; Make the device a bus master
        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
        or      al, PCI_CMD_MASTER
        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
 
 
        ; TODO: validate the device
 
 
 
 
reset:
 
        DEBUGF  1,"Reset\n"
 
        movzx   eax, [ebx + device.irq_line]
        DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
        invoke  AttachIntHandler, eax, int_handler, ebx
        test    eax, eax
        jnz     @f
        DEBUGF  1,"\nCould not attach int handler!\n"
;        or      eax, -1
;        ret
  @@:
 
        call    read_mac
 
; Set the mtu, kernel will be able to send now
        mov     [ebx + device.mtu], 1514
 
; Set link state to unknown
        mov     [ebx + device.state], ETH_LINK_UNKNOWN
 
        ret
 
 
 
 
align 4
read_mac:
 
        DEBUGF  1,"Read MAC\n"
 
        mov     esi, [ebx + device.mmio_addr]
        lea     edi, [ebx + device.mac]
        movsd
        movsw
 
  .mac_ok:
        DEBUGF  1,"MAC = %x-%x-%x-%x-%x-%x\n",\
        [ebx + device.mac+0]: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
 
        ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                         ;;
;; Transmit                                ;;
;;                                         ;;
;; In: buffer pointer in [esp+4]           ;;
;;     size of buffer in [esp+8]           ;;
;;     pointer to device structure in ebx  ;;
;;                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc transmit stdcall bufferptr, buffersize
 
        pushf
        cli
 
        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
        mov     eax, [bufferptr]
        DEBUGF  1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
        [eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
        [eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
        [eax+13]:2,[eax+12]:2
 
        cmp     [buffersize], 1514
        ja      .fail
        cmp     [buffersize], 60
        jb      .fail
 
 
 
 
 
; Update stats
        inc     [ebx + device.packets_tx]
        mov     eax, [buffersize]
        add     dword[ebx + device.bytes_tx], eax
        adc     dword[ebx + device.bytes_tx + 4], 0
 
        DEBUGF  1,"Transmit OK\n"
        popf
        xor     eax, eax
        ret
 
  .fail:
        DEBUGF  2,"Transmit failed\n"
        invoke  KernelFree, [bufferptr]
        popf
        or      eax, -1
        ret
 
endp
 
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; Interrupt handler ;;
;;                   ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
int_handler:
 
        push    ebx esi edi
 
        DEBUGF  1,"INT\n"
;-------------------------------------------
; Find pointer of device wich made IRQ occur
 
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .nothing
        mov     esi, device_list
  .nextdevice:
        mov     ebx, [esi]
 
;        mov     edi, [ebx + device.mmio_addr]
;        mov     eax, [edi + REG_ICR]
        test    eax, eax
        jnz     .got_it
  .continue:
        add     esi, 4
        dec     ecx
        jnz     .nextdevice
  .nothing:
        pop     edi esi ebx
        xor     eax, eax
 
        ret
 
  .got_it:
 
        DEBUGF  1,"Device: %x Status: %x ", ebx, eax
 
        pop     edi esi ebx
        xor     eax, eax
        inc     eax
 
        ret
 
 
 
 
; End of code
 
data fixups
end data
 
include '../peimport.inc'
 
my_service      db 'BCM57XX',0                   ; max 16 chars include zero
 
include_debug_strings                           ; All data wich FDO uses will be included here
 
align 4
devices         dd 0
device_list     rd MAX_DEVICES                  ; This list contains all pointers to device structures the driver is handling

Rev 5074	Rev 5363
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; Broadcom NetXtreme 57xx driver for KolibriOS ;;	6	;; Broadcom NetXtreme 57xx driver for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; ;;	8	;; ;;
9	;; GNU GENERAL PUBLIC LICENSE ;;	9	;; GNU GENERAL PUBLIC LICENSE ;;
10	;; Version 2, June 1991 ;;	10	;; Version 2, June 1991 ;;
11	;; ;;	11	;; ;;
12	;; Broadcom's programmers's manual for the BCM57xx ;;	12	;; Broadcom's programmers's manual for the BCM57xx ;;
13	;; http://www.broadcom.com/collateral/pg/57XX-PG105-R.pdf ;;	13	;; http://www.broadcom.com/collateral/pg/57XX-PG105-R.pdf ;;
14	;; ;;	14	;; ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		16
17	format PE DLL native	17	format PE DLL native
18	entry START	18	entry START
19		19
20	CURRENT_API = 0x0200	20	CURRENT_API = 0x0200
21	COMPATIBLE_API = 0x0100	21	COMPATIBLE_API = 0x0100
22	API_VERSION = (COMPATIBLE_API shl 16) + CURRENT_API	22	API_VERSION = (COMPATIBLE_API shl 16) + CURRENT_API
23		23
24	MAX_DEVICES = 16	24	MAX_DEVICES = 16
25		25
26	__DEBUG__ = 1	26	__DEBUG__ = 1
27	__DEBUG_LEVEL__ = 2	27	__DEBUG_LEVEL__ = 2
28		28
29	section '.flat' readable writable executable	29	section '.flat' readable writable executable
30		30
31	include '../proc32.inc'	31	include '../proc32.inc'
32	include '../struct.inc'	32	include '../struct.inc'
33	include '../macros.inc'	33	include '../macros.inc'
34	include '../fdo.inc'	34	include '../fdo.inc'
35	include '../netdrv.inc'	35	include '../netdrv.inc'
36		36
37	struct device ETH_DEVICE	37	struct device ETH_DEVICE
38		38
39	mmio_addr dd ?	39	mmio_addr dd ?
40	pci_bus dd ?	40	pci_bus dd ?
41	pci_dev dd ?	41	pci_dev dd ?
42	irq_line db ?	42	irq_line db ?
43		43
44	cur_tx dd ?	44	cur_tx dd ?
45	last_tx dd ?	45	last_tx dd ?
46		46
47	rb 0x100 - ($ and 0xff) ; align 256	47	rb 0x100 - ($ and 0xff) ; align 256
48	rx_desc rd 256/8	48	rx_desc rd 256/8
49		49
50	rb 0x100 - ($ and 0xff) ; align 256	50	rb 0x100 - ($ and 0xff) ; align 256
51	tx_desc rd 256/8	51	tx_desc rd 256/8
52		52
53	ends	53	ends
54		54
55		55
56	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	56	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
57	;; ;;	57	;; ;;
58	;; proc START ;;	58	;; proc START ;;
59	;; ;;	59	;; ;;
60	;; (standard driver proc) ;;	60	;; (standard driver proc) ;;
61	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	61	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
62		62
63	proc START c, reason:dword, cmdline:dword	63	proc START c, reason:dword, cmdline:dword
64		64
65	cmp [reason], DRV_ENTRY	65	cmp [reason], DRV_ENTRY
66	jne .fail	66	jne .fail
67		67
68	DEBUGF 1,"Loading driver\n"	68	DEBUGF 1,"Loading driver\n"
69	invoke RegService, my_service, service_proc	69	invoke RegService, my_service, service_proc
70	ret	70	ret
71		71
72	.fail:	72	.fail:
73	xor eax, eax	73	xor eax, eax
74	ret	74	ret
75		75
76	endp	76	endp
77		77
78		78
79		79
80	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	80	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
81	;; ;;	81	;; ;;
82	;; proc SERVICE_PROC ;;	82	;; proc SERVICE_PROC ;;
83	;; ;;	83	;; ;;
84	;; (standard driver proc) ;;	84	;; (standard driver proc) ;;
85	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	85	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
86		86
87	proc service_proc stdcall, ioctl:dword	87	proc service_proc stdcall, ioctl:dword
88		88
89	mov edx, [ioctl]	89	mov edx, [ioctl]
90	mov eax, [edx + IOCTL.io_code]	90	mov eax, [edx + IOCTL.io_code]
91		91
92	;------------------------------------------------------	92	;------------------------------------------------------
93		93
94	cmp eax, 0 ;SRV_GETVERSION	94	cmp eax, 0 ;SRV_GETVERSION
95	jne @F	95	jne @F
96		96
97	cmp [edx + IOCTL.out_size], 4	97	cmp [edx + IOCTL.out_size], 4
98	jb .fail	98	jb .fail
99	mov eax, [edx + IOCTL.output]	99	mov eax, [edx + IOCTL.output]
100	mov [eax], dword API_VERSION	100	mov [eax], dword API_VERSION
101		101
102	xor eax, eax	102	xor eax, eax
103	ret	103	ret
104		104
105	;------------------------------------------------------	105	;------------------------------------------------------
106	@@:	106	@@:
107	cmp eax, 1 ;SRV_HOOK	107	cmp eax, 1 ;SRV_HOOK
108	jne .fail	108	jne .fail
109		109
110	cmp [edx + IOCTL.inp_size], 3 ; Data input must be at least 3 bytes	110	cmp [edx + IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
111	jb .fail	111	jb .fail
112		112
113	mov eax, [edx + IOCTL.input]	113	mov eax, [edx + IOCTL.input]
114	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given	114	cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
115	jne .fail ; other types arent supported for this card yet	115	jne .fail ; other types arent supported for this card yet
116		116
117	; check if the device is already listed	117	; check if the device is already listed
118		118
119	mov esi, device_list	119	mov esi, device_list
120	mov ecx, [devices]	120	mov ecx, [devices]
121	test ecx, ecx	121	test ecx, ecx
122	jz .firstdevice	122	jz .firstdevice
123		123
124	; mov eax, [edx + IOCTL.input] ; get the pci bus and device numbers	124	; mov eax, [edx + IOCTL.input] ; get the pci bus and device numbers
125	mov ax, [eax+1] ;	125	mov ax, [eax+1] ;
126	.nextdevice:	126	.nextdevice:
127	mov ebx, [esi]	127	mov ebx, [esi]
128	cmp al, byte [ebx + device.pci_bus]	128	cmp al, byte [ebx + device.pci_bus]
129	jne .next	129	jne .next
130	cmp ah, byte [ebx + device.pci_dev]	130	cmp ah, byte [ebx + device.pci_dev]
131	je .find_devicenum ; Device is already loaded, let's find it's device number	131	je .find_devicenum ; Device is already loaded, let's find it's device number
132	.next:	132	.next:
133	add esi, 4	133	add esi, 4
134	loop .nextdevice	134	loop .nextdevice
135		135
136		136
137	; This device doesnt have its own eth_device structure yet, lets create one	137	; This device doesnt have its own eth_device structure yet, lets create one
138	.firstdevice:	138	.firstdevice:
139	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card	139	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
140	jae .fail	140	jae .fail
141		141
142	allocate_and_clear ebx, sizeof.device, .fail ; Allocate the buffer for device structure	142	allocate_and_clear ebx, sizeof.device, .fail ; Allocate the buffer for device structure
143		143
144	; Fill in the direct call addresses into the struct	144	; Fill in the direct call addresses into the struct
145		145
146	mov [ebx + device.reset], reset	146	mov [ebx + device.reset], reset
147	mov [ebx + device.transmit], transmit	147	mov [ebx + device.transmit], transmit
148	mov [ebx + device.unload], unload	148	mov [ebx + device.unload], unload
149	mov [ebx + device.name], my_service	149	mov [ebx + device.name], my_service
150		150
151	; save the pci bus and device numbers	151	; save the pci bus and device numbers
152		152
153	mov eax, [edx + IOCTL.input]	153	mov eax, [edx + IOCTL.input]
154	movzx ecx, byte [eax+1]	154	movzx ecx, byte [eax+1]
155	mov [ebx + device.pci_bus], ecx	155	mov [ebx + device.pci_bus], ecx
156	movzx ecx, byte [eax+2]	156	movzx ecx, byte [eax+2]
157	mov [ebx + device.pci_dev], ecx	157	mov [ebx + device.pci_dev], ecx
158		158
159	; Now, it's time to find the base mmio addres of the PCI device	159	; Now, it's time to find the base mmio addres of the PCI device
160		160
161	stdcall PCI_find_mmio32, [ebx + device.pci_bus], [ebx + device.pci_dev]	161	stdcall PCI_find_mmio32, [ebx + device.pci_bus], [ebx + device.pci_dev]
162		162
163	; Create virtual mapping of the physical memory	163	; Create virtual mapping of the physical memory
164		164
165	push 1Bh ; PG_SW+PG_NOCACHE	165	push 1Bh ; PG_SW+PG_NOCACHE
166	push 10000h ; size of the map	166	push 10000h ; size of the map
167	push eax	167	push eax
168	invoke MapIoMem	168	invoke MapIoMem
169	mov [ebx + device.mmio_addr], eax	169	mov [ebx + device.mmio_addr], eax
170		170
171	; We've found the mmio address, find IRQ now	171	; We've found the mmio address, find IRQ now
172		172
173	invoke PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line	173	invoke PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
174	mov [ebx + device.irq_line], al	174	mov [ebx + device.irq_line], al
175		175
176	DEBUGF 1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\	176	DEBUGF 1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
177	[ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.mmio_addr]:8	177	[ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.mmio_addr]:8
178		178
179	; Ok, the eth_device structure is ready, let's probe the device	179	; Ok, the eth_device structure is ready, let's probe the device
180	call probe ; this function will output in eax	180	call probe ; this function will output in eax
181	test eax, eax	181	test eax, eax
182	jnz .err ; If an error occured, exit	182	jnz .err ; If an error occured, exit
183		183
184	mov eax, [devices] ; Add the device structure to our device list	184	mov eax, [devices] ; Add the device structure to our device list
185	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)	185	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)
186	inc [devices] ;	186	inc [devices] ;
187		187
188	mov [ebx + device.type], NET_TYPE_ETH	188	mov [ebx + device.type], NET_TYPE_ETH
189	invoke NetRegDev	189	invoke NetRegDev
190		190
191	cmp eax, -1	191	cmp eax, -1
192	je .destroy	192	je .destroy
193		193
194	ret	194	ret
195		195
196	; If the device was already loaded, find the device number and return it in eax	196	; If the device was already loaded, find the device number and return it in eax
197		197
198	.find_devicenum:	198	.find_devicenum:
199	DEBUGF 1,"Trying to find device number of already registered device\n"	199	DEBUGF 1,"Trying to find device number of already registered device\n"
200	invoke NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx	200	invoke NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
201	; into a device number in edi	201	; into a device number in edi
202	mov eax, edi ; Application wants it in eax instead	202	mov eax, edi ; Application wants it in eax instead
203	DEBUGF 1,"Kernel says: %u\n", eax	203	DEBUGF 1,"Kernel says: %u\n", eax
204	ret	204	ret
205		205
206	; If an error occured, remove all allocated data and exit (returning -1 in eax)	206	; If an error occured, remove all allocated data and exit (returning -1 in eax)
207		207
208	.destroy:	208	.destroy:
209	; todo: reset device into virgin state	209	; todo: reset device into virgin state
210		210
211	.err:	211	.err:
212	invoke KernelFree, ebx	212	invoke KernelFree, ebx
213		213
214	.fail:	214	.fail:
215	or eax, -1	215	or eax, -1
216	ret	216	ret
217		217
218	;------------------------------------------------------	218	;------------------------------------------------------
219	endp	219	endp
220		220
221		221
222	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	222	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
223	;; ;;	223	;; ;;
224	;; Actual Hardware dependent code starts here ;;	224	;; Actual Hardware dependent code starts here ;;
225	;; ;;	225	;; ;;
226	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;	226	;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
227		227
228	unload:	228	unload:
229	; TODO: (in this particular order)	229	; TODO: (in this particular order)
230	;	230	;
231	; - Stop the device	231	; - Stop the device
232	; - Detach int handler	232	; - Detach int handler
233	; - Remove device from local list (device_list)	233	; - Remove device from local list (device_list)
234	; - call unregister function in kernel	234	; - call unregister function in kernel
235	; - Remove all allocated structures and buffers the card used	235	; - Remove all allocated structures and buffers the card used
236		236
237	or eax, -1	237	or eax, -1
238		238
239	ret	239	ret
240		240
241		241
242		242
243	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	243	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
244	;;	244	;;
245	;; probe: enables the device (if it really is BCM57XX)	245	;; probe: enables the device (if it really is BCM57XX)
246	;;	246	;;
247	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	247	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
248		248
249	probe:	249	probe:
250		250
251	DEBUGF 1,"Probe\n"	251	DEBUGF 1,"Probe\n"
252		252
253	; Make the device a bus master	253	; Make the device a bus master
254	invoke PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command	254	invoke PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
255	or al, PCI_CMD_MASTER	255	or al, PCI_CMD_MASTER
256	invoke PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax	256	invoke PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
257		257
258		258
259	; TODO: validate the device	259	; TODO: validate the device
260		260
261		261
262		262
263		263
264	reset:	264	reset:
265		265
266	DEBUGF 1,"Reset\n"	266	DEBUGF 1,"Reset\n"
267		267
268	movzx eax, [ebx + device.irq_line]	268	movzx eax, [ebx + device.irq_line]
269	DEBUGF 1,"Attaching int handler to irq %x\n", eax:1	269	DEBUGF 1,"Attaching int handler to irq %x\n", eax:1
270	invoke AttachIntHandler, eax, int_handler, ebx	270	invoke AttachIntHandler, eax, int_handler, ebx
271	test eax, eax	271	test eax, eax
272	jnz @f	272	jnz @f
273	DEBUGF 1,"\nCould not attach int handler!\n"	273	DEBUGF 1,"\nCould not attach int handler!\n"
274	; or eax, -1	274	; or eax, -1
275	; ret	275	; ret
276	@@:	276	@@:
277		277
278	call read_mac	278	call read_mac
279		279
280	; Set the mtu, kernel will be able to send now	280	; Set the mtu, kernel will be able to send now
281	mov [ebx + device.mtu], 1514	281	mov [ebx + device.mtu], 1514
282		282
283	; Set link state to unknown	283	; Set link state to unknown
284	mov [ebx + device.state], ETH_LINK_UNKNOWN	284	mov [ebx + device.state], ETH_LINK_UNKNOWN
285		285
286	ret	286	ret
287		287
288		288
289		289
290		290
291	align 4	291	align 4
292	read_mac:	292	read_mac:
293		293
294	DEBUGF 1,"Read MAC\n"	294	DEBUGF 1,"Read MAC\n"
295		295
296	mov esi, [ebx + device.mmio_addr]	296	mov esi, [ebx + device.mmio_addr]
297	lea edi, [ebx + device.mac]	297	lea edi, [ebx + device.mac]
298	movsd	298	movsd
299	movsw	299	movsw
300		300
301	.mac_ok:	301	.mac_ok:
302	DEBUGF 1,"MAC = %x-%x-%x-%x-%x-%x\n",\	302	DEBUGF 1,"MAC = %x-%x-%x-%x-%x-%x\n",\
303	[ebx + device.mac+0]: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	303	[ebx + device.mac+0]: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
304		304
305	ret	305	ret
306		306
307		307
308	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	308	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
309	;; ;;	309	;; ;;
310	;; Transmit ;;	310	;; Transmit ;;
311	;; ;;	311	;; ;;
312	;; In: buffer pointer in [esp+4] ;;	312	;; In: buffer pointer in [esp+4] ;;
313	;; size of buffer in [esp+8] ;;	313	;; size of buffer in [esp+8] ;;
314	;; pointer to device structure in ebx ;;	314	;; pointer to device structure in ebx ;;
315	;; ;;	315	;; ;;
316	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	316	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
317		317
318	proc transmit stdcall bufferptr, buffersize	318	proc transmit stdcall bufferptr, buffersize
319		319
320	pushf	320	pushf
321	cli	321	cli
322		322
323	DEBUGF 1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]	323	DEBUGF 1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
324	mov eax, [bufferptr]	324	mov eax, [bufferptr]
325	DEBUGF 1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\	325	DEBUGF 1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
326	[eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\	326	[eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
327	[eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\	327	[eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
328	[eax+13]:2,[eax+12]:2	328	[eax+13]:2,[eax+12]:2
329		329
330	cmp [buffersize], 1514	330	cmp [buffersize], 1514
331	ja .fail	331	ja .fail
332	cmp [buffersize], 60	332	cmp [buffersize], 60
333	jb .fail	333	jb .fail
334		334
335		335
336		336
337		337
338		338
339	; Update stats	339	; Update stats
340	inc [ebx + device.packets_tx]	340	inc [ebx + device.packets_tx]
341	mov eax, [buffersize]	341	mov eax, [buffersize]
342	add dword[ebx + device.bytes_tx], eax	342	add dword[ebx + device.bytes_tx], eax
343	adc dword[ebx + device.bytes_tx + 4], 0	343	adc dword[ebx + device.bytes_tx + 4], 0
344		344
345	DEBUGF 1,"Transmit OK\n"	345	DEBUGF 1,"Transmit OK\n"
346	popf	346	popf
347	xor eax, eax	347	xor eax, eax
348	ret	348	ret
349		349
350	.fail:	350	.fail:
351	DEBUGF 2,"Transmit failed\n"	351	DEBUGF 2,"Transmit failed\n"
352	invoke KernelFree, [bufferptr]	352	invoke KernelFree, [bufferptr]
353	popf	353	popf
354	or eax, -1	354	or eax, -1
355	ret	355	ret
356		356
357	endp	357	endp
358		358
359		359
360	;;;;;;;;;;;;;;;;;;;;;;;	360	;;;;;;;;;;;;;;;;;;;;;;;
361	;; ;;	361	;; ;;
362	;; Interrupt handler ;;	362	;; Interrupt handler ;;
363	;; ;;	363	;; ;;
364	;;;;;;;;;;;;;;;;;;;;;;;	364	;;;;;;;;;;;;;;;;;;;;;;;
365		365
366	align 4	366	align 4
367	int_handler:	367	int_handler:
368		368
369	push ebx esi edi	369	push ebx esi edi
370		370
371	DEBUGF 1,"INT\n"	371	DEBUGF 1,"INT\n"
372	;-------------------------------------------	372	;-------------------------------------------
373	; Find pointer of device wich made IRQ occur	373	; Find pointer of device wich made IRQ occur
374		374
375	mov ecx, [devices]	375	mov ecx, [devices]
376	test ecx, ecx	376	test ecx, ecx
377	jz .nothing	377	jz .nothing
378	mov esi, device_list	378	mov esi, device_list
379	.nextdevice:	379	.nextdevice:
380	mov ebx, [esi]	380	mov ebx, [esi]
381		381
382	; mov edi, [ebx + device.mmio_addr]	382	; mov edi, [ebx + device.mmio_addr]
383	; mov eax, [edi + REG_ICR]	383	; mov eax, [edi + REG_ICR]
384	test eax, eax	384	test eax, eax
385	jnz .got_it	385	jnz .got_it
386	.continue:	386	.continue:
387	add esi, 4	387	add esi, 4
388	dec ecx	388	dec ecx
389	jnz .nextdevice	389	jnz .nextdevice
390	.nothing:	390	.nothing:
391	pop edi esi ebx	391	pop edi esi ebx
392	xor eax, eax	392	xor eax, eax
393		393
394	ret	394	ret
395		395
396	.got_it:	396	.got_it:
397		397
398	DEBUGF 1,"Device: %x Status: %x ", ebx, eax	398	DEBUGF 1,"Device: %x Status: %x ", ebx, eax
399		399
400	pop edi esi ebx	400	pop edi esi ebx
401	xor eax, eax	401	xor eax, eax
402	inc eax	402	inc eax
403		403
404	ret	404	ret
405		405
406		406
407		407
408		408
409	; End of code	409	; End of code
410		410
411	data fixups	411	data fixups
412	end data	412	end data
413		413
414	include '../peimport.inc'	414	include '../peimport.inc'
415		415
416	my_service db 'BCM57XX',0 ; max 16 chars include zero	416	my_service db 'BCM57XX',0 ; max 16 chars include zero
417		417
418	include_debug_strings ; All data wich FDO uses will be included here	418	include_debug_strings ; All data wich FDO uses will be included here
419		419
420	align 4	420	align 4
421	devices dd 0	421	devices dd 0
422	device_list rd MAX_DEVICES ; This list contains all pointers to device structures the driver is handling	422	device_list rd MAX_DEVICES ; This list contains all pointers to device structures the driver is handling

Subversion Repositories Kolibri OS

(root)/drivers/unfinished/bcm57xx.asm – Rev 5074 → 5363