From 671c31fc5d20a82bf39cdcd2a105daa65e0eb555 Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Tue, 3 Apr 2018 16:24:31 +0200 Subject: bsp: Move umon support to bsps The umon support is only used by the csb337 BSP. This patch is a part of the BSP source reorganization. Update #3285. --- bsps/arm/csb337/umon/README | 50 ++ bsps/arm/csb337/umon/doxygen.h | 7 + bsps/arm/csb337/umon/monlib.c | 1166 ++++++++++++++++++++++++++ bsps/arm/csb337/umon/tfsDriver.c | 683 +++++++++++++++ bsps/arm/csb337/umon/umoncons.c | 131 +++ bsps/arm/csb337/umon/umonrtemsglue.c | 34 + c/src/lib/libbsp/arm/csb337/Makefile.am | 11 +- c/src/lib/libbsp/shared/umon/README | 50 -- c/src/lib/libbsp/shared/umon/doxygen.h | 7 - c/src/lib/libbsp/shared/umon/monlib.c | 1166 -------------------------- c/src/lib/libbsp/shared/umon/tfsDriver.c | 683 --------------- c/src/lib/libbsp/shared/umon/umoncons.c | 131 --- c/src/lib/libbsp/shared/umon/umonrtemsglue.c | 34 - 13 files changed, 2075 insertions(+), 2078 deletions(-) create mode 100644 bsps/arm/csb337/umon/README create mode 100644 bsps/arm/csb337/umon/doxygen.h create mode 100644 bsps/arm/csb337/umon/monlib.c create mode 100644 bsps/arm/csb337/umon/tfsDriver.c create mode 100644 bsps/arm/csb337/umon/umoncons.c create mode 100644 bsps/arm/csb337/umon/umonrtemsglue.c delete mode 100644 c/src/lib/libbsp/shared/umon/README delete mode 100644 c/src/lib/libbsp/shared/umon/doxygen.h delete mode 100644 c/src/lib/libbsp/shared/umon/monlib.c delete mode 100644 c/src/lib/libbsp/shared/umon/tfsDriver.c delete mode 100644 c/src/lib/libbsp/shared/umon/umoncons.c delete mode 100644 c/src/lib/libbsp/shared/umon/umonrtemsglue.c diff --git a/bsps/arm/csb337/umon/README b/bsps/arm/csb337/umon/README new file mode 100644 index 0000000000..aa8b0b972c --- /dev/null +++ b/bsps/arm/csb337/umon/README @@ -0,0 +1,50 @@ +# Fernando Nicodemos +# from NCB - Sistemas Embarcados Ltda. (Brazil) +# +# Joel Sherill +# from OAR Corporation +# + +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/bsps/arm/csb337/umon/doxygen.h b/bsps/arm/csb337/umon/doxygen.h new file mode 100644 index 0000000000..a74d3c3e8b --- /dev/null +++ b/bsps/arm/csb337/umon/doxygen.h @@ -0,0 +1,7 @@ +/** + * @defgroup shared_umon SHARED UMON Modules + * + * @ingroup bsp_shared + * + * @brief SHARED UMON Modules + */ \ No newline at end of file diff --git a/bsps/arm/csb337/umon/monlib.c b/bsps/arm/csb337/umon/monlib.c new file mode 100644 index 0000000000..36f9158a36 --- /dev/null +++ b/bsps/arm/csb337/umon/monlib.c @@ -0,0 +1,1166 @@ +/* + * 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@alcatel-lucent.com + * Phone: 908-582-2351 + ************************************************************************** + * + * Ed Sutter has been informed that this code is being used in RTEMS. + * + * This code was reformatted by Joel Sherrill from OAR Corporation and + * Fernando Nicodemos from NCB - Sistemas + * Embarcados Ltda. (Brazil) to be more compliant with RTEMS coding + * standards and to eliminate C++ style comments. + */ + +#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 + +/* + * Prototype these to avoid warnings but let them appear varargs to user. + */ +extern 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 +); +extern 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 +); +extern 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 +); +extern 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 +); + +/************************************************************************** + * + * 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; + +#if KEEP_TO_STAY_IN_SYNC_WITH_UPSTREAM_BUT_UNUSED +static void +DisableMonLock(void) +{ + ignorelock = 2; +} + +static void +EnableMonLock(void) +{ + ignorelock = 0; +} +#endif + +/* 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/bsps/arm/csb337/umon/tfsDriver.c b/bsps/arm/csb337/umon/tfsDriver.c new file mode 100644 index 0000000000..01953469bb --- /dev/null +++ b/bsps/arm/csb337/umon/tfsDriver.c @@ -0,0 +1,683 @@ +/* + * tfsDriver.c - MicroMonitor TFS Hookup to RTEMS FS + * + * Initial release: Oct 1, 2004 by Ed Sutter + * + * Modifications to support reference counting in the file system are + * Copyright (c) 2012 embedded brains GmbH. + * + * 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 reformatted by Joel Sherrill from OAR Corporation and + * Fernando Nicodemos from NCB - Sistemas + * Embarcados Ltda. (Brazil) to be more compliant with RTEMS coding + * standards and to eliminate C++ style comments. + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rtems.org/license/LICENSE. + */ + +#include +#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]; + +static const rtems_filesystem_operations_table rtems_tfs_ops; +static const rtems_filesystem_file_handlers_r rtems_tfs_handlers; + +static bool rtems_tfs_is_directory( + const char *path, + size_t pathlen +) +{ + return path [pathlen - 1] == '/'; +} + +static int rtems_tfs_mount_me( + rtems_filesystem_mount_table_entry_t *mt_entry, + const void *data +) +{ + char *root_path = strdup("/"); + + if (root_path == NULL) { + rtems_set_errno_and_return_minus_one(ENOMEM); + } + + mt_entry->ops = &rtems_tfs_ops; + mt_entry->mt_fs_root->location.handlers = &rtems_tfs_handlers; + mt_entry->mt_fs_root->location.node_access = root_path; + + return 0; +} + +/* Initialize the TFS-RTEMS file system + */ +int rtems_initialize_tfs_filesystem( + const char *path +) +{ + int status; + + 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; + } + + if (rtems_filesystem_register( "tfs", rtems_tfs_mount_me ) < 0) + return -1; + + status = mount( "umon", TFS_PATHNAME_PREFIX, "tfs", RTEMS_FILESYSTEM_READ_WRITE, NULL); + + if (status < 0) { + printk( "TFS: Unable to mount on %s\n", TFS_PATHNAME_PREFIX ); + perror("TFS mount failed"); + } + + return(status); +} + +/* + * 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 void rtems_tfs_eval_path(rtems_filesystem_eval_path_context_t *self) +{ + int eval_flags = rtems_filesystem_eval_path_get_flags(self); + + if ((eval_flags & RTEMS_FS_MAKE) == 0) { + int rw = RTEMS_FS_PERMS_READ | RTEMS_FS_PERMS_WRITE; + + if ((eval_flags & rw) != rw) { + rtems_filesystem_location_info_t *currentloc = + rtems_filesystem_eval_path_get_currentloc(self); + char *current = currentloc->node_access; + size_t currentlen = strlen(current); + const char *path = rtems_filesystem_eval_path_get_path(self); + size_t pathlen = rtems_filesystem_eval_path_get_pathlen(self); + size_t len = currentlen + pathlen; + + rtems_filesystem_eval_path_clear_path(self); + + current = realloc(current, len + 1); + if (current != NULL) { + memcpy(current + currentlen, path, pathlen); + current [len] = '\0'; + if (!rtems_tfs_is_directory(current, len)) { + fixPath (current); + } + currentloc->node_access = current; + } else { + rtems_filesystem_eval_path_error(self, ENOMEM); + } + } else { + rtems_filesystem_eval_path_error(self, EINVAL); + } + } else { + rtems_filesystem_eval_path_error(self, EIO); + } +} + +/* + * 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, + int oflag, + mode_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%x,0x%" PRIx32 ")\n",path,oflag,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 ((oflag & (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(oflag & 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%i not supported\n",oflag); + 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->data0 = (uint32_t)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, + int oflag, + mode_t mode +) +{ + char *full_path_name; + int err; + + full_path_name = iop->pathinfo.node_access; + + if (RTEMS_TFS_DEBUG) + printk("rtems_tfs_open(%s)\n",full_path_name); + + if (rtems_tfs_is_directory(full_path_name, strlen(full_path_name))) { + rtems_set_errno_and_return_minus_one (ENOTSUP); + } + + err = rtems_tfs_open_worker (iop, full_path_name, oflag, mode); + if (err != 0) { + rtems_set_errno_and_return_minus_one (err); + } + + return err; +} + +/* + * Read from an open TFS file... + */ +static ssize_t rtems_tfs_read( + rtems_libio_t *iop, + void *buffer, + size_t count +) +{ + int ret, fd; + + fd = (int) iop->data0; + + if (RTEMS_TFS_DEBUG) + printk("_read_r(%d,%zi)\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->data0; + + 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, + size_t count +) +{ + int ret, fd; + + fd = (int) iop->data0; + + if (RTEMS_TFS_DEBUG) + printk("rtems_tfs_write(%d,%zi)\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 off_t rtems_tfs_lseek( + rtems_libio_t *iop, + off_t offset, + int whence +) +{ + int ret, fd; + + fd = (int) iop->data0; + + 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 (off_t)ret; +} + +/* + * + */ +static int rtems_tfs_ftruncate( + rtems_libio_t *iop, + off_t count +) +{ + int ret, fd; + + fd = (int) iop->data0; + 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 ret; + + ret = mon_tfsctrl(cmd,(long)buf,0); + if (ret != TFS_OKAY) + return(-1); + + return(0); +} + +static int rtems_tfs_fstat( + const rtems_filesystem_location_info_t *loc, + struct stat *buf +) +{ + const char *path = loc->node_access; + size_t pathlen = strlen(path); + + buf->st_mode = S_IRWXU | S_IRWXG | S_IRWXO + | (rtems_tfs_is_directory(path, pathlen) ? S_IFDIR : S_IFREG); + + return 0; +} + +static int rtems_tfs_clone_node_info( + rtems_filesystem_location_info_t *loc +) +{ + int rv = 0; + + loc->node_access = strdup(loc->node_access); + + if (loc->node_access == NULL) { + errno = ENOMEM; + rv = -1; + } + + return rv; +} + +static void rtems_tfs_free_node_info( + const rtems_filesystem_location_info_t *loc +) +{ + free(loc->node_access); +} + +static bool rtems_tfs_are_nodes_equal( + const rtems_filesystem_location_info_t *a, + const rtems_filesystem_location_info_t *b +) +{ + return strcmp(a->node_access, b->node_access) == 0; +} + +static const rtems_filesystem_operations_table rtems_tfs_ops = { + .lock_h = rtems_filesystem_default_lock, + .unlock_h = rtems_filesystem_default_unlock, + .eval_path_h = rtems_tfs_eval_path, + .link_h = rtems_filesystem_default_link, + .are_nodes_equal_h = rtems_tfs_are_nodes_equal, + .mknod_h = rtems_filesystem_default_mknod, + .rmnod_h = rtems_filesystem_default_rmnod, + .fchmod_h = rtems_filesystem_default_fchmod, + .chown_h = rtems_filesystem_default_chown, + .clonenod_h = rtems_tfs_clone_node_info, + .freenod_h = rtems_tfs_free_node_info, + .mount_h = rtems_filesystem_default_mount, + .unmount_h = rtems_filesystem_default_unmount, + .fsunmount_me_h = rtems_filesystem_default_fsunmount, + .utime_h = rtems_filesystem_default_utime, + .symlink_h = rtems_filesystem_default_symlink, + .readlink_h = rtems_filesystem_default_readlink, + .rename_h = rtems_filesystem_default_rename, + .statvfs_h = rtems_filesystem_default_statvfs +}; + +static const rtems_filesystem_file_handlers_r rtems_tfs_handlers = { + .open_h = rtems_tfs_open, + .close_h = rtems_tfs_close, + .read_h = rtems_tfs_read, + .write_h = rtems_tfs_write, + .ioctl_h = rtems_tfs_ioctl, + .lseek_h = rtems_tfs_lseek, + .fstat_h = rtems_tfs_fstat, + .ftruncate_h = rtems_tfs_ftruncate, + .fsync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fcntl_h = rtems_filesystem_default_fcntl, + .kqfilter_h = rtems_filesystem_default_kqfilter, + .poll_h = rtems_filesystem_default_poll, + .readv_h = rtems_filesystem_default_readv, + .writev_h = rtems_filesystem_default_writev +}; diff --git a/bsps/arm/csb337/umon/umoncons.c b/bsps/arm/csb337/umon/umoncons.c new file mode 100644 index 0000000000..ef49585ef8 --- /dev/null +++ b/bsps/arm/csb337/umon/umoncons.c @@ -0,0 +1,131 @@ +/* + * uMon Support Output Driver + * + * COPYRIGHT (c) 1989-2009. + * On-Line Applications Research Corporation (OAR). + * + * Modified by Fernando Nicodemos + * from NCB - Sistemas Embarcados Ltda. (Brazil) + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rtems.org/license/LICENSE. + */ + +#include +#include +#include + +/* static function prototypes */ +static int umoncons_first_open(int major, int minor, void *arg); +static int umoncons_last_close(int major, int minor, void *arg); +static int umoncons_read(int minor); +static ssize_t umoncons_write(int minor, const char *buf, size_t len); +static void umoncons_init(int minor); +static void umoncons_write_polled(int minor, char c); +static int umoncons_set_attributes(int minor, const struct termios *t); + +/* Pointers to functions for handling the UART. */ +const console_fns umoncons_fns = +{ + libchip_serial_default_probe, + umoncons_first_open, + umoncons_last_close, + umoncons_read, + umoncons_write, + umoncons_init, + umoncons_write_polled, /* not used in this driver */ + umoncons_set_attributes, + false /* TRUE if interrupt driven, FALSE if not. */ +}; + +/*********************************************************************/ +/* Functions called via callbacks (i.e. the ones in uart_fns */ +/*********************************************************************/ + +/* + * This is called the first time each device is opened. Since + * the driver is polled, we don't have to do anything. If the driver + * were interrupt driven, we'd enable interrupts here. +*/ +static int umoncons_first_open(int major, int minor, void *arg) +{ + return 0; +} + + +/* + * This is called the last time each device is closed. Since + * the driver is polled, we don't have to do anything. If the driver + * were interrupt driven, we'd disable interrupts here. +*/ +static int umoncons_last_close(int major, int minor, void *arg) +{ + return 0; +} + + +/* + * Read one character from UART. + * + * return -1 if there's no data, otherwise return + * the character in lowest 8 bits of returned int. +*/ +static int umoncons_read(int minor) +{ + if ( !mon_gotachar() ) + return -1; + return mon_getchar(); +} + + +/* + * Write buffer to LCD + * + * return 1 on success, -1 on error +*/ +static ssize_t umoncons_write(int minor, const char *buf, size_t len) +{ + size_t i; + + for ( i=0 ; i + * from NCB - Sistemas Embarcados Ltda. (Brazil) + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rtems.org/license/LICENSE. +*/ + +#include + +/* XXX eventually add lock/unlock methods */ + +static int rtems_umon_connected = 0; + +void rtems_umon_connect(void) +{ + int(*moncomptr)(int,void *,void *,void *); + + if ( rtems_umon_connected ) + return; + + rtems_umon_connected = 1; + + moncomptr = rtems_bsp_get_umon_monptr(); + monConnect( + moncomptr, /* monitor base */ + (void *)0, /* lock */ + (void *)0 /* unlock */ + ); +} diff --git a/c/src/lib/libbsp/arm/csb337/Makefile.am b/c/src/lib/libbsp/arm/csb337/Makefile.am index 9a99d69cb1..38382de004 100644 --- a/c/src/lib/libbsp/arm/csb337/Makefile.am +++ b/c/src/lib/libbsp/arm/csb337/Makefile.am @@ -8,9 +8,6 @@ dist_project_lib_DATA = startup/bsp_specs if ENABLE_LCD endif -if ENABLE_UMON -endif - DISTCLEANFILES = include/bspopts.h noinst_PROGRAMS = @@ -61,12 +58,12 @@ libbsp_a_SOURCES += console/sed1356.c console/fbcons.c endif # umon if ENABLE_UMON -libbsp_a_SOURCES += ../../shared/umon/umonrtemsglue.c \ - ../../shared/umon/monlib.c ../../shared/umon/tfsDriver.c \ - ../../shared/umon/umoncons.c startup/umonsupp.c +libbsp_a_SOURCES += ../../../../../../bsps/arm/csb337/umon/monlib.c +libbsp_a_SOURCES += ../../../../../../bsps/arm/csb337/umon/tfsDriver.c +libbsp_a_SOURCES += ../../../../../../bsps/arm/csb337/umon/umonrtemsglue.c endif if ENABLE_UMON_CONSOLE -libbsp_a_SOURCES += ../../shared/umon/umoncons.c +libbsp_a_SOURCES += ../../../../../../bsps/arm/csb337/umon/umoncons.c endif # Cache diff --git a/c/src/lib/libbsp/shared/umon/README b/c/src/lib/libbsp/shared/umon/README deleted file mode 100644 index aa8b0b972c..0000000000 --- a/c/src/lib/libbsp/shared/umon/README +++ /dev/null @@ -1,50 +0,0 @@ -# Fernando Nicodemos -# from NCB - Sistemas Embarcados Ltda. (Brazil) -# -# Joel Sherill -# from OAR Corporation -# - -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/doxygen.h b/c/src/lib/libbsp/shared/umon/doxygen.h deleted file mode 100644 index a74d3c3e8b..0000000000 --- a/c/src/lib/libbsp/shared/umon/doxygen.h +++ /dev/null @@ -1,7 +0,0 @@ -/** - * @defgroup shared_umon SHARED UMON Modules - * - * @ingroup bsp_shared - * - * @brief SHARED UMON Modules - */ \ No newline at end of file diff --git a/c/src/lib/libbsp/shared/umon/monlib.c b/c/src/lib/libbsp/shared/umon/monlib.c deleted file mode 100644 index 36f9158a36..0000000000 --- a/c/src/lib/libbsp/shared/umon/monlib.c +++ /dev/null @@ -1,1166 +0,0 @@ -/* - * 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@alcatel-lucent.com - * Phone: 908-582-2351 - ************************************************************************** - * - * Ed Sutter has been informed that this code is being used in RTEMS. - * - * This code was reformatted by Joel Sherrill from OAR Corporation and - * Fernando Nicodemos from NCB - Sistemas - * Embarcados Ltda. (Brazil) to be more compliant with RTEMS coding - * standards and to eliminate C++ style comments. - */ - -#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 - -/* - * Prototype these to avoid warnings but let them appear varargs to user. - */ -extern 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 -); -extern 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 -); -extern 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 -); -extern 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 -); - -/************************************************************************** - * - * 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; - -#if KEEP_TO_STAY_IN_SYNC_WITH_UPSTREAM_BUT_UNUSED -static void -DisableMonLock(void) -{ - ignorelock = 2; -} - -static void -EnableMonLock(void) -{ - ignorelock = 0; -} -#endif - -/* 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/tfsDriver.c b/c/src/lib/libbsp/shared/umon/tfsDriver.c deleted file mode 100644 index 01953469bb..0000000000 --- a/c/src/lib/libbsp/shared/umon/tfsDriver.c +++ /dev/null @@ -1,683 +0,0 @@ -/* - * tfsDriver.c - MicroMonitor TFS Hookup to RTEMS FS - * - * Initial release: Oct 1, 2004 by Ed Sutter - * - * Modifications to support reference counting in the file system are - * Copyright (c) 2012 embedded brains GmbH. - * - * 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 reformatted by Joel Sherrill from OAR Corporation and - * Fernando Nicodemos from NCB - Sistemas - * Embarcados Ltda. (Brazil) to be more compliant with RTEMS coding - * standards and to eliminate C++ style comments. - * - * The license and distribution terms for this file may be - * found in the file LICENSE in this distribution or at - * http://www.rtems.org/license/LICENSE. - */ - -#include -#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]; - -static const rtems_filesystem_operations_table rtems_tfs_ops; -static const rtems_filesystem_file_handlers_r rtems_tfs_handlers; - -static bool rtems_tfs_is_directory( - const char *path, - size_t pathlen -) -{ - return path [pathlen - 1] == '/'; -} - -static int rtems_tfs_mount_me( - rtems_filesystem_mount_table_entry_t *mt_entry, - const void *data -) -{ - char *root_path = strdup("/"); - - if (root_path == NULL) { - rtems_set_errno_and_return_minus_one(ENOMEM); - } - - mt_entry->ops = &rtems_tfs_ops; - mt_entry->mt_fs_root->location.handlers = &rtems_tfs_handlers; - mt_entry->mt_fs_root->location.node_access = root_path; - - return 0; -} - -/* Initialize the TFS-RTEMS file system - */ -int rtems_initialize_tfs_filesystem( - const char *path -) -{ - int status; - - 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; - } - - if (rtems_filesystem_register( "tfs", rtems_tfs_mount_me ) < 0) - return -1; - - status = mount( "umon", TFS_PATHNAME_PREFIX, "tfs", RTEMS_FILESYSTEM_READ_WRITE, NULL); - - if (status < 0) { - printk( "TFS: Unable to mount on %s\n", TFS_PATHNAME_PREFIX ); - perror("TFS mount failed"); - } - - return(status); -} - -/* - * 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 void rtems_tfs_eval_path(rtems_filesystem_eval_path_context_t *self) -{ - int eval_flags = rtems_filesystem_eval_path_get_flags(self); - - if ((eval_flags & RTEMS_FS_MAKE) == 0) { - int rw = RTEMS_FS_PERMS_READ | RTEMS_FS_PERMS_WRITE; - - if ((eval_flags & rw) != rw) { - rtems_filesystem_location_info_t *currentloc = - rtems_filesystem_eval_path_get_currentloc(self); - char *current = currentloc->node_access; - size_t currentlen = strlen(current); - const char *path = rtems_filesystem_eval_path_get_path(self); - size_t pathlen = rtems_filesystem_eval_path_get_pathlen(self); - size_t len = currentlen + pathlen; - - rtems_filesystem_eval_path_clear_path(self); - - current = realloc(current, len + 1); - if (current != NULL) { - memcpy(current + currentlen, path, pathlen); - current [len] = '\0'; - if (!rtems_tfs_is_directory(current, len)) { - fixPath (current); - } - currentloc->node_access = current; - } else { - rtems_filesystem_eval_path_error(self, ENOMEM); - } - } else { - rtems_filesystem_eval_path_error(self, EINVAL); - } - } else { - rtems_filesystem_eval_path_error(self, EIO); - } -} - -/* - * 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, - int oflag, - mode_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%x,0x%" PRIx32 ")\n",path,oflag,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 ((oflag & (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(oflag & 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%i not supported\n",oflag); - 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->data0 = (uint32_t)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, - int oflag, - mode_t mode -) -{ - char *full_path_name; - int err; - - full_path_name = iop->pathinfo.node_access; - - if (RTEMS_TFS_DEBUG) - printk("rtems_tfs_open(%s)\n",full_path_name); - - if (rtems_tfs_is_directory(full_path_name, strlen(full_path_name))) { - rtems_set_errno_and_return_minus_one (ENOTSUP); - } - - err = rtems_tfs_open_worker (iop, full_path_name, oflag, mode); - if (err != 0) { - rtems_set_errno_and_return_minus_one (err); - } - - return err; -} - -/* - * Read from an open TFS file... - */ -static ssize_t rtems_tfs_read( - rtems_libio_t *iop, - void *buffer, - size_t count -) -{ - int ret, fd; - - fd = (int) iop->data0; - - if (RTEMS_TFS_DEBUG) - printk("_read_r(%d,%zi)\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->data0; - - 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, - size_t count -) -{ - int ret, fd; - - fd = (int) iop->data0; - - if (RTEMS_TFS_DEBUG) - printk("rtems_tfs_write(%d,%zi)\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 off_t rtems_tfs_lseek( - rtems_libio_t *iop, - off_t offset, - int whence -) -{ - int ret, fd; - - fd = (int) iop->data0; - - 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 (off_t)ret; -} - -/* - * - */ -static int rtems_tfs_ftruncate( - rtems_libio_t *iop, - off_t count -) -{ - int ret, fd; - - fd = (int) iop->data0; - 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 ret; - - ret = mon_tfsctrl(cmd,(long)buf,0); - if (ret != TFS_OKAY) - return(-1); - - return(0); -} - -static int rtems_tfs_fstat( - const rtems_filesystem_location_info_t *loc, - struct stat *buf -) -{ - const char *path = loc->node_access; - size_t pathlen = strlen(path); - - buf->st_mode = S_IRWXU | S_IRWXG | S_IRWXO - | (rtems_tfs_is_directory(path, pathlen) ? S_IFDIR : S_IFREG); - - return 0; -} - -static int rtems_tfs_clone_node_info( - rtems_filesystem_location_info_t *loc -) -{ - int rv = 0; - - loc->node_access = strdup(loc->node_access); - - if (loc->node_access == NULL) { - errno = ENOMEM; - rv = -1; - } - - return rv; -} - -static void rtems_tfs_free_node_info( - const rtems_filesystem_location_info_t *loc -) -{ - free(loc->node_access); -} - -static bool rtems_tfs_are_nodes_equal( - const rtems_filesystem_location_info_t *a, - const rtems_filesystem_location_info_t *b -) -{ - return strcmp(a->node_access, b->node_access) == 0; -} - -static const rtems_filesystem_operations_table rtems_tfs_ops = { - .lock_h = rtems_filesystem_default_lock, - .unlock_h = rtems_filesystem_default_unlock, - .eval_path_h = rtems_tfs_eval_path, - .link_h = rtems_filesystem_default_link, - .are_nodes_equal_h = rtems_tfs_are_nodes_equal, - .mknod_h = rtems_filesystem_default_mknod, - .rmnod_h = rtems_filesystem_default_rmnod, - .fchmod_h = rtems_filesystem_default_fchmod, - .chown_h = rtems_filesystem_default_chown, - .clonenod_h = rtems_tfs_clone_node_info, - .freenod_h = rtems_tfs_free_node_info, - .mount_h = rtems_filesystem_default_mount, - .unmount_h = rtems_filesystem_default_unmount, - .fsunmount_me_h = rtems_filesystem_default_fsunmount, - .utime_h = rtems_filesystem_default_utime, - .symlink_h = rtems_filesystem_default_symlink, - .readlink_h = rtems_filesystem_default_readlink, - .rename_h = rtems_filesystem_default_rename, - .statvfs_h = rtems_filesystem_default_statvfs -}; - -static const rtems_filesystem_file_handlers_r rtems_tfs_handlers = { - .open_h = rtems_tfs_open, - .close_h = rtems_tfs_close, - .read_h = rtems_tfs_read, - .write_h = rtems_tfs_write, - .ioctl_h = rtems_tfs_ioctl, - .lseek_h = rtems_tfs_lseek, - .fstat_h = rtems_tfs_fstat, - .ftruncate_h = rtems_tfs_ftruncate, - .fsync_h = rtems_filesystem_default_fsync_or_fdatasync, - .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync, - .fcntl_h = rtems_filesystem_default_fcntl, - .kqfilter_h = rtems_filesystem_default_kqfilter, - .poll_h = rtems_filesystem_default_poll, - .readv_h = rtems_filesystem_default_readv, - .writev_h = rtems_filesystem_default_writev -}; diff --git a/c/src/lib/libbsp/shared/umon/umoncons.c b/c/src/lib/libbsp/shared/umon/umoncons.c deleted file mode 100644 index ef49585ef8..0000000000 --- a/c/src/lib/libbsp/shared/umon/umoncons.c +++ /dev/null @@ -1,131 +0,0 @@ -/* - * uMon Support Output Driver - * - * COPYRIGHT (c) 1989-2009. - * On-Line Applications Research Corporation (OAR). - * - * Modified by Fernando Nicodemos - * from NCB - Sistemas Embarcados Ltda. (Brazil) - * - * The license and distribution terms for this file may be - * found in the file LICENSE in this distribution or at - * http://www.rtems.org/license/LICENSE. - */ - -#include -#include -#include - -/* static function prototypes */ -static int umoncons_first_open(int major, int minor, void *arg); -static int umoncons_last_close(int major, int minor, void *arg); -static int umoncons_read(int minor); -static ssize_t umoncons_write(int minor, const char *buf, size_t len); -static void umoncons_init(int minor); -static void umoncons_write_polled(int minor, char c); -static int umoncons_set_attributes(int minor, const struct termios *t); - -/* Pointers to functions for handling the UART. */ -const console_fns umoncons_fns = -{ - libchip_serial_default_probe, - umoncons_first_open, - umoncons_last_close, - umoncons_read, - umoncons_write, - umoncons_init, - umoncons_write_polled, /* not used in this driver */ - umoncons_set_attributes, - false /* TRUE if interrupt driven, FALSE if not. */ -}; - -/*********************************************************************/ -/* Functions called via callbacks (i.e. the ones in uart_fns */ -/*********************************************************************/ - -/* - * This is called the first time each device is opened. Since - * the driver is polled, we don't have to do anything. If the driver - * were interrupt driven, we'd enable interrupts here. -*/ -static int umoncons_first_open(int major, int minor, void *arg) -{ - return 0; -} - - -/* - * This is called the last time each device is closed. Since - * the driver is polled, we don't have to do anything. If the driver - * were interrupt driven, we'd disable interrupts here. -*/ -static int umoncons_last_close(int major, int minor, void *arg) -{ - return 0; -} - - -/* - * Read one character from UART. - * - * return -1 if there's no data, otherwise return - * the character in lowest 8 bits of returned int. -*/ -static int umoncons_read(int minor) -{ - if ( !mon_gotachar() ) - return -1; - return mon_getchar(); -} - - -/* - * Write buffer to LCD - * - * return 1 on success, -1 on error -*/ -static ssize_t umoncons_write(int minor, const char *buf, size_t len) -{ - size_t i; - - for ( i=0 ; i - * from NCB - Sistemas Embarcados Ltda. (Brazil) - * - * The license and distribution terms for this file may be - * found in the file LICENSE in this distribution or at - * http://www.rtems.org/license/LICENSE. -*/ - -#include - -/* XXX eventually add lock/unlock methods */ - -static int rtems_umon_connected = 0; - -void rtems_umon_connect(void) -{ - int(*moncomptr)(int,void *,void *,void *); - - if ( rtems_umon_connected ) - return; - - rtems_umon_connected = 1; - - moncomptr = rtems_bsp_get_umon_monptr(); - monConnect( - moncomptr, /* monitor base */ - (void *)0, /* lock */ - (void *)0 /* unlock */ - ); -} -- cgit v1.2.3