WebSVN – Kolibri OS – Diff – /kernel/trunk/core/dll.inc


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 2103 → 2112