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


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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/dll.inc – Rev 444 → 462