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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 1992 → 2089