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


DRV_ENTRY    equ  1
DRV_EXIT     equ -1
DRV_COMPAT   equ  2  ;minimal required drivers version
DRV_CURRENT  equ  2  ;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, 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_TASK]
           shl ebx,8
           test dword [ebx+PROC_BASE+0xA8],EVENT_NOTIFY
	   jz @f
           and dword [ebx+PROC_BASE+0xA8], not EVENT_NOTIFY
	   mov edi, [p_ev]
	   mov dword [edi], EV_INTR
           mov eax, [ebx+PROC_BASE+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
 
align 4
proc srv_handlerEx stdcall, ioctl:dword
           mov esi, [ioctl]
           test esi, esi
           jz .err
           add esi, new_app_base
 
           mov edi, [esi+handle]
           cmp [edi+SRV.magic], ' SRV'
	   jne .fail
 
           cmp [edi+SRV.size], SRV_SIZE
	   jne .fail
 
           add [esi+input], new_app_base
           add [esi+output], new_app_base
 
           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
 
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:
           stdcall find_service, [sz_name]
           test eax, eax
           jz @F
           stdcall load_driver, eax
@@:
           ret
.ok:
           mov eax, edx
           ret
endp
 
align 4
proc find_service stdcall ,sz_name:dword
 
	   mov eax, [sz_name]
	   test eax, eax
	   jz .fail
 
           mov esi, services
@@:
           mov eax, [esi]
           test eax, eax
           jz .fail
           push esi
           stdcall strncmp, eax, [sz_name], 16
           pop esi
           test eax, eax
           je .ok
 
           add esi, 8
           jmp @B
.ok:
           mov eax, [esi+4]
           ret
.fail:
           xor eax, eax
           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]
           sub ebx, new_app_base
           sub esi, new_app_base
 
           mov [cmd], eax
           mov [offset], ecx
           mov [offset+4], eax
           mov [count], edx
           mov [buff], esi
           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 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, ebx          ;from file end
           add ecx, 4095
           and ecx, not 4095
           sub ecx, ebx
           xor eax, eax
           cld
           rep stosb
           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, file_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             start     dd ?
 
             exports   dd ?   ;fake exports table
                       dd ?
           endl
 
           stdcall load_file, [file_name]
 
           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, [file_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, [file_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, 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 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= pid
;  ebx= size
 
align 4
create_kernel_object:
 
           push ebx
           call malloc
           pop ebx
           test eax, eax
           jz .fail
 
           mov ecx,[CURRENT_TASK]
           shl ecx,8
           add ecx, PROC_BASE+APP_OBJ_OFFSET
 
           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
.fail:
           ret
 
; param
;  eax= object
 
align 4
destroy_kernel_object:
 
           mov ebx, [eax+APPOBJ.fd]
           mov ecx, [eax+APPOBJ.bk]
           mov [ebx+APPOBJ.bk], ecx
           mov [ecx+APPOBJ.fd], ebx
 
           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
 
 
drv_sound      db '/rd/1/drivers/unisound.obj', 0
drv_infinity   db '/rd/1/drivers/infinity.obj', 0
drv_hw_mouse   db '/rd/1/drivers/ati2d.obj',0
 
szSound        db 'SOUND',0
szInfinity     db 'INFINITY',0
szHwMouse      db 'HWCURSOR',0
 
szSTART        db 'START',0
szEXPORTS      db 'EXPORTS',0
szIMPORTS      db 'IMPORTS',0
 
msg_unresolved db 'unresolved ',0
msg_module     db 'in module ',0
msg_version    db 'incompatible driver version',13,10,0
msg_www        db 'please visit www.kolibrios.org',13,10,0
msg_CR         db  13,10,0
 
align 4
create_cursor    dd 0
set_hw_cursor    dd 0
hw_restore       dd 0
 
align 16
services:
           dd szSound,    drv_sound
           dd szInfinity, drv_infinity
           dd szHwMouse,  drv_hw_mouse
           dd 0

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 278 → 281