WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/core/dll.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2106 $
 
 
DRV_COMPAT   equ  5  ;minimal required drivers version
DRV_CURRENT  equ  6  ;current drivers model version
 
DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
PID_KERNEL  equ 1    ;os_idle thread
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
align 4
proc get_notify stdcall, p_ev:dword
 
.wait:
	   mov ebx,[current_slot]
	   test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
	   jz @f
	   and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
	   mov edi, [p_ev]
	   mov dword [edi], EV_INTR
	   mov eax, [ebx+APPDATA.event]
	   mov dword [edi+4], eax
	   ret
@@:
	   call change_task
	   jmp .wait
endp
 
align 4
proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
	   push ebx
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
	   mov al, 6
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   pop ebx
	   ret
endp
 
align 4
proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
	   push ebx
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
	   mov al, 5
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   pop ebx
	   ret
endp
 
align 4
proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
	   push ebx
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
	   mov al, 4
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   pop ebx
	   ret
endp
 
align 4
proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
	   push ebx
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
	   mov al, 8
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   mov ecx, [val]
	   call pci_write_reg
	   pop ebx
	   ret
endp
 
align 4
proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
	   push ebx
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
	   mov al, 9
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   mov ecx, [val]
	   call pci_write_reg
	   pop ebx
	   ret
endp
 
align 4
proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
	   push ebx
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
	   mov al, 10
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   mov ecx, [val]
	   call pci_write_reg
	   pop ebx
	   ret
endp
 
handle	   equ	IOCTL.handle
io_code    equ	IOCTL.io_code
input	   equ	IOCTL.input
inp_size   equ	IOCTL.inp_size
output	   equ	IOCTL.output
out_size   equ	IOCTL.out_size
 
 
align 4
proc srv_handler stdcall, ioctl:dword
	   mov esi, [ioctl]
	   test esi, esi
	   jz .err
 
	   mov edi, [esi+handle]
	   cmp [edi+SRV.magic], ' SRV'
	   jne .fail
 
       cmp [edi+SRV.size], SRV.sizeof
	   jne .fail
 
	   stdcall [edi+SRV.srv_proc], esi
	   ret
.fail:
	   xor eax, eax
	   not eax
	   mov [esi+output], eax
	   mov [esi+out_size], 4
	   ret
.err:
	   xor eax, eax
	   not eax
	   ret
endp
 
; param
;  ecx= io_control
;
; retval
;  eax= error code
 
align 4
srv_handlerEx:
	   cmp ecx, OS_BASE
	   jae .fail
 
	   mov eax, [ecx+handle]
	   cmp [eax+SRV.magic], ' SRV'
	   jne .fail
 
       cmp [eax+SRV.size], SRV.sizeof
	   jne .fail
 
	   stdcall [eax+SRV.srv_proc], ecx
	   ret
.fail:
	   or eax, -1
	   ret
 
restore  handle
restore  io_code
restore  input
restore  inp_size
restore  output
restore  out_size
 
align 4
proc get_service stdcall, sz_name:dword
	   mov eax, [sz_name]
	   test eax, eax
	   jnz @F
	   ret
@@:
	   mov edx, [srv.fd]
@@:
	   cmp edx, srv.fd-SRV_FD_OFFSET
	   je .not_load
 
	   stdcall strncmp, edx, [sz_name], 16
	   test eax, eax
	   je .ok
 
	   mov edx, [edx+SRV.fd]
	   jmp @B
.not_load:
	   pop ebp
	   jmp load_driver
.ok:
	   mov eax, edx
	   ret
endp
 
align 4
proc reg_service stdcall, name:dword, handler:dword
 
	   push ebx
 
           xor eax, eax
 
	   cmp [name], eax
	   je .fail
 
	   cmp [handler], eax
	   je .fail
 
       mov eax, SRV.sizeof
       call malloc
	   test eax, eax
	   jz .fail
 
	   push esi
	   push edi
	   mov edi, eax
	   mov esi, [name]
       movsd
       movsd
       movsd
       movsd
	   pop edi
	   pop esi
 
	   mov [eax+SRV.magic], ' SRV'
       mov [eax+SRV.size], SRV.sizeof
 
	   mov ebx, srv.fd-SRV_FD_OFFSET
	   mov edx, [ebx+SRV.fd]
	   mov [eax+SRV.fd], edx
	   mov [eax+SRV.bk], ebx
	   mov [ebx+SRV.fd], eax
	   mov [edx+SRV.bk], eax
 
	   mov ecx, [handler]
	   mov [eax+SRV.srv_proc], ecx
	   pop ebx
	   ret
.fail:
	   xor eax, eax
           pop ebx
	   ret
endp
 
align 4
proc get_proc stdcall, exp:dword, sz_name:dword
 
	   mov edx, [exp]
.next:
	   mov eax, [edx]
	   test eax, eax
	   jz .end
 
	   push edx
	   stdcall strncmp, eax, [sz_name], 16
	   pop edx
	   test eax, eax
	   jz .ok
 
	   add edx,8
	   jmp .next
.ok:
	   mov eax, [edx+4]
.end:
	   ret
endp
 
align 4
proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
 
@@:
	   stdcall strncmp, [pSym], [sz_sym], 8
	   test eax,eax
	   jz .ok
	   add [pSym], 18
	   dec [count]
	   jnz @b
	   xor eax, eax
	   ret
.ok:
	   mov eax, [pSym]
	   mov eax, [eax+8]
	   ret
endp
 
align 4
proc get_curr_task
	   mov eax,[CURRENT_TASK]
	   shl eax, 8
	   ret
endp
 
align 4
proc get_fileinfo stdcall, file_name:dword, info:dword
	   locals
	     cmd     dd ?
	     offset  dd ?
		     dd ?
	     count   dd ?
	     buff    dd ?
		     db ?
	     name    dd ?
	   endl
 
	   xor eax, eax
	   mov ebx, [file_name]
	   mov ecx, [info]
 
	   mov [cmd], 5
	   mov [offset], eax
	   mov [offset+4], eax
	   mov [count], eax
	   mov [buff], ecx
	   mov byte [buff+4], al
	   mov [name], ebx
 
	   mov eax, 70
	   lea ebx, [cmd]
	   int 0x40
	   ret
endp
 
align 4
proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
				     bytes:dword
	   locals
	     cmd     dd ?
	     offset  dd ?
		     dd ?
	     count   dd ?
	     buff    dd ?
		     db ?
	     name    dd ?
	   endl
 
	   xor eax, eax
	   mov ebx, [file_name]
	   mov ecx, [off]
	   mov edx, [bytes]
	   mov esi, [buffer]
 
	   mov [cmd], eax
	   mov [offset], ecx
	   mov [offset+4], eax
	   mov [count], edx
	   mov [buff], esi
	   mov byte [buff+4], al
	   mov [name], ebx
 
	   pushad
	   lea ebx, [cmd]
	   call file_system_lfn
	   popad
	   ret
endp
 
; description
;  allocate kernel memory and loads the specified file
;
; param
;  file_name= full path to file
;
; retval
;  eax= file image in kernel memory
;  ebx= size of file
;
; warging
;  You mast call kernel_free() to delete each file
;  loaded by the load_file() function
 
align 4
proc load_file stdcall, file_name:dword
	   locals
	     attr	dd ?
	     flags	dd ?
	     cr_time	dd ?
	     cr_date	dd ?
	     acc_time	dd ?
	     acc_date	dd ?
	     mod_time	dd ?
	     mod_date	dd ?
	     file_size	dd ?
 
	     file	dd ?
	     file2	dd ?
	   endl
 
	   push esi
	   push edi
 
	   lea eax, [attr]
	   stdcall get_fileinfo, [file_name], eax
	   test eax, eax
	   jnz .fail
 
	   mov eax, [file_size]
	   cmp eax, 1024*1024*16
	   ja .fail
 
	   stdcall kernel_alloc, [file_size]
	   mov [file], eax
       test eax, eax
       jz .fail
 
	   stdcall read_file, [file_name], eax, dword 0, [file_size]
	   cmp ebx, [file_size]
	   jne .cleanup
 
	   mov eax, [file]
	   cmp dword [eax], 0x4B43504B
	   jne .exit
	   mov ebx, [eax+4]
	   mov [file_size], ebx
	   stdcall kernel_alloc, ebx
 
	   test eax, eax
	   jz .cleanup
 
	   mov [file2], eax
       pushfd
       cli
	   stdcall unpack, [file], eax
       popfd
	   stdcall kernel_free, [file]
	   mov eax, [file2]
	   mov ebx, [file_size]
.exit:
	   push eax
	   lea edi, [eax+ebx]	  ;cleanup remain space
	   mov ecx, 4096	  ;from file end
	   and ebx, 4095
	   jz  @f
	   sub ecx, ebx
	   xor eax, eax
	   cld
	   rep stosb
@@:
	   mov ebx, [file_size]
	   pop eax
	   pop edi
	   pop esi
	   ret
.cleanup:
	   stdcall kernel_free, [file]
.fail:
	   xor eax, eax
	   xor ebx, ebx
	   pop edi
	   pop esi
	   ret
endp
 
align 4
proc get_proc_ex stdcall, proc_name:dword, imports:dword
 
.look_up:
	   mov edx, [imports]
	   test edx, edx
	   jz .end
	   mov edx, [edx]
	   test edx, edx
	   jz .end
.next:
	   mov eax, [edx]
	   test eax, eax
	   jz .next_table
 
	   push edx
       stdcall strncmp, eax, [proc_name], 256
	   pop edx
	   test eax, eax
	   jz .ok
 
	   add edx,8
	   jmp .next
.next_table:
	   add [imports], 4
	   jmp .look_up
.ok:
	   mov eax, [edx+4]
	   ret
.end:
	   xor eax, eax
	   ret
endp
 
align 4
proc fix_coff_symbols stdcall uses ebx esi, sec:dword, symbols:dword,\
		      sym_count:dword, strings:dword, imports:dword
	   locals
	     retval dd ?
	   endl
 
	   mov edi, [symbols]
	   mov [retval], 1
.fix:
	   movzx ebx, [edi+CSYM.SectionNumber]
	   test ebx, ebx
	   jnz .internal
	   mov eax, dword [edi+CSYM.Name]
	   test eax, eax
	   jnz @F
 
	   mov edi, [edi+4]
	   add edi, [strings]
@@:
	   push edi
	   stdcall get_proc_ex, edi,[imports]
	   pop edi
 
	   xor ebx, ebx
	   test eax, eax
	   jnz @F
 
	   mov esi, msg_unresolved
	   call sys_msg_board_str
	   mov esi, edi
	   call sys_msg_board_str
	   mov esi, msg_CR
	   call sys_msg_board_str
 
	   mov [retval],0
@@:
	   mov edi, [symbols]
	   mov [edi+CSYM.Value], eax
	   jmp .next
.internal:
	   cmp bx, -1
	   je .next
	   cmp bx, -2
	   je .next
 
	   dec ebx
	   shl ebx, 3
	   lea ebx, [ebx+ebx*4]
	   add ebx, [sec]
 
	   mov eax, [ebx+CFS.VirtualAddress]
	   add [edi+CSYM.Value], eax
.next:
	   add edi, CSYM_SIZE
	   mov [symbols], edi
	   dec [sym_count]
	   jnz .fix
	   mov eax, [retval]
	   ret
endp
 
align 4
proc fix_coff_relocs stdcall uses ebx esi, coff:dword, sym:dword, \
	delta:dword
	   locals
	     n_sec     dd ?
	   endl
 
	   mov eax, [coff]
	   movzx ebx, [eax+CFH.nSections]
	   mov [n_sec], ebx
	   lea esi, [eax+20]
.fix_sec:
	   mov edi, [esi+CFS.PtrReloc]
	   add edi, [coff]
 
	   movzx ecx, [esi+CFS.NumReloc]
	   test ecx, ecx
	   jz .next
.reloc_loop:
	   mov ebx, [edi+CRELOC.SymIndex]
	   add ebx,ebx
	   lea ebx,[ebx+ebx*8]
	   add ebx, [sym]
 
	   mov edx, [ebx+CSYM.Value]
 
	   cmp [edi+CRELOC.Type], 6
	   je .dir_32
 
	   cmp [edi+CRELOC.Type], 20
	   jne .next_reloc
.rel_32:
	   mov eax, [edi+CRELOC.VirtualAddress]
	   add eax, [esi+CFS.VirtualAddress]
	   sub edx, eax
	   sub edx, 4
	   jmp .fix
.dir_32:
	   mov eax, [edi+CRELOC.VirtualAddress]
	   add eax, [esi+CFS.VirtualAddress]
.fix:
	   add eax, [delta]
	   add [eax], edx
.next_reloc:
	   add edi, 10
	   dec ecx
	   jnz .reloc_loop
.next:
	   add esi, COFF_SECTION_SIZE
	   dec [n_sec]
	   jnz .fix_sec
.exit:
	   ret
endp
 
align 4
proc rebase_coff stdcall uses ebx esi, coff:dword, sym:dword, \
	delta:dword
	   locals
	     n_sec     dd ?
	   endl
 
	   mov eax, [coff]
	   movzx ebx, [eax+CFH.nSections]
	   mov [n_sec], ebx
	   lea esi, [eax+20]
	   mov edx, [delta]
.fix_sec:
	   mov edi, [esi+CFS.PtrReloc]
	   add edi, [coff]
 
	   movzx ecx, [esi+CFS.NumReloc]
	   test ecx, ecx
	   jz .next
.reloc_loop:
	   cmp [edi+CRELOC.Type], 6
	   jne .next_reloc
.dir_32:
	   mov eax, [edi+CRELOC.VirtualAddress]
	   add eax, [esi+CFS.VirtualAddress]
	   add [eax+edx], edx
.next_reloc:
	   add edi, 10
	   dec ecx
	   jnz .reloc_loop
.next:
	   add esi, COFF_SECTION_SIZE
	   dec [n_sec]
	   jnz .fix_sec
.exit:
	   ret
endp
 
align 4
proc load_driver stdcall, driver_name:dword
	   locals
	     coff      dd ?
	     sym       dd ?
	     strings   dd ?
	     img_size  dd ?
	     img_base  dd ?
	     start     dd ?
 
	     exports   dd ?   ;fake exports table
		       dd ?
	     file_name rb 13+16+4+1	 ; '/sys/drivers/.obj'
	   endl
 
	   lea	   edx, [file_name]
	   mov	   dword [edx], '/sys'
	   mov	   dword [edx+4], '/dri'
	   mov	   dword [edx+8], 'vers'
	   mov	   byte [edx+12], '/'
	   mov	   esi, [driver_name]
.redo:
           lea     edx, [file_name]
	   lea	   edi, [edx+13]
	   mov	   ecx, 16
@@:
	   lodsb
	   test    al, al
	   jz	   @f
	   stosb
	   loop    @b
@@:
	   mov	   dword [edi], '.obj'
	   mov	   byte [edi+4], 0
	   stdcall load_file, edx
 
	   test eax, eax
	   jz .exit
 
	   mov [coff], eax
 
	   movzx ecx, [eax+CFH.nSections]
	   xor ebx, ebx
 
	   lea edx, [eax+20]
@@:
	   add ebx, [edx+CFS.SizeOfRawData]
	   add ebx, 15
	   and ebx, not 15
	   add edx, COFF_SECTION_SIZE
	   dec ecx
	   jnz @B
	   mov [img_size], ebx
 
	   stdcall kernel_alloc, ebx
	   test eax, eax
	   jz .fail
	   mov [img_base], eax
 
	   mov edi, eax
	   xor eax, eax
	   mov ecx, [img_size]
	   add ecx, 4095
	   and ecx, not 4095
	   shr ecx, 2
	   cld
	   rep stosd
 
	   mov edx, [coff]
	   movzx ebx, [edx+CFH.nSections]
	   mov edi, [img_base]
	   lea eax, [edx+20]
@@:
	   mov [eax+CFS.VirtualAddress], edi
	   mov esi, [eax+CFS.PtrRawData]
	   test esi, esi
	   jnz .copy
	   add edi, [eax+CFS.SizeOfRawData]
	   jmp .next
.copy:
	   add esi, edx
	   mov ecx, [eax+CFS.SizeOfRawData]
	   cld
	   rep movsb
.next:
	   add edi, 15
	   and edi, not 15
	   add eax, COFF_SECTION_SIZE
	   dec ebx
	   jnz @B
 
	   mov ebx, [edx+CFH.pSymTable]
	   add ebx, edx
	   mov [sym], ebx
	   mov ecx, [edx+CFH.nSymbols]
	   add ecx,ecx
	   lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
	   add ecx, [sym]
	   mov [strings], ecx
 
	   lea ebx, [exports]
	   mov dword [ebx], kernel_export
	   mov dword [ebx+4], 0
	   lea eax, [edx+20]
 
	   stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
				     [strings], ebx
	   test eax, eax
	   jz .link_fail
 
	   mov ebx, [coff]
	   stdcall fix_coff_relocs, ebx, [sym], 0
 
	   stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
	   test eax, eax
	   jz .link_fail
 
	   mov eax, [eax]
	   shr eax, 16
	   cmp eax, DRV_COMPAT
	   jb .ver_fail
 
	   cmp eax, DRV_CURRENT
	   ja .ver_fail
 
	   mov ebx, [coff]
	   stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
	   mov [start], eax
 
	   stdcall kernel_free, [coff]
 
	   mov ebx, [start]
	   stdcall ebx, DRV_ENTRY
	   test eax, eax
	   jnz .ok
 
	   stdcall kernel_free, [img_base]
           cmp     dword [file_name+13], 'SOUN'
           jnz     @f
           cmp     dword [file_name+17], 'D.ob'
           jnz     @f
           cmp     word [file_name+21], 'j'
           jnz     @f
           mov     esi, aSis
           jmp     .redo
@@:
	   xor eax, eax
	   ret
.ok:
	   mov ebx, [img_base]
	   mov [eax+SRV.base], ebx
	   mov ecx, [start]
	   mov [eax+SRV.entry], ecx
	   ret
 
.ver_fail:
	   mov esi, msg_CR
	   call sys_msg_board_str
	   mov esi, [driver_name]
	   call sys_msg_board_str
	   mov esi, msg_CR
	   call sys_msg_board_str
	   mov esi, msg_version
	   call sys_msg_board_str
	   mov esi, msg_www
	   call sys_msg_board_str
	   jmp .cleanup
 
.link_fail:
	   mov esi, msg_module
	   call sys_msg_board_str
	   mov esi, [driver_name]
	   call sys_msg_board_str
	   mov esi, msg_CR
	   call sys_msg_board_str
.cleanup:
	   stdcall kernel_free,[img_base]
.fail:
	   stdcall kernel_free, [coff]
.exit:
	   xor eax, eax
	   ret
endp
 
; in: edx -> COFF_SECTION struct
; out: eax = alignment as mask for bits to drop
coff_get_align:
; Rules:
; - if alignment is not given, use default = 4K;
; - if alignment is given and is no more than 4K, use it;
; - if alignment is more than 4K, revert to 4K.
	push	ecx
	mov	cl, byte [edx+CFS.Characteristics+2]
	mov	eax, 1
	shr	cl, 4
	dec	cl
	js	.default
	cmp	cl, 12
	jbe	@f
.default:
	mov	cl, 12
@@:
	shl	eax, cl
	pop	ecx
	dec	eax
	ret
 
align 4
proc load_library stdcall, file_name:dword
	   locals
	     fullname  rb 260
	     fileinfo  rb 40
	     coff      dd ?
	     img_base  dd ?
	   endl
 
	   cli
 
; resolve file name
	   mov ebx, [file_name]
	   lea edi, [fullname+1]
	   mov byte [edi-1], '/'
	   stdcall get_full_file_name, edi, 259
	   test al, al
	   jz .fail
 
; scan for required DLL in list of already loaded for this process,
; ignore timestamp
	   mov esi, [CURRENT_TASK]
	   shl esi, 8
	   lea edi, [fullname]
	   mov ebx, [esi+SLOT_BASE+APPDATA.dlls_list_ptr]
	   test ebx, ebx
	   jz  .not_in_process
	   mov esi, [ebx+HDLL.fd]
.scan_in_process:
	   cmp esi, ebx
	   jz .not_in_process
	   mov eax, [esi+HDLL.parent]
	   add eax, DLLDESCR.name
	   stdcall strncmp, eax, edi, -1
	   test eax, eax
	   jnz .next_in_process
; simple variant: load DLL which is already loaded in this process
; just increment reference counters and return address of exports table
	   inc [esi+HDLL.refcount]
	   mov ecx, [esi+HDLL.parent]
	   inc [ecx+DLLDESCR.refcount]
	   mov eax, [ecx+DLLDESCR.exports]
	   sub eax, [ecx+DLLDESCR.defaultbase]
	   add eax, [esi+HDLL.base]
	   ret
.next_in_process:
	   mov esi, [esi+HDLL.fd]
	   jmp .scan_in_process
.not_in_process:
 
; scan in full list, compare timestamp
	   lea eax, [fileinfo]
	   stdcall get_fileinfo, edi, eax
	   test eax, eax
	   jnz .fail
	   mov esi, [dll_list.fd]
.scan_for_dlls:
	   cmp esi, dll_list
	   jz .load_new
	   lea eax, [esi+DLLDESCR.name]
	   stdcall strncmp, eax, edi, -1
	   test eax, eax
	   jnz .continue_scan
.test_prev_dll:
	   mov eax, dword [fileinfo+24]	; last modified time
	   mov edx, dword [fileinfo+28]	; last modified date
	   cmp dword [esi+DLLDESCR.timestamp], eax
	   jnz .continue_scan
	   cmp dword [esi+DLLDESCR.timestamp+4], edx
	   jz .dll_already_loaded
.continue_scan:
	   mov esi, [esi+DLLDESCR.fd]
	   jmp .scan_for_dlls
 
; new DLL
.load_new:
; load file
	   stdcall load_file, edi
	   test eax, eax
	   jz .fail
	   mov [coff], eax
	   mov dword [fileinfo+32], ebx
 
; allocate DLLDESCR struct; size is DLLDESCR.sizeof plus size of DLL name
	   mov esi, edi
	   mov ecx, -1
	   xor eax, eax
	   repnz scasb
	   not ecx
	   lea eax, [ecx+DLLDESCR.sizeof]
	   push ecx
	   call malloc
	   pop ecx
	   test eax, eax
	   jz .fail_and_free_coff
; save timestamp
	   lea edi, [eax+DLLDESCR.name]
	   rep movsb
	   mov esi, eax
	   mov eax, dword [fileinfo+24]
	   mov dword [esi+DLLDESCR.timestamp], eax
	   mov eax, dword [fileinfo+28]
	   mov dword [esi+DLLDESCR.timestamp+4], eax
; initialize DLLDESCR struct
	   and dword [esi+DLLDESCR.refcount], 0 ; no HDLLs yet; later it will be incremented
	   mov [esi+DLLDESCR.fd], dll_list
	   mov eax, [dll_list.bk]
	   mov [dll_list.bk], esi
	   mov [esi+DLLDESCR.bk], eax
	   mov [eax+DLLDESCR.fd], esi
 
; calculate size of loaded DLL
	   mov edx, [coff]
	   movzx ecx, [edx+CFH.nSections]
	   xor ebx, ebx
 
	   add edx, 20
@@:
	   call coff_get_align
	   add ebx, eax
	   not eax
	   and ebx, eax
	   add ebx, [edx+CFS.SizeOfRawData]
	   add edx, COFF_SECTION_SIZE
	   dec ecx
	   jnz @B
; it must be nonzero and not too big
	   mov [esi+DLLDESCR.size], ebx
	   test ebx, ebx
	   jz .fail_and_free_dll
	   cmp ebx, MAX_DEFAULT_DLL_ADDR-MIN_DEFAULT_DLL_ADDR
	   ja .fail_and_free_dll
; allocate memory for kernel-side image
	   stdcall kernel_alloc, ebx
	   test eax, eax
	   jz .fail_and_free_dll
	   mov [esi+DLLDESCR.data], eax
; calculate preferred base address
	   add ebx, 0x1FFF
	   and ebx, not 0xFFF
	   mov ecx, [dll_cur_addr]
	   lea edx, [ecx+ebx]
	   cmp edx, MAX_DEFAULT_DLL_ADDR
	   jb @f
	   mov ecx, MIN_DEFAULT_DLL_ADDR
	   lea edx, [ecx+ebx]
@@:
	   mov [esi+DLLDESCR.defaultbase], ecx
	   mov [dll_cur_addr], edx
 
; copy sections and set correct values for VirtualAddress'es in headers
	   push esi
	   mov edx, [coff]
	   movzx ebx, [edx+CFH.nSections]
	   mov edi, eax
	   add edx, 20
	   cld
@@:
	   call coff_get_align
	   add ecx, eax
	   add edi, eax
	   not eax
	   and ecx, eax
	   and edi, eax
	   mov [edx+CFS.VirtualAddress], ecx
	   add ecx, [edx+CFS.SizeOfRawData]
	   mov esi, [edx+CFS.PtrRawData]
	   push ecx
	   mov ecx, [edx+CFS.SizeOfRawData]
	   test esi, esi
	   jnz .copy
	   xor eax, eax
	   rep stosb
	   jmp .next
.copy:
	   add esi, [coff]
	   rep movsb
.next:
           pop ecx
	   add edx, COFF_SECTION_SIZE
	   dec ebx
	   jnz @B
	   pop esi
 
; save some additional data from COFF file
; later we will use COFF header, headers for sections and symbol table
; and also relocations table for all sections
	   mov edx, [coff]
	   mov ebx, [edx+CFH.pSymTable]
	   mov edi, dword [fileinfo+32]
	   sub edi, ebx
	   jc .fail_and_free_data
	   mov [esi+DLLDESCR.symbols_lim], edi
	   add ebx, edx
	   movzx ecx, [edx+CFH.nSections]
	   lea ecx, [ecx*5]
	   lea edi, [edi+ecx*8+20]
	   add edx, 20
@@:
	   movzx eax, [edx+CFS.NumReloc]
	   lea eax, [eax*5]
	   lea edi, [edi+eax*2]
	   add edx, COFF_SECTION_SIZE
	   sub ecx, 5
	   jnz @b
	   stdcall kernel_alloc, edi
	   test eax, eax
	   jz  .fail_and_free_data
	   mov edx, [coff]
	   movzx ecx, [edx+CFH.nSections]
	   lea ecx, [ecx*5]
	   lea ecx, [ecx*2+5]
	   mov [esi+DLLDESCR.coff_hdr], eax
	   push esi
	   mov esi, edx
	   mov edi, eax
	   rep movsd
	   pop esi
	   mov [esi+DLLDESCR.symbols_ptr], edi
	   push esi
	   mov ecx, [edx+CFH.nSymbols]
	   mov [esi+DLLDESCR.symbols_num], ecx
	   mov ecx, [esi+DLLDESCR.symbols_lim]
	   mov esi, ebx
	   rep movsb
	   pop esi
	   mov ebx, [esi+DLLDESCR.coff_hdr]
	   push esi
	   movzx eax, [edx+CFH.nSections]
	   lea edx, [ebx+20]
@@:
           movzx ecx, [edx+CFS.NumReloc]
           lea ecx, [ecx*5]
           mov esi, [edx+CFS.PtrReloc]
           mov [edx+CFS.PtrReloc], edi
           sub [edx+CFS.PtrReloc], ebx
           add esi, [coff]
           shr ecx, 1
           rep movsd
           adc ecx, ecx
           rep movsw
           add edx, COFF_SECTION_SIZE
           dec eax
           jnz @b
	   pop esi
 
; fixup symbols
	   mov edx, ebx
	   mov eax, [ebx+CFH.nSymbols]
	   add edx, 20
	   mov ecx, [esi+DLLDESCR.symbols_num]
	   lea ecx, [ecx*9]
	   add ecx, ecx
	   add ecx, [esi+DLLDESCR.symbols_ptr]
 
	   stdcall fix_coff_symbols, edx, [esi+DLLDESCR.symbols_ptr], eax,\
				     ecx, 0
;	   test eax, eax
;	   jnz @F
;
;@@:
 
	   stdcall get_coff_sym,[esi+DLLDESCR.symbols_ptr],[ebx+CFH.nSymbols],szEXPORTS
	   test eax, eax
	   jnz @F
 
	   stdcall get_coff_sym,[esi+DLLDESCR.symbols_ptr],[ebx+CFH.nSymbols],sz_EXPORTS
@@:
	   mov [esi+DLLDESCR.exports], eax
 
; fix relocs in the hidden copy in kernel memory to default address
; it is first fix; usually this will be enough, but second fix
; can be necessary if real load address will not equal assumption
	   mov eax, [esi+DLLDESCR.data]
	   sub eax, [esi+DLLDESCR.defaultbase]
	   stdcall fix_coff_relocs, ebx, [esi+DLLDESCR.symbols_ptr], eax
 
	   stdcall kernel_free, [coff]
 
.dll_already_loaded:
	   inc [esi+DLLDESCR.refcount]
	   push esi
	   call init_heap
	   pop  esi
 
	   mov edi, [esi+DLLDESCR.size]
	   stdcall user_alloc_at, [esi+DLLDESCR.defaultbase], edi
	   test eax, eax
	   jnz @f
	   stdcall user_alloc, edi
	   test eax, eax
	   jz  .fail_and_dereference
@@:
	   mov [img_base], eax
	   mov eax, HDLL.sizeof
	   call malloc
	   test eax, eax
	   jz  .fail_and_free_user
	   mov ebx, [CURRENT_TASK]
	   shl ebx, 5
	   mov edx, [CURRENT_TASK+ebx+TASKDATA.pid]
	   mov [eax+HDLL.pid], edx
	   push eax
	   call init_dlls_in_thread
	   pop  ebx
	   test eax, eax
	   jz  .fail_and_free_user
	   mov edx, [eax+HDLL.fd]
	   mov [ebx+HDLL.fd], edx
	   mov [ebx+HDLL.bk], eax
	   mov [eax+HDLL.fd], ebx
	   mov [edx+HDLL.bk], ebx
	   mov eax, ebx
	   mov ebx, [img_base]
	   mov [eax+HDLL.base], ebx
	   mov [eax+HDLL.size], edi
	   mov [eax+HDLL.refcount], 1
	   mov [eax+HDLL.parent], esi
	   mov edx, ebx
	   shr edx, 12
	   or dword [page_tabs+(edx-1)*4], DONT_FREE_BLOCK
; copy entries of page table from kernel-side image to usermode
; use copy-on-write for user-mode image, so map as readonly
	   xor edi, edi
	   mov ecx, [esi+DLLDESCR.data]
	   shr ecx, 12
.map_pages_loop:
	   mov eax, [page_tabs+ecx*4]
	   and eax, not 0xFFF
	   or al, PG_USER
	   xchg eax, [page_tabs+edx*4]
	   test al, 1
	   jz @f
	   call free_page
@@:
	   invlpg [ebx+edi]
	   inc ecx
	   inc edx
	   add edi, 0x1000
	   cmp edi, [esi+DLLDESCR.size]
	   jb .map_pages_loop
 
; if real user-mode base is not equal to preferred base, relocate image
	   sub ebx, [esi+DLLDESCR.defaultbase]
	   jz @f
	   stdcall rebase_coff, [esi+DLLDESCR.coff_hdr], [esi+DLLDESCR.symbols_ptr], ebx
@@:
 
	   mov eax, [esi+DLLDESCR.exports]
	   sub eax, [esi+DLLDESCR.defaultbase]
	   add eax, [img_base]
	   ret
.fail_and_free_data:
	   stdcall kernel_free, [esi+DLLDESCR.data]
.fail_and_free_dll:
	   mov eax, esi
	   call free
.fail_and_free_coff:
	   stdcall kernel_free, [coff]
.fail:
	   xor eax, eax
	   ret
.fail_and_free_user:
	   stdcall user_free, [img_base]
.fail_and_dereference:
	   mov eax, 1	; delete 1 reference
	   call dereference_dll
	   xor eax, eax
	   ret
endp
 
; initialize [APPDATA.dlls_list_ptr] for given thread
; DLL is per-process object, so APPDATA.dlls_list_ptr must be
; kept in sync for all threads of one process.
; out: eax = APPDATA.dlls_list_ptr if all is OK,
; NULL if memory allocation failed
init_dlls_in_thread:
	mov	ebx, [current_slot]
	mov	eax, [ebx+APPDATA.dlls_list_ptr]
	test	eax, eax
	jnz	.ret
	push	[ebx+APPDATA.dir_table]
	mov	eax, 8
	call	malloc
	pop	edx
	test	eax, eax
	jz	.ret
	mov	[eax], eax
	mov	[eax+4], eax
	mov	ecx, [TASK_COUNT]
	mov	ebx, SLOT_BASE+256
.set:
	cmp	[ebx+APPDATA.dir_table], edx
	jnz	@f
	mov	[ebx+APPDATA.dlls_list_ptr], eax
@@:
	add	ebx, 256
	dec	ecx
	jnz	.set
.ret:
	ret
 
; in: eax = number of references to delete, esi -> DLLDESCR struc
dereference_dll:
	sub	[esi+DLLDESCR.refcount], eax
	jnz	.ret
	mov	eax, [esi+DLLDESCR.fd]
	mov	edx, [esi+DLLDESCR.bk]
	mov	[eax+DLLDESCR.bk], edx
	mov	[edx+DLLDESCR.fd], eax
	stdcall	kernel_free, [esi+DLLDESCR.coff_hdr]
	stdcall	kernel_free, [esi+DLLDESCR.data]
	mov	eax, esi
	call	free
.ret:
	ret
 
destroy_hdll:
	push	ebx ecx esi edi
	push	eax
	mov	ebx, [eax+HDLL.base]
	mov	esi, [eax+HDLL.parent]
	mov	edx, [esi+DLLDESCR.size]
; The following actions require the context of application where HDLL is mapped.
; However, destroy_hdll can be called in the context of OS thread when
; cleaning up objects created by the application which is destroyed.
; So remember current cr3 and set it to page table of target.
	mov	eax, [ecx+APPDATA.dir_table]
; Because we cheat with cr3, disable interrupts: task switch would restore
; page table from APPDATA of current thread.
; Also set [current_slot] because it is used by user_free.
	pushf
	cli
	push	[current_slot]
	mov	[current_slot], ecx
	mov	ecx, cr3
	push	ecx
	mov	cr3, eax
	push	ebx	; argument for user_free
	mov	eax, ebx
	shr	ebx, 12
	push	ebx
	mov	esi, [esi+DLLDESCR.data]
	shr	esi, 12
.unmap_loop:
	push	eax
	mov	eax, 2
	xchg	eax, [page_tabs+ebx*4]
	mov	ecx, [page_tabs+esi*4]
	and	eax, not 0xFFF
	and	ecx, not 0xFFF
	cmp	eax, ecx
	jz	@f
	call	free_page
@@:
	pop	eax
	invlpg	[eax]
	add	eax, 0x1000
	inc	ebx
	inc	esi
	sub	edx, 0x1000
	ja	.unmap_loop
	pop	ebx
	and	dword [page_tabs+(ebx-1)*4], not DONT_FREE_BLOCK
	call	user_free
; Restore context.
	pop	eax
	mov	cr3, eax
	pop	[current_slot]
	popf
; Ok, cheating is done.
	pop	eax
	push	eax
	mov	esi, [eax+HDLL.parent]
	mov	eax, [eax+HDLL.refcount]
	call	dereference_dll
	pop	eax
	mov	edx, [eax+HDLL.bk]
	mov	ebx, [eax+HDLL.fd]
	mov	[ebx+HDLL.bk], edx
	mov	[edx+HDLL.fd], ebx
	call	free
	pop	edi esi ecx ebx
	ret
 
; ecx -> APPDATA for slot, esi = dlls_list_ptr
destroy_all_hdlls:
	test	esi, esi
	jz	.ret
.loop:
	mov	eax, [esi+HDLL.fd]
	cmp	eax, esi
	jz	free
	call	destroy_hdll
	jmp	.loop
.ret:
	ret
 
align 4
stop_all_services:
       push ebp
	   mov edx, [srv.fd]
.next:
	   cmp edx,  srv.fd-SRV_FD_OFFSET
	   je .done
	   cmp [edx+SRV.magic], ' SRV'
	   jne .next
       cmp [edx+SRV.size], SRV.sizeof
	   jne .next
 
	   mov ebx, [edx+SRV.entry]
	   mov edx, [edx+SRV.fd]
	   test ebx, ebx
	   jz .next
 
	   push edx
       mov ebp, esp
       push  0
       push -1
       call ebx
       mov esp, ebp
	   pop edx
	   jmp .next
.done:
       pop ebp
	   ret
 
; param
;  eax= size
;  ebx= pid
 
align 4
create_kernel_object:
 
	   push ebx
	   call malloc
	   pop ebx
	   test eax, eax
	   jz .fail
 
	   mov ecx,[current_slot]
	   add ecx, APP_OBJ_OFFSET
 
	   pushfd
	   cli
	   mov edx, [ecx+APPOBJ.fd]
	   mov [eax+APPOBJ.fd], edx
	   mov [eax+APPOBJ.bk], ecx
	   mov [eax+APPOBJ.pid], ebx
 
	   mov [ecx+APPOBJ.fd], eax
	   mov [edx+APPOBJ.bk], eax
	   popfd
.fail:
	   ret
 
; param
;  eax= object
 
align 4
destroy_kernel_object:
 
	   pushfd
	   cli
	   mov ebx, [eax+APPOBJ.fd]
	   mov ecx, [eax+APPOBJ.bk]
	   mov [ebx+APPOBJ.bk], ecx
	   mov [ecx+APPOBJ.fd], ebx
	   popfd
 
	   xor edx, edx        ;clear common header
	   mov [eax], edx
	   mov [eax+4], edx
	   mov [eax+8], edx
	   mov [eax+12], edx
	   mov [eax+16], edx
 
	   call free	       ;release object memory
	   ret

Rev 2050	Rev 2106
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2009. 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	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 2050 $	8	$Revision: 2106 $
9		9
10		10
11	DRV_COMPAT equ 5 ;minimal required drivers version	11	DRV_COMPAT equ 5 ;minimal required drivers version
12	DRV_CURRENT equ 5 ;current drivers model version	12	DRV_CURRENT equ 6 ;current drivers model version
13		13
14	DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT	14	DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
15	PID_KERNEL equ 1 ;os_idle thread	15	PID_KERNEL equ 1 ;os_idle thread
16		16
17		-
18	uglobal	-
19		-
20	irq_rights rd IRQ_RESERVE	-
21		-
22	endg	-
23		-
24	proc get_int_handler stdcall, irq:dword	-
25		-
26	mov eax, [irq]	-
27		-
28	cmp [irq_rights + 4 * eax], dword 1	-
29	ja .err	-
30		-
31	mov eax, [irq_tab + 4 * eax]	-
32	ret	-
33		-
34	.err:	-
35	xor eax, eax	-
36	ret	-
37		-
38	endp	-
39		-
40	align 4	-
41	proc detach_int_handler	-
42		-
43	ret	-
44	endp	-
45		-
46		-
47	align 16	-
48	;; proc irq_serv	-
49		-
50	irq_serv:	-
51		-
52	; .irq_1:	-
53	; push 1	-
54	; jmp .main	-
55	; etc...	-
56		-
57	macro irq_serv_h [num] {	-
58	forward	-
59	align 4	-
60	.irq_#num :	-
61	push num	-
62	jmp .main	-
63	}	-
64		-
65	irq_serv_h 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15	-
66		-
67	; I don`t known how to use IRQ_RESERVE	-
68	if IRQ_RESERVE > 16	-
69	irq_serv_h 16, 17, 18, 19, 20, 21, 22, 23	-
70	end if	-
71		-
72	align 16	-
73	.main:	-
74	save_ring3_context	-
75	mov ebp, [esp + 32]	-
76	mov bx, app_data ;os_data	-
77	mov ds, bx	-
78	mov es, bx	-
79		-
80	cmp [v86_irqhooks+ebp*8], 0	-
81	jnz v86_irq	-
82		-
83	cmp bp, 6	-
84	jnz @f	-
85	push ebp	-
86	call [fdc_irq_func]	-
87	pop ebp	-
88	@@:	-
89		-
90	cmp bp, 14	-
91	jnz @f	-
92	push ebp	-
93	call [irq14_func]	-
94	pop ebp	-
95	@@:	-
96	cmp bp, 15	-
97	jnz @f	-
98	push ebp	-
99	call [irq15_func]	-
100	pop ebp	-
101	@@:	-
102	bts [pending_irq_set], ebp	-
103		-
104	lea esi, [irqh_tab+ebp*8] ; esi= list head	-
105	mov ebx, esi	-
106	.next:	-
107	mov ebx, [ebx+IRQH.list.next] ; ebx= irqh pointer	-
108	cmp ebx, esi	-
109	je .done	-
110		-
111	push ebx ; FIX THIS	-
112	push edi	-
113	push esi	-
114		-
115	push [ebx+IRQH.data]	-
116	call [ebx+IRQH.handler]	-
117	add esp, 4	-
118		-
119	pop esi	-
120	pop edi	-
121	pop ebx	-
122		-
123	test eax, eax	-
124	jz .next	-
125		-
126	btr [pending_irq_set], ebp	-
127	jmp .next	-
128		-
129	.done:	-
130	btr [pending_irq_set], ebp	-
131	jnc .exit	-
132		-
133	inc [bogus_irq+ebp*4]	-
134	.exit:	-
135	mov [check_idle_semaphore],5	-
136		-
137	mov eax, ebp	-
138		-
139	call IRQ_EOI	-
140	restore_ring3_context	-
141	add esp, 4	-
142		-
143	iret	17
144		18
145	align 4	19	align 4
146	proc get_notify stdcall, p_ev:dword	20	proc get_notify stdcall, p_ev:dword
147		21
148	.wait:	22	.wait:
149	mov ebx,[current_slot]	23	mov ebx,[current_slot]
150	test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY	24	test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
151	jz @f	25	jz @f
152	and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY	26	and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
153	mov edi, [p_ev]	27	mov edi, [p_ev]
154	mov dword [edi], EV_INTR	28	mov dword [edi], EV_INTR
155	mov eax, [ebx+APPDATA.event]	29	mov eax, [ebx+APPDATA.event]
156	mov dword [edi+4], eax	30	mov dword [edi+4], eax
157	ret	31	ret
158	@@:	32	@@:
159	call change_task	33	call change_task
160	jmp .wait	34	jmp .wait
161	endp	35	endp
162		36
163	align 4	37	align 4
164	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword	38	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
165	push ebx	39	push ebx
166	xor eax, eax	40	xor eax, eax
167	xor ebx, ebx	41	xor ebx, ebx
168	mov ah, byte [bus]	42	mov ah, byte [bus]
169	mov al, 6	43	mov al, 6
170	mov bh, byte [devfn]	44	mov bh, byte [devfn]
171	mov bl, byte [reg]	45	mov bl, byte [reg]
172	call pci_read_reg	46	call pci_read_reg
173	pop ebx	47	pop ebx
174	ret	48	ret
175	endp	49	endp
176		50
177	align 4	51	align 4
178	proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword	52	proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
179	push ebx	53	push ebx
180	xor eax, eax	54	xor eax, eax
181	xor ebx, ebx	55	xor ebx, ebx
182	mov ah, byte [bus]	56	mov ah, byte [bus]
183	mov al, 5	57	mov al, 5
184	mov bh, byte [devfn]	58	mov bh, byte [devfn]
185	mov bl, byte [reg]	59	mov bl, byte [reg]
186	call pci_read_reg	60	call pci_read_reg
187	pop ebx	61	pop ebx
188	ret	62	ret
189	endp	63	endp
190		64
191	align 4	65	align 4
192	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword	66	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
193	push ebx	67	push ebx
194	xor eax, eax	68	xor eax, eax
195	xor ebx, ebx	69	xor ebx, ebx
196	mov ah, byte [bus]	70	mov ah, byte [bus]
197	mov al, 4	71	mov al, 4
198	mov bh, byte [devfn]	72	mov bh, byte [devfn]
199	mov bl, byte [reg]	73	mov bl, byte [reg]
200	call pci_read_reg	74	call pci_read_reg
201	pop ebx	75	pop ebx
202	ret	76	ret
203	endp	77	endp
204		78
205	align 4	79	align 4
206	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	80	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
207	push ebx	81	push ebx
208	xor eax, eax	82	xor eax, eax
209	xor ebx, ebx	83	xor ebx, ebx
210	mov ah, byte [bus]	84	mov ah, byte [bus]
211	mov al, 8	85	mov al, 8
212	mov bh, byte [devfn]	86	mov bh, byte [devfn]
213	mov bl, byte [reg]	87	mov bl, byte [reg]
214	mov ecx, [val]	88	mov ecx, [val]
215	call pci_write_reg	89	call pci_write_reg
216	pop ebx	90	pop ebx
217	ret	91	ret
218	endp	92	endp
219		93
220	align 4	94	align 4
221	proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	95	proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
222	push ebx	96	push ebx
223	xor eax, eax	97	xor eax, eax
224	xor ebx, ebx	98	xor ebx, ebx
225	mov ah, byte [bus]	99	mov ah, byte [bus]
226	mov al, 9	100	mov al, 9
227	mov bh, byte [devfn]	101	mov bh, byte [devfn]
228	mov bl, byte [reg]	102	mov bl, byte [reg]
229	mov ecx, [val]	103	mov ecx, [val]
230	call pci_write_reg	104	call pci_write_reg
231	pop ebx	105	pop ebx
232	ret	106	ret
233	endp	107	endp
234		108
235	align 4	109	align 4
236	proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	110	proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
237	push ebx	111	push ebx
238	xor eax, eax	112	xor eax, eax
239	xor ebx, ebx	113	xor ebx, ebx
240	mov ah, byte [bus]	114	mov ah, byte [bus]
241	mov al, 10	115	mov al, 10
242	mov bh, byte [devfn]	116	mov bh, byte [devfn]
243	mov bl, byte [reg]	117	mov bl, byte [reg]
244	mov ecx, [val]	118	mov ecx, [val]
245	call pci_write_reg	119	call pci_write_reg
246	pop ebx	120	pop ebx
247	ret	121	ret
248	endp	122	endp
249		123
250	handle equ IOCTL.handle	124	handle equ IOCTL.handle
251	io_code equ IOCTL.io_code	125	io_code equ IOCTL.io_code
252	input equ IOCTL.input	126	input equ IOCTL.input
253	inp_size equ IOCTL.inp_size	127	inp_size equ IOCTL.inp_size
254	output equ IOCTL.output	128	output equ IOCTL.output
255	out_size equ IOCTL.out_size	129	out_size equ IOCTL.out_size
256		130
257		131
258	align 4	132	align 4
259	proc srv_handler stdcall, ioctl:dword	133	proc srv_handler stdcall, ioctl:dword
260	mov esi, [ioctl]	134	mov esi, [ioctl]
261	test esi, esi	135	test esi, esi
262	jz .err	136	jz .err
263		137
264	mov edi, [esi+handle]	138	mov edi, [esi+handle]
265	cmp [edi+SRV.magic], ' SRV'	139	cmp [edi+SRV.magic], ' SRV'
266	jne .fail	140	jne .fail
267		141
268	cmp [edi+SRV.size], SRV.sizeof	142	cmp [edi+SRV.size], SRV.sizeof
269	jne .fail	143	jne .fail
270		144
271	stdcall [edi+SRV.srv_proc], esi	145	stdcall [edi+SRV.srv_proc], esi
272	ret	146	ret
273	.fail:	147	.fail:
274	xor eax, eax	148	xor eax, eax
275	not eax	149	not eax
276	mov [esi+output], eax	150	mov [esi+output], eax
277	mov [esi+out_size], 4	151	mov [esi+out_size], 4
278	ret	152	ret
279	.err:	153	.err:
280	xor eax, eax	154	xor eax, eax
281	not eax	155	not eax
282	ret	156	ret
283	endp	157	endp
284		158
285	; param	159	; param
286	; ecx= io_control	160	; ecx= io_control
287	;	161	;
288	; retval	162	; retval
289	; eax= error code	163	; eax= error code
290		164
291	align 4	165	align 4
292	srv_handlerEx:	166	srv_handlerEx:
293	cmp ecx, OS_BASE	167	cmp ecx, OS_BASE
294	jae .fail	168	jae .fail
295		169
296	mov eax, [ecx+handle]	170	mov eax, [ecx+handle]
297	cmp [eax+SRV.magic], ' SRV'	171	cmp [eax+SRV.magic], ' SRV'
298	jne .fail	172	jne .fail
299		173
300	cmp [eax+SRV.size], SRV.sizeof	174	cmp [eax+SRV.size], SRV.sizeof
301	jne .fail	175	jne .fail
302		176
303	stdcall [eax+SRV.srv_proc], ecx	177	stdcall [eax+SRV.srv_proc], ecx
304	ret	178	ret
305	.fail:	179	.fail:
306	or eax, -1	180	or eax, -1
307	ret	181	ret
308		182
309	restore handle	183	restore handle
310	restore io_code	184	restore io_code
311	restore input	185	restore input
312	restore inp_size	186	restore inp_size
313	restore output	187	restore output
314	restore out_size	188	restore out_size
315		189
316	align 4	190	align 4
317	proc get_service stdcall, sz_name:dword	191	proc get_service stdcall, sz_name:dword
318	mov eax, [sz_name]	192	mov eax, [sz_name]
319	test eax, eax	193	test eax, eax
320	jnz @F	194	jnz @F
321	ret	195	ret
322	@@:	196	@@:
323	mov edx, [srv.fd]	197	mov edx, [srv.fd]
324	@@:	198	@@:
325	cmp edx, srv.fd-SRV_FD_OFFSET	199	cmp edx, srv.fd-SRV_FD_OFFSET
326	je .not_load	200	je .not_load
327		201
328	stdcall strncmp, edx, [sz_name], 16	202	stdcall strncmp, edx, [sz_name], 16
329	test eax, eax	203	test eax, eax
330	je .ok	204	je .ok
331		205
332	mov edx, [edx+SRV.fd]	206	mov edx, [edx+SRV.fd]
333	jmp @B	207	jmp @B
334	.not_load:	208	.not_load:
335	pop ebp	209	pop ebp
336	jmp load_driver	210	jmp load_driver
337	.ok:	211	.ok:
338	mov eax, edx	212	mov eax, edx
339	ret	213	ret
340	endp	214	endp
341		215
342	align 4	216	align 4
343	proc reg_service stdcall, name:dword, handler:dword	217	proc reg_service stdcall, name:dword, handler:dword
344		218
345	push ebx	219	push ebx
346		220
347	xor eax, eax	221	xor eax, eax
348		222
349	cmp [name], eax	223	cmp [name], eax
350	je .fail	224	je .fail
351		225
352	cmp [handler], eax	226	cmp [handler], eax
353	je .fail	227	je .fail
354		228
355	mov eax, SRV.sizeof	229	mov eax, SRV.sizeof
356	call malloc	230	call malloc
357	test eax, eax	231	test eax, eax
358	jz .fail	232	jz .fail
359		233
360	push esi	234	push esi
361	push edi	235	push edi
362	mov edi, eax	236	mov edi, eax
363	mov esi, [name]	237	mov esi, [name]
364	movsd	238	movsd
365	movsd	239	movsd
366	movsd	240	movsd
367	movsd	241	movsd
368	pop edi	242	pop edi
369	pop esi	243	pop esi
370		244
371	mov [eax+SRV.magic], ' SRV'	245	mov [eax+SRV.magic], ' SRV'
372	mov [eax+SRV.size], SRV.sizeof	246	mov [eax+SRV.size], SRV.sizeof
373		247
374	mov ebx, srv.fd-SRV_FD_OFFSET	248	mov ebx, srv.fd-SRV_FD_OFFSET
375	mov edx, [ebx+SRV.fd]	249	mov edx, [ebx+SRV.fd]
376	mov [eax+SRV.fd], edx	250	mov [eax+SRV.fd], edx
377	mov [eax+SRV.bk], ebx	251	mov [eax+SRV.bk], ebx
378	mov [ebx+SRV.fd], eax	252	mov [ebx+SRV.fd], eax
379	mov [edx+SRV.bk], eax	253	mov [edx+SRV.bk], eax
380		254
381	mov ecx, [handler]	255	mov ecx, [handler]
382	mov [eax+SRV.srv_proc], ecx	256	mov [eax+SRV.srv_proc], ecx
383	pop ebx	257	pop ebx
384	ret	258	ret
385	.fail:	259	.fail:
386	xor eax, eax	260	xor eax, eax
387	pop ebx	261	pop ebx
388	ret	262	ret
389	endp	263	endp
390		264
391	align 4	265	align 4
392	proc get_proc stdcall, exp:dword, sz_name:dword	266	proc get_proc stdcall, exp:dword, sz_name:dword
393		267
394	mov edx, [exp]	268	mov edx, [exp]
395	.next:	269	.next:
396	mov eax, [edx]	270	mov eax, [edx]
397	test eax, eax	271	test eax, eax
398	jz .end	272	jz .end
399		273
400	push edx	274	push edx
401	stdcall strncmp, eax, [sz_name], 16	275	stdcall strncmp, eax, [sz_name], 16
402	pop edx	276	pop edx
403	test eax, eax	277	test eax, eax
404	jz .ok	278	jz .ok
405		279
406	add edx,8	280	add edx,8
407	jmp .next	281	jmp .next
408	.ok:	282	.ok:
409	mov eax, [edx+4]	283	mov eax, [edx+4]
410	.end:	284	.end:
411	ret	285	ret
412	endp	286	endp
413		287
414	align 4	288	align 4
415	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	289	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
416		290
417	@@:	291	@@:
418	stdcall strncmp, [pSym], [sz_sym], 8	292	stdcall strncmp, [pSym], [sz_sym], 8
419	test eax,eax	293	test eax,eax
420	jz .ok	294	jz .ok
421	add [pSym], 18	295	add [pSym], 18
422	dec [count]	296	dec [count]
423	jnz @b	297	jnz @b
424	xor eax, eax	298	xor eax, eax
425	ret	299	ret
426	.ok:	300	.ok:
427	mov eax, [pSym]	301	mov eax, [pSym]
428	mov eax, [eax+8]	302	mov eax, [eax+8]
429	ret	303	ret
430	endp	304	endp
431		305
432	align 4	306	align 4
433	proc get_curr_task	307	proc get_curr_task
434	mov eax,[CURRENT_TASK]	308	mov eax,[CURRENT_TASK]
435	shl eax, 8	309	shl eax, 8
436	ret	310	ret
437	endp	311	endp
438		312
439	align 4	313	align 4
440	proc get_fileinfo stdcall, file_name:dword, info:dword	314	proc get_fileinfo stdcall, file_name:dword, info:dword
441	locals	315	locals
442	cmd dd ?	316	cmd dd ?
443	offset dd ?	317	offset dd ?
444	dd ?	318	dd ?
445	count dd ?	319	count dd ?
446	buff dd ?	320	buff dd ?
447	db ?	321	db ?
448	name dd ?	322	name dd ?
449	endl	323	endl
450		324
451	xor eax, eax	325	xor eax, eax
452	mov ebx, [file_name]	326	mov ebx, [file_name]
453	mov ecx, [info]	327	mov ecx, [info]
454		328
455	mov [cmd], 5	329	mov [cmd], 5
456	mov [offset], eax	330	mov [offset], eax
457	mov [offset+4], eax	331	mov [offset+4], eax
458	mov [count], eax	332	mov [count], eax
459	mov [buff], ecx	333	mov [buff], ecx
460	mov byte [buff+4], al	334	mov byte [buff+4], al
461	mov [name], ebx	335	mov [name], ebx
462		336
463	mov eax, 70	337	mov eax, 70
464	lea ebx, [cmd]	338	lea ebx, [cmd]
465	int 0x40	339	int 0x40
466	ret	340	ret
467	endp	341	endp
468		342
469	align 4	343	align 4
470	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\	344	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
471	bytes:dword	345	bytes:dword
472	locals	346	locals
473	cmd dd ?	347	cmd dd ?
474	offset dd ?	348	offset dd ?
475	dd ?	349	dd ?
476	count dd ?	350	count dd ?
477	buff dd ?	351	buff dd ?
478	db ?	352	db ?
479	name dd ?	353	name dd ?
480	endl	354	endl
481		355
482	xor eax, eax	356	xor eax, eax
483	mov ebx, [file_name]	357	mov ebx, [file_name]
484	mov ecx, [off]	358	mov ecx, [off]
485	mov edx, [bytes]	359	mov edx, [bytes]
486	mov esi, [buffer]	360	mov esi, [buffer]
487		361
488	mov [cmd], eax	362	mov [cmd], eax
489	mov [offset], ecx	363	mov [offset], ecx
490	mov [offset+4], eax	364	mov [offset+4], eax
491	mov [count], edx	365	mov [count], edx
492	mov [buff], esi	366	mov [buff], esi
493	mov byte [buff+4], al	367	mov byte [buff+4], al
494	mov [name], ebx	368	mov [name], ebx
495		369
496	pushad	370	pushad
497	lea ebx, [cmd]	371	lea ebx, [cmd]
498	call file_system_lfn	372	call file_system_lfn
499	popad	373	popad
500	ret	374	ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/dll.inc – Rev 2050 → 2106