path: root/main/common/misc.c

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * misc.c:
 *
 * This file contains miscellaneous functions that are used by all target
 * versions of the monitor.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */

#include "config.h"
#include "stddefs.h"
#include "cli.h"
#include "monflags.h"
#include "monlib.h"
#include "genlib.h"
#include "devices.h"
#include "cpuio.h"
#include <ctype.h>
#include "ether.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "warmstart.h"
#include "timer.h"
#include "version.h"
#include "target_version.h"

#ifdef USR_HEADER_FUNC
extern void USR_HEADER_FUNC(int center);
#endif

/* extWatchDog():
 * This function pointer is used by the application to override the
 * monitor's configured watchdog functionality.  Refer to config.h
 * in umon_ports/template for more information on the WATCHDOG macro.
 */
#ifdef WATCHDOG_ENABLED
int (*extWatchDog)(void);
#endif

/* AppExitStatus:
 * Global copy of the application's exit status.
 */
int	AppExitStatus;

char *
monVersion(void)
{
	static char buf[16];

	/* Build the version string as "X.Y.Z"
	 */
	snprintf(buf,sizeof(buf),"%d.%d.%d",
		MAJOR_VERSION,MINOR_VERSION,TARGET_VERSION);

	return(buf);
}

/* ShowVersion():
 *	Display the build time and date of the running monitor.
 */
void
ShowVersion(void)
{
	printf("Monitor core release: %d.%d, target version %d (built: %s)\n",
		MAJOR_VERSION,MINOR_VERSION,TARGET_VERSION,monBuilt());
	if (ApplicationInfo[0])
		printf("%s\n",ApplicationInfo);
}

/* monHeader():
 *	Dump the common stuff that is displayed at the console port when
 *	the monitor first starts up.  If called with 'center' set, then
 *	the printed output is centered on an 80-character screen width.
 */
void
monHeader(int center)
{
	char	*ip, *mac;
	int	(*pfunc)(char *, ...);

	/* Some folks just don't like the opening banner to be centered, so
	 * force center to 0 if DONT_CENTER_MONHEADER is defined...
	 */
#ifdef DONT_CENTER_MONHEADER
	center = 0;
#endif

	if (center) {
		printf("\n\n");
		pfunc = cprintf;
	}
	else
		pfunc = printf;

	/* Optionally support (via config.h) up to four lines of user-specified
	 * header text...
	 */
#ifdef USR_HEADER1
	pfunc("%s\n",USR_HEADER1);
#endif
#ifdef USR_HEADER2
	pfunc("%s\n",USR_HEADER2);
#endif
#ifdef USR_HEADER3
	pfunc("%s\n",USR_HEADER3);
#endif
#ifdef USR_HEADER4
	pfunc("%s\n",USR_HEADER4);
#endif

	pfunc("MICRO MONITOR %s\n",monVersion());
	pfunc("Platform: %s\n",PLATFORM_NAME);
	pfunc("CPU: %s\n",CPU_NAME);
	pfunc("Built: %s\n",monBuilt());
	pfunc("Monitor RAM: 0x%06x-0x%06x\n",&bss_start,&bss_end);
	pfunc("Application RAM Base: 0x%06x\n",APPLICATION_RAMSTART);
	mac = getenv("ETHERADD");
	if (mac)
		pfunc("MAC: %s\n",mac);
	ip = getenv("IPADD");
	if (ip)
		pfunc("IP: %s\n",ip);

#ifdef USR_HEADER_FUNC
	USR_HEADER_FUNC(center);
#endif

#ifdef TOD_IN_MONHEADER
	showDate(center);
#endif
}

/* stkchk():
 *	The monitor's stack is a statically allocated array (MonStack).
 *	At initialization the stack pointer is set to the top of this stack
 *	and the bottom is loaded with 0xdeaddead.  This function simply 
 *	verifies that the bottom of the stack is sane (still reads 0xdeaddead).
 *	If not, an error is printed.
 */
int
stkchk(char *msg)
{
	extern ulong	MonStack[];

	if (MonStack[0] != 0xdeaddead) {
		printf("\n***** Monitor stack overflow (%s) *****\n",msg);
		MonStack[0] = 0xdeaddead;
		return(-1);
	}
	return(0);
}

void
stkusage(void)
{
	int		i;
	ulong	*sp, stackval;
	extern ulong	MonStack[];

	printf("Stack: bottom=0x%lx, size=%d",(long)MonStack,MONSTACKSIZE);

	sp = MonStack;
	sp++;	/* Increment past 0xdeaddead */

	/* If the very first entry in stack space is not set to
	 * STACK_PREINIT_VAL, then we assume that stkinit() was not called
	 * at startup so don't print any stack usage information...
	 */
	if (*sp == STACK_PREINIT_VAL) {
		for(i=0;i<MONSTACKSIZE;i+=4) {
			if (*sp++ != STACK_PREINIT_VAL)
				break;
		}
		printf(" (%d%% used)",((MONSTACKSIZE-i)*100)/MONSTACKSIZE);
	}
	printf("\n");

	/* Finally, check to make sure that the current stack pointer
	 * resides within the MonStack[] array...
	 */
	if ((&stackval < MonStack) || (&stackval > &MonStack[MONSTACKSIZE/4]))
		printf("WARNING: SP outside MonStack[]\n");
}

/* stkinit():
 * This function should be called very early in uMon startup prior to
 * the stack pointer being set to the end of MonStack[].  It
 * simply initializes the MonStack[] array to a defined value so
 * that the stack can be observed for fullness during runtime.
 */
void
stkinit(void)
{
	extern ulong	MonStack[];
	volatile ulong *sp, *spend;

	sp = (ulong *)MonStack;
	spend = MonStack+MONSTACKSIZE/4;
	while(sp < spend)
		*sp++ = STACK_PREINIT_VAL;
}

/* writeprompt():
 *	Called to print out the monitor prompt.  If the shell variable PROMPT
 *	exists, then use the content of that variable as a prompt; otherwise,
 *	just print uMON>.
 */
void
writeprompt(void)
{
	char	*prompt;

	prompt = getenv("PROMPT");
	if (!prompt)
		prompt = "uMON>";
	else if (strcmp(prompt,"NULL") == 0)
		return;

	putstr(prompt);
}

/* CommandLoop():
 *	This function is called at the end of monitor initialization.
 *	The monitor spends most of its time here, waiting for incoming
 *	characters on the console interface.
 */
void
CommandLoop(void)
{
	static	char cmdline[CMDLINESIZE];

	while(1) {
		stkchk("Cmdloop");				/* Verify valid monitor stack */
		writeprompt();					/* Issue prompt */
		memset(cmdline,0,CMDLINESIZE);	/* Clear command line buffer */
		if (getline(cmdline,CMDLINESIZE,INCLUDE_LINEEDIT) == 0)
			continue;
		docommand(cmdline,0);
#if INCLUDE_FLASH
 		LowerFlashProtectWindow();
#endif
	}
}

int	monitorFlags;

struct monflag monflagtbl[] = {
	{ NOMONHEADER,	"nophdr" },		/* Don't print header at startup	  */
	{ NODEFRAGPRN,	"nopdf" },		/* Don't print defrag msg in tfsclean */
	{ NOTFTPPRN,	"noptftp" },	/* Don't print for tftp RRQ or WRQ	  */
	{ NOMONCMDPRN,	"nopmcmd" },	/* Don't print for incoming moncmd	  */
	{ NOTFTPOVW,	"notftpovw" },	/* Don't allow TFTP srvr to overwrite */
	{ NOEXITSTATUS,	"noexitstat" },	/* Don't ptint app exit status */
	{ 0,0 }
};

/* InitMonitorFlags():
 *	If the shell variable MONFLAGS exists, then use the content of that 
 *	variable to populate the value monitorFlags.  The syntax of the shell
 *	variable is "xxx:yyyy:zzzz:abcd" where xxx,yyyy,zzzz and abcd are 
 *	strings from the monflagtbl that represent some bit in the long that
 *	is to be set.
 */
void
InitMonitorFlags(void)
{
	char	*mf, *colon;
	struct monflag *mfp;

	monitorFlags = 0;

	mf = getenv("MONFLAGS");
	if (!mf)
		return;

	while(1) {
		colon = strchr(mf,':');
		if (colon)
			*colon = 0;
		mfp = monflagtbl;
		while(mfp->flagname) {
			if (!strcmp(mf,mfp->flagname)) {
				monitorFlags |= mfp->bit;
				break;
			}
			mfp++;
		}
		if (!mfp->flagname)
			printf("MONFLAGS err: %s\n",mf);
		if (colon)
			*colon = ':';
		else
			break;
		mf = colon+1;
	}
}

/* exceptionAutoRestart():
 *	Serves three purposes:
 *	1. Copies the verbose description of the exception to the
 *	   shell variable EXCEPTION_TYPE.
 *	2. If there is an EXCEPTION_SCRIPT shell variable, then see if the
 *		user wants it to be executed.
 *	3. If there is no NO_EXCEPTION_RESTART variable, then 
 *		call monrestart with the incoming value (usually INITIALIZE).
 */
void
exceptionAutoRestart(int restartvalue)
{
	char *script;
	char *arglist[2];

	setenv("EXCEPTION_TYPE",ExceptionType2String(ExceptionType));
	script = getenv("EXCEPTION_SCRIPT");
	if ((script) &&
		(!pollConsole("Press any key to stop exception script.\n"))) {
		arglist[0] = script;
		arglist[1] = (char *)0;
		tfsrun(arglist,0);
	}

	if (!getenv("NO_EXCEPTION_RESTART")) {
		if (!pollConsole("Press any key to stop auto restart.\n"))
			monrestart(restartvalue);
	}
}

/* getAppRamStart():
 *	First looks for the content of APPRAMBASE shell variable;
 *	if present, that string is converted to a long and returned,
 *	else the value of APPLICATION_RAMSTART is returned.
 */
ulong
getAppRamStart(void)
{
	char	*apprambase;
	ulong	value;

	apprambase = getenv("APPRAMBASE");
	if (apprambase)
		value = strtoul(apprambase,0,0);
	else
		value = APPLICATION_RAMSTART;
	return(value);
}

/* uMonInRam():
 * This function returns 1 if the image of the running monitor is
 * in RAM; else 0.  The function ramtstfunc() should NEVER be called.
 * It is used as a test to determine if text space is writeable.
 * If it is, then we assume that uMon is running from RAM.
 */
static int
ramtstfunc(void)
{
	return(99);
}

int
uMonInRam(void)
{
	int	rc;
	volatile unsigned char origvalue;
	volatile unsigned char *testmem = (unsigned char *)&ramtstfunc;

	origvalue = *testmem;
	*testmem = ~origvalue;

	/* Flush d-cache here to make sure that the write & readback actually
	 * interact with external memory and not just d-cache...
	 */
	flushDcache((char *)testmem,1);

	if (*testmem == (unsigned char)~origvalue)
		rc = 1;
	else
		rc = 0;

	*testmem = origvalue;
	return(rc);
}

/* inUmonBssSpace()
 *	Return 1 if the address range falls within MicroMonitor's
 *	own	RAM space.
 */
int
inUmonBssSpace(char *start,char *end)
{
	static int nowarn;

	if (nowarn || getenv("NO_UMONBSS_WARNING")) {
		nowarn = 1;
		return(0);
	}

	if (((start >= (char *)&bss_start) && (start < (char *)&bss_end)) ||
		((end >= (char *)&bss_start) && (end < (char *)&bss_end)) ||
		((start <= (char *)&bss_start) && (end >= (char *)&bss_end))) {
		printf("\nError: addr range 0x%lx <-> 0x%lx violates uMon ram.\n",
			(long)start,(long)end);
		return(1);
	}

	return(0);
}

void
monrestart(int val)
{
	/* Allow UART0 transmit FIFO to empty...
	 */
	flush_console_out();
	intsoff();
    warmstart(val);
}

void
appexit(int val)
{
	AppExitStatus = val;
	monrestart(APP_EXIT);
}

/* monWatchDog():
 * This function is hooked to the monitor API so that the application
 * can use the same function used by monitor code for exciting the
 * watchdog hardware.
 * Note that if there is no defined WATCHDOG_MACRO, then this function
 * returns -1; else it executes the macro and returns 0.  This
 * return value can be used by the application to decide whether or
 * not the call to mon_watchdog() even needs to occur.
 */
int
monWatchDog(void)
{
#ifdef WATCHDOG_ENABLED
	WATCHDOG_MACRO;
	return(0);
#else
	return(-1);
#endif
}

#if INCLUDE_SHELLVARS

/* putargv() & getargv():
 * The getargv() function provides a hook allowing the downloaded
 * application code to handle main(argc,argv) in a painless way.
 * The Argv[] array location is returned by mon_getargv() and is
 * assumed to contain the NULL terminated list of argv pointers...
 * Immediately after the NULL termination is the data that the argv
 * pointers are referencing.  
 *
 * MONLIB NOTICE: getargv() is accessible through monlib.c.
 */

/* ArgvList:
 * Used by the code that is behind the mon_getargv() API.
 */
static char		*ArgvList[32];

int
putargv(int argnum,char *argptr)
{
	int	i;
	char buf[8];

	if (argnum >= (sizeof(ArgvList)/sizeof(char *)))
		return(-1);

	if (argnum == 0) {
		for(i=0;i<(sizeof(ArgvList)/sizeof(char *));i++) {
			sprintf(buf,"ARG%d",i);
			setenv(buf,0);
		}
		setenv("ARGC",0);
		ArgvList[0] = (char *)0;
	}

	ArgvList[argnum] = argptr;

	if (argptr) {
		sprintf(buf,"ARG%d",argnum);
		setenv(buf,ArgvList[argnum]);
	}
	else {
		shell_sprintf("ARGC","%d",argnum);
	}

	return(0);
}

void
getargv(int *argc,char ***argv)
{
	int	i;

	if (argv)
		*argv = &ArgvList[0];
	for(i=0;;i++)
		if (ArgvList[i] == 0)
			break;
	if (argc)
		*argc = i;
}

#endif