Context Navigation

source: soft/giet_vm/giet_libs/stdio.c @ 496

Last change on this file since 496 was 487, checked in by alain, 10 years ago
1) Change the user sbt_barrier_init() prototype: the two (nclusters/ntasks) arguments replace the single (ntasks) argument. 2) Introduce an explicit (channel) argument in all iuser access functions to the NIC component. Previously, the channel registered in the task context was an implicit argument. The channel is still registered in the task context for checking.
Property svn:executable set to ``*
File size: 24.5 KB

Rev	Line
[258]	1	//////////////////////////////////////////////////////////////////////////////////
	2	// File : stdio.c
	3	// Date : 01/04/2010
	4	// Author : alain greiner & Joel Porquet
	5	// Copyright (c) UPMC-LIP6
	6	///////////////////////////////////////////////////////////////////////////////////
	7
	8	#include <stdarg.h>
	9	#include <stdio.h>
[267]	10	#include <giet_config.h>
[258]	11
	12	////////////////////////////////////////////////////////////////////////////////////
[390]	13	///////////////////// MIPS32 related system calls /////////////////////////////
	14	////////////////////////////////////////////////////////////////////////////////////
	15
[438]	16	////////////////////////////////////////////
[431]	17	void giet_proc_xyp( unsigned int* cluster_x,
	18	unsigned int* cluster_y,
	19	unsigned int* lpid )
[390]	20	{
[438]	21	sys_call( SYSCALL_PROC_XYP,
[431]	22	(unsigned int)cluster_x,
	23	(unsigned int)cluster_y,
	24	(unsigned int)lpid,
	25	0 );
[390]	26	}
	27
[438]	28	////////////////////////////
	29	unsigned int giet_proctime()
[390]	30	{
[438]	31	return (unsigned int)sys_call( SYSCALL_PROC_TIME,
	32	0, 0, 0, 0 );
[390]	33	}
	34
[438]	35	////////////////////////
	36	unsigned int giet_rand()
[390]	37	{
[438]	38	unsigned int x = (unsigned int)sys_call( SYSCALL_PROC_TIME,
	39	0, 0, 0, 0);
[390]	40	if ((x & 0xF) > 7)
	41	{
	42	return (x*x & 0xFFFF);
	43	}
	44	else
	45	{
	46	return (xxx & 0xFFFF);
	47	}
	48	}
	49
[438]	50	//////////////////////////////////////////////////////////////////////////////////
	51	///////////////////// Task context system calls /////////////////////////////////
	52	//////////////////////////////////////////////////////////////////////////////////
	53
	54	////////////////////////////////
	55	unsigned int giet_proc_task_id()
	56	{
	57	return (unsigned int)sys_call( SYSCALL_LOCAL_TASK_ID,
	58	0, 0, 0, 0 );
	59	}
	60
	61	//////////////////////////////////
	62	unsigned int giet_global_task_id()
	63	{
	64	return (unsigned int)sys_call( SYSCALL_GLOBAL_TASK_ID,
	65	0, 0, 0, 0 );
	66	}
	67
	68	/////////////////////////////
	69	unsigned int giet_thread_id()
	70	{
	71	return (unsigned int)sys_call( SYSCALL_THREAD_ID,
	72	0, 0, 0, 0 );
	73	}
	74
	75
[390]	76	////////////////////////////////////////////////////////////////////////////////////
[295]	77	///////////////////// TTY device related system calls /////////////////////////////
[258]	78	////////////////////////////////////////////////////////////////////////////////////
[295]	79
[438]	80	/////////////////////
	81	void giet_tty_alloc()
[258]	82	{
[438]	83	sys_call( SYSCALL_TTY_ALLOC, 0, 0 ,0 ,0 );
	84	}
[258]	85
[438]	86	////////////////////////////////////////////////////////////////////////
	87	static int __printf( char* format, unsigned int channel, va_list* args)
	88	{
	89	int ret; // return value from the syscall
	90
[295]	91	printf_text:
[258]	92
[295]	93	while (*format)
[258]	94	{
[295]	95	unsigned int i;
	96	for (i = 0 ; format[i] && (format[i] != '%') ; i++);
	97	if (i)
	98	{
	99	ret = sys_call(SYSCALL_TTY_WRITE,
	100	(unsigned int)format,
	101	i,
	102	channel,
[258]	103	0);
	104
[295]	105	if (ret != i) goto return_error;
	106
	107	format += i;
[258]	108	}
[295]	109	if (*format == '%')
[258]	110	{
[295]	111	format++;
	112	goto printf_arguments;
[258]	113	}
	114	}
	115
[345]	116	return 0;
[295]	117
	118	printf_arguments:
	119
[258]	120	{
[295]	121	char buf[20];
	122	char * pbuf;
	123	unsigned int len = 0;
	124	static const char HexaTab[] = "0123456789ABCDEF";
	125	unsigned int i;
[258]	126
[295]	127	switch (*format++)
[258]	128	{
[295]	129	case ('c'): /* char conversion */
[258]	130	{
[345]	131	int val = va_arg( *args, int );
[295]	132	len = 1;
	133	buf[0] = val;
	134	pbuf = &buf[0];
	135	break;
[258]	136	}
[295]	137	case ('d'): /* 32 bits decimal signed integer */
[258]	138	{
[345]	139	int val = va_arg( *args, int );
[295]	140	if (val < 0)
	141	{
	142	val = -val;
	143	ret = sys_call(SYSCALL_TTY_WRITE,
	144	(unsigned int)"-",
	145	1,
	146	channel,
	147	0);
	148	if (ret != 1) goto return_error;
	149	}
	150	for(i = 0; i < 10; i++)
	151	{
	152	buf[9 - i] = HexaTab[val % 10];
	153	if (!(val /= 10)) break;
	154	}
	155	len = i + 1;
	156	pbuf = &buf[9 - i];
	157	break;
[258]	158	}
[295]	159	case ('u'): /* 32 bits decimal unsigned integer */
	160	{
[345]	161	unsigned int val = va_arg( *args, unsigned int );
[295]	162	for(i = 0; i < 10; i++)
	163	{
	164	buf[9 - i] = HexaTab[val % 10];
	165	if (!(val /= 10)) break;
	166	}
	167	len = i + 1;
	168	pbuf = &buf[9 - i];
	169	break;
	170	}
	171	case ('x'): /* 32 bits hexadecimal integer */
	172	{
[345]	173	unsigned int val = va_arg( *args, unsigned int );
[295]	174	ret = sys_call(SYSCALL_TTY_WRITE,
	175	(unsigned int)"0x",
	176	2,
	177	channel,
	178	0);
	179	if (ret != 2) goto return_error;
	180	for(i = 0; i < 8; i++)
	181	{
	182	buf[7 - i] = HexaTab[val % 16];
	183	if (!(val /= 16)) break;
	184	}
	185	len = i + 1;
	186	pbuf = &buf[7 - i];
	187	break;
	188	}
	189	case ('l'): /* 64 bits hexadecimal unsigned */
	190	{
[345]	191	unsigned long long val = va_arg( *args, unsigned long long );
[295]	192	ret = sys_call(SYSCALL_TTY_WRITE,
	193	(unsigned int)"0x",
	194	2,
	195	channel,
	196	0);
	197	if (ret != 2) goto return_error;
	198	for(i = 0; i < 16; i++)
	199	{
	200	buf[15 - i] = HexaTab[val % 16];
	201	if (!(val /= 16)) break;
	202	}
	203	len = i + 1;
	204	pbuf = &buf[15 - i];
	205	break;
	206	}
	207	case ('s'): /* string */
	208	{
[345]	209	char* str = va_arg( args, char );
[295]	210	while (str[len])
	211	{
	212	len++;
	213	}
	214	pbuf = str;
	215	break;
	216	}
	217	default:
	218	goto return_error;
[258]	219	}
	220
[295]	221	ret = sys_call(SYSCALL_TTY_WRITE,
	222	(unsigned int)pbuf,
	223	len,
	224	channel,
	225	0);
	226	if (ret != len) goto return_error;
	227
	228	goto printf_text;
[258]	229	}
	230
[295]	231	return_error:
[345]	232	return 1;
	233	} // end __printf()
[295]	234
[345]	235
	236	////////////////////////////////////////
	237	void giet_tty_printf( char* format, ...)
	238	{
	239	va_list args;
	240
	241	va_start( args, format );
	242	int ret = __printf(format, 0xFFFFFFFF, &args);
[295]	243	va_end( args );
[345]	244
	245	if (ret)
	246	{
[382]	247	giet_exit("ERROR in giet_tty_printf()");
[345]	248	}
[295]	249	} // end giet_tty_printf()
	250
	251	////////////////////////////////////////
	252	void giet_shr_printf( char* format, ...)
[258]	253	{
[295]	254	va_list args;
[345]	255	const int channel = 0;
	256	volatile unsigned int sr_save;
[258]	257
[295]	258	sys_call( SYSCALL_TTY_GET_LOCK,
	259	channel,
	260	(unsigned int)&sr_save,
	261	0, 0 );
	262
[345]	263	va_start( args, format );
	264	int ret = __printf(format, channel, &args);
	265	va_end( args );
[258]	266
[295]	267	sys_call( SYSCALL_TTY_RELEASE_LOCK,
	268	channel,
	269	(unsigned int)&sr_save,
	270	0, 0 );
[267]	271
[345]	272	if (ret)
[258]	273	{
[345]	274	giet_exit("error in giet_shr_printf()");
[258]	275	}
[345]	276	} // end giet_shr_printf()
[267]	277
[295]	278	/////////////////////////////////
	279	void giet_tty_getc( char * byte )
	280	{
	281	int ret;
	282
	283	do
[267]	284	{
[295]	285	ret = sys_call(SYSCALL_TTY_READ,
	286	(unsigned int)byte, // buffer address
	287	1, // number of characters
	288	0xFFFFFFFF, // channel index from task context
	289	0);
	290	if ( ret < 0 ) giet_exit("error in giet_tty_getc()");
[267]	291	}
[295]	292	while (ret != 1);
	293	}
[267]	294
[295]	295	/////////////////////////////////////
	296	void giet_tty_gets( char* buf,
	297	unsigned int bufsize )
	298	{
	299	int ret;
	300	unsigned char byte;
	301	unsigned int index = 0;
	302
	303	while (index < (bufsize - 1))
	304	{
	305	do
	306	{
	307	ret = sys_call(SYSCALL_TTY_READ,
	308	(unsigned int)(&byte),
	309	1,
	310	0xFFFFFFFF,
	311	0);
	312	if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
	313	}
	314	while (ret != 1);
	315
	316	if (byte == 0x0A) /* LF */
	317	{
	318	break;
	319	}
	320	else if ((byte == 0x7F) && (index > 0)) /* DEL */
	321	{
	322	index--;
	323	}
	324	else
	325	{
	326	buf[index] = byte;
	327	index++;
	328	}
	329	}
	330	buf[index] = 0;
[258]	331	}
	332
[295]	333	///////////////////////////////////////
	334	void giet_tty_getw( unsigned int* val )
	335	{
	336	unsigned char buf[32];
	337	unsigned int string_byte = 0x00000000; // string containing one single byte
	338	unsigned int string_cancel = 0x00082008; // string containing BS/SPACE/BS
	339	unsigned int save = 0;
	340	unsigned int dec = 0;
	341	unsigned int done = 0;
	342	unsigned int overflow = 0;
	343	unsigned int length = 0;
	344	unsigned int i;
	345	unsigned int channel = 0xFFFFFFFF;
	346	int ret; // return value from syscalls
	347
	348	// get characters
	349	while (done == 0)
	350	{
	351	// read one character
	352	do
	353	{
	354	ret = sys_call( SYSCALL_TTY_READ,
	355	(unsigned int)(&string_byte),
	356	1,
	357	channel,
	358	0);
	359	if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
	360	}
	361	while (ret != 1);
[258]	362
[295]	363	// analyse character
	364	if ((string_byte > 0x2F) && (string_byte < 0x3A)) /* decimal character */
	365	{
	366	buf[length] = (unsigned char)string_byte;
	367	length++;
[258]	368
[295]	369	// echo
	370	ret = sys_call( SYSCALL_TTY_WRITE,
	371	(unsigned int)(&string_byte),
	372	1,
	373	channel,
	374	0 );
	375	if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
	376	}
	377	else if (string_byte == 0x0A) /* LF character */
	378	{
	379	done = 1;
	380	}
	381	else if ( (string_byte == 0x7F) \|\| /* DEL character */
	382	(string_byte == 0x08) ) /* BS character */
	383	{
	384	if ( length > 0 )
	385	{
	386	length--; // cancel the character
	387
	388	ret = sys_call( SYSCALL_TTY_WRITE,
	389	(unsigned int)(&string_cancel),
	390	3,
	391	channel,
	392	0 );
[352]	393	if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
[295]	394	}
	395	}
	396
	397	// test buffer overflow
	398	if ( length >= 32 )
	399	{
	400	overflow = 1;
	401	done = 1;
	402	}
	403	} // end while characters
	404
	405	// string to int conversion with overflow detection
	406	if ( overflow == 0 )
	407	{
	408	for (i = 0; (i < length) && (overflow == 0) ; i++)
	409	{
	410	dec = dec * 10 + (buf[i] - 0x30);
	411	if (dec < save) overflow = 1;
	412	save = dec;
	413	}
	414	}
	415
	416	// final evaluation
	417	if ( overflow == 0 )
	418	{
	419	// return value
	420	*val = dec;
	421	}
	422	else
	423	{
	424	// cancel all echo characters
	425	for (i = 0; i < length ; i++)
	426	{
	427	ret = sys_call( SYSCALL_TTY_WRITE,
	428	(unsigned int)(&string_cancel),
	429	3,
	430	channel,
	431	0 );
[352]	432	if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
[295]	433	}
	434	// echo character '0'
	435	string_byte = 0x30;
	436	ret = sys_call( SYSCALL_TTY_WRITE,
	437	(unsigned int)(&string_byte),
	438	1,
	439	channel,
	440	0 );
[352]	441	if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
[295]	442
	443	// return 0 value
	444	*val = 0;
	445	}
	446	}
	447
	448
[258]	449	//////////////////////////////////////////////////////////////////////////////////
	450	///////////////////// TIMER related system calls ////////////////////////////////
	451	//////////////////////////////////////////////////////////////////////////////////
	452
[295]	453	///////////////////////
[438]	454	void giet_timer_alloc()
[258]	455	{
[438]	456	if ( sys_call( SYSCALL_TIM_ALLOC,
	457	0, 0, 0, 0 ) ) giet_exit("error in giet_timer_alloc()");
[258]	458	}
[295]	459
[438]	460	////////////////////////////////////////////
	461	void giet_timer_start( unsigned int period )
	462	{
	463	if ( sys_call( SYSCALL_TIM_START,
	464	period,
	465	0, 0, 0 ) ) giet_exit("error in giet_timer_start()");
	466	}
	467
[295]	468	//////////////////////
	469	void giet_timer_stop()
[258]	470	{
[438]	471	if ( sys_call( SYSCALL_TIM_STOP,
	472	0, 0, 0, 0 ) ) giet_exit("error in giet_timer_stop()");
[258]	473	}
	474
	475
	476	//////////////////////////////////////////////////////////////////////////////////
	477	/////////////// Frame buffer device related system calls ///////////////////////
	478	//////////////////////////////////////////////////////////////////////////////////
	479
[438]	480	/////////////////////////
	481	void giet_fbf_cma_alloc()
[258]	482	{
[438]	483	if ( sys_call( SYSCALL_FBF_CMA_ALLOC,
	484	0, 0, 0, 0 ) ) giet_exit("error in giet_fbf_cma_alloc()");
[258]	485	}
[295]	486
	487	///////////////////////////////////////////
[438]	488	void giet_fbf_cma_start( void * buf0,
	489	void * buf1,
	490	unsigned int length )
[258]	491	{
[438]	492	if ( sys_call( SYSCALL_FBF_CMA_START,
[295]	493	(unsigned int)buf0,
	494	(unsigned int)buf1,
[438]	495	length,
	496	0 ) ) giet_exit("error in giet_fbf_cma_start()");
[258]	497	}
[295]	498
[438]	499	////////////////////////////////////////////////
	500	void giet_fbf_cma_display( unsigned int buffer )
[258]	501	{
[438]	502	if ( sys_call( SYSCALL_FBF_CMA_DISPLAY,
	503	buffer,
	504	0, 0, 0 ) ) giet_exit("error in giet_fbf_cma_display()");
[258]	505	}
[295]	506
	507	////////////////////////
[438]	508	void giet_fbf_cma_stop()
[258]	509	{
[438]	510	if ( sys_call( SYSCALL_FBF_CMA_STOP,
	511	0, 0, 0, 0 ) ) giet_exit("error in giet_fbf_cma_stop()");
[258]	512	}
	513
[438]	514	//////////////////////////////////////////////
	515	void giet_fbf_sync_write( unsigned int offset,
	516	void * buffer,
	517	unsigned int length )
	518	{
	519	if ( sys_call( SYSCALL_FBF_SYNC_WRITE,
	520	offset,
	521	(unsigned int)buffer,
	522	length,
	523	0 ) ) giet_exit("error in giet_fbf_sync_write()");
	524	}
[258]	525
[438]	526	/////////////////////////////////////////////
	527	void giet_fbf_sync_read( unsigned int offset,
	528	void * buffer,
	529	unsigned int length )
	530	{
	531	if ( sys_call( SYSCALL_FBF_SYNC_READ,
	532	offset,
	533	(unsigned int)buffer,
	534	length,
	535	0 ) ) giet_exit("error in giet_fbf_sync_read()");
	536	}
	537
	538
[258]	539	//////////////////////////////////////////////////////////////////////////////////
	540	/////////////////////// NIC related system calls /////////////////////////////////
	541	//////////////////////////////////////////////////////////////////////////////////
	542
[487]	543	////////////////////////////////
	544	unsigned int giet_nic_rx_alloc()
[258]	545	{
[461]	546	int channel = sys_call( SYSCALL_NIC_ALLOC,
	547	1,
	548	0, 0, 0 );
[487]	549	if ( channel < 0 ) giet_exit("error in giet_nic_rx_alloc()");
[461]	550
[487]	551	return (unsigned int)channel;
[258]	552	}
[295]	553
[487]	554	////////////////////////////////
	555	unsigned int giet_nic_tx_alloc()
[258]	556	{
[461]	557	int channel = sys_call( SYSCALL_NIC_ALLOC,
	558	0,
	559	0, 0, 0 );
	560	if ( channel < 0 ) giet_exit("error in giet_nic_tx_alloc()");
	561
[487]	562	return (unsigned int)channel;
[450]	563	}
	564
[487]	565	//////////////////////////////////////////////
	566	void giet_nic_rx_start( unsigned int channel )
[450]	567	{
[461]	568	if ( sys_call( SYSCALL_NIC_START,
	569	1,
[487]	570	channel,
	571	0, 0 ) ) giet_exit("error in giet_nic_rx_start()");
[450]	572	}
	573
[487]	574	//////////////////////////////////////////////
	575	void giet_nic_tx_start( unsigned int channel )
[450]	576	{
[461]	577	if ( sys_call( SYSCALL_NIC_START,
	578	0,
[487]	579	channel,
	580	0, 0 ) ) giet_exit("error in giet_nic_tx_start()");
[450]	581	}
	582
[461]	583	///////////////////////////////////////////////////////////
	584	void giet_nic_rx_move( unsigned int channel, void* buffer )
[450]	585	{
[461]	586	if ( sys_call( SYSCALL_NIC_MOVE,
	587	1,
	588	channel,
[438]	589	(unsigned int)buffer,
[461]	590	0 ) ) giet_exit("error in giet_nic_rx_move()");
[258]	591	}
	592
[461]	593	///////////////////////////////////////////////////////////
	594	void giet_nic_tx_move( unsigned int channel, void* buffer )
[438]	595	{
[461]	596	if ( sys_call( SYSCALL_NIC_MOVE,
	597	0,
	598	channel,
[438]	599	(unsigned int)buffer,
[461]	600	0 ) ) giet_exit("error in giet_nic_tx_move()");
[438]	601	}
	602
[487]	603	/////////////////////////////////////////////
	604	void giet_nic_rx_stop( unsigned int channel )
[450]	605	{
[461]	606	if ( sys_call( SYSCALL_NIC_STOP,
	607	1,
[487]	608	channel,
	609	0, 0 ) ) giet_exit("error in giet_nic_rx_stop()");
[450]	610	}
	611
[487]	612	/////////////////////////////////////////////
	613	void giet_nic_tx_stop( unsigned int channel )
[450]	614	{
[461]	615	if ( sys_call( SYSCALL_NIC_STOP,
	616	0,
[487]	617	channel,
	618	0, 0 ) ) giet_exit("error in giet_nic_tx_stop()");
[450]	619	}
	620
[487]	621	//////////////////////////////////////////////
	622	void giet_nic_rx_stats( unsigned int channel )
[461]	623	{
	624	if ( sys_call( SYSCALL_NIC_STATS,
	625	1,
[487]	626	channel,
	627	0, 0 ) ) giet_exit("error in giet_nic_rx_stats()");
[461]	628	}
[450]	629
[487]	630	//////////////////////////////////////////////
	631	void giet_nic_tx_stats( unsigned int channel )
[461]	632	{
	633	if ( sys_call( SYSCALL_NIC_STATS,
	634	0,
[487]	635	channel,
	636	0, 0 ) ) giet_exit("error in giet_nic_tx_stats()");
[461]	637	}
	638
[487]	639	//////////////////////////////////////////////
	640	void giet_nic_rx_clear( unsigned int channel )
[461]	641	{
	642	if ( sys_call( SYSCALL_NIC_CLEAR,
	643	1,
[487]	644	channel,
	645	0, 0 ) ) giet_exit("error in giet_nic_rx_clear()");
[461]	646	}
	647
[487]	648	//////////////////////////////////////////////
	649	void giet_nic_tx_clear( unsigned int channel )
[461]	650	{
	651	if ( sys_call( SYSCALL_NIC_CLEAR,
	652	0,
[487]	653	channel,
	654	0, 0 ) ) giet_exit("error in giet_nic_tx_clear()");
[461]	655	}
	656
	657
	658
[295]	659	///////////////////////////////////////////////////////////////////////////////////
	660	///////////////////// FAT related system calls ////////////////////////////////////
	661	///////////////////////////////////////////////////////////////////////////////////
[258]	662
[295]	663	///////////////////////////////////////////
	664	int giet_fat_open( const char* pathname,
	665	unsigned int flags )
	666	{
	667	return sys_call( SYSCALL_FAT_OPEN,
	668	(unsigned int)pathname,
	669	flags,
	670	0, 0 );
	671	}
[258]	672
[295]	673	////////////////////////////////////
	674	void giet_fat_read( unsigned int fd,
	675	void* buffer,
	676	unsigned int count,
	677	unsigned int offset )
	678	{
	679	if ( sys_call( SYSCALL_FAT_READ,
	680	fd,
	681	(unsigned int)buffer,
	682	count,
[390]	683	offset ) != count ) giet_exit("ERROR in giet_fat_read()");
[295]	684	}
	685
	686	/////////////////////////////////////
	687	void giet_fat_write( unsigned int fd,
	688	void* buffer,
	689	unsigned int count,
	690	unsigned int offset )
	691	{
	692	if ( sys_call( SYSCALL_FAT_WRITE,
	693	fd,
	694	(unsigned int)buffer,
	695	count,
[390]	696	offset ) != count ) giet_exit("ERROR in giet_fat_write()");
[295]	697	}
	698
	699	/* variant implementing the UNIX spec
[258]	700	///////////////////////////////////////////////////////////////////////////////////
[295]	701	// This system call writes to a file identified by the "fd" file descriptor.
	702	// - "buffer" is the source buffer virtual address (must be word aligned).
	703	// - "count" is a number of bytes (must be multiple of 4).
	704	// It uses the implicit "lseek" pointer in file descriptor.
[258]	705	///////////////////////////////////////////////////////////////////////////////////
[295]	706	void giet_fat_write( unsigned int fd,
	707	void* buffer,
	708	unsigned int count ) // number of bytes
[258]	709	{
[295]	710	return sys_call( SYSCALL_FAT_WRITE,
	711	fd,
	712	(unsigned int)buffer,
	713	count, 0 );
[258]	714	}
[295]	715	*/
	716
	717	/////////////////////////////////////
	718	void giet_fat_lseek( unsigned int fd,
	719	unsigned int offset,
	720	unsigned int whence )
[258]	721	{
[295]	722	if ( sys_call( SYSCALL_FAT_LSEEK,
	723	fd,
	724	offset,
	725	whence,
[390]	726	0 ) ) giet_exit("ERROR in giet_fat_lseek()");
[258]	727	}
[295]	728
	729	//////////////////////////////////////
	730	void giet_fat_fstat( unsigned int fd )
[258]	731	{
[295]	732	if ( sys_call( SYSCALL_FAT_FSTAT,
	733	fd,
[390]	734	0, 0, 0 ) ) giet_exit("ERROR in giet_fat_lseek()");
[258]	735	}
[295]	736
	737	/////////////////////////////////////
	738	void giet_fat_close( unsigned int fd )
[258]	739	{
[295]	740	if ( sys_call( SYSCALL_FAT_CLOSE,
	741	fd,
[390]	742	0, 0, 0 ) ) giet_exit("ERROR in giet_fat_close()");
[258]	743	}
[295]	744
	745
	746
	747
[390]	748	//////////////////////////////////////////////////////////////////////////////////
	749	///////////////////// Miscellaneous system calls /////////////////////////////////
	750	//////////////////////////////////////////////////////////////////////////////////
	751
[295]	752	//////////////////////////////
	753	void giet_exit( char* string )
[258]	754	{
[295]	755	sys_call( SYSCALL_EXIT,
	756	(unsigned int)string,
	757	0, 0, 0 );
[258]	758	}
[295]	759
	760	/////////////////////////////////////////
	761	void giet_assert( unsigned int condition,
	762	char* string )
[258]	763	{
[295]	764	if ( condition == 0 ) giet_exit( string );
[258]	765	}
[295]	766
[390]	767	//////////////////////////
	768	void giet_context_switch()
	769	{
	770	sys_call( SYSCALL_CTX_SWITCH,
	771	0, 0, 0, 0 );
	772	}
	773
[438]	774	///////////////////////////////////////////////
	775	void giet_proc_number( unsigned int cluster_id,
	776	unsigned int* buffer )
	777	{
	778	if ( sys_call( SYSCALL_PROC_NUMBER,
	779	cluster_id,
	780	(unsigned int) buffer,
	781	0, 0) ) giet_exit("ERROR in giet_proc_number()");
	782	}
	783
[295]	784	////////////////////////////////////////////////////
	785	void giet_vobj_get_vbase( char* vspace_name,
	786	char* vobj_name,
[438]	787	unsigned int* vbase )
[258]	788	{
[295]	789	if ( sys_call( SYSCALL_VOBJ_GET_VBASE,
	790	(unsigned int) vspace_name,
	791	(unsigned int) vobj_name,
[438]	792	(unsigned int) vbase,
[390]	793	0 ) ) giet_exit("ERROR in giet_vobj_get_vbase()");
[258]	794	}
[260]	795
[438]	796	////////////////////////////////////////////////////
	797	void giet_vobj_get_length( char* vspace_name,
	798	char* vobj_name,
	799	unsigned int* length )
[260]	800	{
[438]	801	if ( sys_call( SYSCALL_VOBJ_GET_LENGTH,
	802	(unsigned int) vspace_name,
	803	(unsigned int) vobj_name,
	804	(unsigned int) length,
	805	0 ) ) giet_exit("ERROR in giet_vobj_get_length()");
[260]	806	}
	807
[295]	808	/////////////////////////////////////////
	809	void giet_heap_info( unsigned int* vaddr,
[368]	810	unsigned int* length,
	811	unsigned int x,
	812	unsigned int y )
[258]	813	{
[295]	814	if ( sys_call( SYSCALL_HEAP_INFO,
	815	(unsigned int)vaddr,
	816	(unsigned int)length,
[368]	817	x,
[390]	818	y ) ) giet_exit("ERROR in giet_heap_info()");
[258]	819	}
	820
[390]	821	/////////////////////////////////////////
	822	void giet_get_xy( void* ptr,
	823	unsigned int* px,
	824	unsigned int* py )
	825	{
	826	if ( sys_call( SYSCALL_GET_XY,
	827	(unsigned int)ptr,
	828	(unsigned int)px,
	829	(unsigned int)py,
	830	0 ) ) giet_exit("ERROR in giet_get_xy()");
	831	}
	832
[258]	833	// Local Variables:
	834	// tab-width: 4
	835	// c-basic-offset: 4
	836	// c-file-offsets:((innamespace . 0)(inline-open . 0))
	837	// indent-tabs-mode: nil
	838	// End:
	839	// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
	840

Note: See TracBrowser for help on using the repository browser.

Download in other formats: