2009-08-06 Joel Sherrill <joel.sherrill@oarcorp.com>

	* ChangeLog, README, diagnostics/README, diagnostics/cfg.h,
	diagnostics/cli.h, diagnostics/cstart.c, diagnostics/main.c,
	diagnostics/makefile, diagnostics/monlib.c, diagnostics/monlib.h,
	diagnostics/tfs.h, umon/Makefile, umon/README, umon/test.c: New files.

14 files changed, 2264 insertions, 0 deletions

diff --git a/micromonitor/ChangeLog b/micromonitor/ChangeLog
new file mode 100644
index 0000000..c22a112
--- /dev/null
+++ b/micromonitor/ChangeLog
@@ -0,0 +1,7 @@
+2009-08-06	Joel Sherrill <joel.sherrill@oarcorp.com>
+
+	* ChangeLog, README, diagnostics/README, diagnostics/cfg.h,
+	diagnostics/cli.h, diagnostics/cstart.c, diagnostics/main.c,
+	diagnostics/makefile, diagnostics/monlib.c, diagnostics/monlib.h,
+	diagnostics/tfs.h, umon/Makefile, umon/README, umon/test.c: New files.
+
diff --git a/micromonitor/README b/micromonitor/README
new file mode 100644
index 0000000..fc0f707
--- /dev/null
+++ b/micromonitor/README
@@ -0,0 +1,5 @@
+#
+#  $Id$
+#
+
+This directory contains examples related to MicroMonitor.
diff --git a/micromonitor/diagnostics/README b/micromonitor/diagnostics/README
new file mode 100644
index 0000000..14f7f3f
--- /dev/null
+++ b/micromonitor/diagnostics/README
@@ -0,0 +1,16 @@
+#
+#  $Id$
+#
+
+This is an example of a non-RTEMS diagnostics program built using
+MicroMonitor and the RTEMS tools.  It isn't setup to auto-adapt
+to a new BSP.  You will have to edit the makefile.  
+
+This program reads a key from the user to indicate what the results
+of the "diagnostics" should (e.g. PASS, FAIL, or UNKNOWN).  The
+MicroMonitor environment variable DIAGNOSTICS_RESULT is set to
+that value.  This environment variable may be queried by MicroMonitor
+scripts and the RTEMS application.
+
+
+XXX insert script here
diff --git a/micromonitor/diagnostics/cfg.h b/micromonitor/diagnostics/cfg.h
new file mode 100755
index 0000000..de4f34c
--- /dev/null
+++ b/micromonitor/diagnostics/cfg.h
@@ -0,0 +1 @@
+#define APPSTACKSIZE 0x2000
diff --git a/micromonitor/diagnostics/cli.h b/micromonitor/diagnostics/cli.h
new file mode 100755
index 0000000..6384816
--- /dev/null
+++ b/micromonitor/diagnostics/cli.h
@@ -0,0 +1,123 @@
+/* cli.h:
+ * Header file for Command Line Interface related stuff.
+ *
+ *	General notice:
+ *	This code is part of a boot-monitor package developed as a generic base
+ *	platform for embedded system designs.  As such, it is likely to be
+ *	distributed to various projects beyond the control of the original
+ *	author.  Please notify the author of any enhancements made or bugs found
+ *	so that all may benefit from the changes.  In addition, notification back
+ *	to the author will allow the new user to pick up changes that may have
+ *	been made by other users after this version of the code was distributed.
+ *
+ *	Note1: the majority of this code was edited with 4-space tabs.
+ *	Note2: as more and more contributions are accepted, the term "author"
+ *		   is becoming a mis-representation of credit.
+ *
+ *	Original author:	Ed Sutter
+ *	Email:				esutter@lucent.com
+ *	Phone:				908-582-2351
+ */
+#ifndef _cli_h
+#define _cli_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Command table structure used by the monitor:
+ */
+struct	monCommand {
+    char    *name;					/* Name of command seen by user. */
+    int	    (*func)(int,char **);	/* Called when command is invoked. */
+    char    **helptxt;				/* Help text (see notes below). */
+	long	flags;					/* Single-bit flags for various uses */
+									/* (see the CMDFLAG_XXX macros). */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Bits currently assigned to command flags used in the monCommand
+ * structure...
+ */
+#define CMDFLAG_NOMONRC	1
+
+/* Maximum size of a command line:
+ */
+#ifndef CMDLINESIZE
+#define CMDLINESIZE	128
+#endif
+
+/* Maximum number of arguments in a command line:
+ */
+#define ARGCNT		24
+
+/* Definitions for docommand() return values:
+ *
+ * Note that the CMD_SUCCESS, CMD_FAILURE and CMD_PARAM_ERROR are return
+ * values used by the local command code also.  The remaining errors
+ * (CMD_LINE_ERROR, CMD_ULVL_DENIED and CMD_NOT_FOUND) are used only by
+ # the docommand() function.
+ *
+ *	CMD_SUCCESS:
+ *		Everything worked ok.
+ *	CMD_FAILURE:
+ *		Command parameters were valid, but command itself failed for some other
+ *		reason. The docommand() function does not print a message here, it
+ *		is assumed that the error message was printed by the local function.
+ *	CMD_PARAM_ERROR:
+ *		Command line did not parse properly.  Control was passed to a 
+ *		local command function, but argument syntax caused it to choke.
+ *		In this case docommand() will print out the generic CLI syntax error
+ *		message.
+ *	CMD_LINE_ERROR:
+ *		Command line itself was invalid.  Too many args, invalid shell var
+ *		syntax, etc.. Somekind of command line error prior to checking for
+ *		the command name-to-function match.
+ *	CMD_ULVL_DENIED:
+ *		Command's user level is higher than current user level, so access
+ *		is denied.
+ *	CMD_NOT_FOUND:
+ *		Since these same return values are used for each command function
+ *		plus the docommand() function, this error indicates that docommand()
+ *		could not even find the command in the command table.
+ *	CMD_MONRC_DENIED:
+ *		The command cannot execute because it is considered illegal
+ *		when run from within the monrc file.
+ */
+#define CMD_SUCCESS			0
+#define CMD_FAILURE			-1
+#define CMD_PARAM_ERROR		-2
+#define CMD_LINE_ERROR		-3
+#define CMD_ULVL_DENIED		-4
+#define CMD_NOT_FOUND		-5
+#define CMD_MONRC_DENIED	-6
+
+/* Notes on help text array:
+ * The monitor's CLI processor assumes that every command's help text 
+ * array abides by a few basic rules...
+ * First of all, it assumes that every array has AT LEAST two strings.
+ * The first string in the array of strings is assumed to be a one-line
+ * abstract describing the command.
+ * The second string in the array of strings is assumed to be a usage
+ * message that describes the syntax of the arguments needed by the command.
+ * If this second string is an empty string (""), the docommand() prints out
+ * a generic usage string indicating that there are no options or arguements
+ * to apply to the command.
+ * All remaining lines are formatted based on the needs of the individual
+ * command and the final string is a null pointer to let the CLI processor
+ * know where the end is.
+ * Following is an example help text array...
+ *
+ *	char *HelpHelp[] = {
+ *			"Display command set",
+ *			"-[d] [commandname]",
+ *			"Options:",
+ *			" -d   list commands and descriptions",
+ *			0,
+ *	};
+ *
+ */
+#endif
diff --git a/micromonitor/diagnostics/cstart.c b/micromonitor/diagnostics/cstart.c
new file mode 100644
index 0000000..d6070ae
--- /dev/null
+++ b/micromonitor/diagnostics/cstart.c
@@ -0,0 +1,69 @@
+/* 
+ * 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().
+ */
+
+#include "monlib.h"
+#include "tfs.h"
+#include "cfg.h"
+
+extern int main(int, char**);
+
+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);
+}
+
+#if 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);
+}
+#endif
diff --git a/micromonitor/diagnostics/main.c b/micromonitor/diagnostics/main.c
new file mode 100755
index 0000000..0b453fc
--- /dev/null
+++ b/micromonitor/diagnostics/main.c
@@ -0,0 +1,62 @@
+/* 
+ * This file is a simple example of a "diagnostic" program that
+ * could be run before a real application.
+ *
+ * main():
+ * The main() function demonstrates a simple way to communicate the diagnostics
+ * result back to the MicroMonitor script.
+ */
+
+#include "monlib.h"
+
+int getakey(void)
+{
+  while(!mon_gotachar());
+  return mon_getchar();
+}
+
+int
+main(int argc,char *argv[])
+{
+  char *result = (char *)0;
+
+  mon_printf(
+    "\n\nDiagnotics Program\n"
+    "Should the diagnostics return p (pass), u (unknown), f (fail)? >"
+  );
+
+  /*
+   *  Run the diagnostics.  OK in this case, we are just asking the
+   *  user to decide if they passed or failed.
+   */
+  while (1) {
+     int c = getakey();
+     mon_printf( "%c\n", c);
+     if ( c == 'p' ) {
+       result = "PASS";
+       break;
+     }
+     if ( c == 'f' ) {
+       result = "FAIL";
+       break;
+     }
+     if ( c == 'u' ) {
+       result = "UNKNOWN";
+       break;
+     }
+     mon_printf( "Unknown response %c -- try again\n", c );
+  }
+
+  /*
+   * We broke out of the loop so must have a result.
+   */
+  mon_setenv( "DIAGNOSTICS_RESULT", result );
+
+  mon_printf(
+    "Set DIAGNOSTICS_RESULT to %s\n"
+    "At the MicroMonitor prompt: echo $DIAGNOSTICS_RESULT\n",
+    mon_getenv("DIAGNOSTICS_RESULT")
+  );
+  
+  return 0;
+}
diff --git a/micromonitor/diagnostics/makefile b/micromonitor/diagnostics/makefile
new file mode 100755
index 0000000..f5d77d6
--- /dev/null
+++ b/micromonitor/diagnostics/makefile
@@ -0,0 +1,232 @@
+##########################################################################
+#
+# Basic, target/architecture independent makefile for building an
+# application that runs on its own stack. 
+# The application code in main.c provides a target-independent example
+# of hooking up an application to a target running MicroMonitor.
+# Also, there is a self-induced exception branch (see strace_demo.c)
+# that can be invoked to force the application to take an exception.
+# The purpose of this is to allow the user to then use the monitor's
+# 'strace' command to see the function nesting that occurred prior to
+# the exception.  This requires that the symbol table also be on-board.
+# To walk through this example, establish the site-dependent information
+# specified below, then execute "make" to build the image, and then
+# "make dld sym" to install it (and a symbol table) on the target.
+#
+# Site dependent information:
+# Adjust these values based on your system configuration.  
+# ARCH:
+# 	Set ARCH to one of the accepted CPU architectures (i.e. MIPS
+#	PPC, ARM, BLACKFIN, COLDFIRE, MICROBLAZE).
+# MONCOMPTR:
+# 	Set MONCOMPTR to the output of 'echo $MONCOMPTR' on your target.
+# APPRAMBASE:
+# 	Set APPRAMBASE to the output of 'echo $APPRAMBASE' on your target.
+# TARGET_IP:
+#	Set TARGET_IP to the IP address of your target.
+#
+ARCH		= ARM
+MONCOMPTR	= 0x10000020
+APPRAMBASE	= 0x20100000
+TARGET_IP	= 192.168.1.242
+
+##########################################################################
+#
+# There should be no need to change anything below this point if
+# building for the csb350, csb472, csb337 or csb360...
+# 
+APPNAME		= diagnostics
+NM			= $(TOOL_PREFIX)-nm
+AR			= $(TOOL_PREFIX)-ar
+LD			= $(TOOL_PREFIX)-ld
+ASM			= $(TOOL_PREFIX)-as
+CC			= $(TOOL_PREFIX)-gcc
+STRIP		= $(TOOL_PREFIX)-strip
+OBJCOPY		= $(TOOL_PREFIX)-objcopy
+OBJDUMP		= $(TOOL_PREFIX)-objdump
+LIBGCC		= `$(CC) --print-libgcc-file-name`
+LIBDIR		= $(LIBGCC:/libgcc.a=)
+LIBPATH		= 
+
+ifeq ($(ARCH),MIPS)
+TOOL_PREFIX	:= mips-elf
+CFLAGS		:= -fno-builtin -G 0 -march=r4600 -mips3 -mno-abicalls \
+			  -fno-pic -c -g -O2 -Wall -EB -I . 
+CRT0		:= crt0_mips.o
+CPU			:= -D CPU_IS_MIPS=1
+endif
+
+ifeq ($(ARCH),PPC)
+TOOL_PREFIX	:= ppc-elf
+CFLAGS		:= -fno-builtin -mno-sdata -msoft-float \
+			   -c -Wall -O -g -I. 
+CRT0		:= crt0_ppc.o
+CPU			:= -D CPU_IS_PPC=1
+LIBGCC		= `$(CC) --print-file-name=nof/libgcc.a`
+endif
+
+ifeq ($(ARCH),ARM)
+#TOOL_PREFIX	:= arm-elf
+TOOL_PREFIX	:= arm-rtems4.10
+CFLAGS		:= -fno-builtin -mcpu=arm920t -fno-omit-frame-pointer \
+			   -c -Wall -O -g -I.
+CRT0		:= crt0_arm.o
+CPU			:= -D CPU_IS_ARM=1
+endif
+
+ifeq ($(ARCH),BLACKFIN)
+TOOL_PREFIX	:= bfin-elf
+CFLAGS		:= -fno-builtin -mcsync-anomaly -c -Wall -O -g -I.
+CRT0		:= crt0_bfin.o
+CPU			:= -D CPU_IS_BFIN=1
+endif
+
+ifeq ($(ARCH),MICROBLAZE)
+TOOL_PREFIX	:= C:/EDK/gnu/microblaze/nt/bin/mb
+LIBPATH		:= -L C:/xilinx/els_stuff/projects/avnet_spartan3_devkit/microblaze_0/lib
+CFLAGS		:= -fno-builtin -mno-xl-soft-mul -c -Wall -O -g -I.
+CRT0		:= crt0_mb.o
+CPU			:= -D CPU_IS_MICROBLAZE=1
+endif
+
+ifeq ($(ARCH),COLDFIRE)
+TOOL_PREFIX	:= m68k-elf
+CFLAGS		:= -Wall -fno-builtin -msoft-float -m5200 -g -c -I.
+CRT0		:= crt0_cf.o
+CPU			:= -D CPU_IS_68K=1
+#LIBGCC		= `$(CC) -m5200 --print-libgcc-file-name`
+LIBGCC		= /usr/lib/gcc-lib/m68k-elf/3.2/m5200/libgcc.a -L /usr/m68k-elf/lib/m5200
+endif
+
+START=start
+
+CRT0=cstart.o
+START=Cstart
+OBJS=$(CRT0) main.o monlib.o
+
+all: $(APPNAME)
+#####
+#
+# $(APPNAME):
+# Top level target builds the application.
+#
+$(APPNAME): varcheck $(OBJS) makefile
+	echo tools: $(TOOL_PREFIX)
+	$(LD) -e $(START) -o $(APPNAME) -Ttext $(APPRAMBASE) $(OBJS) $(LIBPATH) -lc $(LIBGCC) 
+	$(NM) --numeric-sort $(APPNAME) >$(APPNAME).sym
+	$(OBJDUMP) --source --disassemble $(APPNAME) > $(APPNAME).dis
+	$(STRIP) $(APPNAME) 
+
+#####
+#
+# Variable checks:
+# Verify that the necessary variables have been set on the make
+# command line.
+#
+varcheck:
+ifndef ARCH
+	@echo Must specify ARCH=XXX on command line.
+	@exit 1
+endif	
+ifndef TOOL_PREFIX
+	@echo Invalid ARCH specification. Use PPC, ARM, MIPS, BLACKFIN or COLDFIRE.
+	@exit 1
+endif	
+ifeq ($(TOOL_PREFIX),-)
+	@echo Invalid ARCH specification. Use PPC, ARM, MIPS, BLACKFIN or COLDFIRE.
+	@exit 1
+endif	
+ifndef MONCOMPTR
+	@echo Must specify MONCOMPTR=XXX on command line.
+	@exit 1
+endif	
+ifndef APPRAMBASE
+	@echo Must specify APPRAMBASE=XXX on command line.
+	@exit 1
+endif	
+
+targetipcheck:
+ifndef TARGET_IP
+	@echo Must specify TARGET_IP=IPADDRESS on command line.
+	@exit 1
+endif	
+
+
+#####
+#
+# Objects:
+#
+crt0_68k.o: crt0_68k.S
+	$(CC) $(CFLAGS) -o $@ crt0_68k.S
+
+crt0_arm.o: crt0_arm.S
+	$(CC) $(CFLAGS) -o $@ crt0_arm.S
+
+crt0_bfin.o: crt0_bfin.S
+	$(CC) $(CFLAGS) -o $@ crt0_bfin.S
+
+crt0_mips.o: crt0_mips.S
+	$(CC) $(CFLAGS) -o $@ crt0_mips.S
+
+crt0_mb.o: crt0_mb.S
+	$(CC) $(CFLAGS) -o $@ crt0_mb.S
+
+crt0_ppc.o: crt0_ppc.S
+	$(CC) $(CFLAGS) -o $@ crt0_ppc.S
+
+crt0_sh2.o: crt0_sh2.S
+	$(CC) $(CFLAGS) -o $@ crt0_sh2.S
+
+main.o: main.c 
+	$(CC) $(CFLAGS) -D MONCOMPTR=$(MONCOMPTR) -o $@ main.c
+
+cstart.o: cstart.c 
+	$(CC) $(CFLAGS) -D MONCOMPTR=$(MONCOMPTR) -o $@ cstart.c
+
+monlib.o: monlib.c
+	$(CC) $(CFLAGS) -o $@ monlib.c
+
+strace.o: strace.c 
+	$(CC) $(CFLAGS) $(CPU) -o $@ strace.c
+
+#####
+#
+# clean:
+# Remove all files created by this make.
+#
+clean:
+	rm -f *.o $(APPNAME) $(APPNAME).ezip $(APPNAME).sym $(APPNAME).dis symtbl
+
+#####
+#
+# sym:
+# Create and download the symbol table file that can be used by uMon
+# with this application...
+#
+sym: targetipcheck
+	@if ! test -f $(APPNAME).sym; then echo Must build $(APPNAME) first; exit 1; fi
+	monsym -p0x $(APPNAME).sym >symtbl
+	ttftp $(TARGET_IP) put symtbl
+
+
+	
+#####
+#
+# dld:
+# Use the ttftp tool (supplied with MicroMonitor) to download the
+# application to the target.
+#
+dld: targetipcheck
+	@if ! test -f $(APPNAME); then echo Must build $(APPNAME) first; exit 1; fi
+	ttftp $(TARGET_IP) put $(APPNAME) $(APPNAME),E
+
+#####
+#
+# zdld:
+# Compress the elf file using the 'elf' tool (supplied with MicroMonitor)
+# The output of this is "$(APPNAME).ezip", then download that compressed file.
+#
+zdld: targetipcheck 
+	@if ! test -f $(APPNAME); then echo Must build $(APPNAME) first; exit 1; fi
+	elf -z6 $(APPNAME)
+	ttftp $(TARGET_IP) put $(APPNAME).ezip $(APPNAME),Ec
diff --git a/micromonitor/diagnostics/monlib.c b/micromonitor/diagnostics/monlib.c
new file mode 100755
index 0000000..33c05e4
--- /dev/null
+++ b/micromonitor/diagnostics/monlib.c
@@ -0,0 +1,1115 @@
+/* monlib.c:
+ *	This file is part of the monitor code, but it is actually linked into
+ *	the application.  It is built with (but not linked with) the monitor,
+ *	then the monlib.o file is linked with the application.
+ *	The only requirement on the application is that it know where the address
+ *	of the monCom function is in the monitor's space.  
+ *	The monCom function will be accessible in some "well-known" way (processor
+ *	and platform dependent) so that this will not be a problem.
+ *
+ *	This monlib.c file is a replacement for the older mechanism that was
+ *	a bit more error-prone...  A table of function pointers existed at some
+ *	well-known location in the monitor, and the content of that table was
+ *	assumed to also be "well-known".  This new version only assumes that the
+ *	pointer to monCom is well-known; everything else will work based on the
+ *	fact that the monitor and application will share the monlib.h header
+ *	file.
+ *
+ *	General notice:
+ *	This code is part of a boot-monitor package developed as a generic base
+ *	platform for embedded system designs.  As such, it is likely to be
+ *	distributed to various projects beyond the control of the original
+ *	author.  Please notify the author of any enhancements made or bugs found
+ *	so that all may benefit from the changes.  In addition, notification back
+ *	to the author will allow the new user to pick up changes that may have
+ *	been made by other users after this version of the code was distributed.
+ *
+ *	Note1: the majority of this code was edited with 4-space tabs.
+ *	Note2: as more and more contributions are accepted, the term "author"
+ *		   is becoming a mis-representation of credit.
+ *
+ *	Original author:	Ed Sutter
+ *	Email:				esutter@lucent.com
+ *	Phone:				908-582-2351
+ */
+#include "monlib.h"
+
+static int		(*_tfsseek)(int,int,int);
+static int 		(*_tfsgetline)(int,char *,int);
+static int		(*_tfsipmod)(char *,char *,int,int);
+static int		(*_tfsinit)(void);
+static int		(*_tfsadd)(char *,char *,char *,unsigned char *,int);
+static int		(*_tfsunlink)(char *);
+static int		(*_tfsrun)(char **,int);
+static int 		(*_tfsread)(int,char *,int);
+static int		(*_tfswrite)(int,char *,int);
+static int		(*_tfsopen)(char *,long,char *);
+static int		(*_tfsclose)(int,char *);
+static int		(*_printf)();
+static int		(*_cprintf)();
+static int		(*_sprintf)();
+static int		(*_monrestart)(int);
+static int		(*_rputchar)(unsigned char c);
+static int		(*_getchar)(void);
+static int		(*_gotachar)(void);
+static int		(*_getbytes)(char *,int,int);
+static int		(*_addcommand)(struct monCommand *,char *);
+static int		(*_docommand)(char *,int);
+static int		(*_getline)(char *,int,int);
+static int		(*_tfsfstat)(char *,struct tfshdr *);
+static int		(*_tfseof)(int);
+static int		(*_decompress)(char *,int,char *);
+static int		(*_tfstruncate)(int,long);
+static int		(*_heapextend)(char *,int);
+static int		(*_tfslink)(char *,char *);
+static int		(*_pcicfgwrite)(int,int,int,int,int,unsigned long);
+static int		(*_i2cwrite)(int,int,unsigned char *,int);
+static int		(*_i2cread)(int,int,unsigned char *,int);
+static int 		(*_flashwrite)(char *,char *,int);
+static int		(*_flasherase)(int);
+static int		(*_flashinfo)(int,int *,char **);
+static int		(*_flashoverride)(void *,int,int);
+static int		(*_sendenet)(char *,int);
+static int		(*_recvenet)(char *,int);
+static int		(*_printpkt)(char *,int,int);
+static int		(*_setenv)(char *,char *);
+static int		(*_watchdog)(void);
+static int		(*_timeofday)(int,void *);
+static int		(*_montimer)(int cmd, void *arg);
+
+static char		*(*_getenv)(char *);
+static char		*(*_version)(void);
+static char		*(*_getenvp)(void);
+#ifdef MALLOC_DEBUG
+static char		*(*_malloc)(int,char *,int);
+static char		*(*_realloc)(char *buf,int,char *,int);
+#else
+static char		*(*_malloc)(int);
+static char		*(*_realloc)(char *,int);
+#endif
+static char		*(*_getsym)(char *,char *,int);
+
+static void		(*_intsrestore)(unsigned long);
+static void		(*_appexit)(int);
+static void		(*_free)(char *);
+static void		(*_getargv)(int *,char ***);
+static void		(*_profiler)(void *);
+static void		(*_bbc)(char *,int);
+static void		(*_memtrace)();
+static void		(*_appwarmstart)(unsigned long);
+static void		(*_mondelay)(long);
+static void		(*_printmem)(char *,int,int);
+
+static long		(*_tfsctrl)(int,long,long);
+static long		(*_tfstell)(int);
+static long		(*_portcmd)(int,void *);
+
+static struct	tfshdr *(*_tfsnext)(struct tfshdr *);
+static struct	tfshdr *(*_tfsstat)(char *);
+
+static unsigned long	(*_i2cctrl)(int,int,unsigned long,unsigned long);
+static unsigned long	(*_pcicfgread)(int,int,int,int,int);
+static unsigned long	(*_pcictrl)(int,int,unsigned long,unsigned long);
+static unsigned long	(*_crc32)(unsigned char *,unsigned long);
+static unsigned long	(*_intsoff)(void);
+static unsigned long	(*_assign_handler)(long,unsigned long,unsigned long);
+
+static unsigned short	(*_xcrc16)(unsigned char *,unsigned long);
+
+
+static void (*_monlock)(void);
+static void (*_monunlock)(void);
+static int	(*_moncom)(int,void *,void *, void *);
+
+/**************************************************************************
+ *
+ * The following macros support the default monitor lock/unlock mechanism when
+ * they point to monLock and monUnlock.  If something other than the default
+ * is to be used, then simply redefine them here.  Refer to the monitor
+ * app note that discusses multi-tasking access to the monitor API for more
+ * information.
+ * 
+ * TFS_MONLOCK/UNLOCK:
+ * Lock/unlock for functions that access TFS flash space:
+ */
+#define TFS_MONLOCK			monLock
+#define TFS_MONUNLOCK		monUnlock
+
+/* ENV_MONLOCK/UNLOCK:
+ * Lock/unlock for functions that access monitor shell variables:
+ */
+#define ENV_MONLOCK			monLock
+#define ENV_MONUNLOCK		monUnlock
+
+/* CONSOLE_MONLOCK/UNLOCK:
+ * Lock/unlock for functions in the monitor that deal with console output.
+ */
+#define CONSOLE_MONLOCK		monLock
+#define CONSOLE_MONUNLOCK	monUnlock
+
+/* HEAP_MONLOCK/UNLOCK:
+ * Lock/unlock for functions in the monitor that deal with the heap.
+ */
+#define HEAP_MONLOCK		monLock
+#define HEAP_MONUNLOCK		monUnlock
+
+/* BLOCKING_MONLOCK/UNLOCK:
+ * Lock/unlock for functions in the monitor that block waiting for 
+ * console input.
+ */
+#define BLOCKING_MONLOCK	monLock
+#define BLOCKING_MONUNLOCK	monUnlock
+
+/* GENERIC_MONLOCK/UNLOCK:
+ * Lock/unlock for all functions not covered by the above macros.
+ */
+#define GENERIC_MONLOCK		monLock
+#define GENERIC_MONUNLOCK	monUnlock
+
+/**************************************************************************
+ *
+ * monConnect():
+ *	This must be the first call by the application code to talk to the
+ *	monitor.  It is expecting three incoming function pointers:
+ *
+ *	mon:	Points to the monitor's _moncom function;
+ *			This is a "well-known" address because the monitor and
+ *			application code (two separately linked binaries) must
+ *			know it.
+ *	lock:	Points to a function in the application code that will be
+ *			used by the monitor as a lock-out function (some kind of
+ *			semaphore in the application).  
+ *	unlock:	Points to a function in the application code that will be
+ *			used by the monitor as an un-lock-out function (undo whatever
+ *			lock-out mechanism was done by lock).
+ */
+int
+monConnect(int (*mon)(int,void *,void *,void *),
+	void (*lock)(void), void (*unlock)(void))
+{
+	int rc = 0;
+
+	/* Assign incoming lock and unlock functions... */
+	_monlock = lock;
+	_monunlock = unlock;
+
+	/* If the mon pointer is non-zero, then make the mon_ connections... */
+	if (mon) {
+
+		_moncom = mon;
+
+		/* Make the connections between "mon_" functions that are			*/
+		/* symbolically	accessible by the application and the corresponding	*/
+		/* functions that exists in the monitor.							*/
+		rc += _moncom(GETMONFUNC_PUTCHAR,&_rputchar,0,0);
+		rc += _moncom(GETMONFUNC_GETCHAR,&_getchar,0,0);
+		rc += _moncom(GETMONFUNC_GOTACHAR,&_gotachar,0,0);
+		rc += _moncom(GETMONFUNC_GETBYTES,&_getbytes,0,0);
+		rc += _moncom(GETMONFUNC_PRINTF,&_printf,0,0);
+		rc += _moncom(GETMONFUNC_CPRINTF,&_cprintf,0,0);
+		rc += _moncom(GETMONFUNC_SPRINTF,&_sprintf,0,0);
+		rc += _moncom(GETMONFUNC_RESTART,&_monrestart,0,0);
+		rc += _moncom(GETMONFUNC_GETENV,&_getenv,0,0);
+		rc += _moncom(GETMONFUNC_SETENV,&_setenv,0,0);
+		rc += _moncom(GETMONFUNC_TFSINIT,&_tfsinit,0,0);
+		rc += _moncom(GETMONFUNC_TFSADD,&_tfsadd,0,0);
+		rc += _moncom(GETMONFUNC_TFSUNLINK,&_tfsunlink,0,0);
+		rc += _moncom(GETMONFUNC_TFSRUN,&_tfsrun,0,0);
+		rc += _moncom(GETMONFUNC_TFSNEXT,&_tfsnext,0,0);
+		rc += _moncom(GETMONFUNC_TFSSTAT,&_tfsstat,0,0);
+		rc += _moncom(GETMONFUNC_TFSREAD,&_tfsread,0,0);
+		rc += _moncom(GETMONFUNC_TFSWRITE,&_tfswrite,0,0);
+		rc += _moncom(GETMONFUNC_TFSOPEN,&_tfsopen,0,0);
+		rc += _moncom(GETMONFUNC_TFSCLOSE,&_tfsclose,0,0);
+		rc += _moncom(GETMONFUNC_TFSSEEK,&_tfsseek,0,0);
+		rc += _moncom(GETMONFUNC_TFSGETLINE,&_tfsgetline,0,0);
+		rc += _moncom(GETMONFUNC_TFSIPMOD,&_tfsipmod,0,0);
+		rc += _moncom(GETMONFUNC_TFSCTRL,&_tfsctrl,0,0);
+		rc += _moncom(GETMONFUNC_ADDCOMMAND,&_addcommand,0,0);
+		rc += _moncom(GETMONFUNC_DOCOMMAND,&_docommand,0,0);
+		rc += _moncom(GETMONFUNC_GETARGV,&_getargv,0,0);
+		rc += _moncom(GETMONFUNC_CRC16,&_xcrc16,0,0);
+		rc += _moncom(GETMONFUNC_CRC32,&_crc32,0,0);
+		rc += _moncom(GETMONFUNC_INTSOFF,&_intsoff,0,0);
+		rc += _moncom(GETMONFUNC_INTSRESTORE,&_intsrestore,0,0);
+		rc += _moncom(GETMONFUNC_APPEXIT,&_appexit,0,0);
+		rc += _moncom(GETMONFUNC_MALLOC,&_malloc,0,0);
+		rc += _moncom(GETMONFUNC_FREE,&_free,0,0);
+		rc += _moncom(GETMONFUNC_GETLINE,&_getline,0,0);
+		rc += _moncom(GETMONFUNC_TFSFSTAT,&_tfsfstat,0,0);
+		rc += _moncom(GETMONFUNC_TFSEOF,&_tfseof,0,0);
+		rc += _moncom(GETMONFUNC_DECOMPRESS,&_decompress,0,0);
+		rc += _moncom(GETMONFUNC_TFSTRUNCATE,&_tfstruncate,0,0);
+		rc += _moncom(GETMONFUNC_HEAPXTEND,&_heapextend,0,0);
+		rc += _moncom(GETMONFUNC_PROFILER,&_profiler,0,0);
+		rc += _moncom(GETMONFUNC_TFSLINK,&_tfslink,0,0);
+		rc += _moncom(GETMONFUNC_BBC,&_bbc,0,0);
+		rc += _moncom(GETMONFUNC_MEMTRACE,&_memtrace,0,0);
+		rc += _moncom(GETMONFUNC_TFSTELL,&_tfstell,0,0);
+		rc += _moncom(GETMONFUNC_VERSION,&_version,0,0);
+		rc += _moncom(GETMONFUNC_WARMSTART,&_appwarmstart,0,0);
+		rc += _moncom(GETMONFUNC_PCICFGREAD,&_pcicfgread,0,0);
+		rc += _moncom(GETMONFUNC_PCICFGWRITE,&_pcicfgwrite,0,0);
+		rc += _moncom(GETMONFUNC_PCICONTROL,&_pcictrl,0,0);
+		rc += _moncom(GETMONFUNC_I2CREAD,&_i2cread,0,0);
+		rc += _moncom(GETMONFUNC_I2CWRITE,&_i2cwrite,0,0);
+		rc += _moncom(GETMONFUNC_I2CCONTROL,&_i2cctrl,0,0);
+		rc += _moncom(GETMONFUNC_MONDELAY,&_mondelay,0,0);
+		rc += _moncom(GETMONFUNC_GETENVP,&_getenvp,0,0);
+		rc += _moncom(GETMONFUNC_REALLOC,&_realloc,0,0);
+		rc += _moncom(GETMONFUNC_SENDENETPKT,&_sendenet,0,0);
+		rc += _moncom(GETMONFUNC_RECVENETPKT,&_recvenet,0,0);
+		rc += _moncom(GETMONFUNC_GETSYM,&_getsym,0,0);
+		rc += _moncom(GETMONFUNC_PRINTPKT,&_printpkt,0,0);
+		rc += _moncom(GETMONFUNC_FLASHWRITE,&_flashwrite,0,0);
+		rc += _moncom(GETMONFUNC_FLASHERASE,&_flasherase,0,0);
+		rc += _moncom(GETMONFUNC_FLASHINFO,&_flashinfo,0,0);
+		rc += _moncom(GETMONFUNC_ASSIGNHDLR,&_assign_handler,0,0);
+		rc += _moncom(GETMONFUNC_WATCHDOG,&_watchdog,0,0);
+		rc += _moncom(GETMONFUNC_PRINTMEM,&_printmem,0,0);
+		rc += _moncom(GETMONFUNC_PORTCMD,&_portcmd,0,0);
+		rc += _moncom(GETMONFUNC_TIMEOFDAY,&_timeofday,0,0);
+		rc += _moncom(GETMONFUNC_TIMER,&_montimer,0,0);
+		rc += _moncom(GETMONFUNC_FLASHOVRRD,&_flashoverride,0,0);
+	}
+	return(rc);
+}
+
+/* ignorelock:
+ * Used as a back-door to disable the monLock()/monUnlock() stuff.
+ * This is useful if the application CLI falls through to the monitor's
+ * CLI and you are using the "call" command in the monitor to execute some
+ * function that has a mon_xxx function in it.  In this case, the fact that
+ * the application has fallen through to the monitor means that the lock
+ * is already active, so when the function tries to call some other mon_xxx
+ * function it won't be able to because of the lock already being set.
+ *
+ * With these functions in the application space, the user can do the 
+ * following:
+ *	call %DisableLock
+ *  call %Func_with_monXXX_in_it
+ *  call %EnableLock
+ *
+ * Note that this is NOT to be used by application code, it is simply a
+ * back-door mechanism to allow "call" from the CLI to invoke functions
+ * that have mon_XXX functionality in them.
+ */
+static int ignorelock = 0;
+
+void
+DisableMonLock(void)
+{
+	ignorelock = 2;
+}
+
+void
+EnableMonLock(void)
+{
+	ignorelock = 0;
+}
+
+/* monLock() & monUnlock():
+ * Used by all of the wrapper functions below this point to call
+ * the function pointed to by _monlock & _monunlock function pointers
+ * (if set).
+ * These functions must test both the function pointer and the state
+ * of the ignorelock variable.  The function DisableMonLock() sets the
+ * ignorelock variable to 2 because it is being executed through "call"
+ * which means that the lock is active.  
+ */
+static void
+monLock()
+{
+	if (_monlock) {
+		switch(ignorelock) {
+			case 1:
+				break;
+			case 2:
+				ignorelock--;
+				break;
+			default:
+				_monlock();
+				break;
+		}
+	}
+}
+
+static void
+monUnlock()
+{
+	if (_monunlock) {
+		switch(ignorelock) {
+			case 1:
+				break;
+			case 2:
+				ignorelock--;
+			default:
+				_monunlock();
+				break;
+		}
+	}
+}
+
+int
+mon_com(int cmd, void *arg1, void *arg2, void *arg3)
+{
+	int	ret;
+	
+	GENERIC_MONLOCK();
+	ret = _moncom(cmd,arg1,arg2,arg3);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_putchar(char c)
+{
+	int	ret;
+	
+	CONSOLE_MONLOCK();
+	ret = _rputchar(c);
+	CONSOLE_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_getchar(void)
+{
+	int	ret;
+
+	BLOCKING_MONLOCK();
+	ret = _getchar();
+	BLOCKING_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_gotachar(void)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _gotachar();
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_getbytes(char *buf,int cnt,int block)
+{
+	int	ret;
+
+	BLOCKING_MONLOCK();
+	ret = _getbytes(buf,cnt,block);
+	BLOCKING_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_printf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
+char *fmt;
+int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
+{
+	int	ret;
+
+	CONSOLE_MONLOCK();
+	ret = _printf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
+	CONSOLE_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_cprintf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
+char *fmt;
+int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
+{
+	int	ret;
+
+	CONSOLE_MONLOCK();
+	ret = _cprintf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
+	CONSOLE_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_sprintf(buf,fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
+char *fmt, *buf;
+int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _sprintf(buf,fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_restart(int val)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _monrestart(val);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+char *
+mon_getenvp(void)
+{
+	char *ret;
+
+	ENV_MONLOCK();
+	ret = _getenvp();
+	ENV_MONUNLOCK();
+	return(ret);
+}
+
+char *
+mon_getenv(char *name)
+{
+	char *ret;
+
+	ENV_MONLOCK();
+	ret = _getenv(name);
+	ENV_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_setenv(char *name,char *val)
+{
+	int ret;
+
+	ENV_MONLOCK();
+	ret = _setenv(name,val);
+	ENV_MONUNLOCK();
+	return(ret);
+}
+
+char *
+mon_getsym(char *name,char *buf, int bufsize)
+{
+	char *ret;
+
+	ENV_MONLOCK();
+	ret = _getsym(name,buf,bufsize);
+	ENV_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsinit(void)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsinit();
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsadd(char *name, char *info, char *flags, unsigned char *src, int size)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsadd(name,info,flags,src,size);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfslink(char *src, char *target)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfslink(src,target);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsunlink(char *name)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsunlink(name);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsrun(char **name,int verbose)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsrun(name,verbose);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+struct tfshdr *
+mon_tfsnext(struct tfshdr *fp)
+{
+	struct tfshdr *ret;
+
+	TFS_MONLOCK();
+	ret = _tfsnext(fp);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfstruncate(int tfd, long len)
+{
+	int ret;
+
+	TFS_MONLOCK();
+	ret = _tfstruncate(tfd,len);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfseof(int tfd)
+{
+	int ret;
+
+	TFS_MONLOCK();
+	ret = _tfseof(tfd);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsfstat(char *name, struct tfshdr *fp)
+{
+	int ret;
+
+	TFS_MONLOCK();
+	ret = _tfsfstat(name,fp);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+struct tfshdr *
+mon_tfsstat(char *name)
+{
+	struct tfshdr *ret;
+
+	TFS_MONLOCK();
+	ret = _tfsstat(name);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsread(int fd, char *buf, int cnt)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsread(fd,buf,cnt);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfswrite(int fd, char *buf, int cnt)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfswrite(fd,buf,cnt);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsopen(char *file,long flagmode,char *buf)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsopen(file,flagmode,buf);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsclose(int fd,char *info)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsclose(fd,info);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsseek(int fd, int offset, int whence)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsseek(fd,offset,whence);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsgetline(int fd,char *bp,int max)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsgetline(fd,bp,max);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_tfsipmod(char *name,char *buf,int offset,int size)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsipmod(name,buf,offset,size);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+long
+mon_tfsctrl(int rqst,long arg1,long arg2)
+{
+	long	ret;
+
+	TFS_MONLOCK();
+	ret = _tfsctrl(rqst,arg1,arg2);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+long
+mon_tfstell(int fd)
+{
+	long	ret;
+
+	TFS_MONLOCK();
+	ret = _tfstell(fd);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_addcommand(struct monCommand *cmdlist, char *cmdlvl)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _addcommand(cmdlist,cmdlvl);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_docommand(char *cmdline,int verbose)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _docommand(cmdline,verbose);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+void
+mon_getargv(int *argc,char ***argv)
+{
+	GENERIC_MONLOCK();
+	_getargv(argc,argv);
+	GENERIC_MONUNLOCK();
+}
+
+unsigned short
+mon_xcrc16(char *buf,long nbytes)
+{
+	unsigned short ret;
+
+	GENERIC_MONLOCK();
+	ret = _xcrc16((unsigned char *)buf,nbytes);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+unsigned long
+mon_intsoff(void)
+{
+	unsigned long ret;
+
+	GENERIC_MONLOCK();
+	ret = _intsoff();
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+void
+mon_intsrestore(unsigned long msr)
+{
+	GENERIC_MONLOCK();
+	_intsrestore(msr);
+	GENERIC_MONUNLOCK();
+}
+
+void
+mon_appexit(int val)
+{
+	GENERIC_MONLOCK();
+	_appexit(val);
+	GENERIC_MONUNLOCK();
+}
+
+#ifdef MALLOC_DEBUG
+char *
+mon_malloc(int size,char *fname,int fline)
+{
+	char *ret;
+
+	HEAP_MONLOCK();
+	ret = _malloc(size,fname,fline);
+	HEAP_MONUNLOCK();
+	return(ret);
+}
+
+char *
+mon_realloc(char *buf, int size, char *fname, int fline)
+{
+	char *ret;
+
+	HEAP_MONLOCK();
+	ret = _realloc(buf,size, fname, fline);
+	HEAP_MONUNLOCK();
+	return(ret);
+}
+#else
+char *
+mon_malloc(int size)
+{
+	char *ret;
+
+	HEAP_MONLOCK();
+	ret = _malloc(size);
+	HEAP_MONUNLOCK();
+	return(ret);
+}
+
+char *
+mon_realloc(char *buf, int size)
+{
+	char *ret;
+
+	HEAP_MONLOCK();
+	ret = _realloc(buf,size);
+	HEAP_MONUNLOCK();
+	return(ret);
+}
+#endif
+
+void
+mon_free(char *cp)
+{
+	HEAP_MONLOCK();
+	_free(cp);
+	HEAP_MONUNLOCK();
+}
+
+int
+mon_getline(char *buf,int max,int ledit)
+{
+	int	ret;
+
+	BLOCKING_MONLOCK();
+	ret = _getline(buf,max,ledit);
+	BLOCKING_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_decompress(char *src,int srcsize,char *dest)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _decompress(src,srcsize,dest);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_heapextend(char *base,int size)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _heapextend(base,size);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+void
+mon_bbc(char *filename, int lineno)
+{
+	_bbc(filename, lineno);
+}
+
+void
+mon_profiler(void *pdata)
+{
+	_profiler(pdata);
+}
+
+void
+mon_memtrace(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
+char *fmt;
+int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
+{
+	_memtrace(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
+}
+
+char *
+mon_version(void)
+{
+	char *ret;
+
+	GENERIC_MONLOCK();
+	ret = _version();
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+void
+mon_warmstart(unsigned long mask)
+{
+	GENERIC_MONLOCK();
+	_appwarmstart(mask);
+	GENERIC_MONUNLOCK();
+}
+
+int
+mon_pcicfgwrite(int interface,int bus,int dev,int func,int reg,
+	unsigned long val)
+{
+	int	retval;
+
+	GENERIC_MONLOCK();
+	retval = _pcicfgwrite(interface,bus,dev,func,reg,val);
+	GENERIC_MONUNLOCK();
+	return(retval);
+}
+
+unsigned long
+mon_pcicfgread(int interface,int bus,int dev, int func,int reg)
+{
+	unsigned long retval;
+
+	GENERIC_MONLOCK();
+	retval = _pcicfgread(interface,bus,dev,func,reg);
+	GENERIC_MONUNLOCK();
+	return(retval);
+}
+
+unsigned long
+mon_pcictrl(int interface, int cmd, unsigned long arg1, unsigned long arg2)
+{
+	unsigned long val;
+
+	GENERIC_MONLOCK();
+	val = _pcictrl(interface,cmd,arg1,arg2);
+	GENERIC_MONUNLOCK();
+	return(val);
+}
+
+unsigned long
+mon_i2cctrl(int interface, int cmd, unsigned long arg1, unsigned long arg2)
+{
+	unsigned long val;
+
+	GENERIC_MONLOCK();
+	val = _i2cctrl(interface,cmd,arg1,arg2);
+	GENERIC_MONUNLOCK();
+	return(val);
+}
+
+int
+mon_i2cwrite(int interface, int bigaddr, unsigned char *data, int len)
+{
+	int	val;
+
+	GENERIC_MONLOCK();
+	val = _i2cwrite(interface,bigaddr,data,len);
+	GENERIC_MONUNLOCK();
+	return(val);
+}
+
+int
+mon_i2cread(int interface, int bigaddr, unsigned char *data, int len)
+{
+	int	val;
+
+	GENERIC_MONLOCK();
+	val = _i2cread(interface,bigaddr,data,len);
+	GENERIC_MONUNLOCK();
+	return(val);
+}
+
+void
+mon_delay(long msec)
+{
+	GENERIC_MONLOCK();
+	_mondelay(msec);
+	GENERIC_MONUNLOCK();
+}
+
+int
+mon_timer(int cmd, void *arg)
+{
+	int ret;
+
+	GENERIC_MONLOCK();
+	ret = _montimer(cmd, arg);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_sendenetpkt(char *pkt,int size)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _sendenet(pkt,size);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_recvenetpkt(char *pkt,int size)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _recvenet(pkt,size);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+void
+mon_printpkt(char *buf,int size, int incoming)
+{
+	GENERIC_MONLOCK();
+	_printpkt(buf,size,incoming);
+	GENERIC_MONUNLOCK();
+}
+
+int
+mon_flashoverride(void *flashinfo,int get,int bank)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _flashoverride(flashinfo,get,bank);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_flashwrite(char *dest,char *src,int bytecnt)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _flashwrite(dest,src,bytecnt);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_flasherase(int snum)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _flasherase(snum);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_flashinfo(int snum, int *size, char **base)
+{
+	int	ret;
+
+	TFS_MONLOCK();
+	ret = _flashinfo(snum,size,base);
+	TFS_MONUNLOCK();
+	return(ret);
+}
+
+unsigned long
+mon_assignhandler(long hnum, unsigned long arg1, unsigned long arg2)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _assign_handler(hnum,arg1,arg2);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_watchdog(void)
+{
+	int	ret;
+
+	GENERIC_MONLOCK();
+	ret = _watchdog();
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+void
+mon_printmem(char *mem, int size, int ascii)
+{
+	GENERIC_MONLOCK();
+	_printmem(mem,size,ascii);
+	GENERIC_MONUNLOCK();
+}
+
+long
+mon_portcmd(int cmd, void *arg)
+{
+	long ret;
+
+	GENERIC_MONLOCK();
+	ret = _portcmd(cmd,arg);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
+
+int
+mon_timeofday(int cmd, void *arg)
+{
+	int ret;
+
+	GENERIC_MONLOCK();
+	ret = _timeofday(cmd,arg);
+	GENERIC_MONUNLOCK();
+	return(ret);
+}
diff --git a/micromonitor/diagnostics/monlib.h b/micromonitor/diagnostics/monlib.h
new file mode 100755
index 0000000..10e37f4
--- /dev/null
+++ b/micromonitor/diagnostics/monlib.h
@@ -0,0 +1,239 @@
+/* monlib.h:
+ *	This header file is used by both the monitor and the application that
+ *	may reside on top of the monitor.
+ *	General notice:
+ *	This code is part of a boot-monitor package developed as a generic base
+ *	platform for embedded system designs.  As such, it is likely to be
+ *	distributed to various projects beyond the control of the original
+ *	author.  Please notify the author of any enhancements made or bugs found
+ *	so that all may benefit from the changes.  In addition, notification back
+ *	to the author will allow the new user to pick up changes that may have
+ *	been made by other users after this version of the code was distributed.
+ *
+ *	Note1: the majority of this code was edited with 4-space tabs.
+ *	Note2: as more and more contributions are accepted, the term "author"
+ *		   is becoming a mis-representation of credit.
+ *
+ *	Original author:	Ed Sutter
+ *	Email:				esutter@lucent.com
+ *	Phone:				908-582-2351
+ */
+#ifndef _MONLIB_H_
+#define _MONLIB_H_
+
+#include "tfs.h"
+#include "cli.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+extern int monConnect(int (*monptr)(int,void *,void *,void *),
+		void (*lock)(void),void (*unlock)(void));
+extern void mon_getargv(int *argc,char ***argv);
+extern void mon_intsrestore(unsigned long oldval);
+extern void mon_appexit(int exit_value);
+extern void mon_free(char *buffer);
+extern void mon_profiler(void *pdata);
+extern void mon_bbc(char *filename, int linenum);
+extern void mon_warmstart(unsigned long mask);
+extern void mon_delay(long msec);
+extern void mon_printpkt(char *buf, int size, int incoming);
+extern void mon_printmem(char *mem, int size, int ascii);
+
+
+extern int mon_com(int cmd,void *arg1,void *arg2,void *arg3);
+extern int mon_timer(int cmd, void * arg);
+extern int mon_setenv(char *varname,char *value);
+extern int mon_putchar(char c);
+extern int mon_getchar(void);
+extern int mon_gotachar(void);
+extern int mon_getbytes(char *buf,int count,int block);
+extern int mon_restart(int restart_value);
+extern int mon_tfsinit(void);
+extern int mon_tfsunlink(char *filename);
+extern int mon_tfslink(char *source, char *target);
+extern int mon_tfsrun(char **arglist,int verbosity);
+extern int mon_tfsfstat(char *filename,struct tfshdr *tfp);
+extern int mon_tfseof(int file_descriptor);
+extern int mon_tfstruncate(int file_descriptor,long length);
+extern int mon_tfsread(int file_descriptor,char *buffer,int size);
+extern int mon_tfswrite(int file_descriptor,char *buffer,int size);
+extern int mon_tfsopen(char *filename,long mode,char *buffer);
+extern int mon_tfsclose(int file_descriptor,char *info);
+extern int mon_tfsseek(int file_descriptor,int offset,int whence);
+extern int mon_tfsgetline(int file_descriptor,char *buffer,int bufsize);
+extern int mon_tfsipmod(char *name,char *buffer,int offset,int size);
+extern int mon_addcommand(struct monCommand *command_list,char *);
+extern int mon_docommand(char *cmdline,int verbosity);
+extern int mon_getline(char *buffer,int max,int ledit);
+extern int mon_decompress(char *src,int srcsize,char *dest);
+extern int mon_heapextend(char *base,int size);
+extern int mon_pcicfgwrite(int interface,int bus,int dev,int func,int reg,
+		unsigned long val);
+extern int mon_tfsadd(char *filename, char *info, char *flags,
+		unsigned char *src, int size);
+extern int mon_i2cwrite(int interface, int bigaddr, unsigned char *data,
+		int len);
+extern int mon_i2cread(int interface, int bigaddr, unsigned char *data,
+		int len);
+extern int mon_sendenetpkt(char *pkt, int len);
+extern int mon_recvenetpkt(char *pkt, int len);
+extern int mon_flashoverride(void *flashinfo, int get, int bank);
+extern int mon_flasherase(int snum);
+extern int mon_flashwrite(char *dest,char *src, int bytecnt);
+extern int mon_flashinfo(int snum,int *size, char **base);
+extern int mon_watchdog(void);
+extern int mon_timeofday(int cmd, void *arg);
+
+extern char *mon_getsym(char *symname, char *buf, int bufsize);
+extern char *mon_getenv(char *varname);
+extern char *mon_getenvp(void);
+extern char *mon_version(void);
+#ifdef MALLOC_DEBUG
+extern char *mon_malloc(int size,char *file, int line);
+extern char *mon_realloc(char *buf,int size,char *file, int line);
+#else
+extern char *mon_malloc(int size);
+extern char *mon_realloc(char *buf,int size);
+#endif
+
+extern long mon_tfsctrl(int command,long arg1,long arg2);
+extern long mon_tfstell(int file_descriptor);
+extern long mon_portcmd(int cmd, void *arg);
+
+extern unsigned short mon_xcrc16(char *buffer,long length);
+
+extern unsigned long mon_intsoff(void);
+
+extern unsigned long mon_pcicfgread(int interface,int bus,int dev,
+		int func,int reg);
+
+extern unsigned long mon_pcictrl(int interface, int cmd,
+		unsigned long arg1, unsigned long arg2);
+
+extern unsigned long mon_i2cctrl(int interface, int cmd,
+		unsigned long arg1, unsigned long arg2);
+
+extern unsigned long mon_assignhandler(long hnum,
+		unsigned long arg1,unsigned long arg2);
+
+extern struct tfshdr *mon_tfsnext(struct tfshdr *tfp);
+extern struct tfshdr *mon_tfsstat(char *filename);
+
+#if SHOWVARARGS
+extern void mon_memtrace(char *fmt, ...);
+extern int mon_printf(char *fmt, ...);
+extern int mon_cprintf(char *fmt, ...);
+extern int mon_sprintf(char *,char *fmt, ...);
+#else
+extern void mon_memtrace();
+extern int mon_printf();
+extern int mon_cprintf();
+extern int mon_sprintf();
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* defines used by monConnect():
+ */
+#define GETMONFUNC_PUTCHAR				1
+#define GETMONFUNC_GETCHAR				2
+#define GETMONFUNC_GOTACHAR				3
+#define GETMONFUNC_GETBYTES				4
+#define GETMONFUNC_PRINTF				5
+#define GETMONFUNC_CPRINTF				6
+#define GETMONFUNC_SPRINTF				7
+#define GETMONFUNC_RESTART				8
+#define GETMONFUNC_GETENV				9
+#define GETMONFUNC_SETENV				10
+#define GETMONFUNC_TFSINIT				11
+#define GETMONFUNC_TFSADD				12
+#define GETMONFUNC_TFSUNLINK			13
+#define GETMONFUNC_TFSRUN				14
+#define GETMONFUNC_TFSNEXT				15
+#define GETMONFUNC_TFSSTAT				16
+#define GETMONFUNC_TFSREAD				17
+#define GETMONFUNC_TFSWRITE				18
+#define GETMONFUNC_TFSOPEN				19
+#define GETMONFUNC_TFSCLOSE				20
+#define GETMONFUNC_TFSSEEK				21
+#define GETMONFUNC_TFSGETLINE			22
+#define GETMONFUNC_TFSIPMOD				23
+#define GETMONFUNC_TFSCTRL				24
+#define GETMONFUNC_ADDCOMMAND			25
+#define GETMONFUNC_DOCOMMAND			26
+#define GETMONFUNC_GETARGV				27
+#define GETMONFUNC_CRC16				28
+#define GETMONFUNC_CRC32				29
+#define GETMONFUNC_PIOGET				30	/* NA (removed as of 1.0) */
+#define GETMONFUNC_PIOSET				31	/* NA (removed as of 1.0) */
+#define GETMONFUNC_PIOCLR				32	/* NA (removed as of 1.0) */
+#define GETMONFUNC_INTSOFF				33
+#define GETMONFUNC_INTSRESTORE			34
+#define GETMONFUNC_APPEXIT				35
+#define GETMONFUNC_MALLOC				36
+#define GETMONFUNC_FREE					37
+#define GETMONFUNC_GETLINE				38
+#define GETMONFUNC_TFSFSTAT				39
+#define GETMONFUNC_TFSEOF				40
+#define GETMONFUNC_DECOMPRESS			41
+#define GETMONFUNC_TFSTRUNCATE			42
+#define GETMONFUNC_HEAPXTEND			43
+#define GETMONFUNC_PROFILER				44
+#define GETMONFUNC_TFSLINK				45
+#define GETMONFUNC_BBC					46
+#define GETMONFUNC_MEMTRACE				47
+#define GETMONFUNC_TFSTELL				48
+#define GETMONFUNC_VERSION				49
+#define GETMONFUNC_WARMSTART			50
+#define GETMONFUNC_PCICFGREAD			51
+#define GETMONFUNC_PCICFGWRITE			52
+#define GETMONFUNC_PCICONTROL			53
+#define GETMONFUNC_I2CREAD				54
+#define GETMONFUNC_I2CWRITE				55
+#define GETMONFUNC_I2CCONTROL			56
+#define GETMONFUNC_MONDELAY				57
+#define GETMONFUNC_GETENVP				58
+#define GETMONFUNC_REALLOC				59
+#define GETMONFUNC_SENDENETPKT			60
+#define GETMONFUNC_RECVENETPKT			61
+#define GETMONFUNC_GETSYM				62
+#define GETMONFUNC_PRINTPKT				63
+#define GETMONFUNC_FLASHWRITE			64
+#define GETMONFUNC_FLASHERASE			65
+#define GETMONFUNC_FLASHINFO			66
+#define GETMONFUNC_ASSIGNHDLR			67
+#define GETMONFUNC_WATCHDOG				68
+#define GETMONFUNC_PRINTMEM				69
+#define GETMONFUNC_PORTCMD				70
+#define GETMONFUNC_TIMEOFDAY			71
+#define GETMONFUNC_TIMER				72
+#define GETMONFUNC_FLASHOVRRD			73
+
+#define CACHEFTYPE_DFLUSH				200
+#define CACHEFTYPE_IINVALIDATE			201
+
+#define	CHARFUNC_PUTCHAR				300
+#define	CHARFUNC_GETCHAR				301
+#define	CHARFUNC_GOTACHAR				302
+#define	CHARFUNC_RAWMODEON				303
+#define	CHARFUNC_RAWMODEOFF				304
+
+#define ASSIGNFUNC_GETUSERLEVEL			400
+
+
+/* Defines used by mon_warmstart():
+ */
+#define WARMSTART_IOINIT			0x00000001
+#define WARMSTART_BSSINIT			0x00000002
+#define WARMSTART_RUNMONRC			0x00000004
+#define WARMSTART_MONHEADER			0x00000008
+#define WARMSTART_TFSAUTOBOOT		0x00000010
+#define WARMSTART_BOARDINFO			0x00000020
+#define WARMSTART_ALL				0xffffffff
+#endif
diff --git a/micromonitor/diagnostics/tfs.h b/micromonitor/diagnostics/tfs.h
new file mode 100755
index 0000000..f83d518
--- /dev/null
+++ b/micromonitor/diagnostics/tfs.h
@@ -0,0 +1,187 @@
+/* tfs.h:
+ *	Header file for TFS transactions, used by both application and monitor.
+ * 
+ *	General notice:
+ *	This code is part of a boot-monitor package developed as a generic base
+ *	platform for embedded system designs.  As such, it is likely to be
+ *	distributed to various projects beyond the control of the original
+ *	author.  Please notify the author of any enhancements made or bugs found
+ *	so that all may benefit from the changes.  In addition, notification back
+ *	to the author will allow the new user to pick up changes that may have
+ *	been made by other users after this version of the code was distributed.
+ *
+ *	Note1: the majority of this code was edited with 4-space tabs.
+ *	Note2: as more and more contributions are accepted, the term "author"
+ *		   is becoming a mis-representation of credit.
+ *
+ *	Original author:	Ed Sutter
+ *	Email:				esutter@lucent.com
+ *	Phone:				908-582-2351
+ */
+#ifndef _tfs_h
+#define _tfs_h
+
+#define TFSINFOSIZE		23		/* Max size of info string (mod4-1). */
+
+#ifndef TFSNAMESIZE				/* This specifies the maximum size of a file */
+#define TFSNAMESIZE		23		/* name that can be used in TFS. */
+#endif							/* This MUST be some value mod4 - 1. */
+
+#ifndef TFS_CHANGELOG_FILE		/* Information used for change-log */
+#define TFS_CHANGELOG_SIZE	0	/* facility within tfs. */
+#define TFS_CHANGELOG_FILE	".tfschlog"
+#endif
+
+#ifndef SYMFILE					/* This specifies the default filename */
+#define SYMFILE		"symtbl"	/* used by the monitor for the symbol */
+#endif							/* table. */
+
+#define MINUSRLEVEL		0		/* Minimum user level supported. */
+#define MAXUSRLEVEL		3		/* Maximum user level supported. */
+
+#ifndef TFS_RESERVED
+#define TFS_RESERVED	4		/* Number of "reserved" entries (ulong) */
+#endif							/* in the TFS header. */
+
+
+/* Flags: */
+#define TFS_EXEC	0x00000001	/* 'e': Executable script. */
+#define TFS_BRUN	0x00000002	/* 'b': To be executed at boot. */
+#define TFS_QRYBRUN	0x00000004	/* 'B': To be executed at boot if */
+								/*      query passes. */
+#define TFS_SYMLINK	0x00000008	/* 'l': Symbolic link file. */
+#define TFS_EBIN	0x00000010	/* 'E': Executable binary (coff/elf/a.out). */
+#define TFS_CPRS	0x00000040	/* 'c': File is compressed. */
+#define TFS_IPMOD	0x00000080	/* 'i': File is in-place modifiable. */
+#define TFS_UNREAD	0x00000100	/* 'u':	File is not even readable if the */
+								/*		user-level requirement is not met; */
+								/*		else, it is read-only. */
+#define TFS_ULVLMSK	0x00000600	/*	User level mask defines 4 access levels: */
+#define TFS_ULVL0	0x00000000	/* '0'	level 0 */
+#define TFS_ULVL1	0x00000200	/* '1'	level 1 */
+#define TFS_ULVL2	0x00000400	/* '2'	level 2 */
+#define TFS_ULVL3	0x00000600	/* '3'	level 3 */
+#define TFS_NSTALE	0x00000800	/* File is NOT stale, invisible to user.
+								 * When this bit is clear, the file is 
+								 * considered stale (see notes in tfsadd()). 
+								 * See notes in tfsclose() for this.
+								 */
+#define TFS_ACTIVE	0x00008000	/* Used to indicate that file is not deleted. */
+
+#define TFS_ULVLMAX	TFS_ULVL3
+#define TFS_USRLVL(f)	((f->flags & TFS_ULVLMSK) >> 9)
+
+/* Open modes */
+#define	TFS_RDONLY		0x00010000	/* File is opened for reading. */
+#define	TFS_CREATE		0x00020000	/* File is to be created. Error if file */
+									/* with the same name already exists. */
+#define	TFS_APPEND		0x00040000	/* Append to existing file.  If OR'ed */
+									/* with TFS_CREATE, then create if */
+									/* necessary. */
+#define	TFS_ALLFFS		0x00080000	/* File is created with all FFs. */
+#define	TFS_CREATERM	0x00100000	/* File is to be created. If file with */
+									/* same name already exists, then allow */
+									/* tfsadd() to remove it if necessary. */
+
+/* The function tfsrunrc() will search through the current file set and */
+/* if the file defined by TFS_RCFILE exists, it will be executed. */
+/* If this file exists, it will NOT be run by tfsrunboot(). */
+#define TFS_RCFILE		"monrc"
+
+/* Requests that can be made to tfsctrl(): */
+#define	TFS_ERRMSG		1
+#define	TFS_MEMUSE		2
+#define	TFS_MEMDEAD		3
+#define	TFS_DEFRAG		4
+#define	TFS_TELL		5
+#define	TFS_UNOPEN		7
+#define	TFS_FATOB		8
+#define	TFS_FBTOA		9
+#define	TFS_MEMAVAIL	10
+#define	TFS_TIMEFUNCS	11
+#define	TFS_DOCOMMAND	12
+#define	TFS_INITDEV		13
+#define	TFS_CHECKDEV	14
+#define	TFS_DEFRAGDEV	15
+#define	TFS_DEFRAGOFF	16
+#define	TFS_DEFRAGON	17
+#define	TFS_HEADROOM	18
+#define	TFS_FCOUNT		19
+
+/* struct tfshdr:
+ *	It is in FLASH as part of the file system to record the attributes of
+ *	the file at the time of creation.
+ */
+struct tfshdr {
+	unsigned short	hdrsize;		/* Size of this header.					*/
+	unsigned short	hdrvrsn;		/* Header version #.					*/
+	long	filsize;				/* Size of the file.					*/
+	long	flags;					/* Flags describing the file.			*/
+	unsigned long filcrc; 			/* 32 bit CRC of file.					*/
+	unsigned long hdrcrc;			/* 32 bit CRC of the header.			*/
+	unsigned long	modtime;		/* Time when file was last modified.	*/
+	struct	tfshdr	*next;			/* Pointer to next file in list.		*/
+	char	name[TFSNAMESIZE+1];	/* Name of file.						*/
+	char	info[TFSINFOSIZE+1];	/* Miscellaneous info field.			*/
+#if TFS_RESERVED
+	unsigned long	rsvd[TFS_RESERVED];
+#endif
+};
+
+#define TFSHDRSIZ	sizeof(struct tfshdr)
+
+/* TFS error returns. */
+#define TFS_OKAY				0
+#define TFSERR_NOFILE			-1
+#define TFSERR_NOSLOT			-2
+#define TFSERR_EOF				-3
+#define TFSERR_BADARG			-4
+#define TFSERR_NOTEXEC			-5
+#define TFSERR_BADCRC			-6
+#define TFSERR_FILEEXISTS		-7
+#define TFSERR_FLASHFAILURE		-8
+#define TFSERR_WRITEMAX			-9
+#define TFSERR_RDONLY			-10
+#define TFSERR_BADFD			-11
+#define TFSERR_BADHDR			-12
+#define TFSERR_CORRUPT			-13
+#define TFSERR_MEMFAIL			-14
+#define TFSERR_NOTIPMOD			-16
+#define TFSERR_MUTEXFAILURE		-17
+#define TFSERR_FLASHFULL		-18
+#define TFSERR_USERDENIED		-19
+#define TFSERR_NAMETOOBIG		-20
+#define TFSERR_FILEINUSE		-21
+#define TFSERR_NOTCPRS			-22
+#define TFSERR_NOTAVAILABLE		-23
+#define TFSERR_BADFLAG			-24
+#define TFSERR_CLEANOFF			-25
+#define TFSERR_FLAKEYSOURCE		-26
+#define TFSERR_BADEXTENSION		-27
+#define TFSERR_MIN				-100
+
+/* TFS seek options. */
+#define TFS_BEGIN		1
+#define TFS_CURRENT		2
+#define TFS_END			3
+
+/* Macros: */
+#define TFS_DELETED(fp)		(!((fp)->flags & TFS_ACTIVE))
+#define TFS_FILEEXISTS(fp)	((fp)->flags & TFS_ACTIVE)
+#define TFS_ISCPRS(fp)		((fp)->flags & TFS_CPRS)
+#define TFS_ISEXEC(fp)		((fp)->flags & TFS_EXEC)
+#define TFS_ISBOOT(fp)		((fp)->flags & TFS_BRUN)
+#define TFS_ISLINK(fp)		((fp)->flags & TFS_SYMLINK)
+#define TFS_STALE(fp) 		(!((fp)->flags & TFS_NSTALE))
+#define TFS_FLAGS(fp)		((fp)->flags)
+#define TFS_NAME(fp)		((fp)->name)
+#define TFS_SIZE(fp)		((fp)->filsize)
+#define TFS_TIME(fp)		((fp)->modtime)
+#define TFS_INFO(fp)		((fp)->info)
+#define TFS_NEXT(fp)		((fp)->next)
+#define TFS_CRC(fp)			((fp)->filcrc)
+#define TFS_ENTRY(fp)		((fp)->entry)
+#define TFS_BASE(fp)		((char *)(fp)+(fp)->hdrsize)
+
+typedef struct tfshdr TFILE;
+#endif
diff --git a/micromonitor/umon/Makefile b/micromonitor/umon/Makefile
new file mode 100644
index 0000000..b9288d6
--- /dev/null
+++ b/micromonitor/umon/Makefile
@@ -0,0 +1,30 @@
+#
+#  $Id$
+#
+
+#
+#  RTEMS_MAKEFILE_PATH is typically set in an environment variable
+#
+
+VPATH=.
+PGM=${ARCH}/umon.exe
+
+# optional managers required
+MANAGERS=all
+
+# C source names
+CSRCS = test.c ## monlib.c tfsDriver.c
+COBJS = $(CSRCS:%.c=${ARCH}/%.o)
+
+include $(RTEMS_MAKEFILE_PATH)/Makefile.inc
+include $(RTEMS_CUSTOM)
+include $(PROJECT_ROOT)/make/leaf.cfg
+
+## DEFINES += -I.
+
+OBJS= $(COBJS) $(CXXOBJS) $(ASOBJS)
+
+all:    ${ARCH} $(PGM)
+
+$(PGM): $(OBJS)
+	$(make-exe)
diff --git a/micromonitor/umon/README b/micromonitor/umon/README
new file mode 100644
index 0000000..aea2d84
--- /dev/null
+++ b/micromonitor/umon/README
@@ -0,0 +1,17 @@
+#
+#  $Id$
+#
+
+This is a demonstration of using Micromonitor capabilities from an
+RTEMS application.  
+
+The following files are from umon-1.17:
+
+monlib.c
+monlib.h
+tfs.h
+cli.h
+
+After printing the arguments, it will attempt to cat the contents
+of mon_getenv("TFSFS_FILENAME") followed by "csbboot" and "boot"
+from the TFS filesystem.
diff --git a/micromonitor/umon/test.c b/micromonitor/umon/test.c
new file mode 100644
index 0000000..4ca13d8
--- /dev/null
+++ b/micromonitor/umon/test.c
@@ -0,0 +1,161 @@
+/*
+ *  Simple test program -- simplified version of sample test hello.
+ *
+ *  $Id$
+ */
+
+#include <bsp.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <assert.h>
+
+#include <rtems/umon.h>
+
+/* this code is lifted from the umon demo application */
+int umon_demo(int argc, char **argv)
+{
+  int    i, tfd;
+  char  line[80], *ab, *filename;
+
+  /* If argument count is greater than one, then dump out the
+   * set of CLI arguments...
+   */
+  if (argc > 1) {
+    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);
+
+    mon_printf("Dumping memory at 0x%lx...\n",addr);
+    mon_printmem(addr,128,1);
+  }
+
+  filename = "csbboot";
+
+  /* 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 catFile(const char *name)
+{
+  int   i;
+  FILE *fp;
+  char  line[128];
+
+  if (!name)
+    return;
+
+  printf( "====> Start of file %s\n", name );
+  /* Attempt to open and print a file through the
+   * the TFS based FS...
+   */
+  fp = fopen(name,"r");
+  if (!fp) {
+    printf("fopen() failed\n");
+    perror("fopen()");
+    return;
+  } 
+
+  for (i=0 ; fgets(line,sizeof(line),fp) ; i++)
+    printf("LINE %d: %s",i, line);
+
+  printf( "====> End of file %s\n", name );
+  fclose(fp);
+}
+
+void tfsFsDemo(void)
+{
+  char *name;
+
+  /* Initialize the TFS based file system...
+   */
+  puts( "Mounting RTEMS TFS filesystem" );
+  if (rtems_initialize_tfs_filesystem( "/JOEL/" ) != 0) {
+    puts("tfs init failed");
+    return;
+  }
+
+  /* Use uMon's environment to store the name of the file.
+   * If the shell variable TFSFS_FILENAME is present, then
+   * assume it contains the name of the file to open and
+   * print to the console...
+   * For TFS to run as a file system under RTEMS, all filenames
+   * that are associated with tfs are preceded with "/TFS/".
+   */
+  name = mon_getenv("TFSFS_FILENAME");
+  if (!name)
+    puts("Shell variable TFSFS_FILENAME not available");
+  else
+    catFile( name );
+  catFile( "/JOEL/csbboot" );
+  catFile( "/JOEL/boot" );
+}
+
+
+rtems_task Init(
+  rtems_task_argument ignored
+)
+{
+  puts( "\n\n*** MicroMonitor Demonstration ***" );
+
+  puts( "calling monConnect ..." );
+  rtems_umon_connect();
+
+  umon_demo(0, NULL);
+  tfsFsDemo();
+
+  puts( "*** MicroMonitor Demonstration ***" );
+  exit( 0 );
+}
+
+/* configuration information */
+
+/* NOTICE: the clock driver is explicitly disabled */
+#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
+#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
+
+#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
+#define CONFIGURE_MAXIMUM_TASKS 1
+#define CONFIGURE_MAXIMUM_SEMAPHORES 5
+#define CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
+#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 4
+#define CONFIGURE_MICROSECONDS_PER_TICK 5000
+#define CONFIGURE_INIT_TASK_STACK_SIZE  \
+  (CONFIGURE_MINIMUM_TASK_STACK_SIZE * 10)
+
+#define CONFIGURE_INIT
+
+#include <rtems/confdefs.h>
+
+/* end of file */