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_TASK]
           shl ebx,8
           test dword [ebx+SLOT_BASE+0xA8],EVENT_NOTIFY
	   jz @f
           and dword [ebx+SLOT_BASE+0xA8], not EVENT_NOTIFY
	   mov edi, [p_ev]
	   mov dword [edi], EV_INTR
           mov eax, [ebx+SLOT_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, -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_TASK]
           shl ecx,8
           add ecx, SLOT_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

Rev 419	Rev 420
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, 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_TASK]
155	shl ebx,8	155	shl ebx,8
156	test dword [ebx+SLOT_BASE+0xA8],EVENT_NOTIFY	156	test dword [ebx+SLOT_BASE+0xA8],EVENT_NOTIFY
157	jz @f	157	jz @f
158	and dword [ebx+SLOT_BASE+0xA8], not EVENT_NOTIFY	158	and dword [ebx+SLOT_BASE+0xA8], not EVENT_NOTIFY
159	mov edi, [p_ev]	159	mov edi, [p_ev]
160	mov dword [edi], EV_INTR	160	mov dword [edi], EV_INTR
161	mov eax, [ebx+SLOT_BASE+APPDATA.event]	161	mov eax, [ebx+SLOT_BASE+APPDATA.event]
162	mov dword [edi+4], eax	162	mov dword [edi+4], eax
163	ret	163	ret
164	@@:	164	@@:
165	call change_task	165	call change_task
166	jmp .wait	166	jmp .wait
167	endp	167	endp
168		168
169	align 4	169	align 4
170	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword	170	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
171	xor eax, eax	171	xor eax, eax
172	xor ebx, ebx	172	xor ebx, ebx
173	mov ah, byte [bus]	173	mov ah, byte [bus]
174	mov al, 6	174	mov al, 6
175	mov bh, byte [devfn]	175	mov bh, byte [devfn]
176	mov bl, byte [reg]	176	mov bl, byte [reg]
177	call pci_read_reg	177	call pci_read_reg
178	ret	178	ret
179	endp	179	endp
180		180
181	align 4	181	align 4
182	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword	182	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
183	xor eax, eax	183	xor eax, eax
184	xor ebx, ebx	184	xor ebx, ebx
185	mov ah, byte [bus]	185	mov ah, byte [bus]
186	mov al, 4	186	mov al, 4
187	mov bh, byte [devfn]	187	mov bh, byte [devfn]
188	mov bl, byte [reg]	188	mov bl, byte [reg]
189	call pci_read_reg	189	call pci_read_reg
190	ret	190	ret
191	endp	191	endp
192		192
193	align 4	193	align 4
194	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	194	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
195	xor eax, eax	195	xor eax, eax
196	xor ebx, ebx	196	xor ebx, ebx
197	mov ah, byte [bus]	197	mov ah, byte [bus]
198	mov al, 8	198	mov al, 8
199	mov bh, byte [devfn]	199	mov bh, byte [devfn]
200	mov bl, byte [reg]	200	mov bl, byte [reg]
201	mov ecx, [val]	201	mov ecx, [val]
202	call pci_write_reg	202	call pci_write_reg
203	ret	203	ret
204	endp	204	endp
205		205
206	handle equ IOCTL.handle	206	handle equ IOCTL.handle
207	io_code equ IOCTL.io_code	207	io_code equ IOCTL.io_code
208	input equ IOCTL.input	208	input equ IOCTL.input
209	inp_size equ IOCTL.inp_size	209	inp_size equ IOCTL.inp_size
210	output equ IOCTL.output	210	output equ IOCTL.output
211	out_size equ IOCTL.out_size	211	out_size equ IOCTL.out_size
212		212
213		213
214	align 4	214	align 4
215	proc srv_handler stdcall, ioctl:dword	215	proc srv_handler stdcall, ioctl:dword
216	mov esi, [ioctl]	216	mov esi, [ioctl]
217	test esi, esi	217	test esi, esi
218	jz .err	218	jz .err
219		219
220	mov edi, [esi+handle]	220	mov edi, [esi+handle]
221	cmp [edi+SRV.magic], ' SRV'	221	cmp [edi+SRV.magic], ' SRV'
222	jne .fail	222	jne .fail
223		223
224	cmp [edi+SRV.size], SRV_SIZE	224	cmp [edi+SRV.size], SRV_SIZE
225	jne .fail	225	jne .fail
226		226
227	stdcall [edi+SRV.srv_proc], esi	227	stdcall [edi+SRV.srv_proc], esi
228	ret	228	ret
229	.fail:	229	.fail:
230	xor eax, eax	230	xor eax, eax
231	not eax	231	not eax
232	mov [esi+output], eax	232	mov [esi+output], eax
233	mov [esi+out_size], 4	233	mov [esi+out_size], 4
234	ret	234	ret
235	.err:	235	.err:
236	xor eax, eax	236	xor eax, eax
237	not eax	237	not eax
238	ret	238	ret
239	endp	239	endp
240		240
241	; param	241	; param
242	; ebx= io_control	242	; ebx= io_control
243	;	243	;
244	; retval	244	; retval
245	; eax= error code	245	; eax= error code
246		246
247	align 4	247	align 4
248	srv_handlerEx:	248	srv_handlerEx:
249	test ebx, ebx	249	test ebx, ebx
250	jz .fail	250	jz .fail
251	; add ebx, new_app_base	251	; add ebx, new_app_base
252		252
253	mov eax, [ebx+handle]	253	mov eax, [ebx+handle]
254	cmp [eax+SRV.magic], ' SRV'	254	cmp [eax+SRV.magic], ' SRV'
255	jne .fail	255	jne .fail
256		256
257	cmp [eax+SRV.size], SRV_SIZE	257	cmp [eax+SRV.size], SRV_SIZE
258	jne .fail	258	jne .fail
259		259
260	; add [ebx+input], new_app_base	260	; add [ebx+input], new_app_base
261	; add [ebx+output], new_app_base	261	; add [ebx+output], new_app_base
262		262
263	stdcall [eax+SRV.srv_proc], ebx	263	stdcall [eax+SRV.srv_proc], ebx
264	ret	264	ret
265	.fail:	265	.fail:
266	or eax, -1	266	or eax, -1
267	ret	267	ret
268		268
269	restore handle	269	restore handle
270	restore io_code	270	restore io_code
271	restore input	271	restore input
272	restore inp_size	272	restore inp_size
273	restore output	273	restore output
274	restore out_size	274	restore out_size
275		275
276	align 4	276	align 4
277	proc get_service stdcall, sz_name:dword	277	proc get_service stdcall, sz_name:dword
278	mov eax, [sz_name]	278	mov eax, [sz_name]
279	test eax, eax	279	test eax, eax
280	jnz @F	280	jnz @F
281	ret	281	ret
282	@@:	282	@@:
283	mov edx, [srv.fd]	283	mov edx, [srv.fd]
284	@@:	284	@@:
285	cmp edx, srv.fd-SRV_FD_OFFSET	285	cmp edx, srv.fd-SRV_FD_OFFSET
286	je .not_load	286	je .not_load
287		287
288	stdcall strncmp, edx, [sz_name], 16	288	stdcall strncmp, edx, [sz_name], 16
289	test eax, eax	289	test eax, eax
290	je .ok	290	je .ok
291		291
292	mov edx, [edx+SRV.fd]	292	mov edx, [edx+SRV.fd]
293	jmp @B	293	jmp @B
294	.not_load:	294	.not_load:
295	pop ebp	295	pop ebp
296	jmp load_driver	296	jmp load_driver
297	.ok:	297	.ok:
298	mov eax, edx	298	mov eax, edx
299	ret	299	ret
300	endp	300	endp
301		301
302	align 4	302	align 4
303	reg_service:	303	reg_service:
304	.sz_name equ esp+4	304	.sz_name equ esp+4
305	.handler equ esp+8	305	.handler equ esp+8
306	mov eax, [.sz_name]	306	mov eax, [.sz_name]
307	test eax, eax	307	test eax, eax
308	jz .fail	308	jz .fail
309		309
310	mov ebx, [.handler]	310	mov ebx, [.handler]
311	test ebx, ebx	311	test ebx, ebx
312	jz .fail	312	jz .fail
313		313
314	mov eax, SRV_SIZE	314	mov eax, SRV_SIZE
315	call malloc ;call alloc_service	315	call malloc ;call alloc_service
316	test eax, eax	316	test eax, eax
317	jz .fail	317	jz .fail
318		318
319	mov edi, eax	319	mov edi, eax
320	mov esi, [.sz_name]	320	mov esi, [.sz_name]
321	mov ecx, 16/4	321	mov ecx, 16/4
322	rep movsd	322	rep movsd
323		323
324	mov [eax+SRV.magic], ' SRV'	324	mov [eax+SRV.magic], ' SRV'
325	mov [eax+SRV.size], SRV_SIZE	325	mov [eax+SRV.size], SRV_SIZE
326		326
327	mov ebx, srv.fd-SRV_FD_OFFSET	327	mov ebx, srv.fd-SRV_FD_OFFSET
328	mov edx, [ebx+SRV.fd]	328	mov edx, [ebx+SRV.fd]
329	mov [eax+SRV.fd], edx	329	mov [eax+SRV.fd], edx
330	mov [eax+SRV.bk], ebx	330	mov [eax+SRV.bk], ebx
331	mov [ebx+SRV.fd], eax	331	mov [ebx+SRV.fd], eax
332	mov [edx+SRV.bk], eax	332	mov [edx+SRV.bk], eax
333		333
334	mov ecx, [.handler]	334	mov ecx, [.handler]
335	mov [eax+SRV.srv_proc], ecx	335	mov [eax+SRV.srv_proc], ecx
336	ret 8	336	ret 8
337	.fail:	337	.fail:
338	xor eax, eax	338	xor eax, eax
339	ret 8	339	ret 8
340		340
341	align 4	341	align 4
342	proc get_proc stdcall, exp:dword, sz_name:dword	342	proc get_proc stdcall, exp:dword, sz_name:dword
343		343
344	mov edx, [exp]	344	mov edx, [exp]
345	.next:	345	.next:
346	mov eax, [edx]	346	mov eax, [edx]
347	test eax, eax	347	test eax, eax
348	jz .end	348	jz .end
349		349
350	push edx	350	push edx
351	stdcall strncmp, eax, [sz_name], 16	351	stdcall strncmp, eax, [sz_name], 16
352	pop edx	352	pop edx
353	test eax, eax	353	test eax, eax
354	jz .ok	354	jz .ok
355		355
356	add edx,8	356	add edx,8
357	jmp .next	357	jmp .next
358	.ok:	358	.ok:
359	mov eax, [edx+4]	359	mov eax, [edx+4]
360	.end:	360	.end:
361	ret	361	ret
362	endp	362	endp
363		363
364	align 4	364	align 4
365	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	365	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
366		366
367	@@:	367	@@:
368	stdcall strncmp, [pSym], [sz_sym], 8	368	stdcall strncmp, [pSym], [sz_sym], 8
369	test eax,eax	369	test eax,eax
370	jz .ok	370	jz .ok
371	add [pSym], 18	371	add [pSym], 18
372	dec [count]	372	dec [count]
373	jnz @b	373	jnz @b
374	xor eax, eax	374	xor eax, eax
375	ret	375	ret
376	.ok:	376	.ok:
377	mov ebx, [pSym]	377	mov ebx, [pSym]
378	mov eax, [ebx+8]	378	mov eax, [ebx+8]
379	ret	379	ret
380	endp	380	endp
381		381
382	align 4	382	align 4
383	proc get_curr_task	383	proc get_curr_task
384	mov eax,[CURRENT_TASK]	384	mov eax,[CURRENT_TASK]
385	shl eax, 8	385	shl eax, 8
386	ret	386	ret
387	endp	387	endp
388		388
389	align 4	389	align 4
390	proc get_fileinfo stdcall, file_name:dword, info:dword	390	proc get_fileinfo stdcall, file_name:dword, info:dword
391	locals	391	locals
392	cmd dd ?	392	cmd dd ?
393	offset dd ?	393	offset dd ?
394	dd ?	394	dd ?
395	count dd ?	395	count dd ?
396	buff dd ?	396	buff dd ?
397	db ?	397	db ?
398	name dd ?	398	name dd ?
399	endl	399	endl
400		400
401	xor eax, eax	401	xor eax, eax
402	mov ebx, [file_name]	402	mov ebx, [file_name]
403	; sub ebx, new_app_base	403	; sub ebx, new_app_base
404	mov ecx, [info]	404	mov ecx, [info]
405	; sub ecx, new_app_base	405	; sub ecx, new_app_base
406		406
407	mov [cmd], 5	407	mov [cmd], 5
408	mov [offset], eax	408	mov [offset], eax
409	mov [offset+4], eax	409	mov [offset+4], eax
410	mov [count], eax	410	mov [count], eax
411	mov [buff], ecx	411	mov [buff], ecx
412	mov byte [buff+4], al	412	mov byte [buff+4], al
413	mov [name], ebx	413	mov [name], ebx
414		414
415	mov eax, 70	415	mov eax, 70
416	lea ebx, [cmd]	416	lea ebx, [cmd]
417	; sub ebx, new_app_base	417	; sub ebx, new_app_base
418	int 0x40	418	int 0x40
419	ret	419	ret
420	endp	420	endp
421		421
422	align 4	422	align 4
423	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\	423	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
424	bytes:dword	424	bytes:dword
425	locals	425	locals
426	cmd dd ?	426	cmd dd ?
427	offset dd ?	427	offset dd ?
428	dd ?	428	dd ?
429	count dd ?	429	count dd ?
430	buff dd ?	430	buff dd ?
431	db ?	431	db ?
432	name dd ?	432	name dd ?
433	endl	433	endl
434		434
435	xor eax, eax	435	xor eax, eax
436	mov ebx, [file_name]	436	mov ebx, [file_name]
437	mov ecx, [off]	437	mov ecx, [off]
438	mov edx, [bytes]	438	mov edx, [bytes]
439	mov esi, [buffer]	439	mov esi, [buffer]
440	; sub ebx, new_app_base	440	; sub ebx, new_app_base
441	; sub esi, new_app_base	441	; sub esi, new_app_base
442		442
443	mov [cmd], eax	443	mov [cmd], eax
444	mov [offset], ecx	444	mov [offset], ecx
445	mov [offset+4], eax	445	mov [offset+4], eax
446	mov [count], edx	446	mov [count], edx
447	mov [buff], esi	447	mov [buff], esi
448	mov byte [buff+4], al	448	mov byte [buff+4], al
449	mov [name], ebx	449	mov [name], ebx
450		450
451	mov eax, 70	451	mov eax, 70
452	lea ebx, [cmd]	452	lea ebx, [cmd]
453	; sub ebx, new_app_base	453	; sub ebx, new_app_base
454	int 0x40	454	int 0x40
455	ret	455	ret
456	endp	456	endp
457		457
458	; description	458	; description
459	; allocate kernel memory and loads the specified file	459	; allocate kernel memory and loads the specified file
460	;	460	;
461	; param	461	; param
462	; file_name= full path to file	462	; file_name= full path to file
463	;	463	;
464	; retval	464	; retval
465	; eax= file image in kernel memory	465	; eax= file image in kernel memory
466	; ebx= size of file	466	; ebx= size of file
467	;	467	;
468	; warging	468	; warging
469	; You mast call kernel_free() to delete each file	469	; You mast call kernel_free() to delete each file
470	; loaded by the load_file() function	470	; loaded by the load_file() function
471		471
472	align 4	472	align 4
473	proc load_file stdcall, file_name:dword	473	proc load_file stdcall, file_name:dword
474	locals	474	locals
475	attr dd ?	475	attr dd ?
476	flags dd ?	476	flags dd ?
477	cr_time dd ?	477	cr_time dd ?
478	cr_date dd ?	478	cr_date dd ?
479	acc_time dd ?	479	acc_time dd ?
480	acc_date dd ?	480	acc_date dd ?
481	mod_time dd ?	481	mod_time dd ?
482	mod_date dd ?	482	mod_date dd ?
483	file_size dd ?	483	file_size dd ?
484		484
485	file dd ?	485	file dd ?
486	file2 dd ?	486	file2 dd ?
487	endl	487	endl
488		488
489	lea eax, [attr]	489	lea eax, [attr]
490	stdcall get_fileinfo, [file_name], eax	490	stdcall get_fileinfo, [file_name], eax
491	test eax, eax	491	test eax, eax
492	jnz .fail	492	jnz .fail
493		493
494	mov eax, [file_size]	494	mov eax, [file_size]
495	cmp eax, 1024102416	495	cmp eax, 1024102416
496	ja .fail	496	ja .fail
497		497
498	stdcall kernel_alloc, [file_size]	498	stdcall kernel_alloc, [file_size]
499	mov [file], eax	499	mov [file], eax
500		500

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/dll.inc @ 432 – Rev 419 → 420