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


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, app_data  ;os_data
	   mov	 ds, bx
	   mov	 es, bx
 
	   mov ebx, [irq_tab+eax*4]
	   test ebx, ebx
	   jz .exit
 
           call ebx
 
.exit:
	   restore_ring3_context
 
           cmp eax, 8
	   mov al, 0x20
           jb @f
	   out 0xa0, al
@@:
           out 0x20, al
 
           pop eax
	   iret
 
align 4
proc get_notify stdcall, p_ev:dword
 
.wait:
           mov ebx,[current_slot]
           test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
 
	   jz @f
           and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
	   mov edi, [p_ev]
	   mov dword [edi], EV_INTR
           mov eax, [ebx+APPDATA.event]
	   mov dword [edi+4], eax
	   ret
@@:
	   call change_task
	   jmp .wait
endp
 
align 4
proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 6
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   ret
endp
 
align 4
proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 4
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   ret
endp
 
align 4
proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 8
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
           mov ecx, [val]
           call pci_write_reg
	   ret
endp
 
handle     equ  IOCTL.handle
io_code    equ  IOCTL.io_code
input      equ  IOCTL.input
inp_size   equ  IOCTL.inp_size
output     equ  IOCTL.output
out_size   equ  IOCTL.out_size
 
 
align 4
proc srv_handler stdcall, ioctl:dword
           mov esi, [ioctl]
           test esi, esi
           jz .err
 
           mov edi, [esi+handle]
           cmp [edi+SRV.magic], ' SRV'
	   jne .fail
 
           cmp [edi+SRV.size], SRV_SIZE
	   jne .fail
 
           stdcall [edi+SRV.srv_proc], esi
           ret
.fail:
           xor eax, eax
           not eax
           mov [esi+output], eax
           mov [esi+out_size], 4
           ret
.err:
           xor eax, eax
           not eax
           ret
endp
 
; param
;  ebx= io_control
;
; retval
;  eax= error code
 
align 4
srv_handlerEx:
           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, -16
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           mov ebx, [edx+CFH.pSymTable]
           add ebx, edx
           mov [sym], ebx
           mov ecx, [edx+CFH.nSymbols]
           add ecx,ecx
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
           add ecx, [sym]
           mov [strings], ecx
 
           lea eax, [edx+20]
 
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
                                     [strings], dword 0
           test eax, eax
           jnz @F
 
@@:
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, new_app_base
           lea eax, [edx+20]
@@:
           add [eax+CFS.VirtualAddress], edi  ;patch user space offset
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           add edx, 20
           stdcall fix_coff_relocs, [coff], edx, [sym]
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
           mov [exports], eax
 
           stdcall kernel_free, [coff]
           mov eax, [exports]
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
proc stop_all_services
 
           mov edx, [srv.fd]
.next:
           cmp edx,  srv.fd-SRV_FD_OFFSET
           je .done
           cmp [edx+SRV.magic], ' SRV'
           jne .next
           cmp [edx+SRV.size], SRV_SIZE
           jne .next
           mov ebx, [edx+SRV.entry]
           mov edx, [edx+SRV.fd]
           push edx
           stdcall ebx, dword -1
           pop edx
           jmp .next
.done:
           ret
endp
 
; param
;  eax= size
;  ebx= pid
 
align 4
create_kernel_object:
 
           push ebx
           call malloc
           pop ebx
           test eax, eax
           jz .fail
 
           mov ecx,[current_slot]
 
           add ecx, APP_OBJ_OFFSET
 
           pushfd
           cli
           mov edx, [ecx+APPOBJ.fd]
           mov [eax+APPOBJ.fd], edx
           mov [eax+APPOBJ.bk], ecx
           mov [eax+APPOBJ.pid], ebx
 
           mov [ecx+APPOBJ.fd], eax
           mov [edx+APPOBJ.bk], eax
           popfd
.fail:
           ret
 
; param
;  eax= object
 
align 4
destroy_kernel_object:
 
           pushfd
           cli
           mov ebx, [eax+APPOBJ.fd]
           mov ecx, [eax+APPOBJ.bk]
           mov [ebx+APPOBJ.bk], ecx
           mov [ecx+APPOBJ.fd], ebx
           popfd
 
           xor edx, edx        ;clear common header
           mov [eax], edx
           mov [eax+4], edx
           mov [eax+8], edx
           mov [eax+12], edx
           mov [eax+16], edx
 
           call free           ;release object memory
           ret
 
 
 
if 0
 
irq:
 
.irq0:
           pusfd
           pushad
           push IRQ_0
           jmp .master
.irq_1:
           pusfd
           pushad
           push IRQ_1
           jmp .master
 
.master:
           mov ax, app_data
           mov ds, eax
           mov es, eax
           mov ebx, [esp+4]  ;IRQ_xx
           mov eax, [irq_handlers+ebx+4]
           call intr_handler
           mov ecx, [esp+4]
           cmp [irq_actids+ecx*4], 0
           je @F
           in al, 0x21
           bts eax, ecx
           out 0x21, al
           mov al, 0x20
           out 0x20, al
           jmp .restart
 
.slave:
           mov ax, app_data
           mov ds, eax
           mov es, eax
           mov ebx, [esp+4]  ;IRQ_xx
           mov eax, [irq_handlers+ebx+4]
           call intr_handler
           mov ecx, [esp+4]
           sub ecx, 8
           cmp [irq_actids+ecx*4], 0
           je @F
           in al, 0xA1
           bts eax, ecx
           out 0xA1, al
           mov al, 0x20
           out 0xA0, al
           out 0x20, al
.restart:
           mov ebx, [next_slot]
           test ebx, ebx
           jz @F
           mov [next_task],0
           mov esi, [prev_slot]
           call do_change_task
           add esp, 4
           iretd
 
end if




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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/dll.inc – Rev 420 → 427