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

Subversion Repositories Kolibri OS

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