WebSVN – Kolibri OS – Blame – /drivers/include/syscall.h

Rev	Author	Line No.	Line
1029	serge	1
1630	serge	2
		3
1408	serge	4	#define __SYSCALL_H__
		5
		6
5270	serge	7	typedef u32 count_t;
		8
		9
1029	serge	10
		11
1434	serge	12	#define FASTCALL __attribute__ ((fastcall)) __attribute__ ((dllimport))
		13
1029	serge	14
1434	serge	15
		16
1029	serge	17
		18
		19	#define PciApi __PciApi
		20	#define CreateObject __CreateObject
		21	#define DestroyObject __DestroyObject
		22
		23
1872	serge	24
		25
1029	serge	26
		27
		28
		29	void STDCALL FreeKernelSpace(void *mem)__asm__("FreeKernelSpace");
1408	serge	30	addr_t STDCALL MapIoMem(addr_t base, size_t size, u32 flags)__asm__("MapIoMem");
5270	serge	31	void* STDCALL KernelAlloc(size_t size)__asm__("KernelAlloc");
1029	serge	32	void* STDCALL KernelFree(void *mem)__asm__("KernelFree");
		33	void* STDCALL UserAlloc(size_t size)__asm__("UserAlloc");
		34	int STDCALL UserFree(void *mem)__asm__("UserFree");
		35
		36
1613	serge	37
1408	serge	38
5270	serge	39
1408	serge	40
1613	serge	41	addr_t STDCALL AllocPages(count_t count)__asm__("AllocPages");
1029	serge	42	void IMPORT __attribute__((regparm(1)))
2967	Serge	43	FreePage(addr_t page)__asm__("FreePage");
		44	void STDCALL MapPage(void *vaddr, addr_t paddr, u32 flags)__asm__("MapPage");
5270	serge	45
1029	serge	46
2967	Serge	47
5270	serge	48
1029	serge	49
5270	serge	50
1029	serge	51
5270	serge	52
1029	serge	53
1434	serge	54	void FASTCALL MutexLock(struct mutex*)__asm__("MutexLock");
		55	void FASTCALL MutexUnlock(struct mutex*)__asm__("MutexUnlock");
		56
1029	serge	57
1872	serge	58	u32 IMPORT GetPid(void)__asm__("GetPid");
5270	serge	59
1872	serge	60
4125	Serge	61	void fn, void data)asm("TimerHS");
		62
2967	Serge	63
4125	Serge	64
		65
3482	Serge	66
		67
1029	serge	68
		69
		70	int z, int h)__asm__("SetMouseData");
		71
		72
5270	serge	73
1872	serge	74
		75
5270	serge	76	u16 STDCALL PciRead16(u32 bus, u32 devfn, u32 reg)__asm__("PciRead16");
		77	u32 STDCALL PciRead32(u32 bus, u32 devfn, u32 reg)__asm__("PciRead32");
		78
1029	serge	79
5270	serge	80	u32 STDCALL PciWrite16(u32 bus, u32 devfn, u32 reg,u16 val)__asm__("PciWrite16");
		81	u32 STDCALL PciWrite32(u32 bus, u32 devfn, u32 reg,u32 val)__asm__("PciWrite32");
		82
1029	serge	83
		84	PciRead8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))
		85
		86
		87	PciRead16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))
		88
		89
		90	PciRead32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))
		91
		92
		93	PciWrite8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))
		94
		95
		96	PciWrite16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))
		97
		98
		99	PciWrite32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))
		100
		101
3031	serge	102	u8 *val)
		103	{
		104	*val = PciRead8(dev->busnr, dev->devfn, where);
		105	return 1;
		106	}
		107
		108
		109	u16 *val)
		110	{
		111	*val = PciRead16(dev->busnr, dev->devfn, where);
		112	return 1;
		113	}
		114
		115
		116	u32 *val)
		117	{
		118	*val = PciRead32(dev->busnr, dev->devfn, where);
		119	return 1;
		120	}
		121
		122
		123	u8 val)
		124	{
		125	PciWrite8(dev->busnr, dev->devfn, where, val);
		126	return 1;
		127	}
		128
		129
		130	u16 val)
		131	{
		132	PciWrite16(dev->busnr, dev->devfn, where, val);
		133	return 1;
		134	}
		135
		136
		137	u32 val)
		138	{
		139	PciWrite32(dev->busnr, dev->devfn, where, val);
		140	return 1;
		141	}
		142
		143
1029	serge	144
		145
		146	int dbgprintf(const char* format, ...);
		147
		148
		149
		150
4110	Serge	151	{
		152	int pid;
		153	__asm__ __volatile__ (
		154	"call *__imp__CreateThread"
		155	:"=a"(pid)
		156	:"b"(1),"c"(entry),"d"(0)
		157	:"memory");
		158	__asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");
		159	return pid;
		160	};
		161
		162
		163
5270	serge	164	{
1029	serge	165	evhandle_t evh;
1616	serge	166
1613	serge	167
		168	"call *__imp__CreateEvent"
		169	:"=A"(evh.raw)
1616	serge	170	:"S" (ev), "c"(flags)
		171	:"memory");
		172	__asm__ __volatile__ ("":::"ebx","ecx","edx","esi", "edi");
2005	serge	173
1613	serge	174
1616	serge	175	};
		176
1613	serge	177
5270	serge	178	{
1616	serge	179	__asm__ __volatile__ (
		180	"call *__imp__RaiseEvent"
		181	::"a"(evh.handle),"b"(evh.euid),"d"(flags),"S" (ev)
		182	:"memory");
		183	__asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");
2005	serge	184
1616	serge	185
		186
		187
2005	serge	188	{
1616	serge	189	__asm__ __volatile__ (
		190	"call *__imp__WaitEvent"
		191	::"a"(evh.handle),"b"(evh.euid));
2005	serge	192	__asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");
		193	};
1616	serge	194
		195
3391	Serge	196	{
		197	int retval;
		198	__asm__ __volatile__ (
		199	"call *__imp__WaitEventTimeout"
		200	:"=a"(retval)
		201	:"a"(evh.handle),"b"(evh.euid), "c"(timeout));
		202	__asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");
		203	return retval;
		204	};
		205
		206
2967	Serge	207	{
		208	__asm__ __volatile__ (
		209	"call *__imp__DestroyEvent"
		210	::"a"(evh.handle),"b"(evh.euid));
		211	__asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");
		212	};
		213
		214
5270	serge	215	{
1616	serge	216	u32 handle;
5270	serge	217
1616	serge	218
		219	"call *__imp__GetEvent"
		220	:"=a"(handle)
		221	:"D"(ev)
		222	:"memory");
		223	__asm__ __volatile__ ("":::"ebx","ecx","edx", "esi","edi");
		224	return handle;
1613	serge	225	};
		226
		227
1616	serge	228
1613	serge	229	{
		230	int retval;
1029	serge	231
		232
		233	:"=a"(retval)
		234	:"a"(61), "b"(1));
		235	return retval;
		236	}
		237
		238
1613	serge	239	{
1029	serge	240	int retval;
		241
		242
		243	:"=a"(retval)
		244	:"a"(61), "b"(2));
		245	return retval;
		246	}
		247
		248
1613	serge	249	{
1029	serge	250	int retval;
		251
		252
		253	:"=a"(retval)
		254	:"a"(61), "b"(3));
		255	return retval;
		256	}
		257
		258
5270	serge	259	{
1029	serge	260	u32 retval;
5270	serge	261
1029	serge	262
		263	"call *__imp__GetPgAddr \n\t"
		264	:"=a" (retval)
2967	Serge	265	:"a" (mem) );
1029	serge	266	return retval;
		267	};
		268
		269
5270	serge	270	{
1029	serge	271	size = (size+4095) & ~4095;
		272	__asm__ __volatile__ (
		273	"call *__imp__CommitPages"
		274	::"a" (page), "b"(mem),"c"(size>>12)
		275	:"edx" );
		276	__asm__ __volatile__ ("":::"eax","ebx","ecx");
		277	};
		278
		279
1408	serge	280	{
1029	serge	281	size = (size+4095) & ~4095;
		282	__asm__ __volatile__ (
		283	"call *__imp__UnmapPages"
		284	::"a" (mem), "c"(size>>12)
		285	:"edx");
		286	__asm__ __volatile__ ("":::"eax","ecx");
		287	};
		288
		289
5270	serge	290	{
1029	serge	291	if( !delay )
		292	delay++;
		293	delay*= 500;
1408	serge	294
1029	serge	295
		296	__asm__ __volatile__(
1408	serge	297	"xorl %%eax, %%eax \n\t"
		298	"cpuid \n\t"
		299	:::"eax","ebx","ecx","edx");
		300	};
		301
		302
5270	serge	303	{
1408	serge	304	if(!delay) delay++;
		305	delay*= 100;
2967	Serge	306
1408	serge	307
		308	{
		309	__asm__ __volatile__(
		310	"xorl %%eax, %%eax \n\t"
		311	"cpuid"
		312	:::"eax","ebx","ecx","edx" );
		313	}
		314	}
		315
		316
5270	serge	317	{
1964	serge	318	msecs /= 10;
		319	if(!msecs) msecs = 1;
		320
		321
		322	"call *__imp__Delay"
		323	::"b" (msecs));
		324	__asm__ __volatile__ (
		325	"":::"ebx");
		326
		327
		328
		329
5270	serge	330	{
1408	serge	331	time /= 10;
		332	if(!time) time = 1;
		333
		334
1029	serge	335	"call *__imp__Delay"
1408	serge	336	::"b" (time));
		337	__asm__ __volatile__ (
		338	"":::"ebx");
		339
		340
1029	serge	341
		342
5270	serge	343	{
1029	serge	344	u32 retval;
5270	serge	345
1029	serge	346
		347	"call *__imp__PciApi \n\t"
1616	serge	348	"movzxb %%al, %%eax"
		349	:"=a" (retval)
1029	serge	350	:"a" (cmd)
		351	:"cc");
1630	serge	352
		353
1029	serge	354	};
		355
		356
5270	serge	357	{
1029	serge	358	void *retval;
		359
		360
		361	"call *__imp__CreateObject \n\t"
		362	:"=a" (retval)
		363	:"a" (size),"b"(pid)
		364	:"esi","edi", "memory");
		365	return retval;
		366	}
		367
		368
1408	serge	369	{
1029	serge	370	__asm__ __volatile__ (
		371	"call *__imp__DestroyObject \n\t"
1408	serge	372	:
1029	serge	373	:"a" (obj));
1408	serge	374	__asm__ __volatile__ (
		375	""
		376	:::"eax","ebx","ecx","edx","esi","edi","cc","memory");
		377	}
1029	serge	378
		379
5270	serge	380	{
1029	serge	381	u32 handle;
5270	serge	382
1408	serge	383
		384	(
		385	"pushl %%eax \n\t"
		386	"call *__imp__GetService"
		387	:"=a" (handle)
2967	Serge	388	:"a" (name)
1408	serge	389	:"ebx","ecx","edx","esi", "edi"
		390	);
		391	return handle;
		392	};
		393
		394
5270	serge	395	{
1408	serge	396	u32 ifl;
5270	serge	397	__asm__ __volatile__ (
1029	serge	398	"pushf\n\t"
		399	"popl %0\n\t"
		400	"cli\n"
		401	: "=r" (ifl));
		402	return ifl;
		403	}
		404
		405
5270	serge	406	{
1029	serge	407	if (efl & (1<<9))
1616	serge	408	__asm__ __volatile__ ("sti");
		409	}
1029	serge	410
		411
5270	serge	412	{
1613	serge	413	u32 val;
5270	serge	414	asm volatile (
1613	serge	415	"pushfl\n\t"
		416	"popl %0\n"
		417	: "=r" (val));
		418	return val;
		419	}
		420
		421
1408	serge	422	{
1029	serge	423	u32 tmp;
5270	serge	424	__asm__ __volatile__ (
1029	serge	425	"cld \n\t"
		426	"rep stosb \n"
		427	:"=c"(tmp),"=D"(tmp)
		428	:"a"(0),"c"(len),"D"(dst));
		429	__asm__ __volatile__ ("":::"ecx","edi");
		430	};
		431
		432
5270	serge	433	{
1029	serge	434	__asm__ __volatile__
		435	("outb %1, %0\n" : : "dN"(port), "a"(val));
		436	}
		437
		438
5270	serge	439	{
1029	serge	440	__asm__ __volatile__
		441	("outw %1, %0\n" : : "dN"(port), "a"(val));
		442	}
		443
		444
5270	serge	445	{
1029	serge	446	__asm__ __volatile__
		447	("outl %1, %0\n" : : "dN"(port), "a"(val));
		448	}
		449
		450
5270	serge	451	{
1029	serge	452	u8 tmp;
5270	serge	453	__asm__ __volatile__
1029	serge	454	("inb %1, %0\n" : "=a"(tmp) : "dN"(port));
		455	return tmp;
		456	};
		457
		458
5270	serge	459	{
1029	serge	460	u16 tmp;
5270	serge	461	__asm__ __volatile__
1029	serge	462	("inw %1, %0\n" : "=a"(tmp) : "dN"(port));
		463	return tmp;
		464	};
		465
		466
5270	serge	467	{
1029	serge	468	u32 tmp;
5270	serge	469	__asm__ __volatile__
1029	serge	470	("inl %1, %0\n" : "=a"(tmp) : "dN"(port));
		471	return tmp;
		472	};
		473
		474
1408	serge	475	{
1029	serge	476	__asm__ __volatile__ (
		477	"call *__imp__Delay"
		478	::"b" (time));
		479	__asm__ __volatile__ (
		480	"":::"ebx");
		481
		482
		483
		484
1613	serge	485	{
1029	serge	486	__asm__ __volatile__ (
		487	"call *__imp__ChangeTask");
		488	}
		489
		490
1613	serge	491	{
1408	serge	492	__asm__ __volatile__
		493	(
		494	"call *__imp__SetScreen"
		495	:
		496	:"a" (width-1),"d"(height-1), "c"(pitch)
		497	);
		498	__asm__ __volatile__
		499	("" :::"eax","ecx","edx");
		500	}
		501
		502
		503
		504
5270	serge	505	{
1408	serge	506	return (void __iomem*) MapIoMem(offset, size, PG_SW\|PG_NOCACHE\|0x100);
4538	Serge	507	}
1408	serge	508
		509
5270	serge	510	{
3391	Serge	511	return (void __iomem*) MapIoMem(offset, size, PG_SW\|0x100);
4538	Serge	512	}
3391	Serge	513
		514
		515
1408	serge	516	{
		517	FreeKernelSpace(addr);
		518	}
		519
		520
		521	{
		522	__asm__ __volatile__(
		523	"call *__imp__SysMsgBoardStr"
		524	::"S" (text));
		525	};
		526
		527
3031	serge	528	{
		529	void *mem;
		530
		531
		532	if(mem)
		533	memset(mem, 0, size);
		534
		535
		536	};
		537
		538
		539	{
		540	KernelFree(addr);
		541	}
		542
		543
		544
		545
		546
1408	serge	547	>

Subversion Repositories Kolibri OS

(root)/drivers/include/syscall.h – Rev 5272