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: 1452 $
 
 
DRV_COMPAT   equ  5  ;minimal required drivers version
DRV_CURRENT  equ  5  ;current drivers model version
 
DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
PID_KERNEL  equ 1    ;os_idle thread
 
align 4
proc attach_int_handler stdcall, irq:dword, handler:dword, access_rights:dword
 
         push ebx
 
         mov  ebx, [irq]                   ;irq num
         test ebx, ebx
         jz   .err
         cmp  ebx, 15                      ; hidnplayr says: we only have 16 IRQ's
         ja   .err
         mov  eax, [handler]
         test eax, eax
         jz   .err
         cmp  [irq_owner + 4 * ebx], 0
         je   @f
 
         mov  ecx, [irq_rights + 4 * ebx]  ; Rights : 0 - full access, 1 - read only, 2 - forbidden
         test ecx, ecx
         jnz  .err
 
@@:
         mov  [irq_tab+ebx*4], eax
 
         mov  eax, [access_rights]
         mov  [irq_rights + 4 * ebx], eax
 
         mov  [irq_owner + 4 * ebx], PID_KERNEL  ; all handlers belong to a kernel
 
         stdcall enable_irq, [irq]
         pop ebx
         mov eax, 1
         ret
.err:
         pop ebx
         xor eax, eax
         ret
endp
 
uglobal
 
	irq_rights	 rd	 16
 
endg
 
proc get_int_handler stdcall, irq:dword
 
	mov	eax, [irq]
 
	cmp	[irq_rights + 4 * eax], dword 1
	ja	.err
 
	mov	eax, [irq_tab + 4 * eax]
	ret
 
     .err:
	xor	eax, eax
	ret
 
endp
 
align 4
proc  detach_int_handler
 
	   ret
endp
 
align 4
proc enable_irq stdcall, irq_line:dword
	   mov ebx, [irq_line]
	   mov edx, 0x21
	   cmp ebx, 8
	   jb @F
	   mov edx, 0xA1
	   sub ebx,8
@@:
	   in al,dx
	   btr eax, ebx
	   out dx, al
	   ret
endp
 
align 16
;; proc irq_serv
 
irq_serv:
 
.irq_1:
	   push 1
	   jmp .main
align 4
.irq_2:
	   push 2
	   jmp .main
align 4
.irq_3:
	   push 3
	   jmp .main
align 4
.irq_4:
	   push 4
	   jmp .main
align 4
.irq_5:
	   push 5
	   jmp .main
; align 4
; .irq_6:
;	   push 6
;	   jmp .main
align 4
.irq_7:
	   push 7
	   jmp .main
align 4
.irq_8:
	   push 8
	   jmp .main
align 4
.irq_9:
	   push 9
	   jmp .main
align 4
.irq_10:
	   push 10
	   jmp .main
align 4
.irq_11:
	   push 11
	   jmp .main
align 4
.irq_12:
	   push 12
	   jmp .main
; align 4
; .irq_13:
;	   push 13
;	   jmp .main
; align 4
; .irq_14:
;	   push 14
;	   jmp .main
; align 4
; .irq_15:
;	   push 15
;	   jmp .main
 
align 16
.main:
	   save_ring3_context
	   mov	 eax, [esp + 32]
	   mov	 bx, app_data  ;os_data
	   mov	 ds, bx
	   mov	 es, bx
 
	   cmp	 [v86_irqhooks+eax*8], 0
	   jnz	 v86_irq
 
	   mov ebx, [irq_tab+eax*4]
	   test ebx, ebx
	   jz .exit
 
	   call ebx
	   mov	[check_idle_semaphore],5
 
.exit:
 
	   cmp dword [esp + 32], 8
	   mov al, 0x20
	   jb @f
	   out 0xa0, al
@@:
	   out 0x20, al
 
	   restore_ring3_context
	   add	 esp, 4
 
	   iret
 
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
	   push eax
	   lea eax, [cmd]
	   call file_system_lfn
	   pop eax
	   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
 
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
 
 
 
if 0
 
irq:
 
.irq0:
	   pusfd
	   pushad
	   push IRQ_0
	   jmp .master
.irq_1:
	   pusfd
	   pushad
	   push IRQ_1
	   jmp .master
 
.master:
	   mov ax, app_data
	   mov ds, eax
	   mov es, eax
	   mov ebx, [esp+4]  ;IRQ_xx
	   mov eax, [irq_handlers+ebx+4]
	   call intr_handler
	   mov ecx, [esp+4]
	   cmp [irq_actids+ecx*4], 0
	   je @F
	   in al, 0x21
	   bts eax, ecx
	   out 0x21, al
	   mov al, 0x20
	   out 0x20, al
	   jmp .restart
 
.slave:
	   mov ax, app_data
	   mov ds, eax
	   mov es, eax
	   mov ebx, [esp+4]  ;IRQ_xx
	   mov eax, [irq_handlers+ebx+4]
	   call intr_handler
	   mov ecx, [esp+4]
	   sub ecx, 8
	   cmp [irq_actids+ecx*4], 0
	   je @F
	   in al, 0xA1
	   bts eax, ecx
	   out 0xA1, al
	   mov al, 0x20
	   out 0xA0, al
	   out 0x20, al
.restart:
	   mov ebx, [next_slot]
	   test ebx, ebx
	   jz @F
	   mov [next_task],0
	   mov esi, [prev_slot]
	   call do_change_task
	   add esp, 4
	   iretd
 
end if

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 1345 → 1452