Context Navigation

stdio.c @ 313

Last change on this file since 313 was 295, checked in by alain, 11 years ago

Introducing a major release, to suppoort the tsar_generic_leti platform
and the various (external or internal) peripherals configurations.
The map.xml format has been modified, in order to support the new
vci_iopic componentand a new policy for peripherals initialisation.
The IRQs are nom described in the XICU and IOPIC components
(and not anymore in the processors).
To enforce this major change, the map.xml file signature changed:
The signature value must be: 0xDACE2014

This new release has been tested on the tsar_generic_leti platform
for the following mappings:

4c_4p_sort_leti
4c_4p_sort_leti_ext
4c_4p_transpose_leti
4c_4p_transpose_leti_ext
4c_1p_four_leti_ext

Property svn:executable set to *

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

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

Context Navigation

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

Download in other formats: