From ba6f12b7e42e9d85102e83b27d1e7ea65107f0e4 Mon Sep 17 00:00:00 2001 From: Joel Sherrill Date: Fri, 12 Jun 2009 17:20:42 +0000 Subject: 2009-06-12 Joel Sherrill * umon/README, umon/cli.h, umon/monlib.c, umon/monlib.h, umon/tfs.h, umon/tfsDriver.c, umon/umonrtemsglue.c: New files. --- c/src/lib/libbsp/shared/ChangeLog | 5 + c/src/lib/libbsp/shared/umon/README | 47 ++ c/src/lib/libbsp/shared/umon/cli.h | 123 +++ c/src/lib/libbsp/shared/umon/monlib.c | 1128 ++++++++++++++++++++++++++ c/src/lib/libbsp/shared/umon/monlib.h | 262 ++++++ c/src/lib/libbsp/shared/umon/tfs.h | 187 +++++ c/src/lib/libbsp/shared/umon/tfsDriver.c | 726 +++++++++++++++++ c/src/lib/libbsp/shared/umon/umonrtemsglue.c | 26 + 8 files changed, 2504 insertions(+) create mode 100644 c/src/lib/libbsp/shared/umon/README create mode 100644 c/src/lib/libbsp/shared/umon/cli.h create mode 100644 c/src/lib/libbsp/shared/umon/monlib.c create mode 100644 c/src/lib/libbsp/shared/umon/monlib.h create mode 100644 c/src/lib/libbsp/shared/umon/tfs.h create mode 100644 c/src/lib/libbsp/shared/umon/tfsDriver.c create mode 100644 c/src/lib/libbsp/shared/umon/umonrtemsglue.c (limited to 'c/src/lib/libbsp/shared') diff --git a/c/src/lib/libbsp/shared/ChangeLog b/c/src/lib/libbsp/shared/ChangeLog index c96339c3e5..c3bfd5602b 100644 --- a/c/src/lib/libbsp/shared/ChangeLog +++ b/c/src/lib/libbsp/shared/ChangeLog @@ -1,3 +1,8 @@ +2009-06-12 Joel Sherrill + + * umon/README, umon/cli.h, umon/monlib.c, umon/monlib.h, umon/tfs.h, + umon/tfsDriver.c, umon/umonrtemsglue.c: New files. + 2009-05-27 Sebastian Huber * tod.h, tod.c: Update for new RTC driver interface. diff --git a/c/src/lib/libbsp/shared/umon/README b/c/src/lib/libbsp/shared/umon/README new file mode 100644 index 0000000000..49c7f0d00d --- /dev/null +++ b/c/src/lib/libbsp/shared/umon/README @@ -0,0 +1,47 @@ +# +# $Id$ +# + +This directory contains support for utilitizing MicroMonitor +(http://www.umonfw.com/) capabilities from within an RTEMS +application. This directory contiains: + ++ "MonLib" functionality as documented in the MicroMonitor + User's Manual. ++ TFS filesystem which makes the MicroMonitor TFS filesystem + available under RTEMS as a regular filesystem. + +Usage +===== + +For any of this functionality to work, the application is +responsible for connecting the library to the monitor. +This is done by calling rtems_umon_connect() early in the +application. This routine assumes that the BSP has provided +the routine rtems_bsp_get_umon_monptr() which returns the +value referred to as MONCOMPTR by MicroMonitor. + +To use the TFS filesystem, it is necessary to mount it +by calling the rtems_initialize_tfs_filesystem() routine +and providing it the name of the mount point directory. + +CONFIGURATION +============= +The TFS filesystem uses a single Classic API Semaphore. + +The monlib functionality will eventually also use a single +Classic API Semaphore. + +STATUS +====== + ++ Limited testing -- especially of TFS RTEMS filesystem. ++ monlib is NOT currently protected by a mutex. + +SOURCE ORIGIN +============= +Some of the files in this directory are included in the +MicroMonitor distribution and may need to be updated +in the future. + +12 June 2009: Source is from umon 1.17 diff --git a/c/src/lib/libbsp/shared/umon/cli.h b/c/src/lib/libbsp/shared/umon/cli.h new file mode 100644 index 0000000000..6384816b1b --- /dev/null +++ b/c/src/lib/libbsp/shared/umon/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/c/src/lib/libbsp/shared/umon/monlib.c b/c/src/lib/libbsp/shared/umon/monlib.c new file mode 100644 index 0000000000..f43390f0a2 --- /dev/null +++ b/c/src/lib/libbsp/shared/umon/monlib.c @@ -0,0 +1,1128 @@ +/* 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 + +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)( + char *, int,int,int,int,int,int,int,int,int,int,int,int); +static int (*_cprintf)( + char *, int,int,int,int,int,int,int,int,int,int,int,int); +static int (*_sprintf)( + char *, char *, int,int,int,int,int,int,int,int,int,int,int,int); +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)( + char *, int,int,int,int,int,int,int,int,int,int,int,int); +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(void) +{ + if (_monlock) { + switch(ignorelock) { + case 1: + break; + case 2: + ignorelock--; + break; + default: + _monlock(); + break; + } + } +} + +static void +monUnlock(void) +{ + 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( + char *fmt, + int a1, int a2, int a3, int a4, int a5, int a6, + int a7, int a8, int a9, int a10, int a11, int 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( + char *fmt, + int a1, int a2, int a3, int a4, int a5, int a6, + int a7, int a8, int a9, int a10, int a11, int 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( + char *buf, + char *fmt, + int a1, int a2, int a3, int a4, int a5, int a6, + int a7, int a8, int a9, int a10, int a11, int 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( + char *fmt, + int a1, int a2, int a3, int a4, int a5, int a6, + int a7, int a8, int a9, int a10, int a11, int 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/c/src/lib/libbsp/shared/umon/monlib.h b/c/src/lib/libbsp/shared/umon/monlib.h new file mode 100644 index 0000000000..6d52968f18 --- /dev/null +++ b/c/src/lib/libbsp/shared/umon/monlib.h @@ -0,0 +1,262 @@ +/* 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 +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The following additions are RTEMS specific. + */ +#if defined(__rtems__) + /* + * RTEMS uMonitor wrapper for monConnect(). This will deal with the + * getting MONCOMPTR as well as providing the locking routines. + */ + void rtems_umon_connect(void); + + /* + * BSP specific routine to help when calling monConnect(). This + * returns the value known to uMon as MONCOMPTR. + */ + void *rtems_bsp_get_umon_monptr(void); + + /* + * Initialize the TFS-RTEMS file system + */ + int rtems_initialize_tfs_filesystem( + const char *path + ); +#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/c/src/lib/libbsp/shared/umon/tfs.h b/c/src/lib/libbsp/shared/umon/tfs.h new file mode 100644 index 0000000000..f83d518237 --- /dev/null +++ b/c/src/lib/libbsp/shared/umon/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/c/src/lib/libbsp/shared/umon/tfsDriver.c b/c/src/lib/libbsp/shared/umon/tfsDriver.c new file mode 100644 index 0000000000..7b64483f01 --- /dev/null +++ b/c/src/lib/libbsp/shared/umon/tfsDriver.c @@ -0,0 +1,726 @@ +/* + * MicroMonitor TFS Hookup to RTEMS FS + * + * Initial release: Oct 1, 2004 by Ed Sutter + * + * This code was derived from the tftpDriver.c code written by + * W. Eric Norum, which was apparently derived from the IMFS driver. + * + * This code was updated and merged with RTEMS CVS by Joel Sherrill, 2009. + * + * $Id$ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#ifdef RTEMS_TFS_DRIVER_DEBUG +#define RTEMS_TFS_DEBUG 1 +#else +#define RTEMS_TFS_DEBUG 0 +#endif + +#define MAXFILESIZE 0x4000 +#define MAXTFDS 15 + +/* Define these for thread safety... + */ +#ifndef newlib_tfdlock +#define newlib_tfdlock() +#endif + +#ifndef newlib_tfdunlock +#define newlib_tfdunlock() +#endif + +/* TFS file descriptor info: + */ +struct tfdinfo { + int inuse; + int tfd; + char *buf; + char name[TFSNAMESIZE+1]; + char info[TFSNAMESIZE+1]; +} tfdtable[MAXTFDS]; + +/* + * Pathname prefix + */ +char TFS_PATHNAME_PREFIX[128]; + +/* + * Root node_access value + * By using the address of a local static variable + * we ensure a unique value for this identifier. + */ +#define ROOT_NODE_ACCESS (&tfs_mutex) + +/* Number of streams open at the same time + */ +static rtems_id tfs_mutex; + +extern rtems_filesystem_operations_table rtems_tfs_ops; +extern rtems_filesystem_file_handlers_r rtems_tfs_handlers; + +/* Direct copy from the IMFS. Look at this. + */ + +rtems_filesystem_limits_and_options_t rtems_tfs_limits_and_options = { + 5, /* link_max */ + 6, /* max_canon */ + 7, /* max_input */ + 255, /* name_max */ + 255, /* path_max */ + 2, /* pipe_buf */ + 1, /* posix_async_io */ + 2, /* posix_chown_restrictions */ + 3, /* posix_no_trunc */ + 4, /* posix_prio_io */ + 5, /* posix_sync_io */ + 6 /* posix_vdisable */ +}; + +static int rtems_tfs_mount_me( + rtems_filesystem_mount_table_entry_t *temp_mt_entry +) +{ + rtems_status_code sc; + + temp_mt_entry->mt_fs_root.handlers = &rtems_tfs_handlers; + temp_mt_entry->mt_fs_root.ops = &rtems_tfs_ops; + + /* We have no TFS specific data to maintain. This filesystem + * may only be mounted once. And we maintain no real filesystem + * nodes, so there is no real root. + */ + + temp_mt_entry->fs_info = NULL; + temp_mt_entry->mt_fs_root.node_access = ROOT_NODE_ACCESS; + + /* These need to be looked at for full POSIX semantics. + */ + + temp_mt_entry->pathconf_limits_and_options = rtems_tfs_limits_and_options; + + + /* Now allocate a semaphore for mutual exclusion. + * NOTE: This could be in an fsinfo for this filesystem type. + */ + + sc = rtems_semaphore_create ( + rtems_build_name('U', 'M', 'O', 'N'), + 1, + RTEMS_FIFO | + RTEMS_BINARY_SEMAPHORE | + RTEMS_NO_INHERIT_PRIORITY | + RTEMS_NO_PRIORITY_CEILING | + RTEMS_LOCAL, + 0, + &tfs_mutex); + + if (sc != RTEMS_SUCCESSFUL) + rtems_set_errno_and_return_minus_one( ENOMEM ); + + return 0; +} + +/* Initialize the TFS-RTEMS file system + */ +int rtems_initialize_tfs_filesystem( + const char *path +) +{ + int status; + rtems_filesystem_mount_table_entry_t *entry; + + if (!path) { + printk( "TFS: No mount point specified\n" ); + return -1; + } + + strncpy( TFS_PATHNAME_PREFIX, path, sizeof(TFS_PATHNAME_PREFIX) ); + + status = mkdir( TFS_PATHNAME_PREFIX, S_IRWXU | S_IRWXG | S_IRWXO ); + if ( status == -1 ) { + printk( "TFS: Unable to mkdir %s\n", TFS_PATHNAME_PREFIX ); + return status; + } + + status = mount( &entry, &rtems_tfs_ops, RTEMS_FILESYSTEM_READ_WRITE, + NULL, TFS_PATHNAME_PREFIX); + + if (status) { + printk( "TFS: Unable to mount on %s\n", TFS_PATHNAME_PREFIX ); + perror("TFS mount failed"); + } + + return(status); +} + +static int rtems_tfs_evaluate_for_make( + const char *path, + rtems_filesystem_location_info_t *pathloc, + const char **name +) +{ + pathloc->node_access = NULL; + rtems_set_errno_and_return_minus_one( EIO ); +} + +/* + * Convert a path to canonical form + */ +static void fixPath(char *path) +{ + char *inp, *outp, *base; + + outp = inp = path; + base = NULL; + for (;;) { + if (inp[0] == '.') { + if (inp[1] == '\0') + break; + if (inp[1] == '/') { + inp += 2; + continue; + } + if (inp[1] == '.') { + if (inp[2] == '\0') { + if ((base != NULL) && (outp > base)) { + outp--; + while ((outp > base) && (outp[-1] != '/')) + outp--; + } + break; + } + if (inp[2] == '/') { + inp += 3; + if (base == NULL) + continue; + if (outp > base) { + outp--; + while ((outp > base) && (outp[-1] != '/')) + outp--; + } + continue; + } + } + } + if (base == NULL) + base = inp; + while (inp[0] != '/') { + if ((*outp++ = *inp++) == '\0') + return; + } + *outp++ = '/'; + while (inp[0] == '/') + inp++; + } + *outp = '\0'; +} + +static int rtems_tfs_eval_path( + const char *pathname, + int flags, + rtems_filesystem_location_info_t *pathloc +) +{ + pathloc->handlers = &rtems_tfs_handlers; + + /* + * Hack to provide the illusion of directories inside the TFS file system. + * Paths ending in a / are assumed to be directories. + */ + if (pathname[strlen(pathname)-1] == '/') { + int isRelative = (pathloc->node_access != ROOT_NODE_ACCESS); + char *cp; + + /* + * Reject attempts to open() directories + */ + if (flags & RTEMS_LIBIO_PERMS_RDWR) + rtems_set_errno_and_return_minus_one( EISDIR ); + if (isRelative) { + cp = malloc (strlen(pathloc->node_access)+strlen(pathname)+1); + if (cp == NULL) + rtems_set_errno_and_return_minus_one( ENOMEM ); + strcpy (cp, pathloc->node_access); + strcat (cp, pathname); + } else { + cp = strdup (pathname); + if (cp == NULL) + rtems_set_errno_and_return_minus_one( ENOMEM ); + } + fixPath (cp); + pathloc->node_access = cp; + return 0; + } + if (pathloc->node_access != ROOT_NODE_ACCESS) + pathloc->node_access = 0; + + /* + * Reject it if it's not read-only or write-only. + */ + flags &= RTEMS_LIBIO_PERMS_READ | RTEMS_LIBIO_PERMS_WRITE; + if ((flags != RTEMS_LIBIO_PERMS_READ) && (flags != RTEMS_LIBIO_PERMS_WRITE) ) + rtems_set_errno_and_return_minus_one( EINVAL ); + return 0; +} + +/* + * The routine which does most of the work for the IMFS open handler + * The full_path_name here is all text AFTER the TFS_PATHNAME_PREFIX + * string, so if the filename is "/TFS/abc", the full_path_name string + * is "abc"... + * + * Attempts to remap the incoming flags to TFS equivalent. + * Its not a perfect mapping, but gets pretty close. + * A comma-delimited path is supported to allow the user + * to specify TFS-stuff (flag string, info string, and a buffer). + * For example: + * abc,e,script,0x400000 + * This is a file called "abc" that will have the TFS 'e' flag + * and the TFS info field of "script". The storage buffer is + * supplied by the user at 0x400000. + */ +static int rtems_tfs_open_worker( + rtems_libio_t *iop, + char *path, + uint32_t flags, + uint32_t mode +) +{ + static int beenhere = 0; + long flagmode; + int tfdidx, tfd; + struct tfdinfo *tip; + char *buf, *fstr, *istr, *bstr, pathcopy[TFSNAMESIZE*3+1]; + + if (RTEMS_TFS_DEBUG) + printk("_open_r(%s,0x%" PRIx32 ",0x%" PRIx32 ")\n",path,flags,mode); + + if (!beenhere) { + newlib_tfdlock(); + for(tfdidx=0;tfdidx TFSNAMESIZE*3) { + return(ENAMETOOLONG); + } + strcpy(pathcopy,path); + + /* The incoming string may have commas that are used to delimit the + * name from the TFS flag string, TFS info string and buffer. + * Check for the commas and test for maximum string length... + */ + fstr = strchr(pathcopy,','); + if (fstr) { + *fstr++ = 0; + istr = strchr(fstr,','); + if (istr) { + *istr++ = 0; + bstr = strchr(istr,','); + if (bstr) + *bstr++ = 0; + } + } + if (strlen(pathcopy) > TFSNAMESIZE) { + return(ENAMETOOLONG); + } + if (istr) { + if (strlen(istr) > TFSNAMESIZE) { + return(ENAMETOOLONG); + } + } + + /* If O_EXCL and O_CREAT are set, then fail if the file exists... + */ + if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) { + if (mon_tfsstat((char *)pathcopy)) { + return(EEXIST); + } + } + + /* Only a few flag combinations are supported... + * O_RDONLY Simple read-only + * O_WRONLY | O_APPEND Each write starts at end of file + * O_WRONLY | O_TRUNC If file exists, truncate it + * O_WRONLY | O_CREAT Create if it doesn't exist + * O_WRONLY | O_CREAT | O_EXCL Fail if file exists + */ + switch(flags & O_ACCMODE) { + case O_RDONLY: + flagmode = TFS_RDONLY; + break; + case O_WRONLY|O_APPEND: + flagmode = TFS_APPEND; + break; + case O_WRONLY|O_TRUNC: + case O_WRONLY|O_CREAT|O_TRUNC: + mon_tfsunlink((char *)pathcopy); + flagmode = TFS_CREATE|TFS_APPEND; + break; + case O_WRONLY|O_CREAT: + case O_WRONLY|O_CREAT|O_APPEND: + flagmode = TFS_CREATE|TFS_APPEND; + break; + case O_RDWR: + case O_WRONLY|O_CREAT|O_EXCL: + flagmode = TFS_CREATE|TFS_APPEND; + break; + default: + printk("_open_r(): flag 0x%" PRIx32 " not supported\n",flags); + return(ENOTSUP); + } + + /* Find an open slot in our tfd table: + */ + newlib_tfdlock(); + for(tfdidx=0;tfdidxinuse = 1; + newlib_tfdunlock(); + + /* If file is opened for something other than O_RDONLY, then + * we need to allocate a buffer for the file.. + * WARNING: It is the user's responsibility to make sure that + * the file size does not exceed this buffer. Note that the + * buffer may be specified as part of the comma-delimited path. + */ + if (flagmode == TFS_RDONLY) { + buf = (char *)0; + } else { + if (bstr) + buf = (char *)strtol(bstr,0,0); + else + buf = malloc(MAXFILESIZE); + if (!buf) { + newlib_tfdlock(); + tip->inuse = 0; + newlib_tfdunlock(); + return(ENOMEM); + } + } + + /* Deal with tfs flags and tfs info fields if necessary: + */ + if (fstr) { + long bflag; + + bflag = mon_tfsctrl(TFS_FATOB,(long)fstr,0); + if (bflag == -1) { + return(EINVAL); + } + flagmode |= bflag; + } + + if (istr) + strcpy(tip->info,istr); + else + tip->info[0] = 0; + + tfd = mon_tfsopen((char *)pathcopy,flagmode,buf); + if (tfd >= 0) { + tip->tfd = tfd; + tip->buf = buf; + strcpy(tip->name,pathcopy); + iop->file_info = (void *)tfdidx; + return(0); + } else { + printk("%s: %s\n",pathcopy, + (char *)mon_tfsctrl(TFS_ERRMSG,tfd,0)); + } + + if (buf) + free(buf); + + newlib_tfdlock(); + tip->inuse = 0; + newlib_tfdunlock(); + return(EINVAL); +} + +/* + * The IMFS open handler + */ +static int rtems_tfs_open( + rtems_libio_t *iop, + const char *new_name, + uint32_t flags, + uint32_t mode +) +{ + char *full_path_name; + char *s1; + int err; + + if (RTEMS_TFS_DEBUG) + printk("rtems_tfs_open(%s)\n",new_name); + + /* + * Tack the `current directory' on to relative paths. + * We know that the current directory ends in a / character. + */ + if (*new_name == '/') { + /* + * Skip the TFS filesystem prefix. + */ + int len = strlen (TFS_PATHNAME_PREFIX); + if (strncmp (new_name, TFS_PATHNAME_PREFIX, len)) + return ENOENT; + new_name += len; + s1 = ""; + } else { + s1 = rtems_filesystem_current.node_access; + } + full_path_name = malloc (strlen (s1) + strlen (new_name) + 1); + if (full_path_name == NULL) + return ENOMEM; + strcpy (full_path_name, s1); + strcat (full_path_name, new_name); + fixPath (full_path_name); + err = rtems_tfs_open_worker (iop, full_path_name, flags, mode); + free (full_path_name); + return err; +} + +/* + * Read from an open TFS file... + */ +static ssize_t rtems_tfs_read( + rtems_libio_t *iop, + void *buffer, + uint32_t count +) +{ + int ret, fd; + + fd = (int) iop->file_info; + + if (RTEMS_TFS_DEBUG) + printk("_read_r(%d,%" PRId32 ")\n",fd,count); + + if ((fd < 3) || (fd >= MAXTFDS)) + return(EBADF); + + ret = mon_tfsread(tfdtable[fd].tfd,buffer,count); + if (ret == TFSERR_EOF) + ret = 0; + + return(ret); +} + +/* + * Close the open tfs file. + */ +static int rtems_tfs_close( + rtems_libio_t *iop +) +{ + int fd; + char *info; + struct tfdinfo *tip; + + fd = (int)iop->file_info; + + if (RTEMS_TFS_DEBUG) + printk("rtems_tfs_close(%d)\n",fd); + + if ((fd < 3) || (fd >= MAXTFDS)) { + rtems_set_errno_and_return_minus_one (EBADF); + } + + tip = &tfdtable[fd]; + + if (tip->info[0]) + info = tip->info; + else + info = (char *)0; + + mon_tfsclose(tip->tfd,info); + + if (tip->buf) + free(tip->buf); + + newlib_tfdlock(); + tip->inuse = 0; + newlib_tfdunlock(); + return RTEMS_SUCCESSFUL; +} + +static ssize_t rtems_tfs_write( + rtems_libio_t *iop, + const void *buffer, + uint32_t count +) +{ + int ret, fd; + + fd = (int) iop->file_info; + + if (RTEMS_TFS_DEBUG) + printk("rtems_tfs_write(%d,%" PRId32" )\n",fd,count); + + if ((fd <= 0) || (fd >= MAXTFDS)) { + rtems_set_errno_and_return_minus_one (EBADF); + } + + ret = mon_tfswrite(tfdtable[fd].tfd,(char *)buffer,count); + if (ret < 0) + return(-1); + + return(ret); +} + +static rtems_off64_t rtems_tfs_lseek( + rtems_libio_t *iop, + rtems_off64_t offset, + int whence +) +{ + int ret, fd; + + fd = (int) iop->file_info; + + if (RTEMS_TFS_DEBUG) + printk("rtems_tfs_lseek(%d,%ld,%d)\n",fd,(long)offset,whence); + + switch (whence) { + case SEEK_END: + printk("rtems_tfs_lseek doesn't support SEEK_END\n"); + return(-1); + case SEEK_CUR: + whence = TFS_CURRENT; + break; + case SEEK_SET: + whence = TFS_BEGIN; + break; + } + ret = mon_tfsseek(tfdtable[fd].tfd,offset,whence); + + if (ret < 0) + return(-1); + + return (rtems_off64_t)ret; +} + +/* + * + */ +static int rtems_tfs_ftruncate( + rtems_libio_t *iop, + rtems_off64_t count +) +{ + int ret, fd; + + fd = (int) iop->file_info; + ret = mon_tfstruncate(tfdtable[fd].tfd,count); + if (ret != TFS_OKAY) + return(-1); + + return(0); +} + +static int rtems_tfs_ioctl( + rtems_libio_t *iop, + uint32_t cmd, + void *buf +) +{ + int fd, ret; + + fd = (int) iop->file_info; + ret = mon_tfsctrl(cmd,(long)buf,0); + return(-1); +} + +static rtems_filesystem_node_types_t rtems_tfs_node_type( + rtems_filesystem_location_info_t *pathloc +) +{ + if ((pathloc->node_access == NULL) || + (pathloc->node_access == ROOT_NODE_ACCESS)) + return RTEMS_FILESYSTEM_MEMORY_FILE; + return RTEMS_FILESYSTEM_DIRECTORY; +} + +static int rtems_tfs_free_node_info( + +rtems_filesystem_location_info_t *pathloc) +{ + if (pathloc->node_access && (pathloc->node_access != ROOT_NODE_ACCESS)) { + free (pathloc->node_access); + pathloc->node_access = NULL; + } + return 0; +} + + +rtems_filesystem_operations_table rtems_tfs_ops = { + rtems_tfs_eval_path, /* eval_path */ + rtems_tfs_evaluate_for_make, /* evaluate_for_make */ + NULL, /* link */ + NULL, /* unlink */ + rtems_tfs_node_type, /* node_type */ + NULL, /* mknod */ + NULL, /* chown */ + rtems_tfs_free_node_info, /* freenodinfo */ + NULL, /* mount */ + rtems_tfs_mount_me, /* initialize */ + NULL, /* unmount */ + NULL, /* fsunmount */ + NULL, /* utime */ + NULL, /* evaluate_link */ + NULL, /* symlink */ + NULL, /* readlin */ +}; + +rtems_filesystem_file_handlers_r rtems_tfs_handlers = { + rtems_tfs_open, /* open */ + rtems_tfs_close, /* close */ + rtems_tfs_read, /* read */ + rtems_tfs_write, /* write */ + rtems_tfs_ioctl, /* ioctl */ + rtems_tfs_lseek, /* lseek */ + NULL, /* fstat */ + NULL, /* fchmod */ + rtems_tfs_ftruncate, /* ftruncate */ + NULL, /* fpathconf */ + NULL, /* fsync */ + NULL, /* fdatasync */ + NULL, /* fcntl */ + NULL /* rmnod */ +}; diff --git a/c/src/lib/libbsp/shared/umon/umonrtemsglue.c b/c/src/lib/libbsp/shared/umon/umonrtemsglue.c new file mode 100644 index 0000000000..0e1e5dc78b --- /dev/null +++ b/c/src/lib/libbsp/shared/umon/umonrtemsglue.c @@ -0,0 +1,26 @@ +/* + * COPYRIGHT (c) 1989-2009. + * On-Line Applications Research Corporation (OAR). + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rtems.com/license/LICENSE. + * + * $Id$ + */ + +#include + +/* XXX eventually add lock/unlock methods */ + +void rtems_umon_connect(void) +{ + void *moncomptr; + + moncomptr = rtems_bsp_get_umon_monptr(); + monConnect( + (int(*)())(*(unsigned long *)moncomptr), /* monitor base */ + (void *)0, /* lock */ + (void *)0 /* unlock */ + ); +} -- cgit v1.2.3