Context Navigation

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

Last change on this file since 456 was 450, checked in by alain, 10 years ago
1) Introducing an explicit channel initialisation function in the MWMR library. 2) Defining new system calls in stdio.c to support user access to the NIC.
Property svn:executable set to ``*
File size: 22.8 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
[450]	543	////////////////////////
	544	void giet_nic_rx_alloc()
[258]	545	{
[450]	546	if ( sys_call( SYSCALL_NIC_RX_ALLOC,
	547	0, 0, 0, 0 ) ) giet_exit("error in giet_nic_rx_alloc()");
[258]	548	}
[295]	549
[450]	550	////////////////////////
	551	void giet_nic_tx_alloc()
[258]	552	{
[450]	553	if ( sys_call( SYSCALL_NIC_TX_ALLOC,
	554	0, 0, 0, 0 ) ) giet_exit("error in giet_nic_tx_alloc()");
	555	}
	556
	557	////////////////////////
	558	void giet_nic_rx_start()
	559	{
	560	if ( sys_call( SYSCALL_NIC_RX_START,
	561	0, 0, 0, 0 ) ) giet_exit("error in giet_nic_rx_start()");
	562	}
	563
	564	////////////////////////
	565	void giet_nic_tx_start()
	566	{
	567	if ( sys_call( SYSCALL_NIC_TX_START,
	568	0, 0, 0, 0 ) ) giet_exit("error in giet_nic_tx_start()");
	569	}
	570
	571	/////////////////////////////////////
	572	void giet_nic_rx_move( void* buffer )
	573	{
	574	if ( sys_call( SYSCALL_NIC_RX_MOVE,
[438]	575	(unsigned int)buffer,
[450]	576	0, 0, 0 ) ) giet_exit("error in giet_nic_rx_move()");
[258]	577	}
	578
[450]	579	/////////////////////////////////////
	580	void giet_nic_tx_move( void* buffer )
[438]	581	{
[450]	582	if ( sys_call( SYSCALL_NIC_TX_MOVE,
[438]	583	(unsigned int)buffer,
[450]	584	0, 0, 0 ) ) giet_exit("error in giet_nic_tx_move()");
[438]	585	}
	586
[450]	587	////////////////////////
	588	void giet_nic_rx_stop()
	589	{
	590	if ( sys_call( SYSCALL_NIC_RX_STOP,
	591	0, 0, 0, 0 ) ) giet_exit("error in giet_nic_rx_start()");
	592	}
	593
	594	////////////////////////
	595	void giet_nic_tx_stop()
	596	{
	597	if ( sys_call( SYSCALL_NIC_TX_STOP,
	598	0, 0, 0, 0 ) ) giet_exit("error in giet_nic_tx_start()");
	599	}
	600
	601
[295]	602	///////////////////////////////////////////////////////////////////////////////////
	603	///////////////////// FAT related system calls ////////////////////////////////////
	604	///////////////////////////////////////////////////////////////////////////////////
[258]	605
[295]	606	///////////////////////////////////////////
	607	int giet_fat_open( const char* pathname,
	608	unsigned int flags )
	609	{
	610	return sys_call( SYSCALL_FAT_OPEN,
	611	(unsigned int)pathname,
	612	flags,
	613	0, 0 );
	614	}
[258]	615
[295]	616	////////////////////////////////////
	617	void giet_fat_read( unsigned int fd,
	618	void* buffer,
	619	unsigned int count,
	620	unsigned int offset )
	621	{
	622	if ( sys_call( SYSCALL_FAT_READ,
	623	fd,
	624	(unsigned int)buffer,
	625	count,
[390]	626	offset ) != count ) giet_exit("ERROR in giet_fat_read()");
[295]	627	}
	628
	629	/////////////////////////////////////
	630	void giet_fat_write( unsigned int fd,
	631	void* buffer,
	632	unsigned int count,
	633	unsigned int offset )
	634	{
	635	if ( sys_call( SYSCALL_FAT_WRITE,
	636	fd,
	637	(unsigned int)buffer,
	638	count,
[390]	639	offset ) != count ) giet_exit("ERROR in giet_fat_write()");
[295]	640	}
	641
	642	/* variant implementing the UNIX spec
[258]	643	///////////////////////////////////////////////////////////////////////////////////
[295]	644	// This system call writes to a file identified by the "fd" file descriptor.
	645	// - "buffer" is the source buffer virtual address (must be word aligned).
	646	// - "count" is a number of bytes (must be multiple of 4).
	647	// It uses the implicit "lseek" pointer in file descriptor.
[258]	648	///////////////////////////////////////////////////////////////////////////////////
[295]	649	void giet_fat_write( unsigned int fd,
	650	void* buffer,
	651	unsigned int count ) // number of bytes
[258]	652	{
[295]	653	return sys_call( SYSCALL_FAT_WRITE,
	654	fd,
	655	(unsigned int)buffer,
	656	count, 0 );
[258]	657	}
[295]	658	*/
	659
	660	/////////////////////////////////////
	661	void giet_fat_lseek( unsigned int fd,
	662	unsigned int offset,
	663	unsigned int whence )
[258]	664	{
[295]	665	if ( sys_call( SYSCALL_FAT_LSEEK,
	666	fd,
	667	offset,
	668	whence,
[390]	669	0 ) ) giet_exit("ERROR in giet_fat_lseek()");
[258]	670	}
[295]	671
	672	//////////////////////////////////////
	673	void giet_fat_fstat( unsigned int fd )
[258]	674	{
[295]	675	if ( sys_call( SYSCALL_FAT_FSTAT,
	676	fd,
[390]	677	0, 0, 0 ) ) giet_exit("ERROR in giet_fat_lseek()");
[258]	678	}
[295]	679
	680	/////////////////////////////////////
	681	void giet_fat_close( unsigned int fd )
[258]	682	{
[295]	683	if ( sys_call( SYSCALL_FAT_CLOSE,
	684	fd,
[390]	685	0, 0, 0 ) ) giet_exit("ERROR in giet_fat_close()");
[258]	686	}
[295]	687
	688
	689
	690
[390]	691	//////////////////////////////////////////////////////////////////////////////////
	692	///////////////////// Miscellaneous system calls /////////////////////////////////
	693	//////////////////////////////////////////////////////////////////////////////////
	694
[295]	695	//////////////////////////////
	696	void giet_exit( char* string )
[258]	697	{
[295]	698	sys_call( SYSCALL_EXIT,
	699	(unsigned int)string,
	700	0, 0, 0 );
[258]	701	}
[295]	702
	703	/////////////////////////////////////////
	704	void giet_assert( unsigned int condition,
	705	char* string )
[258]	706	{
[295]	707	if ( condition == 0 ) giet_exit( string );
[258]	708	}
[295]	709
[390]	710	//////////////////////////
	711	void giet_context_switch()
	712	{
	713	sys_call( SYSCALL_CTX_SWITCH,
	714	0, 0, 0, 0 );
	715	}
	716
[438]	717	///////////////////////////////////////////////
	718	void giet_proc_number( unsigned int cluster_id,
	719	unsigned int* buffer )
	720	{
	721	if ( sys_call( SYSCALL_PROC_NUMBER,
	722	cluster_id,
	723	(unsigned int) buffer,
	724	0, 0) ) giet_exit("ERROR in giet_proc_number()");
	725	}
	726
[295]	727	////////////////////////////////////////////////////
	728	void giet_vobj_get_vbase( char* vspace_name,
	729	char* vobj_name,
[438]	730	unsigned int* vbase )
[258]	731	{
[295]	732	if ( sys_call( SYSCALL_VOBJ_GET_VBASE,
	733	(unsigned int) vspace_name,
	734	(unsigned int) vobj_name,
[438]	735	(unsigned int) vbase,
[390]	736	0 ) ) giet_exit("ERROR in giet_vobj_get_vbase()");
[258]	737	}
[260]	738
[438]	739	////////////////////////////////////////////////////
	740	void giet_vobj_get_length( char* vspace_name,
	741	char* vobj_name,
	742	unsigned int* length )
[260]	743	{
[438]	744	if ( sys_call( SYSCALL_VOBJ_GET_LENGTH,
	745	(unsigned int) vspace_name,
	746	(unsigned int) vobj_name,
	747	(unsigned int) length,
	748	0 ) ) giet_exit("ERROR in giet_vobj_get_length()");
[260]	749	}
	750
[295]	751	/////////////////////////////////////////
	752	void giet_heap_info( unsigned int* vaddr,
[368]	753	unsigned int* length,
	754	unsigned int x,
	755	unsigned int y )
[258]	756	{
[295]	757	if ( sys_call( SYSCALL_HEAP_INFO,
	758	(unsigned int)vaddr,
	759	(unsigned int)length,
[368]	760	x,
[390]	761	y ) ) giet_exit("ERROR in giet_heap_info()");
[258]	762	}
	763
[390]	764	/////////////////////////////////////////
	765	void giet_get_xy( void* ptr,
	766	unsigned int* px,
	767	unsigned int* py )
	768	{
	769	if ( sys_call( SYSCALL_GET_XY,
	770	(unsigned int)ptr,
	771	(unsigned int)px,
	772	(unsigned int)py,
	773	0 ) ) giet_exit("ERROR in giet_get_xy()");
	774	}
	775
[258]	776	// Local Variables:
	777	// tab-width: 4
	778	// c-basic-offset: 4
	779	// c-file-offsets:((innamespace . 0)(inline-open . 0))
	780	// indent-tabs-mode: nil
	781	// End:
	782	// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
	783

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

Download in other formats: