WebSVN – Kolibri OS – Blame – /kernel/branches/kolibri_pe/core/dll.inc

Rev	Author	Line No.	Line
431	serge	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
709	diamond	3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
431	serge	4	;; Distributed under terms of the GNU General Public License ;;
		5	;; ;;
		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
164	serge	7
593	mikedld	8	$Revision: 928 $
		9
		10
465	serge	11	DRV_COMPAT equ 5 ;minimal required drivers version
		12	DRV_CURRENT equ 5 ;current drivers model version
214	serge	13
227	serge	14	DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
797	serge	15	PID_KERNEL equ 1 ;os_idle thread
227	serge	16
164	serge	17	align 4
774	Rus	18	proc attach_int_handler stdcall, irq:dword, handler:dword, access_rights:dword
164	serge	19
886	serge	20	mov ebx, [irq] ;irq num
		21	test ebx, ebx
		22	jz .err
		23	cmp ebx, 15 ; hidnplayr says: we only have 16 IRQ's
		24	ja .err
		25	mov eax, [handler]
		26	test eax, eax
		27	jz .err
		28	cmp [irq_owner + 4 * ebx], 0
		29	je @f
774	Rus	30
886	serge	31	mov ecx, [irq_rights + 4 * ebx] ; Rights : 0 - full access, 1 - read only, 2 - forbidden
		32	test ecx, ecx
		33	jnz .err
774	Rus	34
802	serge	35	@@:
886	serge	36	mov [irq_tab+ebx*4], eax
769	Rus	37
886	serge	38	mov eax, [access_rights]
		39	mov [irq_rights + 4 * ebx], eax
774	Rus	40
886	serge	41	mov [irq_owner + 4 * ebx], PID_KERNEL ; all handlers belong to a kernel
769	Rus	42
886	serge	43	stdcall enable_irq, [irq]
		44	mov eax, 1
		45	ret
164	serge	46	.err:
886	serge	47	xor eax, eax
		48	ret
164	serge	49	endp
		50
774	Rus	51	uglobal
		52
886	serge	53	irq_rights rd 16
774	Rus	54
		55	endg
		56
		57	proc get_int_handler stdcall, irq:dword
		58
886	serge	59	mov eax, [irq]
774	Rus	60
886	serge	61	cmp [irq_rights + 4 * eax], dword 1
		62	ja .err
774	Rus	63
886	serge	64	mov eax, [irq_tab + 4 * eax]
		65	ret
774	Rus	66
886	serge	67	.err:
		68	xor eax, eax
		69	ret
774	Rus	70	endp
		71
164	serge	72	align 4
		73	proc detach_int_handler
		74
886	serge	75	ret
164	serge	76	endp
		77
		78	align 4
		79	proc enable_irq stdcall, irq_line:dword
886	serge	80	mov ebx, [irq_line]
		81	mov edx, 0x21
		82	cmp ebx, 8
		83	jb @F
		84	mov edx, 0xA1
		85	sub ebx,8
164	serge	86	@@:
886	serge	87	in al,dx
		88	btr eax, ebx
		89	out dx, al
		90	ret
164	serge	91	endp
		92
		93	align 16
		94	;; proc irq_serv
		95
		96	irq_serv:
		97
		98	.irq_1:
886	serge	99	push 1
		100	jmp .main
164	serge	101	align 4
		102	.irq_2:
886	serge	103	push 2
		104	jmp .main
164	serge	105	align 4
		106	.irq_3:
886	serge	107	push 3
		108	jmp .main
164	serge	109	align 4
		110	.irq_4:
886	serge	111	push 4
		112	jmp .main
164	serge	113	align 4
		114	.irq_5:
886	serge	115	push 5
		116	jmp .main
164	serge	117	align 4
		118	.irq_6:
886	serge	119	push 6
		120	jmp .main
164	serge	121	align 4
		122	.irq_7:
886	serge	123	push 7
		124	jmp .main
164	serge	125	align 4
		126	.irq_8:
886	serge	127	push 8
		128	jmp .main
164	serge	129	align 4
		130	.irq_9:
886	serge	131	push 9
		132	jmp .main
164	serge	133	align 4
		134	.irq_10:
886	serge	135	push 10
		136	jmp .main
164	serge	137	align 4
		138	.irq_11:
886	serge	139	push 11
		140	jmp .main
164	serge	141	align 4
		142	.irq_12:
886	serge	143	push 12
		144	jmp .main
164	serge	145	align 4
		146	.irq_13:
886	serge	147	push 13
		148	jmp .main
164	serge	149	align 4
		150	.irq_14:
886	serge	151	push 14
		152	jmp .main
164	serge	153	align 4
		154	.irq_15:
886	serge	155	push 15
		156	jmp .main
164	serge	157
		158	align 16
		159	.main:
886	serge	160	save_ring3_context
		161	mov eax, [esp + 32]
928	serge	162	mov bx, sel_app_data
886	serge	163	mov ds, bx
		164	mov es, bx
164	serge	165
886	serge	166	cmp [v86_irqhooks+eax*8], 0
		167	jnz v86_irq
709	diamond	168
886	serge	169	mov ebx, [irq_tab+eax*4]
		170	test ebx, ebx
		171	jz .exit
164	serge	172
886	serge	173	call ebx
		174	mov [check_idle_semaphore],5
164	serge	175
		176	.exit:
		177
886	serge	178	cmp dword [esp + 32], 8
		179	mov al, 0x20
		180	jb @f
		181
		182	out 0xa0, al
164	serge	183	@@:
886	serge	184	out 0x20, al
164	serge	185
886	serge	186	restore_ring3_context
		187	add esp, 4
769	Rus	188
886	serge	189	iret
164	serge	190
		191	align 4
		192	proc get_notify stdcall, p_ev:dword
		193
		194	.wait:
886	serge	195	mov ebx,[current_slot]
		196	test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
		197	jz @f
		198
		199	and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
		200	mov edi, [p_ev]
		201	mov dword [edi], EV_INTR
		202	mov eax, [ebx+APPDATA.event]
		203	mov dword [edi+4], eax
		204	ret
164	serge	205	@@:
886	serge	206	call change_task
		207	jmp .wait
164	serge	208	endp
		209
		210	align 4
890	serge	211	_PciRead32:
164	serge	212	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
886	serge	213	push ebx
		214	xor eax, eax
		215	xor ebx, ebx
		216	mov ah, byte [bus]
		217	mov al, 6
		218	mov bh, byte [devfn]
		219	mov bl, byte [reg]
		220	call pci_read_reg
		221	pop ebx
		222	ret
164	serge	223	endp
		224
		225	align 4
890	serge	226	_PciRead16:
557	serge	227	proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
886	serge	228	push ebx
		229	xor eax, eax
		230	xor ebx, ebx
		231	mov ah, byte [bus]
		232	mov al, 5
		233	mov bh, byte [devfn]
		234	mov bl, byte [reg]
		235	call pci_read_reg
		236	pop ebx
		237	ret
557	serge	238	endp
		239
		240	align 4
890	serge	241	_PciRead8:
164	serge	242	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
886	serge	243	push ebx
		244	xor eax, eax
		245	xor ebx, ebx
		246	mov ah, byte [bus]
		247	mov al, 4
		248	mov bh, byte [devfn]
		249	mov bl, byte [reg]
		250	call pci_read_reg
		251	pop ebx
		252	ret
164	serge	253	endp
		254
		255	align 4
890	serge	256	_PciWrite8:
164	serge	257	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
886	serge	258	push ebx
		259	xor eax, eax
		260	xor ebx, ebx
		261	mov ah, byte [bus]
		262	mov al, 8
		263	mov bh, byte [devfn]
		264	mov bl, byte [reg]
		265	mov ecx, [val]
		266	call pci_write_reg
		267	pop ebx
		268	ret
164	serge	269	endp
		270
557	serge	271	align 4
890	serge	272	_PciWrite16:
557	serge	273	proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
886	serge	274	push ebx
		275	xor eax, eax
		276	xor ebx, ebx
		277	mov ah, byte [bus]
		278	mov al, 9
		279	mov bh, byte [devfn]
		280	mov bl, byte [reg]
		281	mov ecx, [val]
		282	call pci_write_reg
		283	pop ebx
		284	ret
557	serge	285	endp
		286
672	hidnplayr	287	align 4
890	serge	288	_PciWrite32:
672	hidnplayr	289	proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
886	serge	290	push ebx
		291	xor eax, eax
		292	xor ebx, ebx
		293	mov ah, byte [bus]
		294	mov al, 10
		295	mov bh, byte [devfn]
		296	mov bl, byte [reg]
		297	mov ecx, [val]
		298	call pci_write_reg
		299	pop ebx
		300	ret
672	hidnplayr	301	endp
164	serge	302
672	hidnplayr	303	handle equ IOCTL.handle
		304	io_code equ IOCTL.io_code
		305	input equ IOCTL.input
		306	inp_size equ IOCTL.inp_size
		307	output equ IOCTL.output
		308	out_size equ IOCTL.out_size
164	serge	309
672	hidnplayr	310
164	serge	311	align 4
		312	proc srv_handler stdcall, ioctl:dword
886	serge	313	mov esi, [ioctl]
		314	test esi, esi
		315	jz .err
164	serge	316
886	serge	317	mov edi, [esi+handle]
		318	cmp [edi+SRV.magic], ' SRV'
		319	jne .fail
164	serge	320
886	serge	321	cmp [edi+SRV.size], SRV_SIZE
		322	jne .fail
164	serge	323
886	serge	324	stdcall [edi+SRV.srv_proc], esi
		325	ret
164	serge	326	.fail:
886	serge	327	xor eax, eax
		328	not eax
		329	mov [esi+output], eax
		330	mov [esi+out_size], 4
		331	ret
164	serge	332	.err:
886	serge	333	xor eax, eax
		334	not eax
		335	ret
164	serge	336	endp
		337
377	serge	338	; param
		339	; ebx= io_control
		340	;
		341	; retval
		342	; eax= error code
		343
164	serge	344	align 4
377	serge	345	srv_handlerEx:
886	serge	346	cmp ebx, OS_BASE
		347	jae .fail
164	serge	348
886	serge	349	mov eax, [ebx+handle]
		350	cmp [eax+SRV.magic], ' SRV'
		351	jne .fail
164	serge	352
886	serge	353	cmp [eax+SRV.size], SRV_SIZE
		354	jne .fail
164	serge	355
886	serge	356	stdcall [eax+SRV.srv_proc], ebx
		357	ret
164	serge	358	.fail:
886	serge	359	or eax, -1
		360	ret
164	serge	361
		362	restore handle
		363	restore io_code
		364	restore input
		365	restore inp_size
		366	restore output
		367	restore out_size
		368
		369	align 4
		370	proc get_service stdcall, sz_name:dword
886	serge	371	mov eax, [sz_name]
		372	test eax, eax
		373	jnz @F
		374	ret
164	serge	375	@@:
886	serge	376	mov edx, [srv.fd]
188	serge	377	@@:
886	serge	378	cmp edx, srv.fd-SRV_FD_OFFSET
		379	je .not_load
278	serge	380
886	serge	381	stdcall strncmp, edx, [sz_name], 16
		382	test eax, eax
		383	je .ok
164	serge	384
886	serge	385	mov edx, [edx+SRV.fd]
		386	jmp @B
164	serge	387	.not_load:
886	serge	388	pop ebp
		389	jmp load_driver
164	serge	390	.ok:
886	serge	391	mov eax, edx
		392	ret
164	serge	393	endp
		394
		395	align 4
890	serge	396	_RegService:
740	serge	397	proc reg_service stdcall, name:dword, handler:dword
164	serge	398
886	serge	399	push ebx
164	serge	400
819	serge	401	xor eax, eax
		402
886	serge	403	cmp [name], eax
		404	je .fail
740	serge	405
886	serge	406	cmp [handler], eax
		407	je .fail
740	serge	408
886	serge	409	mov eax, SRV_SIZE
		410	call malloc ;call alloc_service
		411	test eax, eax
		412	jz .fail
164	serge	413
886	serge	414	push esi
		415	push edi
		416	mov edi, eax
		417	mov esi, [name]
		418	mov ecx, 16/4
		419	rep movsd
		420	pop edi
		421	pop esi
164	serge	422
886	serge	423	mov [eax+SRV.magic], ' SRV'
		424	mov [eax+SRV.size], SRV_SIZE
278	serge	425
886	serge	426	mov ebx, srv.fd-SRV_FD_OFFSET
		427	mov edx, [ebx+SRV.fd]
		428	mov [eax+SRV.fd], edx
		429	mov [eax+SRV.bk], ebx
		430	mov [ebx+SRV.fd], eax
		431	mov [edx+SRV.bk], eax
278	serge	432
886	serge	433	mov ecx, [handler]
		434	mov [eax+SRV.srv_proc], ecx
		435	pop ebx
		436	ret
164	serge	437	.fail:
886	serge	438	xor eax, eax
819	serge	439	pop ebx
886	serge	440	ret
740	serge	441	endp
164	serge	442
		443	align 4
		444	proc get_proc stdcall, exp:dword, sz_name:dword
		445
886	serge	446	mov edx, [exp]
164	serge	447	.next:
886	serge	448	mov eax, [edx]
		449	test eax, eax
		450	jz .end
164	serge	451
886	serge	452	push edx
		453	stdcall strncmp, eax, [sz_name], 16
		454	pop edx
		455	test eax, eax
		456	jz .ok
164	serge	457
886	serge	458	add edx,8
		459	jmp .next
164	serge	460	.ok:
886	serge	461	mov eax, [edx+4]
164	serge	462	.end:
886	serge	463	ret
164	serge	464	endp
		465
		466	align 4
		467	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
		468
		469	@@:
886	serge	470	stdcall strncmp, [pSym], [sz_sym], 8
		471	test eax,eax
		472	jz .ok
		473	add [pSym], 18
		474	dec [count]
		475	jnz @b
		476
		477	xor eax, eax
		478	ret
164	serge	479	.ok:
886	serge	480	mov ebx, [pSym]
		481	mov eax, [ebx+8]
		482	ret
164	serge	483	endp
		484
		485	align 4
886	serge	486	get_curr_task:
		487	mov eax,[CURRENT_TASK]
		488	shl eax, 8
		489	ret
164	serge	490
188	serge	491	align 4
		492	proc get_fileinfo stdcall, file_name:dword, info:dword
886	serge	493	locals
		494	cmd dd ?
		495	offset dd ?
		496	dd ?
		497	count dd ?
		498	buff dd ?
		499	db ?
		500	name dd ?
		501	endl
164	serge	502
886	serge	503	xor eax, eax
		504	mov ebx, [file_name]
		505	mov ecx, [info]
164	serge	506
886	serge	507	mov [cmd], 5
		508	mov [offset], eax
		509	mov [offset+4], eax
		510	mov [count], eax
		511	mov [buff], ecx
		512	mov byte [buff+4], al
		513	mov [name], ebx
164	serge	514
886	serge	515	mov eax, 70
		516	lea ebx, [cmd]
928	serge	517	int 0x41
886	serge	518	ret
188	serge	519	endp
164	serge	520
188	serge	521	align 4
		522	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
672	hidnplayr	523	bytes:dword
886	serge	524	locals
		525	cmd dd ?
		526	offset dd ?
		527	dd ?
		528	count dd ?
		529	buff dd ?
		530	db ?
		531	name dd ?
		532	endl
164	serge	533
886	serge	534	xor eax, eax
		535	mov ebx, [file_name]
		536	mov ecx, [off]
		537	mov edx, [bytes]
		538	mov esi, [buffer]
164	serge	539
886	serge	540	mov [cmd], eax
		541	mov [offset], ecx
		542	mov [offset+4], eax
		543	mov [count], edx
		544	mov [buff], esi
		545	mov byte [buff+4], al
		546	mov [name], ebx
188	serge	547
886	serge	548	pushad
		549	push eax
		550	lea eax, [cmd]
		551	call file_system_lfn
		552	pop eax
		553	popad
		554	ret
188	serge	555	endp
		556
363	serge	557	; description
		558	; allocate kernel memory and loads the specified file
		559	;
		560	; param
		561	; file_name= full path to file
		562	;
		563	; retval
		564	; eax= file image in kernel memory
		565	; ebx= size of file
		566	;
		567	; warging
887	serge	568	; You mast call mem_free() to delete each file
363	serge	569	; loaded by the load_file() function
		570
188	serge	571	align 4
890	serge	572	_LoadFile:
889	serge	573	_load_file@4:
188	serge	574	proc load_file stdcall, file_name:dword
886	serge	575	locals
		576	attr dd ?
		577	flags dd ?
		578	cr_time dd ?
		579	cr_date dd ?
		580	acc_time dd ?
		581	acc_date dd ?
		582	mod_time dd ?
		583	mod_date dd ?
		584	file_size dd ?
188	serge	585
886	serge	586	file dd ?
		587	file2 dd ?
		588	endl
188	serge	589
886	serge	590	push esi
		591	push edi
662	serge	592
886	serge	593	lea eax, [attr]
		594	stdcall get_fileinfo, [file_name], eax
		595	test eax, eax
		596	jnz .fail
164	serge	597
864	serge	598	mov ecx, [file_size]
		599	cmp ecx, 1024102416
886	serge	600	ja .fail
206	serge	601
864	serge	602	mov edx, PG_SW
		603	call @mem_alloc@8
886	serge	604	mov [file], eax
864	serge	605	test eax, eax
		606	jz .fail
164	serge	607
886	serge	608	stdcall read_file, [file_name], eax, dword 0, [file_size]
		609	cmp ebx, [file_size]
		610	jne .cleanup
211	serge	611
886	serge	612	mov eax, [file]
		613	cmp dword [eax], 0x4B43504B
		614	jne .exit
211	serge	615
864	serge	616	mov ecx, [eax+4]
		617	mov [file_size], ecx
		618	mov edx, PG_SW
		619	call @mem_alloc@8
886	serge	620	test eax, eax
		621	jz .cleanup
211	serge	622
886	serge	623	mov [file2], eax
		624	stdcall unpack, [file], eax
		625
		626	mov ecx, [file]
		627	call @mem_free@4
		628
		629	mov eax, [file2]
		630	mov ebx, [file_size]
211	serge	631	.exit:
886	serge	632	push eax
		633	lea edi, [eax+ebx] ;cleanup remain space
887	serge	634	mov ecx, 4096 ;from file end
886	serge	635	and ebx, 4095
		636	jz @f
		637	sub ecx, ebx
		638	xor eax, eax
		639	cld
		640	rep stosb
521	diamond	641	@@:
886	serge	642	mov ebx, [file_size]
		643	pop eax
		644	pop edi
		645	pop esi
		646	ret
188	serge	647	.cleanup:
887	serge	648	mov ecx, [file]
		649	call @mem_free@4
188	serge	650	.fail:
886	serge	651	xor eax, eax
		652	xor ebx, ebx
		653	pop edi
		654	pop esi
		655	ret
188	serge	656	endp
164	serge	657
188	serge	658	align 4
		659	proc get_proc_ex stdcall, proc_name:dword, imports:dword
		660
		661	.look_up:
886	serge	662	mov edx, [imports]
		663	test edx, edx
		664	jz .end
		665	mov edx, [edx]
		666	test edx, edx
		667	jz .end
188	serge	668	.next:
886	serge	669	mov eax, [edx]
		670	test eax, eax
		671	jz .next_table
164	serge	672
886	serge	673	push edx
		674	stdcall strncmp, eax, [proc_name], 16
		675	pop edx
		676	test eax, eax
		677	jz .ok
164	serge	678
886	serge	679	add edx,8
		680	jmp .next
188	serge	681	.next_table:
886	serge	682	add [imports], 4
		683	jmp .look_up
188	serge	684	.ok:
886	serge	685	mov eax, [edx+4]
		686	ret
188	serge	687	.end:
886	serge	688	xor eax, eax
		689	ret
188	serge	690	endp
164	serge	691
188	serge	692	align 4
		693	proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
672	hidnplayr	694	sym_count:dword, strings:dword, imports:dword
886	serge	695	locals
		696	retval dd ?
		697	endl
164	serge	698
886	serge	699	mov edi, [symbols]
		700	mov [retval], 1
188	serge	701	.fix:
886	serge	702	movzx ebx, [edi+CSYM.SectionNumber]
		703	test ebx, ebx
		704	jnz .internal
		705	mov eax, dword [edi+CSYM.Name]
		706	test eax, eax
		707	jnz @F
164	serge	708
886	serge	709	mov edi, [edi+4]
		710	add edi, [strings]
188	serge	711	@@:
886	serge	712	push edi
		713	stdcall get_proc_ex, edi,[imports]
		714	pop edi
164	serge	715
886	serge	716	xor ebx, ebx
		717	test eax, eax
		718	jnz @F
164	serge	719
886	serge	720	mov esi, msg_unresolved
		721	call sys_msg_board_str
		722	mov esi, edi
		723	call sys_msg_board_str
		724	mov esi, msg_CR
		725	call sys_msg_board_str
164	serge	726
886	serge	727	mov [retval],0
188	serge	728	@@:
886	serge	729	mov edi, [symbols]
		730	mov [edi+CSYM.Value], eax
		731	jmp .next
188	serge	732	.internal:
886	serge	733	cmp bx, -1
		734	je .next
		735	cmp bx, -2
		736	je .next
541	serge	737
886	serge	738	dec ebx
		739	shl ebx, 3
		740	lea ebx, [ebx+ebx*4]
		741	add ebx, [sec]
188	serge	742
886	serge	743	mov eax, [ebx+CFS.VirtualAddress]
		744	add [edi+CSYM.Value], eax
188	serge	745	.next:
886	serge	746	add edi, CSYM_SIZE
		747	mov [symbols], edi
		748	dec [sym_count]
		749	jnz .fix
		750	mov eax, [retval]
		751	ret
164	serge	752	endp
		753
		754	align 4
188	serge	755	proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
886	serge	756	locals
		757	n_sec dd ?
		758	endl
164	serge	759
886	serge	760	mov eax, [coff]
		761	movzx ebx, [eax+CFH.nSections]
		762	mov [n_sec], ebx
188	serge	763	.fix_sec:
886	serge	764	mov esi, [sec]
		765	mov edi, [esi+CFS.PtrReloc]
		766	add edi, [coff]
164	serge	767
886	serge	768	movzx ecx, [esi+CFS.NumReloc]
		769	test ecx, ecx
		770	jz .next
188	serge	771	.next_reloc:
886	serge	772	mov ebx, [edi+CRELOC.SymIndex]
		773	add ebx,ebx
		774	lea ebx,[ebx+ebx*8]
		775	add ebx, [sym]
164	serge	776
886	serge	777	mov edx, [ebx+CSYM.Value]
164	serge	778
886	serge	779	cmp [edi+CRELOC.Type], 6
		780	je .dir_32
164	serge	781
886	serge	782	cmp [edi+CRELOC.Type], 20
		783	jne .next_reloc
188	serge	784	.rel_32:
886	serge	785	mov eax, [edi+CRELOC.VirtualAddress]
		786	add eax, [esi+CFS.VirtualAddress]
		787	sub edx, eax
		788	sub edx, 4
		789	jmp .fix
188	serge	790	.dir_32:
886	serge	791	mov eax, [edi+CRELOC.VirtualAddress]
		792	add eax, [esi+CFS.VirtualAddress]
188	serge	793	.fix:
886	serge	794	add [eax], edx
		795	add edi, 10
		796	dec ecx
		797	jnz .next_reloc
188	serge	798	.next:
886	serge	799	add [sec], COFF_SECTION_SIZE
		800	dec [n_sec]
		801	jnz .fix_sec
164	serge	802	.exit:
886	serge	803	ret
164	serge	804	endp
		805
188	serge	806	align 4
346	diamond	807	proc load_driver stdcall, driver_name:dword
886	serge	808	locals
		809	coff dd ?
		810	sym dd ?
		811	strings dd ?
		812	img_size dd ?
		813	img_base dd ?
		814	start dd ?
188	serge	815
886	serge	816	exports dd ? ;fake exports table
		817	dd ?
		818	file_name rb 13+16+4+1 ; '/sys/drivers/.obj'
		819	endl
188	serge	820
886	serge	821	lea edx, [file_name]
		822	mov dword [edx], '/sys'
		823	mov dword [edx+4], '/dri'
		824	mov dword [edx+8], 'vers'
		825	mov byte [edx+12], '/'
		826	mov esi, [driver_name]
		827	lea edi, [edx+13]
		828	mov ecx, 16
346	diamond	829	@@:
886	serge	830	lodsb
		831	test al, al
		832	jz @f
		833	stosb
		834	loop @b
346	diamond	835	@@:
886	serge	836	mov dword [edi], '.obj'
		837	mov byte [edi+4], 0
		838	stdcall load_file, edx
887	serge	839	mov [coff], eax
886	serge	840	test eax, eax
		841	jz .exit
188	serge	842
864	serge	843	movzx ebx, [eax+CFH.nSections]
886	serge	844	lea edx, [eax+20]
864	serge	845	xor ecx, ecx
188	serge	846	@@:
864	serge	847	add ecx, [edx+CFS.SizeOfRawData]
		848	add ecx, 15
		849	and ecx, not 15
886	serge	850	add edx, COFF_SECTION_SIZE
864	serge	851	dec ebx
886	serge	852	jnz @B
188	serge	853
864	serge	854	mov [img_size], ecx
		855	mov edx, PG_SW
		856	call @mem_alloc@8
886	serge	857	test eax, eax
887	serge	858	mov [img_base], eax
886	serge	859	jz .fail
188	serge	860
886	serge	861	mov [img_base], eax
188	serge	862
886	serge	863	mov edi, eax
		864	xor eax, eax
		865	mov ecx, [img_size]
		866	add ecx, 4095
		867	and ecx, not 4095
		868	shr ecx, 2
		869	cld
		870	rep stosd
		871
		872	mov edx, [coff]
		873	movzx ebx, [edx+CFH.nSections]
		874	mov edi, [img_base]
		875	lea eax, [edx+20]
188	serge	876	@@:
886	serge	877	mov [eax+CFS.VirtualAddress], edi
		878	mov esi, [eax+CFS.PtrRawData]
		879	test esi, esi
		880	jnz .copy
		881	add edi, [eax+CFS.SizeOfRawData]
		882	jmp .next
188	serge	883	.copy:
886	serge	884	add esi, edx
		885	mov ecx, [eax+CFS.SizeOfRawData]
		886	cld
		887	rep movsb
188	serge	888	.next:
886	serge	889	add edi, 15
		890	and edi, not 15
		891	add eax, COFF_SECTION_SIZE
		892	dec ebx
		893	jnz @B
188	serge	894
886	serge	895	mov ebx, [edx+CFH.pSymTable]
		896	add ebx, edx
		897	mov [sym], ebx
		898	mov ecx, [edx+CFH.nSymbols]
		899	add ecx,ecx
		900	lea ecx,[ecx+ecx8] ;ecx=18 = nSymbols*CSYM_SIZE
		901	add ecx, [sym]
		902	mov [strings], ecx
188	serge	903
886	serge	904	lea ebx, [exports]
		905	mov dword [ebx], kernel_export
		906	mov dword [ebx+4], 0
		907	lea eax, [edx+20]
188	serge	908
886	serge	909	stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
		910	[strings], ebx
		911	test eax, eax
		912	jz .link_fail
188	serge	913
886	serge	914	mov ebx, [coff]
		915	add ebx, 20
		916	stdcall fix_coff_relocs, [coff], ebx, [sym]
188	serge	917
886	serge	918	mov ebx, [coff]
		919	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
		920	test eax, eax
		921	jz .link_fail
227	serge	922
886	serge	923	mov eax, [eax]
		924	shr eax, 16
		925	cmp eax, DRV_COMPAT
		926	jb .ver_fail
227	serge	927
886	serge	928	cmp eax, DRV_CURRENT
		929	ja .ver_fail
227	serge	930
886	serge	931	mov ebx, [coff]
		932	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
		933	mov [start], eax
188	serge	934
887	serge	935	mov ecx, [coff]
		936	call @mem_free@4
188	serge	937
886	serge	938	mov ebx, [start]
		939	stdcall ebx, DRV_ENTRY
		940	test eax, eax
		941	jnz .ok
188	serge	942
887	serge	943	mov ecx, [img_base]
		944	call @mem_free@4
886	serge	945	xor eax, eax
		946	ret
188	serge	947	.ok:
886	serge	948	mov ebx, [img_base]
		949	mov [eax+SRV.base], ebx
		950	mov ecx, [start]
		951	mov [eax+SRV.entry], ecx
		952	ret
227	serge	953
		954	.ver_fail:
886	serge	955	mov esi, msg_CR
		956	call sys_msg_board_str
		957	mov esi, [driver_name]
		958	call sys_msg_board_str
		959	mov esi, msg_CR
		960	call sys_msg_board_str
		961	mov esi, msg_version
		962	call sys_msg_board_str
		963	mov esi, msg_www
		964	call sys_msg_board_str
		965	jmp .cleanup
227	serge	966
		967	.link_fail:
886	serge	968	mov esi, msg_module
		969	call sys_msg_board_str
		970	mov esi, [driver_name]
		971	call sys_msg_board_str
		972	mov esi, msg_CR
		973	call sys_msg_board_str
227	serge	974	.cleanup:
887	serge	975	mov ecx, [img_base]
		976	call @mem_free@4
188	serge	977	.fail:
887	serge	978	mov ecx, [coff]
		979	call @mem_free@4
227	serge	980	.exit:
886	serge	981	xor eax, eax
		982	ret
164	serge	983	endp
		984
198	serge	985	align 4
		986	proc load_library stdcall, file_name:dword
886	serge	987	locals
		988	coff dd ?
		989	sym dd ?
		990	strings dd ?
		991	img_size dd ?
		992	img_base dd ?
		993	exports dd ?
		994	endl
198	serge	995
886	serge	996	cli
198	serge	997
886	serge	998	stdcall load_file, [file_name]
		999	test eax, eax
		1000	jz .fail
198	serge	1001
886	serge	1002	mov [coff], eax
		1003	movzx ecx, [eax+CFH.nSections]
		1004	xor ebx, ebx
198	serge	1005
886	serge	1006	lea edx, [eax+20]
198	serge	1007	@@:
886	serge	1008	add ebx, [edx+CFS.SizeOfRawData]
		1009	add ebx, 15
		1010	and ebx, not 15
		1011	add edx, COFF_SECTION_SIZE
		1012	dec ecx
		1013	jnz @B
		1014	mov [img_size], ebx
198	serge	1015
886	serge	1016	call init_heap
		1017	stdcall user_alloc, [img_size]
198	serge	1018
886	serge	1019	test eax, eax
		1020	jz .fail
		1021	mov [img_base], eax
198	serge	1022
886	serge	1023	mov edx, [coff]
		1024	movzx ebx, [edx+CFH.nSections]
		1025	mov edi, [img_base]
		1026	lea eax, [edx+20]
198	serge	1027	@@:
886	serge	1028	mov [eax+CFS.VirtualAddress], edi
		1029	mov esi, [eax+CFS.PtrRawData]
		1030	test esi, esi
		1031	jnz .copy
		1032	add edi, [eax+CFS.SizeOfRawData]
		1033	jmp .next
198	serge	1034	.copy:
886	serge	1035	add esi, edx
		1036	mov ecx, [eax+CFS.SizeOfRawData]
		1037	cld
		1038	rep movsb
198	serge	1039	.next:
886	serge	1040	add edi, 15 ;-new_app_base
		1041	and edi, -16
		1042	add eax, COFF_SECTION_SIZE
		1043	dec ebx
		1044	jnz @B
198	serge	1045
886	serge	1046	mov ebx, [edx+CFH.pSymTable]
		1047	add ebx, edx
		1048	mov [sym], ebx
		1049	mov ecx, [edx+CFH.nSymbols]
		1050	add ecx,ecx
		1051	lea ecx,[ecx+ecx8] ;ecx=18 = nSymbols*CSYM_SIZE
		1052	add ecx, [sym]
		1053	mov [strings], ecx
198	serge	1054
886	serge	1055	lea eax, [edx+20]
198	serge	1056
886	serge	1057	stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
		1058	[strings], dword 0
		1059	test eax, eax
		1060	jnz @F
198	serge	1061
		1062	@@:
886	serge	1063	mov edx, [coff]
198	serge	1064
840	serge	1065	; movzx ebx, [edx+CFH.nSections]
		1066	; xor edi, edi
		1067	; lea eax, [edx+20]
		1068	;@@:
		1069	; add [eax+CFS.VirtualAddress], edi ;patch user space offset
		1070	; add eax, COFF_SECTION_SIZE
		1071	; dec ebx
		1072	; jnz @B
		1073
886	serge	1074	add edx, 20
		1075	stdcall fix_coff_relocs, [coff], edx, [sym]
198	serge	1076
886	serge	1077	mov ebx, [coff]
		1078	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
		1079	mov [exports], eax
198	serge	1080
887	serge	1081	mov ecx, [coff]
		1082	call @mem_free@4
		1083
886	serge	1084	mov eax, [exports]
		1085	ret
198	serge	1086	.fail:
886	serge	1087	xor eax, eax
		1088	ret
198	serge	1089	endp
		1090
214	serge	1091	align 4
		1092	proc stop_all_services
278	serge	1093
886	serge	1094	mov edx, [srv.fd]
214	serge	1095	.next:
886	serge	1096	cmp edx, srv.fd-SRV_FD_OFFSET
		1097	je .done
		1098	cmp [edx+SRV.magic], ' SRV'
		1099	jne .next
		1100	cmp [edx+SRV.size], SRV_SIZE
		1101	jne .next
732	serge	1102
886	serge	1103	mov ebx, [edx+SRV.entry]
		1104	mov edx, [edx+SRV.fd]
		1105	test ebx, ebx
		1106	jz .next
732	serge	1107
886	serge	1108	push edx
		1109	stdcall ebx, dword -1
		1110	pop edx
		1111	jmp .next
278	serge	1112	.done:
886	serge	1113	ret
214	serge	1114	endp
198	serge	1115
281	serge	1116	; param
291	serge	1117	; eax= size
		1118	; ebx= pid
214	serge	1119
281	serge	1120	align 4
890	serge	1121	_CreateObject:
281	serge	1122	create_kernel_object:
		1123
886	serge	1124	push ebx
		1125	call malloc
		1126	pop ebx
		1127	test eax, eax
		1128	jz .fail
281	serge	1129
886	serge	1130	mov ecx,[current_slot]
		1131	add ecx, APP_OBJ_OFFSET
281	serge	1132
886	serge	1133	pushfd
		1134	cli
		1135	mov edx, [ecx+APPOBJ.fd]
		1136	mov [eax+APPOBJ.fd], edx
		1137	mov [eax+APPOBJ.bk], ecx
		1138	mov [eax+APPOBJ.pid], ebx
281	serge	1139
886	serge	1140	mov [ecx+APPOBJ.fd], eax
		1141	mov [edx+APPOBJ.bk], eax
		1142	popfd
281	serge	1143	.fail:
886	serge	1144	ret
281	serge	1145
		1146	; param
		1147	; eax= object
		1148
		1149	align 4
890	serge	1150	_DestroyObject:
281	serge	1151	destroy_kernel_object:
		1152
886	serge	1153	pushfd
		1154	cli
		1155	mov ebx, [eax+APPOBJ.fd]
		1156	mov ecx, [eax+APPOBJ.bk]
		1157	mov [ebx+APPOBJ.bk], ecx
		1158	mov [ecx+APPOBJ.fd], ebx
		1159	popfd
281	serge	1160
886	serge	1161	xor edx, edx ;clear common header
		1162	mov [eax], edx
		1163	mov [eax+4], edx
		1164	mov [eax+8], edx
		1165	mov [eax+12], edx
		1166	mov [eax+16], edx
281	serge	1167
886	serge	1168	call free ;release object memory
		1169	ret
281	serge	1170
		1171
164	serge	1172
465	serge	1173	if 0
164	serge	1174
465	serge	1175	irq:
188	serge	1176
465	serge	1177	.irq0:
672	hidnplayr	1178	pusfd
		1179	pushad
		1180	push IRQ_0
		1181	jmp .master
465	serge	1182	.irq_1:
672	hidnplayr	1183	pusfd
		1184	pushad
		1185	push IRQ_1
		1186	jmp .master
465	serge	1187
		1188	.master:
672	hidnplayr	1189	mov ax, app_data
		1190	mov ds, eax
		1191	mov es, eax
		1192	mov ebx, [esp+4] ;IRQ_xx
		1193	mov eax, [irq_handlers+ebx+4]
		1194	call intr_handler
		1195	mov ecx, [esp+4]
		1196	cmp [irq_actids+ecx*4], 0
		1197	je @F
		1198	in al, 0x21
		1199	bts eax, ecx
		1200	out 0x21, al
		1201	mov al, 0x20
		1202	out 0x20, al
		1203	jmp .restart
465	serge	1204
		1205	.slave:
672	hidnplayr	1206	mov ax, app_data
		1207	mov ds, eax
		1208	mov es, eax
		1209	mov ebx, [esp+4] ;IRQ_xx
		1210	mov eax, [irq_handlers+ebx+4]
		1211	call intr_handler
		1212	mov ecx, [esp+4]
		1213	sub ecx, 8
		1214	cmp [irq_actids+ecx*4], 0
		1215	je @F
		1216	in al, 0xA1
		1217	bts eax, ecx
		1218	out 0xA1, al
		1219	mov al, 0x20
		1220	out 0xA0, al
		1221	out 0x20, al
465	serge	1222	.restart:
672	hidnplayr	1223	mov ebx, [next_slot]
		1224	test ebx, ebx
		1225	jz @F
		1226	mov [next_task],0
		1227	mov esi, [prev_slot]
		1228	call do_change_task
		1229	add esp, 4
		1230	iretd
465	serge	1231
		1232	end if
		1233

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/dll.inc – Rev 928