Sweetbread/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Issues Pull Requests Actions Activity

Replaced signed relative jumps with unsigned ones were needed.

Browse Source 
(I must lose this bad habbit in 2013...)

git-svn-id: svn://kolibrios.org@3155 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
hidnplayr 2013-01-10 17:35:32 +00:00
parent 1dfb449935
commit efb37b3598
12 changed files with 336 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
kernel/branches/net/drivers/3c59x.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; 3Com network driver for KolibriOS ;; ;; 3Com network driver for KolibriOS ;;
@ -374,7 +374,7 @@ proc START stdcall, state:dword
.entry: .entry:
DEBUGF 1,"Loading 3com network driver\n" DEBUGF 1,"Loading %s driver\n", my_service
stdcall RegService, my_service, service_proc stdcall RegService, my_service, service_proc
ret ret
@ -408,7 +408,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -421,7 +421,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -465,7 +465,7 @@ proc service_proc stdcall, ioctl:dword
mov ecx, [BOOMERANG_DEVICES] mov ecx, [BOOMERANG_DEVICES]
add ecx, [VORTEX_DEVICES] add ecx, [VORTEX_DEVICES]
cmp ecx, MAX_DEVICES ; First check if the driver can handle one more card cmp ecx, MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure
@ -2270,7 +2270,7 @@ boomerang_transmit:
[eax+13]:2,[eax+12]:2 [eax+13]:2,[eax+12]:2
cmp dword [esp+8], MAX_ETH_FRAME_SIZE cmp dword [esp+8], MAX_ETH_FRAME_SIZE
jg .fail ja .fail
call check_tx_status call check_tx_status
@ -2280,7 +2280,7 @@ boomerang_transmit:
add esi, dpd.size add esi, dpd.size
lea ecx, [device.dpd_buffer + (NUM_TX_DESC)*dpd.size] lea ecx, [device.dpd_buffer + (NUM_TX_DESC)*dpd.size]
cmp esi, ecx cmp esi, ecx
jl @f jb @f
lea esi, [device.dpd_buffer] ; Wrap if needed lea esi, [device.dpd_buffer] ; Wrap if needed
@@: @@:
DEBUGF 1,"Found a free DPD: %x\n", esi DEBUGF 1,"Found a free DPD: %x\n", esi
@ -2740,7 +2740,7 @@ int_boomerang:
add esi, upd.size add esi, upd.size
lea ecx, [device.upd_buffer+(NUM_RX_DESC)*upd.size] lea ecx, [device.upd_buffer+(NUM_RX_DESC)*upd.size]
cmp esi, ecx cmp esi, ecx
jl @f jb @f
lea esi, [device.upd_buffer] lea esi, [device.upd_buffer]
@@: @@:
mov [device.curr_upd], esi mov [device.curr_upd], esi

16
kernel/branches/net/drivers/R6040.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; R6040 driver for KolibriOS ;; ;; R6040 driver for KolibriOS ;;
@ -224,7 +224,7 @@ proc START stdcall, state:dword
.entry: .entry:
DEBUGF 2,"Loading R6040 driver\n" DEBUGF 2,"Loading %s driver\n", my_service
stdcall RegService, my_service, service_proc stdcall RegService, my_service, service_proc
ret ret
@ -255,7 +255,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -268,7 +268,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -294,7 +294,7 @@ proc service_proc stdcall, ioctl:dword
; This device doesnt have its own eth_device structure yet, lets create one ; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure
@ -756,9 +756,9 @@ transmit:
[eax+13]:2,[eax+12]:2 [eax+13]:2,[eax+12]:2
cmp dword [esp+8], 1514 cmp dword [esp+8], 1514
jg .fail ja .fail
cmp dword [esp+8], 60 cmp dword [esp+8], 60
jl .fail jb .fail
movzx edi, [device.cur_tx] movzx edi, [device.cur_tx]
shl edi, 5 shl edi, 5
@ -813,7 +813,7 @@ transmit:
call Sleep call Sleep
call GetTimerTicks call GetTimerTicks
cmp edx, eax cmp edx, eax
jl .l2 jb .l2
DEBUGF 1,"Send timeout\n" DEBUGF 1,"Send timeout\n"
xor eax, eax xor eax, eax

20
kernel/branches/net/drivers/RTL8029.asm
View File

@ -198,7 +198,7 @@ proc service_proc stdcall, ioctl:dword
jne @F ;--------------- jne @F ;---------------
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -215,12 +215,12 @@ proc service_proc stdcall, ioctl:dword
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp [IOCTL.inp_size], 3 cmp [IOCTL.inp_size], 3
jl .fail jb .fail
cmp byte [eax], 1 cmp byte [eax], 1
je .pci je .pci
cmp [IOCTL.inp_size], 4 cmp [IOCTL.inp_size], 4
jl .fail jb .fail
cmp byte [eax], 0 cmp byte [eax], 0
je .isa je .isa
@ -674,9 +674,9 @@ transmit:
[esi+0]:2,[esi+1]:2,[esi+2]:2,[esi+3]:2,[esi+4]:2,[esi+5]:2,[esi+6]:2,[esi+7]:2,[esi+8]:2,[esi+9]:2,[esi+10]:2,[esi+11]:2,[esi+13]:2,[esi+12]:2 [esi+0]:2,[esi+1]:2,[esi+2]:2,[esi+3]:2,[esi+4]:2,[esi+5]:2,[esi+6]:2,[esi+7]:2,[esi+8]:2,[esi+9]:2,[esi+10]:2,[esi+11]:2,[esi+13]:2,[esi+12]:2
cmp ecx, ETH_FRAME_LEN cmp ecx, ETH_FRAME_LEN
jg .err ; packet is too long ja .err ; packet is too long
cmp ecx, ETH_ZLEN cmp ecx, ETH_ZLEN
jl .err ; packet is too short jb .err ; packet is too short
movzx edi, [device.tx_start] movzx edi, [device.tx_start]
shl edi, 8 shl edi, 8
@ -1171,11 +1171,11 @@ devices dd 0
version dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF) version dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
my_service db 'RTL8029/ne2000',0 ;max 16 chars include zero my_service db 'RTL8029/ne2000',0 ;max 16 chars include zero
device_1 db 'Realtek 8029',0 ;device_1 db 'Realtek 8029',0
device_2 db 'Realtek 8019',0 ;device_2 db 'Realtek 8019',0
device_3 db 'Realtek 8019AS',0 ;device_3 db 'Realtek 8019AS',0
device_4 db 'ne2000',0 ;device_4 db 'ne2000',0
device_5 db 'DP8390',0 ;device_5 db 'DP8390',0
include_debug_strings include_debug_strings

235
kernel/branches/net/drivers/RTL8139.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; Realtek 8139 driver for KolibriOS ;; ;; Realtek 8139 driver for KolibriOS ;;
@ -23,14 +23,16 @@ format MS COFF
MAX_DEVICES = 16 MAX_DEVICES = 16
RBLEN = 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k RBLEN = 3 ; Receive buffer size: 0==8K 1==16k 2==32k 3==64k
NUM_TX_DESC = 4
DEBUG = 1 DEBUG = 1
__DEBUG__ = 1 __DEBUG__ = 1
__DEBUG_LEVEL__ = 2 __DEBUG_LEVEL__ = 1
include 'proc32.inc' include 'proc32.inc'
include 'imports.inc' include 'imports.inc'
include 'fdo.inc' include 'fdo.inc'
include '../struct.inc'
include 'netdrv.inc' include 'netdrv.inc'
public START public START
@ -135,8 +137,7 @@ public version
(1 shl BIT_AM) ; Accept multicast packets (1 shl BIT_AM) ; Accept multicast packets
RX_BUFFER_SIZE = (8192 shl RBLEN);+16 RX_BUFFER_SIZE = (8192 shl RBLEN);+16
MAX_ETH_FRAME_SIZE = 1516 ; exactly 1514 wthout CRC MAX_ETH_FRAME_SIZE = 1514
NUM_TX_DESC = 4
EE_93C46_REG_ETH_ID = 7 ; MAC offset EE_93C46_REG_ETH_ID = 7 ; MAC offset
EE_93C46_READ_CMD = (6 shl 6) ; 110b + 6bit address EE_93C46_READ_CMD = (6 shl 6) ; 110b + 6bit address
@ -237,7 +238,7 @@ proc START stdcall, state:dword
.entry: .entry:
DEBUGF 2,"Loading rtl8139 driver\n" DEBUGF 2, "Loading %s driver\n", my_service
stdcall RegService, my_service, service_proc stdcall RegService, my_service, service_proc
ret ret
@ -268,7 +269,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -281,7 +282,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -306,7 +307,7 @@ proc service_proc stdcall, ioctl:dword
; This device doesnt have its own eth_device structure yet, lets create one ; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure
@ -322,9 +323,9 @@ proc service_proc stdcall, ioctl:dword
; save the pci bus and device numbers ; save the pci bus and device numbers
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
mov cl , [eax+1] mov cl, [eax+1]
mov [device.pci_bus], cl mov [device.pci_bus], cl
mov cl , [eax+2] mov cl, [eax+2]
mov [device.pci_dev], cl mov [device.pci_dev], cl
; Now, it's time to find the base io addres of the PCI device ; Now, it's time to find the base io addres of the PCI device
@ -335,7 +336,7 @@ proc service_proc stdcall, ioctl:dword
find_irq [device.pci_bus], [device.pci_dev], [device.irq_line] find_irq [device.pci_bus], [device.pci_dev], [device.irq_line]
DEBUGF 2,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\ DEBUGF 2, "Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4 [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
; Allocate the receive buffer ; Allocate the receive buffer
@ -366,11 +367,11 @@ proc service_proc stdcall, ioctl:dword
; If the device was already loaded, find the device number and return it in eax ; If the device was already loaded, find the device number and return it in eax
.find_devicenum: .find_devicenum:
DEBUGF 2,"Trying to find device number of already registered device\n" DEBUGF 2, "Trying to find device number of already registered device\n"
call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx call NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
; into a device number in edi ; into a device number in edi
mov eax, edi ; Application wants it in eax instead mov eax, edi ; Application wants it in eax instead
DEBUGF 2,"Kernel says: %u\n", eax DEBUGF 2, "Kernel says: %u\n", eax
ret ret
; If an error occured, remove all allocated data and exit (returning -1 in eax) ; If an error occured, remove all allocated data and exit (returning -1 in eax)
@ -379,7 +380,7 @@ proc service_proc stdcall, ioctl:dword
; todo: reset device into virgin state ; todo: reset device into virgin state
.err: .err:
stdcall KernelFree, dword [device.rx_buffer] stdcall KernelFree, [device.rx_buffer]
stdcall KernelFree, ebx stdcall KernelFree, ebx
.fail: .fail:
@ -406,7 +407,7 @@ unload:
; - call unregister function in kernel ; - call unregister function in kernel
; - Remove all allocated structures and buffers the card used ; - Remove all allocated structures and buffers the card used
or eax,-1 or eax, -1
ret ret
@ -419,7 +420,7 @@ ret
align 4 align 4
probe: probe:
DEBUGF 2,"Probing rtl8139 device: " DEBUGF 2, "Probing %s device\n", my_service
make_bus_master [device.pci_bus], [device.pci_dev] make_bus_master [device.pci_bus], [device.pci_dev]
@ -427,14 +428,14 @@ probe:
set_io 0 set_io 0
set_io REG_TXCONFIG + 2 set_io REG_TXCONFIG + 2
in ax , dx in ax, dx
shr ah , 2 shr ah, 2
shr ax , 6 shr ax, 6
and al , 01111111b and al, 01111111b
mov ecx, HW_VER_ARRAY_SIZE-1 mov ecx, HW_VER_ARRAY_SIZE-1
.chip_ver_loop: .chip_ver_loop:
cmp al , [hw_ver_array + ecx] cmp al, [hw_ver_array + ecx]
je .chip_ver_found je .chip_ver_found
dec ecx dec ecx
jns .chip_ver_loop jns .chip_ver_loop
@ -442,65 +443,65 @@ probe:
mov ecx, 8 mov ecx, 8
.chip_ver_found: .chip_ver_found:
cmp ecx, 8 cmp ecx, 8
jg .unknown ja .unknown
mov [device.hw_ver_id], cl mov [device.hw_ver_id], cl
mov ecx, [crosslist + ecx*4] mov ecx, [crosslist+ecx*4]
mov [device.name], ecx mov [device.name], ecx
DEBUGF 2,"Chip version: %s\n", ecx DEBUGF 2, "Chip version: %s\n", ecx
; wake up the chip ; wake up the chip
set_io 0 set_io 0
set_io REG_HLTCLK set_io REG_HLTCLK
mov al , 'R' ; run the clock mov al, 'R' ; run the clock
out dx , al out dx, al
; unlock config and BMCR registers ; unlock config and BMCR registers
set_io REG_9346CR set_io REG_9346CR
mov al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0) mov al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
out dx , al out dx, al
; enable power management ; enable power management
set_io REG_CONFIG1 set_io REG_CONFIG1
in al , dx in al, dx
cmp [device.hw_ver_id], IDX_RTL8139B cmp [device.hw_ver_id], IDX_RTL8139B
jl .old_chip jb .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. ; this signal is used to inform the motherboard to execute a wake-up process.
; only at newer chips. ; only at newer chips.
or al , (1 shl BIT_PMEn) or al, (1 shl BIT_PMEn)
and al , not (1 shl BIT_LWACT) and al, not (1 shl BIT_LWACT)
out dx , al out dx, al
set_io REG_CONFIG4 set_io REG_CONFIG4
in al , dx in al, dx
and al , not (1 shl BIT_LWPTN) and al, not (1 shl BIT_LWPTN)
out dx , al out dx, al
jmp .finish_wake_up jmp .finish_wake_up
.old_chip: .old_chip:
; wake up older chips ; wake up older chips
and al , not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN)) and al, not ((1 shl BIT_SLEEP) or (1 shl BIT_PWRDWN))
out dx , al out dx, al
.finish_wake_up: .finish_wake_up:
; lock config and BMCR registers ; lock config and BMCR registers
xor al , al xor al, al
set_io 0 set_io 0
set_io REG_9346CR set_io REG_9346CR
out dx , al out dx, al
DEBUGF 2,"done!\n" DEBUGF 2, "done!\n"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -510,23 +511,23 @@ probe:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
reset: reset:
DEBUGF 2,"Resetting rtl8139\n" DEBUGF 2, "Resetting\n"
; attach int handler ; attach int handler
movzx eax, [device.irq_line] movzx eax, [device.irq_line]
DEBUGF 1,"Attaching int handler to irq %x, ",eax:1 DEBUGF 1, "Attaching int handler to irq %x, ", eax:1
stdcall AttachIntHandler, eax, int_handler, dword 0 stdcall AttachIntHandler, eax, int_handler, dword 0
test eax, eax test eax, eax
jnz @f jnz @f
DEBUGF 1,"\nCould not attach int handler!\n" DEBUGF 1, "\nCould not attach int handler!\n"
; or eax, -1 ; or eax, -1
; ret ; ret
@@: @@:
; reset chip ; reset chip
DEBUGF 1,"Resetting chip\n" DEBUGF 1, "Resetting chip\n"
set_io 0 set_io 0
set_io REG_COMMAND set_io REG_COMMAND
mov al , 1 shl BIT_RST mov al , 1 shl BIT_RST
@ -543,56 +544,56 @@ reset:
; unlock config and BMCR registers ; unlock config and BMCR registers
set_io REG_9346CR set_io REG_9346CR
mov al , (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0) mov al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
out dx , al out dx, al
; initialize multicast registers (no filtering) ; initialize multicast registers (no filtering)
mov eax, 0xffffffff mov eax, 0xffffffff
set_io REG_MAR0 set_io REG_MAR0
out dx , eax out dx, eax
set_io REG_MAR4 set_io REG_MAR4
out dx , eax out dx, eax
; enable Rx/Tx ; enable Rx/Tx
mov al , (1 shl BIT_RE) or (1 shl BIT_TE) mov al, (1 shl BIT_RE) or (1 shl BIT_TE)
set_io REG_COMMAND set_io REG_COMMAND
out dx , al out dx, al
; Rxbuffer size, unlimited dma burst, no wrapping, no rx threshold ; Rxbuffer size, 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 set_io REG_RXCONFIG
out dx , ax out dx, ax
; 1024 bytes DMA burst, total retries = 16 + 8 * 16 = 144 ; 1024 bytes DMA burst, total retries = 16 + 8 * 16 = 144
mov eax , (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0 mov eax, (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0
set_io REG_TXCONFIG set_io REG_TXCONFIG
out dx , eax out dx, eax
; enable auto negotiation ; enable auto negotiation
set_io REG_BMCR set_io REG_BMCR
in ax , dx in ax, dx
or ax , (1 shl BIT_ANE) or ax, (1 shl BIT_ANE)
out dx , ax out dx, ax
; set auto negotiation advertisement ; set auto negotiation advertisement
set_io REG_ANAR set_io REG_ANAR
in ax , dx 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) 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 out dx, ax
; lock config and BMCR registers ; lock config and BMCR registers
xor eax, eax xor eax, eax
set_io REG_9346CR set_io REG_9346CR
out dx , al out dx, al
; init RX/TX pointers ; init RX/TX pointers
@ -600,7 +601,7 @@ reset:
mov [device.curr_tx_desc], al mov [device.curr_tx_desc], al
; set_io REG_CAPR ; set_io REG_CAPR
; out dx , ax ; out dx, ax
; clear packet/byte counters ; clear packet/byte counters
@ -611,17 +612,17 @@ reset:
; clear missing packet counter ; clear missing packet counter
set_io REG_MPC set_io REG_MPC
out dx , eax out dx, eax
; set RxBuffer address, init RX buffer offset ; set RxBuffer address, init RX buffer offset
mov eax, [device.rx_buffer] mov eax, [device.rx_buffer]
mov dword[eax], 0 mov dword[eax], 0
DEBUGF 2,"RX buffer: %x\n", eax DEBUGF 2, "RX buffer: %x\n", eax
GetRealAddr GetRealAddr
DEBUGF 2,"RX buffer: %x\n", eax DEBUGF 2, "RX buffer: %x\n", eax
set_io REG_RBSTART set_io REG_RBSTART
out dx , eax out dx, eax
; Read MAC address ; Read MAC address
@ -639,7 +640,7 @@ reset:
; Indicate that we have successfully reset the card ; Indicate that we have successfully reset the card
DEBUGF 2,"Done!\n" DEBUGF 2, "Done!\n"
xor eax, eax xor eax, eax
ret ret
@ -656,9 +657,9 @@ reset:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4 align 4
transmit: transmit:
DEBUGF 1,"\nTransmitting packet, buffer:%x, size:%u\n",[esp+4],[esp+8] DEBUGF 1, "\nTransmitting packet, buffer:%x, size:%u\n", [esp+4], [esp+8]
mov eax, [esp+4] mov eax, [esp+4]
DEBUGF 1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\ DEBUGF 1, "To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
[eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\ [eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
[eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\ [eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
[eax+13]:2,[eax+12]:2 [eax+13]:2,[eax+12]:2
@ -687,7 +688,7 @@ transmit:
inc [device.packets_tx] inc [device.packets_tx]
mov eax, [esp+8] mov eax, [esp+8]
add dword [device.bytes_tx], eax add dword [device.bytes_tx], eax
adc dword [device.bytes_tx + 4], 0 adc dword [device.bytes_tx+4], 0
; Set the buffer address ; Set the buffer address
set_io REG_TSAD0 set_io REG_TSAD0
@ -702,12 +703,12 @@ transmit:
or eax, (ERTXTH shl BIT_ERTXTH) ; Early threshold or eax, (ERTXTH shl BIT_ERTXTH) ; Early threshold
out dx, eax out dx, eax
DEBUGF 1,"Packet Sent!\n" DEBUGF 1, "Packet Sent!\n"
xor eax, eax xor eax, eax
ret 8 ret 8
.wait_to_send: .wait_to_send:
DEBUGF 1,"Waiting for timeout\n" DEBUGF 1, "Waiting for timeout\n"
push edx push edx
mov esi, 30 mov esi, 30
@ -725,7 +726,7 @@ transmit:
jmp .send_packet jmp .send_packet
.fail: .fail:
DEBUGF 1,"failed!\n" DEBUGF 1, "failed!\n"
stdcall KernelFree, [esp+4] stdcall KernelFree, [esp+4]
or eax, -1 or eax, -1
ret 8 ret 8
@ -743,7 +744,7 @@ transmit:
align 4 align 4
int_handler: int_handler:
DEBUGF 1,"\n%s int\n", my_service DEBUGF 1, "\n%s int\n", my_service
; find pointer of device wich made IRQ occur ; find pointer of device wich made IRQ occur
@ -769,7 +770,7 @@ int_handler:
.got_it: .got_it:
DEBUGF 1,"Device: %x Status: %x ", ebx, ax DEBUGF 1, "Device: %x Status: %x\n", ebx, ax
;---------------------------------------------------- ;----------------------------------------------------
; Received packet ok? ; Received packet ok?
@ -785,7 +786,7 @@ int_handler:
test al , BUFE ; test if RX buffer is empty test al , BUFE ; test if RX buffer is empty
jnz .finish ; jnz .finish ;
DEBUGF 1,"RX: " DEBUGF 1, "RX: "
mov eax, [device.rx_buffer] mov eax, [device.rx_buffer]
add eax, [device.rx_data_offset] add eax, [device.rx_data_offset]
@ -802,7 +803,7 @@ int_handler:
adc dword [device.bytes_rx + 4], 0 adc dword [device.bytes_rx + 4], 0
inc dword [device.packets_rx] inc dword [device.packets_rx]
DEBUGF 1,"Received %u bytes\n", ecx DEBUGF 1, "Received %u bytes\n", ecx
push ebx eax ecx push ebx eax ecx
stdcall KernelAlloc, ecx ; Allocate a buffer to put packet into stdcall KernelAlloc, ecx ; Allocate a buffer to put packet into
@ -842,12 +843,12 @@ int_handler:
and eax, not 3 ; dword alignment and eax, not 3 ; dword alignment
cmp eax, RX_BUFFER_SIZE cmp eax, RX_BUFFER_SIZE
jl .no_wrap jb .no_wrap
DEBUGF 2,"Wrapping" DEBUGF 2, "Wrapping"
sub eax, RX_BUFFER_SIZE sub eax, RX_BUFFER_SIZE
.no_wrap: .no_wrap:
mov [device.rx_data_offset], eax mov [device.rx_data_offset], eax
DEBUGF 1,"New RX ptr: %d\n", eax DEBUGF 1, "New RX ptr: %d\n", eax
set_io 0 set_io 0
set_io REG_CAPR ; update 'Current Address of Packet Read register' set_io REG_CAPR ; update 'Current Address of Packet Read register'
@ -859,27 +860,27 @@ int_handler:
.reset_rx: .reset_rx:
test byte [eax], (1 shl BIT_CRC) test byte [eax], (1 shl BIT_CRC)
jz .no_crc_error jz .no_crc_error
DEBUGF 2,"\nCRC error!\n" DEBUGF 2, "\nCRC error!\n"
.no_crc_error: .no_crc_error:
test byte [eax], (1 shl BIT_FAE) test byte [eax], (1 shl BIT_FAE)
jz .no_fae_error jz .no_fae_error
DEBUGF 1,"\nFrame alignment error!\n" DEBUGF 1, "\nFrame alignment error!\n"
.no_fae_error: .no_fae_error:
DEBUGF 1,"Reset RX\n" DEBUGF 1, "Reset RX\n"
in al , dx ; read command register in al, dx ; read command register
push ax push ax
and al , not (1 shl BIT_RE) ; Clear the RE bit and al, not (1 shl BIT_RE) ; Clear the RE bit
out dx , al out dx, al
pop ax pop ax
out dx , al ; write original command back out dx, al ; write original command back
add edx, REG_RXCONFIG - REG_COMMAND ; Restore RX configuration add edx, REG_RXCONFIG - REG_COMMAND ; Restore RX configuration
mov ax , RX_CONFIG mov ax, RX_CONFIG
out dx , ax out dx, ax
.finish: .finish:
pop ax pop ax
@ -891,8 +892,8 @@ int_handler:
jz @f jz @f
push ax push ax
xor ecx, ecx mov ecx, (NUM_TX_DESC-1)*4
.txdesloop: .txdescloop:
set_io 0 set_io 0
set_io REG_TSD0 set_io REG_TSD0
add edx, ecx add edx, ecx
@ -926,16 +927,15 @@ int_handler:
; ;
; .nocsl: ; .nocsl:
DEBUGF 1,"TX OK: free buffer %x\n", [device.TX_DESC+ecx]:8 DEBUGF 1, "TX OK: free buffer %x\n", [device.TX_DESC+ecx]:8
push ecx ebx push ecx ebx
stdcall KernelFree, [device.TX_DESC+ecx] stdcall KernelFree, [device.TX_DESC+ecx]
pop ebx ecx pop ebx ecx
mov [device.TX_DESC+ecx], 0 mov [device.TX_DESC+ecx], 0
.notthisone: .notthisone:
add ecx, 4 sub ecx, 4
cmp ecx, 16 ja .txdescloop
jl .txdesloop
pop ax pop ax
;---------------------------------------------------- ;----------------------------------------------------
@ -945,12 +945,12 @@ int_handler:
jz @f jz @f
push ax push ax
DEBUGF 2,"RX-buffer overflow!\n" DEBUGF 2, "RX-buffer overflow!\n"
set_io 0 set_io 0
set_io REG_ISR set_io REG_ISR
mov ax , ISR_FIFOOVW or ISR_RXOVW mov ax, ISR_FIFOOVW or ISR_RXOVW
out dx , ax out dx, ax
pop ax pop ax
;---------------------------------------------------- ;----------------------------------------------------
@ -959,7 +959,7 @@ int_handler:
test ax, ISR_PUN test ax, ISR_PUN
jz @f jz @f
DEBUGF 2,"Packet underrun!\n" DEBUGF 2, "Packet underrun!\n"
;---------------------------------------------------- ;----------------------------------------------------
; Receive FIFO overflow ? ; Receive FIFO overflow ?
@ -968,12 +968,12 @@ int_handler:
jz @f jz @f
push ax push ax
DEBUGF 2,"RX fifo overflow!\n" DEBUGF 2, "RX fifo overflow!\n"
set_io 0 set_io 0
set_io REG_ISR set_io REG_ISR
mov ax , ISR_FIFOOVW or ISR_RXOVW mov ax, ISR_FIFOOVW or ISR_RXOVW
out dx , ax out dx, ax
pop ax pop ax
;---------------------------------------------------- ;----------------------------------------------------
@ -982,10 +982,11 @@ int_handler:
test ax, ISR_LENCHG test ax, ISR_LENCHG
jz .fail jz .fail
DEBUGF 2,"Cable changed!\n" DEBUGF 2, "Cable changed!\n"
call cable call cable
.fail: .fail:
DEBUGF 2, "\n"
ret ret
@ -999,7 +1000,7 @@ int_handler:
align 4 align 4
cable: cable:
DEBUGF 1,"Checking Cable status: " DEBUGF 1, "Checking Cable status: "
mov edx, dword [device.io_addr] mov edx, dword [device.io_addr]
add edx, REG_MSR add edx, REG_MSR
@ -1015,7 +1016,7 @@ cable:
and al, 3 and al, 3
mov byte [device.mode+3], al mov byte [device.mode+3], al
DEBUGF 1,"Done!\n" DEBUGF 1, "Done!\n"
ret ret
@ -1029,47 +1030,47 @@ ret
align 4 align 4
write_mac: ; in: mac pushed onto stack (as 3 words) write_mac: ; in: mac pushed onto stack (as 3 words)
DEBUGF 2,"Writing MAC: " DEBUGF 2, "Writing MAC: "
; disable all in command registers ; disable all in command registers
set_io 0 set_io 0
set_io REG_9346CR set_io REG_9346CR
xor eax, eax xor eax, eax
out dx , al out dx, al
set_io REG_IMR set_io REG_IMR
xor eax, eax xor eax, eax
out dx , ax out dx, ax
set_io REG_ISR set_io REG_ISR
mov eax, -1 mov eax, -1
out dx , ax out dx, ax
; enable writing ; enable writing
set_io REG_9346CR set_io REG_9346CR
mov eax, REG_9346CR_WE mov eax, REG_9346CR_WE
out dx , al out dx, al
; write the mac ... ; write the mac ...
set_io REG_IDR0 set_io REG_IDR0
pop eax pop eax
out dx , eax out dx, eax
set_io REG_IDR0+4 set_io REG_IDR0+4
xor eax, eax xor eax, eax
pop ax pop ax
out dx , eax out dx, eax
; disable writing ; disable writing
set_io REG_9346CR set_io REG_9346CR
xor eax, eax xor eax, eax
out dx , al out dx, al
DEBUGF 2,"ok!\n" DEBUGF 2, "ok!\n"
; Notice this procedure does not ret, but continues to read_mac instead. ; Notice this procedure does not ret, but continues to read_mac instead.
@ -1081,7 +1082,7 @@ write_mac: ; in: mac pushed onto stack (as 3 words)
;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;
read_mac: read_mac:
DEBUGF 2,"Reading MAC: " DEBUGF 2, "Reading MAC: "
set_io 0 set_io 0
lea edi, [device.mac] lea edi, [device.mac]
@ -1091,7 +1092,7 @@ read_mac:
in ax, dx in ax, dx
stosw stosw
DEBUGF 2,"%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2 DEBUGF 2, "%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2
ret ret

12
kernel/branches/net/drivers/RTL8169.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; RTL8169 driver for KolibriOS ;; ;; RTL8169 driver for KolibriOS ;;
@ -8,9 +8,7 @@
;; Copyright 2007 mike.dld, ;; ;; Copyright 2007 mike.dld, ;;
;; mike.dld@gmail.com ;; ;; mike.dld@gmail.com ;;
;; ;; ;; ;;
;; Version 0.1 11 February 2007 ;; ;; port to net branch by hidnplayr ;;
;; Version 0.2 3 August 2010 - port to net branch by hidnplayr ;;
;; Version 0.3 31 Januari 2011 - bugfixes by hidnplayr ;;
;; ;; ;; ;;
;; References: ;; ;; References: ;;
;; r8169.c - linux driver (etherboot project) ;; ;; r8169.c - linux driver (etherboot project) ;;
@ -414,7 +412,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -427,7 +425,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -453,7 +451,7 @@ proc service_proc stdcall, ioctl:dword
; This device doesnt have its own eth_device structure yet, lets create one ; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, device_size, .fail ; Allocate memory to put the device structure in allocate_and_clear ebx, device_size, .fail ; Allocate memory to put the device structure in

14
kernel/branches/net/drivers/dec21x4x.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; DEC 21x4x driver for KolibriOS ;; ;; DEC 21x4x driver for KolibriOS ;;
@ -351,7 +351,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -364,7 +364,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -390,7 +390,7 @@ proc service_proc stdcall, ioctl:dword
; This device doesnt have its own eth_device structure yet, lets create one ; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
push edx push edx
stdcall KernelAlloc, dword device.size ; Allocate the buffer for eth_device structure stdcall KernelAlloc, dword device.size ; Allocate the buffer for eth_device structure
@ -1085,7 +1085,7 @@ int_handler:
; inc free desc ; inc free desc
inc [device.tx_free_des] inc [device.tx_free_des]
cmp [device.tx_free_des], TX_DES_COUNT cmp [device.tx_free_des], TX_DES_COUNT
jle @f jbe @f
mov [device.tx_free_des], TX_DES_COUNT mov [device.tx_free_des], TX_DES_COUNT
@@: @@:
@ -1239,7 +1239,7 @@ read_mac_eeprom:
stosw stosw
inc esi inc esi
cmp esi, 26/2 cmp esi, 26/2
jl .loop jb .loop
DEBUGF 2,"%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2 DEBUGF 2,"%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2
@ -1297,7 +1297,7 @@ SROM_GetWidth: ; should be 6 or 8 according to some manuals (returns in ecx)
inc ecx inc ecx
cmp ecx, 12 cmp ecx, 12
jle .loop2 jbe .loop2
.end_loop2: .end_loop2:
DEBUGF 1,"Srom width=%u\n", ecx DEBUGF 1,"Srom width=%u\n", ecx

24
kernel/branches/net/drivers/i8254x.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; i8254x driver for KolibriOS ;; ;; i8254x driver for KolibriOS ;;
@ -166,7 +166,7 @@ MDIC_E = 0x40000000 ; Error
ICR_TXDW = 0x00000001 ; TX Desc Written back ICR_TXDW = 0x00000001 ; TX Desc Written back
ICR_TXQE = 0x00000002 ; TX Queue Empty ICR_TXQE = 0x00000002 ; TX Queue Empty
ICR_LSC = 0x00000004 ; Link Status Change ICR_LSC = 0x00000004 ; Link Status Change
ICR_RXSEQ = 0x00000008 ; RX S= ence Error ICR_RXSEQ = 0x00000008 ; RX Sence Error
ICR_RXDMT0 = 0x00000010 ; RX Desc min threshold reached ICR_RXDMT0 = 0x00000010 ; RX Desc min threshold reached
ICR_RXO = 0x00000040 ; RX Overrun ICR_RXO = 0x00000040 ; RX Overrun
ICR_RXT0 = 0x00000080 ; RX Timer Interrupt ICR_RXT0 = 0x00000080 ; RX Timer Interrupt
@ -324,7 +324,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -337,7 +337,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -366,7 +366,7 @@ proc service_proc stdcall, ioctl:dword
; This device doesnt have its own eth_device structure yet, lets create one ; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, sizeof.device_struct, .fail ; Allocate the buffer for device structure allocate_and_clear ebx, sizeof.device_struct, .fail ; Allocate the buffer for device structure
@ -569,6 +569,10 @@ reset_dontstart:
xor eax, eax xor eax, eax
ret ret
align 4
reset:
call reset_dontstart
start_i8254x: start_i8254x:
xor eax, eax xor eax, eax
@ -584,12 +588,6 @@ start_i8254x:
xor eax, eax xor eax, eax
ret ret
align 4
reset:
call reset_dontstart
call start_i8254x
ret
@ -652,9 +650,9 @@ transmit:
[eax+13]:2,[eax+12]:2 [eax+13]:2,[eax+12]:2
cmp dword [esp + 8], 1514 cmp dword [esp + 8], 1514
jg .fail ja .fail
cmp dword [esp + 8], 60 cmp dword [esp + 8], 60
jl .fail jb .fail
; Program the descriptor (use legacy mode) ; Program the descriptor (use legacy mode)

10
kernel/branches/net/drivers/i8255x.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; i8255x (Intel eepro 100) driver for KolibriOS ;; ;; i8255x (Intel eepro 100) driver for KolibriOS ;;
@ -217,7 +217,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -230,7 +230,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -594,9 +594,9 @@ transmit:
[eax+13]:2,[eax+12]:2 [eax+13]:2,[eax+12]:2
cmp dword [esp+8], 1500 cmp dword [esp+8], 1500
jg .error ; packet is too long ja .error ; packet is too long
cmp dword [esp+8], 60 cmp dword [esp+8], 60
jl .error ; packet is too short jb .error ; packet is too short
set_io 0 set_io 0
in ax, dx in ax, dx

10
kernel/branches/net/drivers/mtd80x.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; MTD80x driver for KolibriOS ;; ;; MTD80x driver for KolibriOS ;;
@ -325,7 +325,7 @@ proc START stdcall, state:dword
.entry: .entry:
DEBUGF 2,"Loading mtd80x driver\n" DEBUGF 2,"Loading %s driver\n", my_service
stdcall RegService, my_service, service_proc stdcall RegService, my_service, service_proc
ret ret
@ -356,7 +356,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -369,7 +369,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -395,7 +395,7 @@ proc service_proc stdcall, ioctl:dword
; This device doesnt have its own eth_device structure yet, lets create one ; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, device_size, .fail allocate_and_clear ebx, device_size, .fail

20
kernel/branches/net/drivers/pcnet32.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; PCnet driver for KolibriOS ;; ;; PCnet driver for KolibriOS ;;
@ -14,7 +14,7 @@
;; ;; ;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $Revision$ $Revision$
format MS COFF format MS COFF
@ -365,7 +365,7 @@ proc START stdcall, state:dword
.entry: .entry:
DEBUGF 1,"Loading PCnet driver\n" DEBUGF 1,"Loading %s driver\n", my_service
stdcall RegService, my_service, service_proc stdcall RegService, my_service, service_proc
ret ret
@ -396,7 +396,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -409,7 +409,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -435,7 +435,7 @@ proc service_proc stdcall, ioctl:dword
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, device_size, .fail allocate_and_clear ebx, device_size, .fail
@ -955,9 +955,9 @@ transmit:
[eax+13]:2,[eax+12]:2 [eax+13]:2,[eax+12]:2
cmp dword [esp+8], 1514 cmp dword [esp+8], 1514
jg .nospace ; packet is too long ja .nospace ; packet is too long
cmp dword [esp+8], 60 cmp dword [esp+8], 60
jl .nospace ; packet is too short jb .nospace ; packet is too short
; check descriptor ; check descriptor
movzx eax, [device.cur_tx] movzx eax, [device.cur_tx]
@ -1161,7 +1161,7 @@ write_mac: ; in: mac pushed onto stack (as 3 words)
DEBUGF 1,"." DEBUGF 1,"."
inc ecx inc ecx
cmp ecx, PCNET_CSR_PAR2 cmp ecx, PCNET_CSR_PAR2
jl @r jb @r
DEBUGF 1,"\n" DEBUGF 1,"\n"
@ -1185,7 +1185,7 @@ read_mac:
push ax push ax
DEBUGF 1,"." DEBUGF 1,"."
cmp edx, [device.io_addr] cmp edx, [device.io_addr]
jg @r ja @r
DEBUGF 1," %x-%x-%x-%x-%x-%x\n",[esp+0]:2,[esp+1]:2,[esp+2]:2,[esp+3]:2,[esp+4]:2,[esp+5]:2 DEBUGF 1," %x-%x-%x-%x-%x-%x\n",[esp+0]:2,[esp+1]:2,[esp+2]:2,[esp+3]:2,[esp+4]:2,[esp+5]:2

8
kernel/branches/net/drivers/rhine.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2010-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; rhine.asm ;; ;; rhine.asm ;;
@ -584,7 +584,7 @@ proc service_proc stdcall, ioctl:dword
jne @F jne @F
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -597,7 +597,7 @@ proc service_proc stdcall, ioctl:dword
jne .fail jne .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail jb .fail
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
@ -623,7 +623,7 @@ proc service_proc stdcall, ioctl:dword
; This device doesnt have its own eth_device structure yet, lets create one ; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice: .firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail jae .fail
allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure allocate_and_clear ebx, device.size, .fail ; Allocate the buffer for device structure

8
kernel/branches/net/drivers/sis900.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; Ethernet driver for KolibriOS ;; ;; Ethernet driver for KolibriOS ;;
@ -271,7 +271,7 @@ service_proc:
; 3. This is SRV_GETVERSION request, no input, 4 bytes output, API_VERSION. ; 3. This is SRV_GETVERSION request, no input, 4 bytes output, API_VERSION.
; 3a. Output size must be at least 4 bytes. ; 3a. Output size must be at least 4 bytes.
cmp [IOCTL.out_size], 4 cmp [IOCTL.out_size], 4
jl .fail jb .fail
; 3b. Write result to the output buffer. ; 3b. Write result to the output buffer.
mov eax, [IOCTL.output] mov eax, [IOCTL.output]
mov [eax], dword API_VERSION mov [eax], dword API_VERSION
@ -285,7 +285,7 @@ service_proc:
; 4a. The driver works only with PCI devices, ; 4a. The driver works only with PCI devices,
; so input must be at least 3 bytes long. ; so input must be at least 3 bytes long.
cmp [IOCTL.inp_size], 3 cmp [IOCTL.inp_size], 3
jl .fail jb .fail
; 4b. First byte of input is bus type, 1 stands for PCI. ; 4b. First byte of input is bus type, 1 stands for PCI.
mov eax, [IOCTL.input] mov eax, [IOCTL.input]
cmp byte [eax], 1 cmp byte [eax], 1
@ -313,7 +313,7 @@ service_proc:
.firstdevice: .firstdevice:
; 4f. Check that we have place for new device. ; 4f. Check that we have place for new device.
cmp [devices], MAX_DEVICES cmp [devices], MAX_DEVICES
jge .fail jae .fail
; 4g. Allocate memory for device descriptor and receive+transmit buffers. ; 4g. Allocate memory for device descriptor and receive+transmit buffers.
; 4h. Zero the structure. ; 4h. Zero the structure.
allocate_and_clear ebx, device.size, .fail allocate_and_clear ebx, device.size, .fail