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


;
;   This file is part of the Infinity sound AC97 driver.
;   (C) copyright Serge 2006
;   email: infinity_sound@mail.ru
;
;   This program is free software; you can redistribute it and/or modify
;   it under the terms of the GNU General Public License as published by
;   the Free Software Foundation; either version 2 of the License, or
;   (at your option) any later version.
;
;   This program is distributed in the hope that it will be useful,
;   but WITHOUT ANY WARRANTY; without even the implied warranty of
;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;   GNU General Public License for more details.
 
align 4
proc attach_int_handler stdcall, irq:dword, handler:dword
 
	 mov ebx, [irq]        ;irq num
	 test ebx, ebx
	 jz .err
	 mov eax, [handler]
	 test eax, eax
	 jz .err
	 mov [irq_tab+ebx*4], eax
         stdcall enable_irq, [irq]
	 ret
.err:
	 xor eax, eax
	 ret
endp
 
align 4
proc  detach_int_handler
 
	   ret
endp
 
align 4
proc enable_irq stdcall, irq_line:dword
           mov ebx, [irq_line]
           mov edx, 0x21
           cmp ebx, 8
           jb @F
           mov edx, 0xA1
           sub ebx,8
@@:
           in al,dx
           btr eax, ebx
           out dx, al
           ret
endp
 
align 16
;; proc irq_serv
 
irq_serv:
 
.irq_1:
	   push eax
	   mov eax, 1
	   jmp .main
align 4
.irq_2:
	   push eax
	   mov eax, 2
	   jmp .main
align 4
.irq_3:
	   push eax
	   mov eax, 3
	   jmp .main
align 4
.irq_4:
	   push eax
	   mov eax, 4
	   jmp .main
align 4
.irq_5:
	   push eax
	   mov eax, 5
	   jmp .main
align 4
.irq_6:
	   push eax
	   mov eax, 6
	   jmp .main
align 4
.irq_7:
	   push eax
	   mov eax, 7
	   jmp .main
align 4
.irq_8:
	   push eax
	   mov eax, 8
	   jmp .main
align 4
.irq_9:
	   push eax
	   mov eax, 9
	   jmp .main
align 4
.irq_10:
	   push eax
	   mov eax, 10
	   jmp .main
align 4
.irq_11:
	   push eax
	   mov eax, 11
	   jmp .main
align 4
.irq_12:
	   push eax
	   mov eax, 12
	   jmp .main
align 4
.irq_13:
	   push eax
	   mov eax, 13
	   jmp .main
align 4
.irq_14:
	   push eax
	   mov eax, 14
	   jmp .main
align 4
.irq_15:
	   push eax
	   mov eax, 15
	   jmp .main
 
align 16
.main:
	   save_ring3_context
	   mov	 bx, os_data
	   mov	 ds, bx
	   mov	 es, bx
 
	   mov ebx, [irq_tab+eax*4]
	   test ebx, ebx
	   jz .exit
 
           call ebx
 
.exit:
	   restore_ring3_context
 
           cmp eax, 8
	   mov al, 0x20
           jb @f
	   out 0xa0, al
@@:
           out 0x20, al
 
           pop eax
	   iret
 
align 4
proc get_notify stdcall, p_ev:dword
 
.wait:
           mov ebx,[CURRENT_TASK]
           shl ebx,8
           test dword [ebx+PROC_BASE+0xA8],EVENT_NOTIFY
	   jz @f
           and dword [ebx+PROC_BASE+0xA8], not EVENT_NOTIFY
	   mov edi, [p_ev]
	   mov dword [edi], EV_INTR
           mov eax, [ebx+PROC_BASE+APPDATA.event]
	   mov dword [edi+4], eax
	   ret
@@:
	   call change_task
	   jmp .wait
endp
 
align 4
proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 6
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   ret
endp
 
align 4
proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 4
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   ret
endp
 
align 4
proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 8
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
           mov ecx, [val]
           call pci_write_reg
	   ret
endp
 
handle     equ  IOCTL.handle
io_code    equ  IOCTL.io_code
input      equ  IOCTL.input
inp_size   equ  IOCTL.inp_size
output     equ  IOCTL.output
out_size   equ  IOCTL.out_size
 
 
align 4
proc srv_handler stdcall, ioctl:dword
           mov esi, [ioctl]
           test esi, esi
           jz .err
 
           mov edi, [esi+handle]
           cmp [edi+SRV.magic], ' SRV'
	   jne .fail
 
           cmp [edi+SRV.size], SRV_SIZE
	   jne .fail
 
           stdcall [edi+SRV.srv_proc], esi
           ret
.fail:
           xor eax, eax
           not eax
           mov [esi+output], eax
           mov [esi+out_size], 4
           ret
.err:
           xor eax, eax
           not eax
           ret
endp
 
align 4
proc srv_handlerEx stdcall, ioctl:dword
           mov esi, [ioctl]
           test esi, esi
           jz .err
           add esi, new_app_base
 
           mov edi, [esi+handle]
           cmp [edi+SRV.magic], ' SRV'
	   jne .fail
 
           cmp [edi+SRV.size], SRV_SIZE
	   jne .fail
 
           add [esi+input], new_app_base
           add [esi+output], new_app_base
 
           stdcall [edi+SRV.srv_proc], esi
           ret
.fail:
           xor eax, eax
           not eax
           mov [esi+output], eax
           mov [esi+out_size], 4
           ret
.err:
           xor eax, eax
           not eax
           ret
endp
 
restore  handle
restore  io_code
restore  input
restore  inp_size
restore  output
restore  out_size
 
align 4
proc get_service stdcall, sz_name:dword
	   locals
	     srv_ptr  dd ?
	     counter  dd ?
           endl
 
           mov eax, [sz_name]
           test eax, eax
           jnz @F
           ret
@@:
           mov [srv_ptr], srv_tab
           mov [counter], 16
@@:
           stdcall strncmp, [srv_ptr], [sz_name], 16
           test eax, eax
           je .ok
 
           add [srv_ptr], SRV_SIZE
           dec [counter]
           jnz @B
.not_load:
           stdcall find_service, [sz_name]
           test eax, eax
           jnz @F
           ret
@@:
           stdcall load_driver, eax
           ret
.ok:
           mov eax, [srv_ptr]
           ret
endp
 
align 4
proc find_service stdcall ,sz_name:dword
 
	   mov eax, [sz_name]
	   test eax, eax
	   jz .fail
 
           mov esi, services
@@:
           mov eax, [esi]
           test eax, eax
           jz .fail
           push esi
           stdcall strncmp, eax, [sz_name], 16
           pop esi
           test eax, eax
           je .ok
 
           add esi, 8
           jmp @B
.ok:
           mov eax, [esi+4]
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
proc reg_service stdcall, sz_name:dword, handler:dword
	   locals
	     srv dd ?
	   endl
 
	   mov eax, [sz_name]
	   test eax, eax
	   jz .fail
 
	   mov ebx, [handler]
	   test ebx, ebx
	   jz .fail
 
	   call alloc_service
	   test eax, eax
	   jz .fail
 
	   mov [srv], eax
	   mov edi, eax
	   mov esi, [sz_name]
	   mov ecx, 16
	   rep movsb
 
	   mov edi, eax
	   mov [edi+SRV.magic], ' SRV'
	   mov [edi+SRV.size], SRV_SIZE
	   mov ebx, [handler]
	   mov [edi+SRV.srv_proc], ebx
           mov eax, [srv]
	   ret
.fail:
	   xor eax, eax
	   ret
endp
 
align 4
proc get_proc stdcall, exp:dword, sz_name:dword
 
           mov edx, [exp]
.next:
           mov eax, [edx]
           test eax, eax
           jz .end
 
           push edx
           stdcall strncmp, eax, [sz_name], 16
           pop edx
           test eax, eax
           jz .ok
 
           add edx,8
           jmp .next
.ok:
           mov eax, [edx+4]
.end:
           ret
endp
 
align 4
proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
 
@@:
	   stdcall strncmp, [pSym], [sz_sym], 8
	   test eax,eax
	   jz .ok
	   add [pSym], 18
	   dec [count]
	   jnz @b
	   xor eax, eax
	   ret
.ok:
	   mov ebx, [pSym]
	   mov eax, [ebx+8]
	   ret
endp
 
align 4
proc get_curr_task
           mov eax,[CURRENT_TASK]
           shl eax, 8
           ret
endp
 
align 4
proc get_fileinfo stdcall, file_name:dword, info:dword
           locals
             cmd     dd ?
             offset  dd ?
                     dd ?
             count   dd ?
             buff    dd ?
                     db ?
             name    dd ?
           endl
 
           xor eax, eax
           mov ebx, [file_name]
           sub ebx, new_app_base
           mov ecx, [info]
           sub ecx, new_app_base
 
           mov [cmd], 5
           mov [offset], eax
           mov [offset+4], eax
           mov [count], eax
           mov [buff], ecx
           mov byte [buff+4], al
           mov [name], ebx
 
           mov eax, 70
           lea ebx, [cmd]
           sub ebx, new_app_base
           int 0x40
           ret
endp
 
align 4
proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
                                     bytes:dword
           locals
             cmd     dd ?
             offset  dd ?
                     dd ?
             count   dd ?
             buff    dd ?
                     db ?
             name    dd ?
           endl
 
           xor eax, eax
           mov ebx, [file_name]
           mov ecx, [off]
           mov edx, [bytes]
           mov esi, [buffer]
           sub ebx, new_app_base
           sub esi, new_app_base
 
           mov [cmd], eax
           mov [offset], ecx
           mov [offset+4], eax
           mov [count], edx
           mov [buff], esi
           mov byte [buff+4], al
           mov [name], ebx
 
           mov eax, 70
           lea ebx, [cmd]
           sub ebx, new_app_base
           int 0x40
           ret
endp
 
align 4
proc load_file stdcall, file_name:dword
           locals
             attr       dd ?
             flags      dd ?
             cr_time    dd ?
             cr_date    dd ?
             acc_time   dd ?
             acc_date   dd ?
             mod_time   dd ?
             mod_date   dd ?
             file_size  dd ?
 
             file       dd ?
           endl
 
           lea eax, [attr]
           stdcall get_fileinfo, [file_name], eax
           test eax, eax
           jnz .fail
 
           mov eax, [file_size]
 
           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]
           ret
.cleanup:
           stdcall kernel_free, [file]
.fail:
           xor eax, eax
           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, file_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             start     dd ?
 
             exports   dd ?   ;fake exports table
                       dd ?
           endl
 
           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
 
           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
           jnz @F
 
           mov esi, msg_module
           call sys_msg_board_str
           mov esi, [file_name]
           call sys_msg_board_str
           mov esi, msg_CR
           call sys_msg_board_str
 
           stdcall kernel_free,[coff]
           xor eax, eax
           ret
@@:
           mov ebx, [coff]
           add ebx, 20
           stdcall fix_coff_relocs, [coff], ebx, [sym]
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
           mov [start], eax
 
           stdcall kernel_free, [coff]
 
           mov ebx, [start]
           call ebx
           test eax, eax
           jnz .ok
 
           stdcall kernel_free, [img_base]
           xor eax, eax
           ret
.ok:
           mov ebx, [img_base]
           mov [eax+SRV.base], ebx
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
proc load_library stdcall, file_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             exports   dd ?
           endl
 
           cli
 
           stdcall load_file, [file_name]
 
           test eax, eax
           jz .fail
 
           mov [coff], eax
           movzx ecx, [eax+CFH.nSections]
           xor ebx, ebx
 
           lea edx, [eax+20]
@@:
           add ebx, [edx+CFS.SizeOfRawData]
           add ebx, 15
           and ebx, not 15
           add edx, COFF_SECTION_SIZE
           dec ecx
           jnz @B
           mov [img_size], ebx
 
           call init_heap
           stdcall user_alloc, [img_size]
 
           test eax, eax
           jz .fail
           mov [img_base], eax
 
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, [img_base]
           lea eax, [edx+20]
@@:
           mov [eax+CFS.VirtualAddress], edi
           mov esi, [eax+CFS.PtrRawData]
           test esi, esi
           jnz .copy
           add edi, [eax+CFS.SizeOfRawData]
           jmp .next
.copy:
           add esi, edx
           add edi, new_app_base
           mov ecx, [eax+CFS.SizeOfRawData]
           cld
           rep movsb
.next:
           add edi, 15-new_app_base
           and edi, not 15
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           mov ebx, [edx+CFH.pSymTable]
           add ebx, edx
           mov [sym], ebx
           mov ecx, [edx+CFH.nSymbols]
           add ecx,ecx
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
           add ecx, [sym]
           mov [strings], ecx
 
           lea eax, [edx+20]
 
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
                                     [strings], dword 0
           test eax, eax
           jnz @F
 
@@:
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, new_app_base
           lea eax, [edx+20]
@@:
           add [eax+CFS.VirtualAddress], edi  ;patch user space offset
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           add edx, 20
           stdcall fix_coff_relocs, [coff], edx, [sym]
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
           mov [exports], eax
 
           stdcall kernel_free, [coff]
           mov eax, [exports]
           ret
.fail:
           xor eax, eax
           ret
endp
 
 
drv_sound      db '/rd/1/drivers/unisound.obj', 0
drv_infinity   db '/rd/1/drivers/infinity.obj', 0
 
szSound        db 'SOUND',0
szInfinity     db 'INFINITY',0
 
szSTART        db 'START',0
szEXPORTS      db 'EXPORTS',0
szIMPORTS      db 'IMPORTS',0
 
msg_unresolved db 'unresolved ',0
msg_module     db 'in module ',0
msg_CR         db  13,10,0
 
align 16
services:
           dd szSound,    drv_sound
           dd szInfinity, drv_infinity
           dd 0

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 202 → 206