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

Subversion Repositories Kolibri OS

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