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
 
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:
           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
 
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 346	Rev 357
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	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	pop ebp	300	pop ebp
301	jmp load_driver	301	jmp load_driver
302	.ok:	302	.ok:
303	mov eax, edx	303	mov eax, edx
304	ret	304	ret
305	endp	305	endp
306		306
307	align 4	307	align 4
308	reg_service:	308	reg_service:
309	.sz_name equ esp+4	309	.sz_name equ esp+4
310	.handler equ esp+8	310	.handler equ esp+8
311	mov eax, [.sz_name]	311	mov eax, [.sz_name]
312	test eax, eax	312	test eax, eax
313	jz .fail	313	jz .fail
314		314
315	mov ebx, [.handler]	315	mov ebx, [.handler]
316	test ebx, ebx	316	test ebx, ebx
317	jz .fail	317	jz .fail
318		318
319	mov eax, SRV_SIZE	319	mov eax, SRV_SIZE
320	call malloc ;call alloc_service	320	call malloc ;call alloc_service
321	test eax, eax	321	test eax, eax
322	jz .fail	322	jz .fail
323		323
324	mov edi, eax	324	mov edi, eax
325	mov esi, [.sz_name]	325	mov esi, [.sz_name]
326	mov ecx, 16/4	326	mov ecx, 16/4
327	rep movsd	327	rep movsd
328		328
329	mov [eax+SRV.magic], ' SRV'	329	mov [eax+SRV.magic], ' SRV'
330	mov [eax+SRV.size], SRV_SIZE	330	mov [eax+SRV.size], SRV_SIZE
331		331
332	mov ebx, srv.fd-SRV_FD_OFFSET	332	mov ebx, srv.fd-SRV_FD_OFFSET
333	mov edx, [ebx+SRV.fd]	333	mov edx, [ebx+SRV.fd]
334	mov [eax+SRV.fd], edx	334	mov [eax+SRV.fd], edx
335	mov [eax+SRV.bk], ebx	335	mov [eax+SRV.bk], ebx
336	mov [ebx+SRV.fd], eax	336	mov [ebx+SRV.fd], eax
337	mov [edx+SRV.bk], eax	337	mov [edx+SRV.bk], eax
338		338
339	mov ecx, [.handler]	339	mov ecx, [.handler]
340	mov [eax+SRV.srv_proc], ecx	340	mov [eax+SRV.srv_proc], ecx
341	ret 8	341	ret 8
342	.fail:	342	.fail:
343	xor eax, eax	343	xor eax, eax
344	ret 8	344	ret 8
345		345
346	align 4	346	align 4
347	proc get_proc stdcall, exp:dword, sz_name:dword	347	proc get_proc stdcall, exp:dword, sz_name:dword
348		348
349	mov edx, [exp]	349	mov edx, [exp]
350	.next:	350	.next:
351	mov eax, [edx]	351	mov eax, [edx]
352	test eax, eax	352	test eax, eax
353	jz .end	353	jz .end
354		354
355	push edx	355	push edx
356	stdcall strncmp, eax, [sz_name], 16	356	stdcall strncmp, eax, [sz_name], 16
357	pop edx	357	pop edx
358	test eax, eax	358	test eax, eax
359	jz .ok	359	jz .ok
360		360
361	add edx,8	361	add edx,8
362	jmp .next	362	jmp .next
363	.ok:	363	.ok:
364	mov eax, [edx+4]	364	mov eax, [edx+4]
365	.end:	365	.end:
366	ret	366	ret
367	endp	367	endp
368		368
369	align 4	369	align 4
370	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	370	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
371		371
372	@@:	372	@@:
373	stdcall strncmp, [pSym], [sz_sym], 8	373	stdcall strncmp, [pSym], [sz_sym], 8
374	test eax,eax	374	test eax,eax
375	jz .ok	375	jz .ok
376	add [pSym], 18	376	add [pSym], 18
377	dec [count]	377	dec [count]
378	jnz @b	378	jnz @b
379	xor eax, eax	379	xor eax, eax
380	ret	380	ret
381	.ok:	381	.ok:
382	mov ebx, [pSym]	382	mov ebx, [pSym]
383	mov eax, [ebx+8]	383	mov eax, [ebx+8]
384	ret	384	ret
385	endp	385	endp
386		386
387	align 4	387	align 4
388	proc get_curr_task	388	proc get_curr_task
389	mov eax,[CURRENT_TASK]	389	mov eax,[CURRENT_TASK]
390	shl eax, 8	390	shl eax, 8
391	ret	391	ret
392	endp	392	endp
393		393
394	align 4	394	align 4
395	proc get_fileinfo stdcall, file_name:dword, info:dword	395	proc get_fileinfo stdcall, file_name:dword, info:dword
396	locals	396	locals
397	cmd dd ?	397	cmd dd ?
398	offset dd ?	398	offset dd ?
399	dd ?	399	dd ?
400	count dd ?	400	count dd ?
401	buff dd ?	401	buff dd ?
402	db ?	402	db ?
403	name dd ?	403	name dd ?
404	endl	404	endl
405		405
406	xor eax, eax	406	xor eax, eax
407	mov ebx, [file_name]	407	mov ebx, [file_name]
408	sub ebx, new_app_base	408	sub ebx, new_app_base
409	mov ecx, [info]	409	mov ecx, [info]
410	sub ecx, new_app_base	410	sub ecx, new_app_base
411		411
412	mov [cmd], 5	412	mov [cmd], 5
413	mov [offset], eax	413	mov [offset], eax
414	mov [offset+4], eax	414	mov [offset+4], eax
415	mov [count], eax	415	mov [count], eax
416	mov [buff], ecx	416	mov [buff], ecx
417	mov byte [buff+4], al	417	mov byte [buff+4], al
418	mov [name], ebx	418	mov [name], ebx
419		419
420	mov eax, 70	420	mov eax, 70
421	lea ebx, [cmd]	421	lea ebx, [cmd]
422	sub ebx, new_app_base	422	sub ebx, new_app_base
423	int 0x40	423	int 0x40
424	ret	424	ret
425	endp	425	endp
426		426
427	align 4	427	align 4
428	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\	428	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
429	bytes:dword	429	bytes:dword
430	locals	430	locals
431	cmd dd ?	431	cmd dd ?
432	offset dd ?	432	offset dd ?
433	dd ?	433	dd ?
434	count dd ?	434	count dd ?
435	buff dd ?	435	buff dd ?
436	db ?	436	db ?
437	name dd ?	437	name dd ?
438	endl	438	endl
439		439
440	xor eax, eax	440	xor eax, eax
441	mov ebx, [file_name]	441	mov ebx, [file_name]
442	mov ecx, [off]	442	mov ecx, [off]
443	mov edx, [bytes]	443	mov edx, [bytes]
444	mov esi, [buffer]	444	mov esi, [buffer]
445	sub ebx, new_app_base	445	sub ebx, new_app_base
446	sub esi, new_app_base	446	sub esi, new_app_base
447		447
448	mov [cmd], eax	448	mov [cmd], eax
449	mov [offset], ecx	449	mov [offset], ecx
450	mov [offset+4], eax	450	mov [offset+4], eax
451	mov [count], edx	451	mov [count], edx
452	mov [buff], esi	452	mov [buff], esi
453	mov byte [buff+4], al	453	mov byte [buff+4], al
454	mov [name], ebx	454	mov [name], ebx
455		455
456	mov eax, 70	456	mov eax, 70
457	lea ebx, [cmd]	457	lea ebx, [cmd]
458	sub ebx, new_app_base	458	sub ebx, new_app_base
459	int 0x40	459	int 0x40
460	ret	460	ret
461	endp	461	endp
462		462
463	align 4	463	align 4
464	proc load_file stdcall, file_name:dword	464	proc load_file stdcall, file_name:dword
465	locals	465	locals
466	attr dd ?	466	attr dd ?
467	flags dd ?	467	flags dd ?
468	cr_time dd ?	468	cr_time dd ?
469	cr_date dd ?	469	cr_date dd ?
470	acc_time dd ?	470	acc_time dd ?
471	acc_date dd ?	471	acc_date dd ?
472	mod_time dd ?	472	mod_time dd ?
473	mod_date dd ?	473	mod_date dd ?
474	file_size dd ?	474	file_size dd ?
475		475
476	file dd ?	476	file dd ?
477	file2 dd ?	477	file2 dd ?
478	endl	478	endl
479		479
480	lea eax, [attr]	480	lea eax, [attr]
481	stdcall get_fileinfo, [file_name], eax	481	stdcall get_fileinfo, [file_name], eax
482	test eax, eax	482	test eax, eax
483	jnz .fail	483	jnz .fail
484		484
485	mov eax, [file_size]	485	mov eax, [file_size]
486	cmp eax, 1024102416	486	cmp eax, 1024102416
487	ja .fail	487	ja .fail
488		488
489	stdcall kernel_alloc, [file_size]	489	stdcall kernel_alloc, [file_size]
490	mov [file], eax	490	mov [file], eax
491		491
492	stdcall read_file, [file_name], eax, dword 0, [file_size]	492	stdcall read_file, [file_name], eax, dword 0, [file_size]
493	cmp ebx, [file_size]	493	cmp ebx, [file_size]
494	jne .cleanup	494	jne .cleanup
495		495
496	mov eax, [file]	496	mov eax, [file]
497	cmp dword [eax], 0x4B43504B	497	cmp dword [eax], 0x4B43504B
498	jne .exit	498	jne .exit
499	mov ebx, [eax+4]	499	mov ebx, [eax+4]
500	mov [file_size], ebx	500	mov [file_size], ebx

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 346 → 357