;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;; ETHERNET.INC ;;
;; ;;
;; Ethernet network layer for KolibriOS ;;
;; ;;
;; Written by hidnplayr@kolibrios.org ;;
;; ;;
;; GNU GENERAL PUBLIC LICENSE ;;
;; Version 2, June 1991 ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$Revision: 1473 $
MAX_ETH_DEVICES equ MAX_NET_DEVICES
ETH_QUEUE_SIZE equ 16
struct ETH_FRAME
.DstMAC dp ? ; destination MAC-address [6 bytes]
.SrcMAC dp ? ; source MAC-address [6 bytes]
.Type dw ? ; type of the upper-layer protocol [2 bytes]
.Data: ; data [46-1500 bytes]
ends
struct ETH_DEVICE
.unload dd ?
.reset dd ?
.transmit dd ?
.set_MAC dd ?
.get_MAC dd ?
.set_mode dd ?
.get_mode dd ?
.bytes_tx dq ?
.bytes_rx dq ?
.packets_tx dd ?
.packets_rx dd ?
.mode dd ? ; This dword contains cable status (10mbit/100mbit, full/half duplex, auto negotiation or not,..)
.name dd ?
.mac dp ?
ends ; the rest of the device struct depends on the type of device
struct eth_queue_entry
.owner dd ?
.data_ptr dd ?
.data_size dd ?
.size:
ends
align 4
iglobal
ETH_BROADCAST dp 0xffffffffffff
endg
align 4
uglobal
ETH_RUNNING dd ?
ETH_DRV_LIST rd MAX_ETH_DEVICES
ETH_IN_QUEUE rd 3*ETH_QUEUE_SIZE+3
if QUEUE_BEFORE_SENDING
ETH_OUT_QUEUE rd 3*ETH_QUEUE_SIZE+3
end if
endg
;-----------------------------------------------------------------
;
; ETH_init
;
; This function resets all ethernet variables
;
; IN: /
; OUT: /
;
;-----------------------------------------------------------------
align 4
ETH_init:
xor eax, eax
mov edi, ETH_RUNNING
mov ecx, (1+MAX_ETH_DEVICES)
rep stosd
init_queue ETH_IN_QUEUE
if QUEUE_BEFORE_SENDING
init_queue ETH_OUT_QUEUE
end if
ret
;-----------------------------------------------------------------
;
; ETH_Add_Device:
;
; This function is called by ethernet drivers,
; to register each running ethernet device to the kernel
;
; IN: Pointer to device structure in ebx
; OUT: Device num in eax, -1 on error
;
;-----------------------------------------------------------------
align 4
ETH_add_device:
DEBUGF 1,"ETH_Add_Device: %x ", ebx
mov eax, [ETH_RUNNING]
cmp eax, MAX_ETH_DEVICES
jge .error
test eax, eax
jnz .notfirst
mov dword [ETH_IN_QUEUE], eax
if QUEUE_BEFORE_SENDING
mov dword [ETH_OUT_QUEUE], eax
end if
.notfirst:
mov eax, ebx
mov ecx, MAX_ETH_DEVICES ; We need to check whole list because a device may be removed without re-organizing list
mov edi, ETH_DRV_LIST
repne scasd ; See if device is already in the list
jz .error
xor eax, eax
mov ecx, MAX_ETH_DEVICES
mov edi, ETH_DRV_LIST
repne scasd ; Find empty spot in the list
jnz .error
sub edi, 4
mov [edi], ebx ; add device to list
sub edi, ETH_DRV_LIST ; edi = 4*device num Calculate device number in eax
mov eax, edi ; edx = 4*device num
shr eax, 2
inc [ETH_RUNNING] ; Indicate that one more ethernet device is up and running
DEBUGF 1,"- succes: %u\n",eax
ret
.error:
or eax, -1
DEBUGF 2,"Adding ETH device failed\n"
ret
;-----------------------------------------------------------------
;
; ETH_Remove_Device:
;
; This function is called by ethernet drivers,
; to unregister ethernet devices from the kernel
;
; IN: Pointer to device structure in ebx
; OUT: eax: -1 on error
;
;-----------------------------------------------------------------
align 4
ETH_remove_device:
cmp [ETH_RUNNING], 0
je .error
mov eax, ebx
mov ecx, MAX_ETH_DEVICES
mov edi, ETH_DRV_LIST
repne scasd
jnz .error
xor eax, eax
mov dword [edi-4], eax
dec [ETH_RUNNING]
jnz .notlast
mov dword [ETH_IN_QUEUE], ETH_QUEUE_SIZE
if QUEUE_BEFORE_SENDING
mov dword [ETH_OUT_QUEUE], ETH_QUEUE_SIZE
end if
.notlast:
ret
.error:
or eax, -1
ret
;-----------------------------------------------------------------
;
; ETH_Receiver:
;
; This function is called by ethernet drivers,
; It pushes the received ethernet packets onto the eth_in_queue
;
; IN: [esp] = Pointer to buffer
; [esp-4] = size of buffer
; ebx = pointer to eth_device
; OUT: /
;
;-----------------------------------------------------------------
align 4
ETH_receiver:
; DEBUGF 1,"ETH_Receiver: "
; push ebx
; mov esi, esp
; add_to_queue ETH_IN_QUEUE, ETH_QUEUE_SIZE, eth_queue_entry.size, .fail
; DEBUGF 1,"Queued packet successfully\n"
; add esp, 4*3
;
; ret
;
; .fail:
; DEBUGF 1,"ETH_IN_QUEUE is full!\n"
; add esp, 4
; call kernel_free
; add esp, 4
;
; ret
;
;
;
;;-----------------------------------------------------------------
;;
;; ETH_Handler:
;;
;; Handles all queued eth packets (called from kernel's main_loop)
;;
;; IN: /
;; OUT: /
;;
;;-----------------------------------------------------------------
;align 4
;ETH_handler:
;
; get_from_queue ETH_IN_QUEUE, ETH_QUEUE_SIZE, eth_queue_entry.size, .gohome
;
; push ETH_handler
;
; lodsd
; mov ebx, eax
; lodsd
; mov ecx, eax
; lodsd
; xchg eax, ecx
; push ecx
; push eax
;-----------------------------
mov eax, [esp]
mov ecx, [esp+4]
;-----------------------------
DEBUGF 1,"ETH_Handler - size: %u\n", ecx
cmp ecx, 60 ; check packet length
jl .dump
sub ecx, ETH_FRAME.Data
lea edx, [eax + ETH_FRAME.Data]
mov ax , [eax + ETH_FRAME.Type]
cmp ax, ETHER_IPv4
je IPv4_handler
cmp ax, ETHER_ARP
je ARP_handler
DEBUGF 2,"Unknown ethernet packet type %x\n", ax
.dump:
DEBUGF 2,"ETH_Handler - dumping\n"
call kernel_free
add esp, 4
.gohome:
ret ; return to get more from queue / to caller
align 4
ETH_handler:
ret
;-----------------------------------------------------------------
;
; ETH_sender:
;
; This function sends an ethernet packet to the correct driver.
;
; IN: Pointer to buffer in [esp]
; size of buffer in [esp+4]
; pointer to device struct in ebx
; OUT: /
;
;-----------------------------------------------------------------
align 4
ETH_sender:
if QUEUE_BEFORE_SENDING
DEBUGF 1,"ETH_Sender: queuing for device: %x, %u bytes\n", [esp], [esp + 4]
push ebx
mov esi, esp
add_to_queue ETH_OUT_QUEUE, ETH_QUEUE_SIZE, eth_queue_entry.size, .fail
DEBUGF 1,"Queued packet successfully\n"
add esp, 3*4
ret
.fail:
DEBUGF 1,"ETH_OUT_QUEUE is full!\n"
add esp, 4
call kernel_free
add esp, 4
ret
;-----------------------------------------------------------------
;
; ETH_send_queued:
;
; IN: /
; OUT: /
;
;-----------------------------------------------------------------
align 4
ETH_send_queued:
get_from_queue ETH_OUT_QUEUE, ETH_QUEUE_SIZE, eth_queue_entry.size, .gohome
push ETH_send_queued ; this will cause the procedure to check for more packets
; when a single packet is handled
mov ebx, [esi]
pushd [esi + 8]
pushd [esi + 4]
DEBUGF 1,"dequeued packet for device %x\n", ebx
end if
call [ebx+ETH_DEVICE.transmit] ; we will return to get_from_queue macro after transmitting packet
call kernel_free
add esp, 4 ; pop (balance stack)
.gohome:
ret
;-----------------------------------------------------------------
;
; ETH_struc2dev
;
; IN: pointer to device struct in ebx
;
; OUT: edi is -1 on error, device number otherwise
;
;-----------------------------------------------------------------
align 4
ETH_struc2dev:
push ecx
mov ecx, MAX_ETH_DEVICES
mov edi, ETH_DRV_LIST
.loop:
cmp ebx, [edi]
jz .found
add edi, 4
dec ecx
jnz .loop
or edi, -1
pop ecx
ret
.found:
sub edi, ETH_DRV_LIST
shr edi, 2
pop ecx
ret
;-----------------------------------------------------------------
;
; ETH_create_packet
;
; IN: pointer to source mac in eax
; pointer to destination mac in ebx
; packet size in ecx
; device number in edx
; protocol in di
;
; OUT: edi is -1 on error, pointer to buffer otherwise
; eax points to buffer start
; ebx is pointer to device structure
; ecx is unchanged (packet size of embedded data)
; edx is size of complete buffer
; esi points to procedure wich needs to be called to send packet
;
;-----------------------------------------------------------------
align 4
ETH_create_packet:
DEBUGF 1,"Creating Ethernet Packet (size=%u): \n", ecx
cmp ecx, 1500
jg .exit
push ecx di eax ebx edx
add ecx, ETH_FRAME.Data
push ecx
push ecx
call kernel_alloc
test eax, eax
jz .pop_exit
pop ecx
pop edx
mov edi, eax
pop esi
movsd
movsw
pop esi
movsd
movsw
pop ax
stosw
lea eax, [edi - ETH_FRAME.Data] ; Set eax to buffer start
mov edx, ecx ; Set ebx to complete buffer size
pop ecx
mov esi, ETH_sender
xor ebx, ebx ;;;; TODO: Fixme
mov ebx, [ETH_DRV_LIST + ebx]
cmp edx, 46 + ETH_FRAME.Data ; If data size is less then 46, add padding bytes
jg .continue
mov edx, 46 + ETH_FRAME.Data
.continue:
DEBUGF 1,"done: %x size:%u device:%x\n", eax, edx, ebx
ret
.pop_exit:
DEBUGF 2,"Out of ram space!!\n"
add esp, 18
or edi,-1
ret
.exit:
DEBUGF 2,"Packet too large!\n"
or edi, -1
ret
;-----------------------------------------------------------------
;
; ETH_API
;
; This function is called by system function 75
;
; IN: subfunction number in bl
; device number in bh
; ecx, edx, .. depends on subfunction
;
; OUT:
;
;-----------------------------------------------------------------
align 4
ETH_API:
movzx eax, bh
shl eax, 2
test bl, bl
jz .packets_tx ; 0
dec bl
jz .packets_rx ; 1
dec bl
jz .bytes_tx ; 2
dec bl
jz .bytes_rx ; 3
dec bl
jz .read_mac ; 4
dec bl
jz .write_mac ; 5
dec bl
jz .in_queue ; 6
dec bl
jz .out_queue ; 7
.error:
mov eax, -1
ret
.packets_tx:
add eax, ETH_DRV_LIST
mov eax, dword [eax]
mov eax, dword [eax + ETH_DEVICE.packets_tx]
ret
.packets_rx:
add eax, ETH_DRV_LIST
mov eax, dword [eax]
mov eax, dword [eax + ETH_DEVICE.packets_rx]
ret
.bytes_tx:
add eax, ETH_DRV_LIST
mov eax, dword [eax]
mov ebx, dword [eax + ETH_DEVICE.bytes_tx + 4]
mov eax, dword [eax + ETH_DEVICE.bytes_tx]
mov [esp+20+4], ebx ; TODO: fix this ugly code
ret
.bytes_rx:
add eax, ETH_DRV_LIST
mov eax, dword [eax]
mov ebx, dword [eax + ETH_DEVICE.bytes_rx + 4]
mov eax, dword [eax + ETH_DEVICE.bytes_rx]
mov [esp+20+4], ebx ; TODO: fix this ugly code
ret
.read_mac:
add eax, ETH_DRV_LIST
mov eax, [eax]
; push eax
; call dword [eax + ETH_DEVICE.get_MAC]
; pop eax
movzx ebx, word [eax + ETH_DEVICE.mac]
mov eax, dword [eax + ETH_DEVICE.mac + 2]
mov [esp+20+4], ebx ; TODO: fix this ugly code
ret
.write_mac:
push ecx
push dx
add eax, ETH_DRV_LIST
mov eax, [eax]
mov eax, dword [eax + ETH_DEVICE.set_MAC]
call eax
ret
.in_queue:
add eax, ETH_IN_QUEUE
mov eax, [eax + queue.size]
ret
.out_queue:
if QUEUE_BEFORE_SENDING
add eax, ETH_OUT_QUEUE
mov eax, [eax + queue.size]
else
mov eax, -1
end if
ret