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


DRV_ENTRY    equ  1
DRV_EXIT     equ -1
DRV_COMPAT   equ  3  ;minimal required drivers version
DRV_CURRENT  equ  3  ;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
 
; param
;  ebx= io_control
;
; retval
;  eax= error code
 
align 4
srv_handlerEx:
 
           test ebx, ebx
           jz .fail
           add ebx, new_app_base
 
           mov eax, [ebx+handle]
           cmp [eax+SRV.magic], ' SRV'
	   jne .fail
 
           cmp [eax+SRV.size], SRV_SIZE
	   jne .fail
 
           add [ebx+input], new_app_base
           add [ebx+output], new_app_base
 
 
 
 
 
 
 
 
           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]
           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
 
; 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, 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= size
;  ebx= pid
 
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
 
           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
 
 
;szSound        db 'SOUND',0
;szInfinity     db 'INFINITY',0
szHwMouse      db 'ATI2D',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

Rev 363	Rev 377
1	DRV_ENTRY equ 1	1	DRV_ENTRY equ 1
2	DRV_EXIT equ -1	2	DRV_EXIT equ -1
3	DRV_COMPAT equ 3 ;minimal required drivers version	3	DRV_COMPAT equ 3 ;minimal required drivers version
4	DRV_CURRENT equ 3 ;current drivers model version	4	DRV_CURRENT equ 3 ;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	; param
-		244	; ebx= io_control
-		245	;
-		246	; retval
-		247	; eax= error code
-		248
243	align 4	249	align 4
244	proc srv_handlerEx stdcall, ioctl:dword	250	srv_handlerEx:
245	mov esi, [ioctl]	-
246	test esi, esi	251	test ebx, ebx
247	jz .err	252	jz .fail
248	add esi, new_app_base	253	add ebx, new_app_base
249		254
250	mov edi, [esi+handle]	255	mov eax, [ebx+handle]
251	cmp [edi+SRV.magic], ' SRV'	256	cmp [eax+SRV.magic], ' SRV'
252	jne .fail	257	jne .fail
253		258
254	cmp [edi+SRV.size], SRV_SIZE	259	cmp [eax+SRV.size], SRV_SIZE
255	jne .fail	260	jne .fail
256		261
257	add [esi+input], new_app_base	262	add [ebx+input], new_app_base
258	add [esi+output], new_app_base	263	add [ebx+output], new_app_base
259		264
260	stdcall [edi+SRV.srv_proc], esi	-
261	ret	-
262	.fail:	-
263	xor eax, eax	-
264	not eax	-
265	mov [esi+output], eax	-
266	mov [esi+out_size], 4	-
267	ret	265	stdcall [eax+SRV.srv_proc], ebx
268	.err:	-
269	xor eax, eax	266	ret
270	not eax	267	.fail:
271	ret	268	or eax, -1
272	endp	269	ret
273		270
274	restore handle	271	restore handle
275	restore io_code	272	restore io_code
276	restore input	273	restore input
277	restore inp_size	274	restore inp_size
278	restore output	275	restore output
279	restore out_size	276	restore out_size
280		277
281	align 4	278	align 4
282	proc get_service stdcall, sz_name:dword	279	proc get_service stdcall, sz_name:dword
283	mov eax, [sz_name]	280	mov eax, [sz_name]
284	test eax, eax	281	test eax, eax
285	jnz @F	282	jnz @F
286	ret	283	ret
287	@@:	284	@@:
288	mov edx, [srv.fd]	285	mov edx, [srv.fd]
289	@@:	286	@@:
290	cmp edx, srv.fd-SRV_FD_OFFSET	287	cmp edx, srv.fd-SRV_FD_OFFSET
291	je .not_load	288	je .not_load
292		289
293	stdcall strncmp, edx, [sz_name], 16	290	stdcall strncmp, edx, [sz_name], 16
294	test eax, eax	291	test eax, eax
295	je .ok	292	je .ok
296		293
297	mov edx, [edx+SRV.fd]	294	mov edx, [edx+SRV.fd]
298	jmp @B	295	jmp @B
299	.not_load:	296	.not_load:
300	pop ebp	297	pop ebp
301	jmp load_driver	298	jmp load_driver
302	.ok:	299	.ok:
303	mov eax, edx	300	mov eax, edx
304	ret	301	ret
305	endp	302	endp
306		303
307	align 4	304	align 4
308	reg_service:	305	reg_service:
309	.sz_name equ esp+4	306	.sz_name equ esp+4
310	.handler equ esp+8	307	.handler equ esp+8
311	mov eax, [.sz_name]	308	mov eax, [.sz_name]
312	test eax, eax	309	test eax, eax
313	jz .fail	310	jz .fail
314		311
315	mov ebx, [.handler]	312	mov ebx, [.handler]
316	test ebx, ebx	313	test ebx, ebx
317	jz .fail	314	jz .fail
318		315
319	mov eax, SRV_SIZE	316	mov eax, SRV_SIZE
320	call malloc ;call alloc_service	317	call malloc ;call alloc_service
321	test eax, eax	318	test eax, eax
322	jz .fail	319	jz .fail
323		320
324	mov edi, eax	321	mov edi, eax
325	mov esi, [.sz_name]	322	mov esi, [.sz_name]
326	mov ecx, 16/4	323	mov ecx, 16/4
327	rep movsd	324	rep movsd
328		325
329	mov [eax+SRV.magic], ' SRV'	326	mov [eax+SRV.magic], ' SRV'
330	mov [eax+SRV.size], SRV_SIZE	327	mov [eax+SRV.size], SRV_SIZE
331		328
332	mov ebx, srv.fd-SRV_FD_OFFSET	329	mov ebx, srv.fd-SRV_FD_OFFSET
333	mov edx, [ebx+SRV.fd]	330	mov edx, [ebx+SRV.fd]
334	mov [eax+SRV.fd], edx	331	mov [eax+SRV.fd], edx
335	mov [eax+SRV.bk], ebx	332	mov [eax+SRV.bk], ebx
336	mov [ebx+SRV.fd], eax	333	mov [ebx+SRV.fd], eax
337	mov [edx+SRV.bk], eax	334	mov [edx+SRV.bk], eax
338		335
339	mov ecx, [.handler]	336	mov ecx, [.handler]
340	mov [eax+SRV.srv_proc], ecx	337	mov [eax+SRV.srv_proc], ecx
341	ret 8	338	ret 8
342	.fail:	339	.fail:
343	xor eax, eax	340	xor eax, eax
344	ret 8	341	ret 8
345		342
346	align 4	343	align 4
347	proc get_proc stdcall, exp:dword, sz_name:dword	344	proc get_proc stdcall, exp:dword, sz_name:dword
348		345
349	mov edx, [exp]	346	mov edx, [exp]
350	.next:	347	.next:
351	mov eax, [edx]	348	mov eax, [edx]
352	test eax, eax	349	test eax, eax
353	jz .end	350	jz .end
354		351
355	push edx	352	push edx
356	stdcall strncmp, eax, [sz_name], 16	353	stdcall strncmp, eax, [sz_name], 16
357	pop edx	354	pop edx
358	test eax, eax	355	test eax, eax
359	jz .ok	356	jz .ok
360		357
361	add edx,8	358	add edx,8
362	jmp .next	359	jmp .next
363	.ok:	360	.ok:
364	mov eax, [edx+4]	361	mov eax, [edx+4]
365	.end:	362	.end:
366	ret	363	ret
367	endp	364	endp
368		365
369	align 4	366	align 4
370	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	367	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
371		368
372	@@:	369	@@:
373	stdcall strncmp, [pSym], [sz_sym], 8	370	stdcall strncmp, [pSym], [sz_sym], 8
374	test eax,eax	371	test eax,eax
375	jz .ok	372	jz .ok
376	add [pSym], 18	373	add [pSym], 18
377	dec [count]	374	dec [count]
378	jnz @b	375	jnz @b
379	xor eax, eax	376	xor eax, eax
380	ret	377	ret
381	.ok:	378	.ok:
382	mov ebx, [pSym]	379	mov ebx, [pSym]
383	mov eax, [ebx+8]	380	mov eax, [ebx+8]
384	ret	381	ret
385	endp	382	endp
386		383
387	align 4	384	align 4
388	proc get_curr_task	385	proc get_curr_task
389	mov eax,[CURRENT_TASK]	386	mov eax,[CURRENT_TASK]
390	shl eax, 8	387	shl eax, 8
391	ret	388	ret
392	endp	389	endp
393		390
394	align 4	391	align 4
395	proc get_fileinfo stdcall, file_name:dword, info:dword	392	proc get_fileinfo stdcall, file_name:dword, info:dword
396	locals	393	locals
397	cmd dd ?	394	cmd dd ?
398	offset dd ?	395	offset dd ?
399	dd ?	396	dd ?
400	count dd ?	397	count dd ?
401	buff dd ?	398	buff dd ?
402	db ?	399	db ?
403	name dd ?	400	name dd ?
404	endl	401	endl
405		402
406	xor eax, eax	403	xor eax, eax
407	mov ebx, [file_name]	404	mov ebx, [file_name]
408	sub ebx, new_app_base	405	sub ebx, new_app_base
409	mov ecx, [info]	406	mov ecx, [info]
410	sub ecx, new_app_base	407	sub ecx, new_app_base
411		408
412	mov [cmd], 5	409	mov [cmd], 5
413	mov [offset], eax	410	mov [offset], eax
414	mov [offset+4], eax	411	mov [offset+4], eax
415	mov [count], eax	412	mov [count], eax
416	mov [buff], ecx	413	mov [buff], ecx
417	mov byte [buff+4], al	414	mov byte [buff+4], al
418	mov [name], ebx	415	mov [name], ebx
419		416
420	mov eax, 70	417	mov eax, 70
421	lea ebx, [cmd]	418	lea ebx, [cmd]
422	sub ebx, new_app_base	419	sub ebx, new_app_base
423	int 0x40	420	int 0x40
424	ret	421	ret
425	endp	422	endp
426		423
427	align 4	424	align 4
428	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\	425	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
429	bytes:dword	426	bytes:dword
430	locals	427	locals
431	cmd dd ?	428	cmd dd ?
432	offset dd ?	429	offset dd ?
433	dd ?	430	dd ?
434	count dd ?	431	count dd ?
435	buff dd ?	432	buff dd ?
436	db ?	433	db ?
437	name dd ?	434	name dd ?
438	endl	435	endl
439		436
440	xor eax, eax	437	xor eax, eax
441	mov ebx, [file_name]	438	mov ebx, [file_name]
442	mov ecx, [off]	439	mov ecx, [off]
443	mov edx, [bytes]	440	mov edx, [bytes]
444	mov esi, [buffer]	441	mov esi, [buffer]
445	sub ebx, new_app_base	442	sub ebx, new_app_base
446	sub esi, new_app_base	443	sub esi, new_app_base
447		444
448	mov [cmd], eax	445	mov [cmd], eax
449	mov [offset], ecx	446	mov [offset], ecx
450	mov [offset+4], eax	447	mov [offset+4], eax
451	mov [count], edx	448	mov [count], edx
452	mov [buff], esi	449	mov [buff], esi
453	mov byte [buff+4], al	450	mov byte [buff+4], al
454	mov [name], ebx	451	mov [name], ebx
455		452
456	mov eax, 70	453	mov eax, 70
457	lea ebx, [cmd]	454	lea ebx, [cmd]
458	sub ebx, new_app_base	455	sub ebx, new_app_base
459	int 0x40	456	int 0x40
460	ret	457	ret
461	endp	458	endp
462		459
463	; description	460	; description
464	; allocate kernel memory and loads the specified file	461	; allocate kernel memory and loads the specified file
465	;	462	;
466	; param	463	; param
467	; file_name= full path to file	464	; file_name= full path to file
468	;	465	;
469	; retval	466	; retval
470	; eax= file image in kernel memory	467	; eax= file image in kernel memory
471	; ebx= size of file	468	; ebx= size of file
472	;	469	;
473	; warging	470	; warging
474	; You mast call kernel_free() to delete each file	471	; You mast call kernel_free() to delete each file
475	; loaded by the load_file() function	472	; loaded by the load_file() function
476		473
477	align 4	474	align 4
478	proc load_file stdcall, file_name:dword	475	proc load_file stdcall, file_name:dword
479	locals	476	locals
480	attr dd ?	477	attr dd ?
481	flags dd ?	478	flags dd ?
482	cr_time dd ?	479	cr_time dd ?
483	cr_date dd ?	480	cr_date dd ?
484	acc_time dd ?	481	acc_time dd ?
485	acc_date dd ?	482	acc_date dd ?
486	mod_time dd ?	483	mod_time dd ?
487	mod_date dd ?	484	mod_date dd ?
488	file_size dd ?	485	file_size dd ?
489		486
490	file dd ?	487	file dd ?
491	file2 dd ?	488	file2 dd ?
492	endl	489	endl
493		490
494	lea eax, [attr]	491	lea eax, [attr]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 363 → 377