/* 
 * This file is a simple example of an application that could be run
 * on top of the monitor.
 *
 * Cstart():
 * The Cstart() function depends on the setting of MONCOMPTR in config.h.
 * It demonstrates the use of monConnect and the first mon_XXX function
 * typically called by an application, mon_getargv().
 *
 * main():
 * The main() function demonstrates argument processing (thanks to
 * the call to mon_getargv() in start()), environment variables and
 * a simple use of TFS to dump the content of an ASCII file.
 * Also, if the first argument is "strace_demo", then the strace_demo()
 * function is called.  Refer to strace.c for details.
 */

#include <string.h>
#include <stdlib.h>
#include "monlib.h"
#include "tfs.h"
#include "cfg.h"
#include "timer.h"

unsigned long AppStack[APPSTACKSIZE/4];

extern void strace_demo(void);

void
hitakey(void)
{
	while(!mon_gotachar());
	mon_getchar();
}

/* timer_demo():
 * This function assumes that the underlying monitor has a relatively
 * new uMon API hook call mon_timer().
 * This demo shows how to do a few different elapsed timer operations
 * using the API.
 */
void
timer_demo(void)
{
	struct elapsed_tmr	tmr;
	unsigned long starttime, endtime;

	/* Here are a few different ways (using the uMon API) to wait for 
	 * three seconds...
	 *
	 * First make sure the underlying monitor has a Hardware-based
	 * timer.  If it doesn't then this is worthless.
	 */
	mon_timer(TIMER_QUERY,&tmr);
	if ((HWRTMR_IS_ENABLED(&tmr)) == 0) {
		mon_printf("This monitor doesn't have INCLUDE_HWTMR configured\n");
		return;
	}

	mon_printf("Timer demo ready to start, hit a key to continue\n");
	hitakey();

	/*****************************************************************
	 *
	 * The first one, also the simplest, but least versatile is to just
	 * use mon_delay().  The mon_delay function just takes the number
	 * of milliseconds you want to wait, and uses the underlying hardware
	 * to busy wait on that duration...
	 */
	mon_printf("1. Wait for 3 seconds...\n");
	mon_delay(3000);
	mon_printf("1. Done, hit a key to continue\n");
	hitakey();

	/*****************************************************************
	 *
	 * The second one, allows the user to specify the elapsed time 
	 * (in milliseconds), then allows the user to poll waiting for that
	 * time to expire.  Meanwhile, the application can do other things
	 * while it waits.
	 */
	mon_printf("2. Wait for 3 seconds...\n");
	tmr.start = 3000;
	mon_timer(TIMER_START,&tmr);
	while(mon_timer(TIMER_ELAPSED,&tmr) == 0) {
		/* Do whatever you like here. */
	}
	mon_printf("2. Done, hit a key to continue\n");
	hitakey();

	/*****************************************************************
	 *
	 * The third method, uses the granularity of the hardware clock
	 * and the returned value of "ticks-per-millisecond".  It provides
	 * the most versatility (without actually knowing the details of 
	 * the hardware clock), but requires the most work.  Note that we
	 * have to deal with the possiblity of 32-bit timer value wrap.
	 */
	mon_printf("3. Wait for 3 seconds...\n");
	mon_timer(TIMER_QUERY,&tmr);
	starttime = tmr.currenttmrval;
	endtime = starttime + 3000 * tmr.tpm;
	if (endtime < starttime) {
		do {
			mon_timer(TIMER_QUERY,&tmr);
		} while(tmr.currenttmrval > starttime);
		do {
			mon_timer(TIMER_QUERY,&tmr);
		} while(tmr.currenttmrval < endtime);
	}
	else {
		do {
			mon_timer(TIMER_QUERY,&tmr);
		} while((tmr.currenttmrval > starttime) &&
			(tmr.currenttmrval < endtime));
	}
	
	mon_printf("3. Done, hit a key to continue\n");
	while(!mon_gotachar());

	mon_printf("Timer demo done\n");
	mon_appexit(1);
}

/* Global variables added just to be able to use this
 * app to demonstrate hookup with gdb...
 */
int argtot;
long apprambase;

int
main(int argc,char *argv[])
{
	int		i, tfd;
	char	line[80], *ab, *filename;

	argtot = argc;

	/* If argument count is greater than one, then dump out the
	 * set of CLI arguments...
	 */
	if (argc > 1) {
		if ((argc == 2) && (strcmp(argv[1],"strace_demo") == 0))
			strace_demo();

		if ((argc == 2) && (strcmp(argv[1],"timer") == 0))
			timer_demo();
		
		mon_printf("Argument list...\n");
		for(i=0;i<argc;i++) {
			mon_printf("  arg[%d]: %s\n",i,argv[i]);
			if (strcmp(argv[i],"match") == 0)
				mon_printf("got a match!\n");
		}
	}

	/* Using the content of the shell variable APPRAMBASE, dump the
	 * memory starting at that location...
	 */
	ab = mon_getenv("APPRAMBASE");
	if (ab) {
		char *addr = (char *)strtoul(ab,0,0);
		apprambase = strtoul(ab,0,0);

		mon_printf("Dumping memory at 0x%lx...\n",addr);
		mon_printmem(addr,128,1);
	}

	filename = "monrc";

	/* If the 'monrc' file exists, the assume it is ASCII and dump it
	 * line by line...
	 */
	if (mon_tfsstat(filename)) {
		mon_printf("Dumping content of '%s'...\n",filename);

		tfd = mon_tfsopen(filename,TFS_RDONLY,0);
		if (tfd >= 0) {
			while(mon_tfsgetline(tfd,line,sizeof(line)))
				mon_printf("%s",line);
			mon_tfsclose(tfd,0);
		}
		else {
			mon_printf("TFS error: %s\n",
				(char *)mon_tfsctrl(TFS_ERRMSG,tfd,0));
		}
	}
	else {
		mon_printf("File '%s' not found\n",filename);
	}
	return(0);
}

void
__gccmain()
{
}

int
Cstart(void)
{
	char	**argv;
	int		argc;

	/* Connect the application to the monitor.  This must be done
	 * prior to the application making any other attempts to use the
	 * "mon_" functions provided by the monitor.
	 */
	monConnect((int(*)())(*(unsigned long *)MONCOMPTR),(void *)0,(void *)0);

	/* When the monitor starts up an application, it stores the argument
	 * list internally.  The call to mon_getargv() retrieves the arg list
	 * for use by this application...
	 */
	mon_getargv(&argc,&argv);

	/* Call main, then exit to monitor.
	 */
	main(argc,argv);

	mon_appexit(0);

	/* Won't get here. */
	return(0);
}

/* CstartAlt():
 * Demonstrates the use of the "call -a" command in uMon. 
 * For example, if for some reason you wanted to do this...
 * Load the application then load the symtbl file using
 * "make TARGET_IP=1.2.3.4 sym", then issue these commands:
 *
 *  tfs -v ld app
 *  call -a %CstartAlt one two three
 *
 * The "call -a" command in uMon correctly sets up the function
 * call parameters so that the following function would see 4
 * arguments (including arg0), with argv[1] thru argv[3] being
 * pointers to each of the number strings (i.e. "one", "two", "three")
 * and argv[0] being the ascii-coded-hex address of the function
 * CstartAlt.
 */
int
CstartAlt(int argc, char *argv[])
{
	monConnect((int(*)())(*(unsigned long *)MONCOMPTR),(void *)0,(void *)0);
	main(argc,argv);
	mon_appexit(0);
	return(0);
}