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


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

Subversion Repositories Kolibri OS

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