interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
riscv-openocd/src/ecosboard.c

2406 lines
55 KiB
C
Raw Normal View History

ZY1000 code git-svn-id: svn://svn.berlios.de/openocd/trunk@1005 b42882b7-edfa-0310-969c-e2dbd0fdcd60
2008-09-25 09:31:10 -05:00
/***************************************************************************
* Copyright (C) 2007-2008 by <EFBFBD>yvind Harboe *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "log.h"
#include "types.h"
#include "jtag.h"
#include "configuration.h"
#include "xsvf.h"
#include "target.h"
#include "flash.h"
#include "nand.h"
#include "pld.h"
#include "command.h"
#include "server.h"
#include "telnet_server.h"
#include "gdb_server.h"
#include <time_support.h>
#include <sys/time.h>
#include <sys/types.h>
#include <strings.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <cyg/io/flash.h>
#include <pkgconf/fs_jffs2.h> // Address of JFFS2
#include <network.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <cyg/fileio/fileio.h>
#include <dirent.h>
#include <cyg/athttpd/http.h>
#include <cyg/athttpd/socket.h>
#include <cyg/athttpd/handler.h>
#include <cyg/athttpd/cgi.h>
#include <cyg/athttpd/forms.h>
#include <cyg/hal/hal_diag.h>
#include <cyg/kernel/kapi.h>
#include <cyg/io/serialio.h>
#include <cyg/io/io.h>
#include <netinet/tcp.h>
#include "rom.h"
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <ifaddrs.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define MAX_IFS 64
#if defined(CYGPKG_NET_FREEBSD_STACK)
#include <tftp_support.h>
/* posix compatibility broken*/
struct tftpd_fileops fileops =
{
(int (*)(const char *, int))open,
close,
(int (*)(int, const void *, int))write,
( int (*)(int, void *, int))read
};
#endif
wip git-svn-id: svn://svn.berlios.de/openocd/trunk@1006 b42882b7-edfa-0310-969c-e2dbd0fdcd60
2008-09-26 02:58:36 -05:00
#define ZYLIN_VERSION "1.43"
ZY1000 code git-svn-id: svn://svn.berlios.de/openocd/trunk@1005 b42882b7-edfa-0310-969c-e2dbd0fdcd60
2008-09-25 09:31:10 -05:00
#define ZYLIN_DATE __DATE__
#define ZYLIN_TIME __TIME__
wip git-svn-id: svn://svn.berlios.de/openocd/trunk@1006 b42882b7-edfa-0310-969c-e2dbd0fdcd60
2008-09-26 02:58:36 -05:00
/* hmmm.... we can't pick up the right # during build if we've checked this out
* in Eclipse... arrggghh...*/
#define ZYLIN_OPENOCD 1005
ZY1000 code git-svn-id: svn://svn.berlios.de/openocd/trunk@1005 b42882b7-edfa-0310-969c-e2dbd0fdcd60
2008-09-25 09:31:10 -05:00
#define ZYLIN_OPENOCD_VERSION "Zylin JTAG ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE " " ZYLIN_TIME
#define ZYLIN_CONFIG_DIR "/config/settings"
void diag_write(char *buf, int len)
{
int j;
for (j = 0; j < len; j++)
{
diag_printf("%c", buf[j]);
}
}
static bool serialLog = true;
static bool writeLog = true;
struct FastLoad
{
u32 address;
u8 *data;
int length;
};
static int fastload_num;
static struct FastLoad *fastload;
static void free_fastload()
{
if (fastload!=NULL)
{
int i;
for (i=0; i<fastload_num; i++)
{
if (fastload[i].data)
free(fastload[i].data);
}
free(fastload);
fastload=NULL;
}
}
int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
u8 *buffer;
u32 buf_cnt;
u32 image_size;
u32 min_address=0;
u32 max_address=0xffffffff;
int i;
int retval;
image_t image;
duration_t duration;
char *duration_text;
if ((argc < 1)||(argc > 5))
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
/* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
if (argc >= 2)
{
image.base_address_set = 1;
image.base_address = strtoul(args[1], NULL, 0);
}
else
{
image.base_address_set = 0;
}
image.start_address_set = 0;
if (argc>=4)
{
min_address=strtoul(args[3], NULL, 0);
}
if (argc>=5)
{
max_address=strtoul(args[4], NULL, 0)+min_address;
}
if (min_address>max_address)
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
duration_start_measure(&duration);
if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
return ERROR_OK;
}
image_size = 0x0;
retval = ERROR_OK;
fastload_num=image.num_sections;
fastload=(struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
if (fastload==NULL)
{
image_close(&image);
return ERROR_FAIL;
}
memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
for (i = 0; i < image.num_sections; i++)
{
buffer = malloc(image.sections[i].size);
if (buffer == NULL)
{
command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
break;
}
if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
{
free(buffer);
break;
}
u32 offset=0;
u32 length=buf_cnt;
/* DANGER!!! beware of unsigned comparision here!!! */
if ((image.sections[i].base_address+buf_cnt>=min_address)&&
(image.sections[i].base_address<max_address))
{
if (image.sections[i].base_address<min_address)
{
/* clip addresses below */
offset+=min_address-image.sections[i].base_address;
length-=offset;
}
if (image.sections[i].base_address+buf_cnt>max_address)
{
length-=(image.sections[i].base_address+buf_cnt)-max_address;
}
fastload[i].address=image.sections[i].base_address+offset;
fastload[i].data=malloc(length);
if (fastload[i].data==NULL)
{
free(buffer);
break;
}
memcpy(fastload[i].data, buffer+offset, length);
fastload[i].length=length;
image_size += length;
command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
}
free(buffer);
}
duration_stop_measure(&duration, &duration_text);
if (retval==ERROR_OK)
{
command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
}
free(duration_text);
image_close(&image);
if (retval!=ERROR_OK)
{
free_fastload();
}
return retval;
}
int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc>0)
return ERROR_COMMAND_SYNTAX_ERROR;
if (fastload==NULL)
{
LOG_ERROR("No image in memory");
return ERROR_FAIL;
}
int i;
int ms=timeval_ms();
int size=0;
for (i=0; i<fastload_num;i++)
{
int retval;
target_t *target = get_current_target(cmd_ctx);
if ((retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data)) != ERROR_OK)
{
return retval;
}
size+=fastload[i].length;
}
int after=timeval_ms();
command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
return ERROR_OK;
}
/* Give TELNET a way to find out what version this is */
int handle_zy1000_version_command(struct command_context_s *cmd_ctx, char *cmd,
char **args, int argc)
{
if (argc > 1)
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (argc == 0)
{
command_print(cmd_ctx, ZYLIN_OPENOCD_VERSION);
} else if (strcmp("openocd", args[0])==0)
{
command_print(cmd_ctx, "%d", ZYLIN_OPENOCD);
} else if (strcmp("zy1000", args[0])==0)
{
command_print(cmd_ctx, "%s", ZYLIN_VERSION);
} else if (strcmp("date", args[0])==0)
{
command_print(cmd_ctx, "%s", ZYLIN_DATE);
} else
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_OK;
}
extern flash_driver_t *flash_drivers[];
extern target_type_t *target_types[];
#ifdef CYGPKG_PROFILE_GPROF
#include <cyg/profile/profile.h>
extern char _stext, _etext; // Defined by the linker
void start_profile(void)
{
// This starts up the system-wide profiling, gathering
// profile information on all of the code, with a 16 byte
// "bucket" size, at a rate of 100us/profile hit.
// Note: a bucket size of 16 will give pretty good function
// resolution. Much smaller and the buffer becomes
// much too large for very little gain.
// Note: a timer period of 100us is also a reasonable
// compromise. Any smaller and the overhead of
// handling the timter (profile) interrupt could
// swamp the system. A fast processor might get
// by with a smaller value, but a slow one could
// even be swamped by this value. If the value is
// too large, the usefulness of the profile is reduced.
// no more interrupts than 1/10ms.
// profile_on(&_stext, &_etext, 16, 10000); // DRAM
//profile_on((void *)0, (void *)0x40000, 16, 10000); // SRAM
profile_on(0, &_etext, 16, 10000); // SRAM & DRAM
}
#endif
// launch GDB server if a config file exists
bool zylinjtag_parse_config_file(struct command_context_s *cmd_ctx, const char *config_file_name)
{
bool foundFile = false;
FILE *config_file = NULL;
command_print(cmd_ctx, "executing config file %s", config_file_name);
config_file = fopen(config_file_name, "r");
if (config_file)
{
fclose(config_file);
int retval;
retval = command_run_linef(cmd_ctx, "script %s", config_file_name);
if (retval == ERROR_OK)
{
foundFile = true;
}
else
{
command_print(cmd_ctx, "Failed executing %s %d", config_file_name, retval);
}
}
else
{
command_print(cmd_ctx, "No %s found", config_file_name);
}
return foundFile;
}
extern int eth0_up;
static FILE *log;
static char reboot_stack[2048];
static void
zylinjtag_reboot(cyg_addrword_t data)
{
serialLog = true;
diag_printf("Rebooting in 100 ticks..\n");
cyg_thread_delay(100);
diag_printf("Unmounting /config..\n");
umount("/config");
diag_printf("Rebooting..\n");
HAL_PLATFORM_RESET();
}
static cyg_thread zylinjtag_thread_object;
static cyg_handle_t zylinjtag_thread_handle;
void reboot(void)
{
cyg_thread_create(1,
zylinjtag_reboot,
(cyg_addrword_t)0,
"reboot Thread",
(void *)reboot_stack,
sizeof(reboot_stack),
&zylinjtag_thread_handle,
&zylinjtag_thread_object);
cyg_thread_resume(zylinjtag_thread_handle);
}
int configuration_output_handler(struct command_context_s *context, const char* line)
{
diag_printf("%s", line);
return ERROR_OK;
}
int zy1000_configuration_output_handler_log(struct command_context_s *context, const char* line)
{
LOG_USER_N("%s", line);
return ERROR_OK;
}
int handle_rm_command(struct command_context_s *cmd_ctx, char *cmd,
char **args, int argc)
{
if (argc != 1)
{
command_print(cmd_ctx, "rm <filename>");
return ERROR_INVALID_ARGUMENTS;
}
if (unlink(args[0]) != 0)
{
command_print(cmd_ctx, "failed: %d", errno);
}
return ERROR_OK;
}
int loadFile(const char *fileName, void **data, int *len);
int handle_cat_command(struct command_context_s *cmd_ctx, char *cmd,
char **args, int argc)
{
if (argc != 1)
{
command_print(cmd_ctx, "cat <filename>");
return ERROR_INVALID_ARGUMENTS;
}
// NOTE!!! we only have line printing capability so we print the entire file as a single line.
void *data;
int len;
int retval = loadFile(args[0], &data, &len);
if (retval == ERROR_OK)
{
command_print(cmd_ctx, "%s", data);
free(data);
}
else
{
command_print(cmd_ctx, "%s not found %d", args[0], retval);
}
return ERROR_OK;
}
int handle_trunc_command(struct command_context_s *cmd_ctx, char *cmd,
char **args, int argc)
{
if (argc != 1)
{
command_print(cmd_ctx, "trunc <filename>");
return ERROR_INVALID_ARGUMENTS;
}
FILE *config_file = NULL;
config_file = fopen(args[0], "w");
if (config_file != NULL)
fclose(config_file);
return ERROR_OK;
}
int handle_meminfo_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
static int prev = 0;
struct mallinfo info;
if (argc != 0)
{
command_print(cmd_ctx, "meminfo");
return ERROR_INVALID_ARGUMENTS;
}
info = mallinfo();
if (prev > 0)
{
command_print(cmd_ctx, "Diff: %d", prev - info.fordblks);
}
prev = info.fordblks;
command_print(cmd_ctx, "Available ram: %d", info.fordblks );
return ERROR_OK;
}
static bool savePower;
static void setPower(bool power)
{
savePower = power;
if (power)
{
HAL_WRITE_UINT32(0x08000014, 0x8);
} else
{
HAL_WRITE_UINT32(0x08000010, 0x8);
}
}
int handle_power_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc > 1)
{
return ERROR_INVALID_ARGUMENTS;
}
if (argc == 1)
{
if (strcmp(args[0], "on") == 0)
{
setPower(1);
}
else if (strcmp(args[0], "off") == 0)
{
setPower(0);
} else
{
command_print(cmd_ctx, "arg is \"on\" or \"off\"");
return ERROR_INVALID_ARGUMENTS;
}
}
command_print(cmd_ctx, "Target power %s", savePower ? "on" : "off");
return ERROR_OK;
}
int handle_append_command(struct command_context_s *cmd_ctx, char *cmd,
char **args, int argc)
{
if (argc < 1)
{
command_print(cmd_ctx,
"append <filename> [<string1>, [<string2>, ...]]");
return ERROR_INVALID_ARGUMENTS;
}
FILE *config_file = NULL;
config_file = fopen(args[0], "a");
if (config_file != NULL)
{
int i;
fseek(config_file, 0, SEEK_END);
for (i = 1; i < argc; i++)
{
fwrite(args[i], strlen(args[i]), 1, config_file);
if (i != argc - 1)
{
fwrite(" ", 1, 1, config_file);
}
}
fwrite("\n", 1, 1, config_file);
fclose(config_file);
}
return ERROR_OK;
}
extern int telnet_socket;
int readMore(int fd, void *data, int length)
{
/* used in select() */
fd_set read_fds;
/* monitor sockets for acitvity */
int fd_max = 1;
FD_ZERO(&read_fds);
/* listen for new connections */
FD_SET(fd, &read_fds);
// Maximum 5 seconds.
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
int retval = select(fd_max + 1, &read_fds, NULL, NULL, &tv);
if (retval == 0)
{
diag_printf("Timed out waiting for binary payload\n");
return -1;
}
if (retval != 1)
return -1;
return read_socket(fd, data, length);
}
int readAll(int fd, void *data, int length)
{
int pos = 0;
for (;;)
{
int actual = readMore(fd, ((char *) data) + pos, length - pos);
// diag_printf("Read %d bytes(pos=%d, length=%d)\n", actual, pos, length);
if (actual <= 0)
return -1;
pos += actual;
if (pos == length)
break;
}
return length;
}
int handle_peek_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
cyg_uint32 value;
if (argc != 1)
{
return ERROR_INVALID_ARGUMENTS;
}
HAL_READ_UINT32(strtoul(args[0], NULL, 0), value);
command_print(cmd_ctx, "0x%x : 0x%x", strtoul(args[0], NULL, 0), value);
return ERROR_OK;
}
int handle_poke_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc != 2)
{
return ERROR_INVALID_ARGUMENTS;
}
HAL_WRITE_UINT32(strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0));
return ERROR_OK;
}
int handle_cp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc != 2)
{
return ERROR_INVALID_ARGUMENTS;
}
// NOTE!!! we only have line printing capability so we print the entire file as a single line.
void *data;
int len;
int retval = loadFile(args[0], &data, &len);
if (retval != ERROR_OK)
return retval;
FILE *f = fopen(args[1], "wb");
if (f == NULL)
retval = ERROR_INVALID_ARGUMENTS;
int pos = 0;
for (;;)
{
int chunk = len - pos;
static const int maxChunk = 512 * 1024; // ~1/sec
if (chunk > maxChunk)
{
chunk = maxChunk;
}
if ((retval==ERROR_OK)&&(fwrite(((char *)data)+pos, 1, chunk, f)!=chunk))
retval = ERROR_INVALID_ARGUMENTS;
if (retval != ERROR_OK)
{
break;
}
command_print(cmd_ctx, "%d", len - pos);
pos += chunk;
if (pos == len)
break;
}
if (retval == ERROR_OK)
{
command_print(cmd_ctx, "Copied %s to %s", args[0], args[1]);
} else
{
command_print(cmd_ctx, "Failed: %d", retval);
}
if (data != NULL)
free(data);
if (f != NULL)
fclose(f);
if (retval != ERROR_OK)
unlink(args[1]);
return retval;
}
#ifdef CYGPKG_PROFILE_GPROF
extern void start_profile();
int eCosBoard_handle_eCosBoard_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
command_print(cmd_ctx, "Profiling started");
start_profile();
return ERROR_OK;
}
#endif
externC void phi_init_all_network_interfaces();
command_context_t *cmd_ctx;
static bool webRunning = false;
void keep_webserver()
{
// Target initialisation is only attempted at startup, so we sleep forever and
// let the http server bail us out(i.e. get config files set up).
diag_printf("OpenOCD has invoked exit().\n"
"Use web server to correct any configuration settings and reboot.\n");
if (!webRunning)
reboot();
// exit() will terminate the current thread and we we'll then sleep eternally or
// we'll have a reboot scheduled.
}
extern void printDccChar(char c);
static char logBuffer[128 * 1024];
static const int logSize = sizeof(logBuffer);
int writePtr = 0;
int logCount = 0;
void _zylinjtag_diag_write_char(char c, void **param)
{
if (writeLog)
{
logBuffer[writePtr] = c;
writePtr = (writePtr + 1) % logSize;
logCount++;
}
if (serialLog)
{
if (c == '\n')
{
HAL_DIAG_WRITE_CHAR('\r');
}
HAL_DIAG_WRITE_CHAR(c);
}
printDccChar(c);
}
#define SHOW_RESULT(a, b) diag_printf(#a " failed %d\n", (int)b)
#define IOSIZE 512
static void copyfile(char *name2, char *name1)
{
int err;
char buf[IOSIZE];
int fd1, fd2;
ssize_t done, wrote;
fd1 = open(name1, O_WRONLY | O_CREAT);
if (fd1 < 0)
SHOW_RESULT( open, fd1 );
fd2 = open(name2, O_RDONLY);
if (fd2 < 0)
SHOW_RESULT( open, fd2 );
for (;;)
{
done = read(fd2, buf, IOSIZE );
if (done < 0)
{
SHOW_RESULT( read, done );
break;
}
if( done == 0 ) break;
wrote = write(fd1, buf, done);
if( wrote != done ) SHOW_RESULT( write, wrote );
if( wrote != done ) break;
}
err = close(fd1);
if( err < 0 ) SHOW_RESULT( close, err );
err = close(fd2);
if( err < 0 ) SHOW_RESULT( close, err );
}
static void copydir(char *name)
{
int err;
DIR *dirp;
mkdir("/ram/cgi", 0777);
dirp = opendir(name);
if( dirp == NULL ) SHOW_RESULT( opendir, -1 );
for (;;)
{
struct dirent *entry = readdir(dirp);
if (entry == NULL)
break;
if (strcmp(entry->d_name, ".") == 0)
continue;
if (strcmp(entry->d_name, "..") == 0)
continue;
bool isDir = false;
struct stat buf;
char fullPath[PATH_MAX];
strncpy(fullPath, name, PATH_MAX);
strcat(fullPath, "/");
strncat(fullPath, entry->d_name, PATH_MAX - strlen(fullPath));
if (stat(fullPath, &buf) == -1)
{
diag_printf("unable to read status from %s", fullPath);
break;
}
isDir = S_ISDIR(buf.st_mode) != 0;
if (isDir)
continue;
// diag_printf("<INFO>: entry %14s",entry->d_name);
char fullname[PATH_MAX];
char fullname2[PATH_MAX];
strcpy(fullname, name);
strcat(fullname, entry->d_name);
strcpy(fullname2, "/ram/cgi/");
strcat(fullname2, entry->d_name);
// diag_printf("from %s to %s\n", fullname, fullname2);
copyfile(fullname, fullname2);
// diag_printf("\n");
}
err = closedir(dirp);
if( err < 0 ) SHOW_RESULT( stat, err );
}
#if 0
MTAB_ENTRY( romfs_mte1,
"/rom",
"romfs",
"",
(CYG_ADDRWORD) &filedata[0] );
#endif
void openocd_sleep_prelude()
{
cyg_mutex_unlock(&httpstate.jim_lock);
}
void openocd_sleep_postlude()
{
cyg_mutex_lock(&httpstate.jim_lock);
}
static int
zylinjtag_Jim_Command_rm(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
int del;
if (argc != 2)
{
Jim_WrongNumArgs(interp, 1, argv, "rm ?dirorfile?");
return JIM_ERR;
}
del = 0;
if (unlink(Jim_GetString(argv[1], NULL)) == 0)
del = 1;
if (rmdir(Jim_GetString(argv[1], NULL)) == 0)
del = 1;
return del ? JIM_OK : JIM_ERR;
}
static int
zylinjtag_Jim_Command_ls(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
if (argc != 2)
{
Jim_WrongNumArgs(interp, 1, argv, "ls ?dir?");
return JIM_ERR;
}
char *name = (char*) Jim_GetString(argv[1], NULL);
DIR *dirp = NULL;
dirp = opendir(name);
if (dirp == NULL)
{
return JIM_ERR;
}
Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
for (;;)
{
struct dirent *entry = NULL;
entry = readdir(dirp);
if (entry == NULL)
break;
if ((strcmp(".", entry->d_name)==0)||(strcmp("..", entry->d_name)==0))
continue;
Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, entry->d_name, strlen(entry->d_name)));
}
closedir(dirp);
Jim_SetResult(interp, objPtr);
return JIM_OK;
}
static int
zylinjtag_Jim_Command_getmem(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
if (argc != 3)
{
Jim_WrongNumArgs(interp, 1, argv, "ls ?dir?");
return JIM_ERR;
}
long address;
long length;
if (Jim_GetLong(interp, argv[1], &address) != JIM_OK)
return JIM_ERR;
if (Jim_GetLong(interp, argv[2], &length) != JIM_OK)
return JIM_ERR;
if (length < 0 && length > (4096 * 1024))
{
Jim_WrongNumArgs(interp, 1, argv, "getmem ?dir?");
return JIM_ERR;
}
void *mem = malloc(length);
if (mem == NULL)
return JIM_ERR;
target_t *target = get_current_target(cmd_ctx);
int retval;
int size = 1;
int count = length;
if ((address % 4 == 0) && (count % 4 == 0))
{
size = 4;
count /= 4;
}
if ((retval = target->type->read_memory(target, address, size, count, mem)) != ERROR_OK)
{
free(mem);
return JIM_ERR;
}
Jim_Obj *objPtr = Jim_NewStringObj(interp, mem, length);
Jim_SetResult(interp, objPtr);
free(mem);
return JIM_OK;
}
static int
zylinjtag_Jim_Command_peek(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
if (argc != 2)
{
Jim_WrongNumArgs(interp, 1, argv, "peek ?address?");
return JIM_ERR;
}
long address;
if (Jim_GetLong(interp, argv[1], &address) != JIM_OK)
return JIM_ERR;
int value = *((volatile int *) address);
Jim_SetResult(interp, Jim_NewIntObj(interp, value));
return JIM_OK;
}
static int
zylinjtag_Jim_Command_poke(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
if (argc != 3)
{
Jim_WrongNumArgs(interp, 1, argv, "poke ?address? ?value?");
return JIM_ERR;
}
long address;
if (Jim_GetLong(interp, argv[1], &address) != JIM_OK)
return JIM_ERR;
long value;
if (Jim_GetLong(interp, argv[2], &value) != JIM_OK)
return JIM_ERR;
*((volatile int *) address) = value;
return JIM_OK;
}
static int
zylinjtag_Jim_Command_flash(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
int retval;
u32 base = 0;
flash_bank_t *t = get_flash_bank_by_num_noprobe(0);
if (t != NULL)
{
base = t->base;
retval = JIM_OK;
} else
{
retval = JIM_ERR;
}
if (retval == JIM_OK)
{
Jim_SetResult(interp, Jim_NewIntObj(interp, base));
}
return retval;
}
static int
zylinjtag_Jim_Command_log(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
if (logCount >= logSize)
{
Jim_AppendString(httpstate.jim_interp, tclOutput, logBuffer+logCount%logSize, logSize-logCount%logSize);
}
Jim_AppendString(httpstate.jim_interp, tclOutput, logBuffer, writePtr);
Jim_SetResult(interp, tclOutput);
return JIM_OK;
}
static int
zylinjtag_Jim_Command_reboot(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
reboot();
return JIM_OK;
}
static int
zylinjtag_Jim_Command_mac(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
int s;
struct ifreq ifr;
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s >= 0)
{
strcpy(ifr.ifr_name, "eth0");
int res;
res = ioctl(s, SIOCGIFHWADDR, &ifr);
close(s);
if (res < 0)
{
return JIM_OK;
}
}
Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
char hwaddr[512];
sprintf(hwaddr, "%02x:%02x:%02x:%02x:%02x:%02x",
(int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[0],
(int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[1],
(int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[2],
(int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[3],
(int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[4],
(int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[5]);
Jim_AppendString(httpstate.jim_interp, tclOutput, hwaddr, strlen(hwaddr));
Jim_SetResult(interp, tclOutput);
return JIM_OK;
}
static int
zylinjtag_Jim_Command_ip(Jim_Interp *interp,
int argc,
Jim_Obj * const *argv)
{
Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
struct ifaddrs *ifa = NULL, *ifp = NULL;
if (getifaddrs(&ifp) < 0)
{
return JIM_ERR;
}
for (ifa = ifp; ifa; ifa = ifa->ifa_next)
{
char ip[200];
socklen_t salen;
if (ifa->ifa_addr->sa_family == AF_INET)
salen = sizeof(struct sockaddr_in);
else if (ifa->ifa_addr->sa_family == AF_INET6)
salen = sizeof(struct sockaddr_in6);
else
continue;
if (getnameinfo(ifa->ifa_addr, salen, ip, sizeof(ip), NULL, 0,
NI_NUMERICHOST) < 0)
{
continue;
}
Jim_AppendString(httpstate.jim_interp, tclOutput, ip, strlen(ip));
break;
}
freeifaddrs(ifp);
Jim_SetResult(interp, tclOutput);
return JIM_OK;
}
extern Jim_Interp *interp;
static void zylinjtag_startNetwork()
{
// Bring TCP/IP up immediately before we're ready to accept commands.
//
// That is as soon as a PING responds, we're accepting telnet sessions.
#if defined(CYGPKG_NET_FREEBSD_STACK)
phi_init_all_network_interfaces();
#else
lwip_init();
#endif
if (!eth0_up)
{
diag_printf("Network not up and running\n");
exit(-1);
}
#if defined(CYGPKG_NET_FREEBSD_STACK)
/*start TFTP*/
tftpd_start(69, &fileops);
#endif
cyg_httpd_init_tcl_interpreter();
interp = httpstate.jim_interp;
Jim_CreateCommand(httpstate.jim_interp, "log", zylinjtag_Jim_Command_log, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "reboot", zylinjtag_Jim_Command_reboot, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "peek", zylinjtag_Jim_Command_peek, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "zy1000_flash", zylinjtag_Jim_Command_flash, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "poke", zylinjtag_Jim_Command_poke, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "ls", zylinjtag_Jim_Command_ls, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "getmem", zylinjtag_Jim_Command_getmem, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "mac", zylinjtag_Jim_Command_mac, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "ip", zylinjtag_Jim_Command_ip, NULL, NULL);
Jim_CreateCommand(httpstate.jim_interp, "rm", zylinjtag_Jim_Command_rm, NULL, NULL);
cyg_httpd_start();
webRunning = true;
diag_printf("Web server running\n");
}
static bool readPowerDropout()
{
cyg_uint32 state;
// sample and clear power dropout
HAL_WRITE_UINT32(0x08000010, 0x80);
HAL_READ_UINT32(0x08000010, state);
bool powerDropout;
powerDropout = (state & 0x80) != 0;
return powerDropout;
}
bool readSRST()
{
cyg_uint32 state;
// sample and clear SRST sensing
HAL_WRITE_UINT32(0x08000010, 0x00000040);
HAL_READ_UINT32(0x08000010, state);
bool srstAsserted;
srstAsserted = (state & 0x40) != 0;
return srstAsserted;
}
// every 300ms we check for reset & powerdropout and issue a "reset halt" if
// so.
static int sense_handler(void *priv)
{
struct command_context_s *cmd_ctx;
cmd_ctx = (struct command_context_s *) priv;
static bool prevSrstAsserted = false;
static bool prevPowerdropout = false;
bool powerDropout;
powerDropout = readPowerDropout();
bool powerRestored;
powerRestored = prevPowerdropout && !powerDropout;
if (powerRestored)
{
LOG_USER("Sensed power restore.");
}
cyg_tick_count_t current = cyg_current_time();
static cyg_tick_count_t lastPower = 0;
bool waitMore = lastPower + 200 > current;
if (powerDropout && !waitMore)
{
LOG_USER("Sensed power dropout.");
lastPower = current;
}
bool srstAsserted = readSRST();
bool srstDeasserted;
srstDeasserted = prevSrstAsserted && !srstAsserted;
static cyg_tick_count_t lastSrst = 0;
waitMore = lastSrst + 200 > current;
if (srstDeasserted && !waitMore)
{
LOG_USER("Sensed nSRST deasserted");
lastSrst = current;
}
if (!prevSrstAsserted && srstAsserted)
{
LOG_USER("Sensed nSRST asserted");
}
prevSrstAsserted = srstAsserted;
prevPowerdropout = powerDropout;
if (srstDeasserted || powerRestored)
{
/* Other than logging the event we can't do anything here.
* Issuing a reset is a particularly bad idea as we might
* be inside a reset already.
*/
}
return ERROR_OK;
}
static void
print_exception_handler(cyg_addrword_t data, cyg_code_t exception, cyg_addrword_t info)
{
writeLog = false;
serialLog = true;
char *infoStr = "unknown";
switch (exception)
{
case CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION:
infoStr = "undefined instruction";
break;
case CYGNUM_HAL_VECTOR_SOFTWARE_INTERRUPT:
infoStr = "software interrupt";
break;
case CYGNUM_HAL_VECTOR_ABORT_PREFETCH:
infoStr = "abort prefetch";
break;
case CYGNUM_HAL_VECTOR_ABORT_DATA:
infoStr = "abort data";
break;
default:
break;
}
diag_printf("Exception: %08x(%s) %08x\n", exception, infoStr, info);
diag_printf("Dumping log\n---\n");
if (logCount >= logSize)
{
diag_write(logBuffer + logCount % logSize, logSize - logCount % logSize);
}
diag_write(logBuffer, writePtr);
diag_printf("---\nLogdump complete.\n");
diag_printf("Exception: %08x(%s) %08x\n", exception, infoStr, info);
diag_printf("\n---\nRebooting\n");
HAL_PLATFORM_RESET();
}
static void setHandler(cyg_code_t exception)
{
cyg_exception_handler_t *old_handler;
cyg_addrword_t old_data;
cyg_exception_set_handler(exception,
print_exception_handler,
0,
&old_handler,
&old_data);
}
static cyg_thread zylinjtag_uart_thread_object;
static cyg_handle_t zylinjtag_uart_thread_handle;
static char uart_stack[4096];
static char forwardBuffer[1024]; // NB! must be smaller than a TCP/IP packet!!!!!
static char backwardBuffer[1024];
static cyg_io_handle_t serial_handle;
void setNoDelay(int session, int flag)
{
#if 1
// This decreases latency dramatically for e.g. GDB load which
// does not have a sliding window protocol
//
// Can cause *lots* of TCP/IP packets to be sent and it would have
// to be enabled/disabled on the fly to avoid the CPU being
// overloaded...
setsockopt(session, /* socket affected */
IPPROTO_TCP, /* set option at TCP level */
TCP_NODELAY, /* name of option */
(char *) &flag, /* the cast is historical
cruft */
sizeof(int)); /* length of option value */
#endif
}
struct
{
int req;
int actual;
int req2;
int actual2;
} tcpipSent[512 * 1024];
int cur;
static void
zylinjtag_uart(cyg_addrword_t data)
{
int so_reuseaddr_option = 1;
int fd;
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
LOG_ERROR("error creating socket: %s", strerror(errno));
exit(-1);
}
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*)&so_reuseaddr_option, sizeof(int));
struct sockaddr_in sin;
unsigned int address_size;
address_size = sizeof(sin);
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(5555);
if (bind(fd, (struct sockaddr *) &sin, sizeof(sin)) == -1)
{
LOG_ERROR("couldn't bind to socket: %s", strerror(errno));
exit(-1);
}
if (listen(fd, 1) == -1)
{
LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
exit(-1);
}
// socket_nonblock(fd);
for (;;)
{
int session = accept(fd, (struct sockaddr *) &sin, &address_size);
if (session < 0)
{
continue;
}
setNoDelay(session, 1);
int oldopts = fcntl(session, F_GETFL, 0);
fcntl(session, F_SETFL, oldopts | O_NONBLOCK); //
int serHandle = open("/dev/ser0", O_RDWR | O_NONBLOCK);
if (serHandle < 0)
{
close(session);
continue;
}
start_profile();
int actual = 0;
int actual2 = 0;
int pos, pos2;
pos = 0;
pos2 = 0;
cur = 0;
for (;;)
{
fd_set write_fds;
fd_set read_fds;
FD_ZERO(&write_fds);
FD_ZERO(&read_fds);
int fd_max = -1;
FD_SET(session, &read_fds);
fd_max = session;
FD_SET(serHandle, &read_fds);
if (serHandle > fd_max)
{
fd_max = serHandle;
}
/* Wait... */
cyg_thread_delay(5); // 50ms fixed delay to wait for data to be sent/received
if ((actual == 0) && (actual2 == 0))
{
int retval = select(fd_max + 1, &read_fds, NULL, NULL, NULL);
if (retval <= 0)
{
break;
}
}
if (actual2 <= 0)
{
memset(backwardBuffer, 's', sizeof(backwardBuffer));
actual2=read(serHandle, backwardBuffer, sizeof(backwardBuffer));
if (actual2 < 0)
{
if (errno != EAGAIN)
{
goto closeSession;
}
actual2 = 0;
}
pos2 = 0;
}
int x = actual2;
int y = 0;
if (actual2 > 0)
{
int written = write(session, backwardBuffer + pos2, actual2);
if (written <= 0)
goto closeSession;
actual2 -= written;
pos2 += written;
y = written;
}
if (FD_ISSET(session, &read_fds)&&(sizeof(forwardBuffer)>actual))
{
// NB! Here it is important that we empty the TCP/IP read buffer
// to make transmission tick right
memmove(forwardBuffer, forwardBuffer + pos, actual);
pos = 0;
int t;
// this will block if there is no data at all
t=read_socket(session, forwardBuffer+actual, sizeof(forwardBuffer)-actual);
if (t <= 0)
{
goto closeSession;
}
actual += t;
}
int x2 = actual;
int y2 = 0;
if (actual > 0)
{
/* Do not put things into the serial buffer if it has something to send
* as that can cause a single byte to be sent at the time.
*
*
*/
int written = write(serHandle, forwardBuffer + pos, actual);
if (written < 0)
{
if (errno != EAGAIN)
{
goto closeSession;
}
// The serial buffer is full
written = 0;
} else
{
actual -= written;
pos += written;
}
y2 = written;
}
if (cur < 1024)
{
tcpipSent[cur].req = x;
tcpipSent[cur].actual = y;
tcpipSent[cur].req2 = x2;
tcpipSent[cur].actual2 = y2;
cur++;
}
}
closeSession:
close(session);
close(serHandle);
int i;
for (i = 0; i < 1024; i++)
{
diag_printf("%d %d %d %d\n", tcpipSent[i].req, tcpipSent[i].actual, tcpipSent[i].req2, tcpipSent[i].actual2);
}
}
close(fd);
}
void startUart(void)
{
cyg_thread_create(1,
zylinjtag_uart,
(cyg_addrword_t)0,
"uart thread",
(void *)uart_stack,
sizeof(uart_stack),
&zylinjtag_uart_thread_handle,
&zylinjtag_uart_thread_object);
cyg_thread_set_priority(zylinjtag_uart_thread_handle, 1); // low priority as it sits in a busy loop
cyg_thread_resume(zylinjtag_uart_thread_handle);
}
int handle_uart_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc != 1)
{
command_print(cmd_ctx, "usage: uart <baudrate>");
return ERROR_INVALID_ARGUMENTS;
}
int baud = atol(args[0]);
switch (baud)
{
case 9600:
baud = CYGNUM_SERIAL_BAUD_9600;
break;
case 19200:
baud = CYGNUM_SERIAL_BAUD_19200;
break;
case 38400:
baud = CYGNUM_SERIAL_BAUD_38400;
break;
case 57600:
baud = CYGNUM_SERIAL_BAUD_57600;
break;
case 115200:
baud = CYGNUM_SERIAL_BAUD_115200;
break;
case 230400:
baud = CYGNUM_SERIAL_BAUD_230400;
break;
default:
command_print(cmd_ctx, "unsupported baudrate");
return ERROR_INVALID_ARGUMENTS;
}
cyg_serial_info_t buf;
cyg_uint32 len = 1;
//get existing serial configuration
len = sizeof(cyg_serial_info_t);
int err;
err = cyg_io_get_config(serial_handle, CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN, &buf, &len);
err = cyg_io_get_config(serial_handle, CYG_IO_GET_CONFIG_SERIAL_INFO, &buf, &len);
if (err != ENOERR)
{
command_print(cmd_ctx, "Failed to get serial port settings %d", err);
return ERROR_OK;
}
buf.baud = baud;
err = cyg_io_set_config(serial_handle, CYG_IO_SET_CONFIG_SERIAL_INFO, &buf, &len);
if (err != ENOERR)
{
command_print(cmd_ctx, "Failed to set serial port settings %d", err);
return ERROR_OK;
}
return ERROR_OK;
}
bool logAllToSerial = false;
/* boolean parameter stored on config */
bool boolParam(char *var)
{
bool result = false;
char *name = alloc_printf(ZYLIN_CONFIG_DIR "/%s", var);
if (name == NULL)
return result;
void *data;
int len;
if (loadFile(name, &data, &len) == ERROR_OK)
{
if (len > 1)
len = 1;
result = strncmp((char *) data, "1", len) == 0;
free(data);
}
free(name);
return result;
}
command_context_t *setup_command_handler();
int add_default_dirs(void)
{
add_script_search_dir(ZYLIN_CONFIG_DIR);
add_script_search_dir("/rom/lib/openocd");
add_script_search_dir("/rom");
return ERROR_OK;
}
int main(int argc, char *argv[])
{
setHandler(CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION);
setHandler(CYGNUM_HAL_VECTOR_ABORT_PREFETCH);
setHandler(CYGNUM_HAL_VECTOR_ABORT_DATA);
int err;
err = cyg_io_lookup("/dev/ser0", &serial_handle);
if (err != ENOERR)
{
diag_printf("/dev/ser0 not found\n");
reboot();
}
setPower(true); // on by default
atexit(keep_webserver);
err = mount("", "/ram", "ramfs");
if (err < 0)
{
diag_printf("unable to mount ramfs\n");
}
chdir("/ram");
char address[16];
sprintf(address, "%p", &filedata[0]);
err = mount(address, "/rom", "romfs");
if (err < 0)
{
diag_printf("unable to mount /rom\n");
}
err = mount("", "/log", "logfs");
if (err < 0)
{
diag_printf("unable to mount logfs\n");
}
err = mount("", "/tftp", "tftpfs");
if (err < 0)
{
diag_printf("unable to mount logfs\n");
}
log = fopen("/log/log", "w");
if (log == NULL)
{
diag_printf("Could not open log file /ram/log\n");
exit(-1);
}
diag_init_putc(_zylinjtag_diag_write_char);
// We want this in the log.
diag_printf("Zylin ZY1000. Copyright Zylin AS 2007-2008.\n");
diag_printf("%s\n", ZYLIN_OPENOCD_VERSION);
copydir("/rom/");
err = mount("/dev/flash1", "/config", "jffs2");
if (err < 0)
{
diag_printf("unable to mount jffs\n");
}
mkdir(ZYLIN_CONFIG_DIR, 0777);
mkdir(ZYLIN_CONFIG_DIR "/target", 0777);
mkdir(ZYLIN_CONFIG_DIR "/event", 0777);
logAllToSerial = boolParam("logserial");
// We need the network & web server in case there is something wrong with
// the config files that invoke exit()
zylinjtag_startNetwork();
/* we're going to access the jim interpreter from here on... */
openocd_sleep_postlude();
startUart();
add_default_dirs();
/* initialize commandline interface */
command_context_t *cmd_ctx;
cmd_ctx = setup_command_handler();
command_set_output_handler(cmd_ctx, configuration_output_handler, NULL);
command_context_mode(cmd_ctx, COMMAND_CONFIG);
register_command(cmd_ctx, NULL, "zy1000_version", handle_zy1000_version_command,
COMMAND_EXEC, "show zy1000 version numbers");
register_command(cmd_ctx, NULL, "rm", handle_rm_command, COMMAND_ANY,
"rm <filname>");
register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
"same args as load_image, image stored in memory");
register_command(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY,
"loads active fast load image to current target");
register_command(cmd_ctx, NULL, "cat", handle_cat_command, COMMAND_ANY,
"cat <filname>");
register_command(cmd_ctx, NULL, "trunc", handle_trunc_command, COMMAND_ANY,
"trunc <filname>");
register_command(cmd_ctx, NULL, "append_file", handle_append_command,
COMMAND_ANY, "append <filname>");
register_command(cmd_ctx, NULL, "power", handle_power_command, COMMAND_ANY,
"power <on/off> - turn power switch to target on/off. No arguments - print status.");
register_command(cmd_ctx, NULL, "meminfo", handle_meminfo_command,
COMMAND_ANY, "meminfo");
register_command(cmd_ctx, NULL, "cp", handle_cp_command,
COMMAND_ANY, "cp <from> <to>");
#ifdef CYGPKG_PROFILE_GPROF
register_command(cmd_ctx, NULL, "ecosboard_profile", eCosBoard_handle_eCosBoard_profile_command,
COMMAND_ANY, NULL);
#endif
register_command(cmd_ctx, NULL, "uart", handle_uart_command,
COMMAND_ANY, "uart <baud> - forward uart on port 5555");
int errVal;
errVal = log_init(cmd_ctx);
if (errVal != ERROR_OK)
{
diag_printf("log_init() failed %d\n", errVal);
exit(-1);
}
set_log_output(cmd_ctx, log);
LOG_DEBUG("log init complete");
// diag_printf("Executing config files\n");
if (logAllToSerial)
{
diag_printf(ZYLIN_CONFIG_DIR "/logserial=1 => sending log output to serial port using \"debug_level 3\" as default.\n");
command_run_line(cmd_ctx, "debug_level 3");
}
zylinjtag_parse_config_file(cmd_ctx, "/rom/openocd.cfg");
target_register_timer_callback(sense_handler, 200, 1, cmd_ctx);
// FIX!!! Yuk!
// diag_printf() is really invoked from many more places than we trust it
// not to cause instabilities(e.g. invoking fputc() from an interrupt is *BAD*).
//
// Disabling it here is safe and gives us enough logged debug output for now. Crossing
// fingers that it doesn't cause any crashes.
diag_printf("Init complete, GDB & telnet servers launched.\n");
command_set_output_handler(cmd_ctx, zy1000_configuration_output_handler_log, NULL);
if (!logAllToSerial)
{
serialLog = false;
}
/* handle network connections */
server_loop(cmd_ctx);
openocd_sleep_prelude();
/* shut server down */
server_quit();
/* free commandline interface */
command_done(cmd_ctx);
umount("/config");
exit(0);
for (;;);
}
cyg_int32
cyg_httpd_exec_cgi_tcl(char *file_name);
cyg_int32 homeForm(CYG_HTTPD_STATE *p)
{
cyg_httpd_exec_cgi_tcl("/ram/cgi/index.tcl");
return 0;
}
CYG_HTTPD_HANDLER_TABLE_ENTRY(root_label, "/", homeForm);
CYG_HTTPD_MIME_TABLE_ENTRY(text_mime_label, "text", "text/plain");
CYG_HTTPD_MIME_TABLE_ENTRY(bin_mime_label, "bin", "application/octet-stream");
#include <pkgconf/system.h>
#include <pkgconf/hal.h>
#include <pkgconf/kernel.h>
#include <pkgconf/io_fileio.h>
#include <pkgconf/fs_rom.h>
#include <cyg/kernel/ktypes.h> // base kernel types
#include <cyg/infra/cyg_trac.h> // tracing macros
#include <cyg/infra/cyg_ass.h> // assertion macros
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <dirent.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cyg/fileio/fileio.h>
#include <cyg/kernel/kapi.h>
#include <cyg/infra/diag.h>
//==========================================================================
// Eventually we want to eXecute In Place from the ROM in a protected
// environment, so we'll need executables to be aligned to a boundary
// suitable for MMU protection. A suitable boundary would be the 4k
// boundary in all the CPU architectures I am currently aware of.
// Forward definitions
// Filesystem operations
static int tftpfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte);
static int tftpfs_umount(cyg_mtab_entry *mte);
static int tftpfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
int mode, cyg_file *fte);
static int tftpfs_fo_read(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio);
static int tftpfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio);
// File operations
static int tftpfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode);
static int tftpfs_fo_close(struct CYG_FILE_TAG *fp);
static int tftpfs_fo_lseek(struct CYG_FILE_TAG *fp, off_t *apos, int whence);
//==========================================================================
// Filesystem table entries
// -------------------------------------------------------------------------
// Fstab entry.
// This defines the entry in the filesystem table.
// For simplicity we use _FILESYSTEM synchronization for all accesses since
// we should never block in any filesystem operations.
#if 1
FSTAB_ENTRY( tftpfs_fste, "tftpfs", 0,
CYG_SYNCMODE_NONE,
tftpfs_mount,
tftpfs_umount,
tftpfs_open,
(cyg_fsop_unlink *)cyg_fileio_erofs,
(cyg_fsop_mkdir *)cyg_fileio_erofs,
(cyg_fsop_rmdir *)cyg_fileio_erofs,
(cyg_fsop_rename *)cyg_fileio_erofs,
(cyg_fsop_link *)cyg_fileio_erofs,
(cyg_fsop_opendir *)cyg_fileio_erofs,
(cyg_fsop_chdir *)cyg_fileio_erofs,
(cyg_fsop_stat *)cyg_fileio_erofs,
(cyg_fsop_getinfo *)cyg_fileio_erofs,
(cyg_fsop_setinfo *)cyg_fileio_erofs);
#endif
// -------------------------------------------------------------------------
// mtab entry.
// This defines a single ROMFS loaded into ROM at the configured address
//
// MTAB_ENTRY( rom_mte, // structure name
// "/rom", // mount point
// "romfs", // FIlesystem type
// "", // hardware device
// (CYG_ADDRWORD) CYGNUM_FS_ROM_BASE_ADDRESS // Address in ROM
// );
// -------------------------------------------------------------------------
// File operations.
// This set of file operations are used for normal open files.
static cyg_fileops tftpfs_fileops =
{
tftpfs_fo_read,
tftpfs_fo_write,
tftpfs_fo_lseek,
(cyg_fileop_ioctl *)cyg_fileio_erofs,
cyg_fileio_seltrue,
tftpfs_fo_fsync,
tftpfs_fo_close,
(cyg_fileop_fstat *) cyg_fileio_erofs,
(cyg_fileop_getinfo *) cyg_fileio_erofs,
(cyg_fileop_setinfo *)cyg_fileio_erofs,
};
// -------------------------------------------------------------------------
// tftpfs_mount()
// Process a mount request. This mainly finds root for the
// filesystem.
static int tftpfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte)
{
return ENOERR;
}
static int tftpfs_umount(cyg_mtab_entry *mte)
{
return ENOERR;
}
struct Tftp
{
int write;
int readFile;
cyg_uint8 *mem;
int actual;
char *server;
char *file;
};
static void freeTftp(struct Tftp *t)
{
if (t == NULL)
return;
if (t->mem)
free(t->mem);
if (t->server)
free(t->server);
if (t->file)
free(t->file);
free(t);
}
static const int tftpMaxSize = 8192 * 1024;
static int tftpfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
int mode, cyg_file *file)
{
struct Tftp *tftp;
tftp = malloc(sizeof(struct Tftp));
if (tftp == NULL)
return EMFILE;
memset(tftp, 0, sizeof(struct Tftp));
file->f_flag |= mode & CYG_FILE_MODE_MASK;
file->f_type = CYG_FILE_TYPE_FILE;
file->f_ops = &tftpfs_fileops;
file->f_offset = 0;
file->f_data = 0;
file->f_xops = 0;
tftp->mem = malloc(tftpMaxSize);
if (tftp->mem == NULL)
{
freeTftp(tftp);
return EMFILE;
}
char *server = strchr(name, '/');
if (server == NULL)
{
freeTftp(tftp);
return EMFILE;
}
tftp->server = malloc(server - name + 1);
if (tftp->server == NULL)
{
freeTftp(tftp);
return EMFILE;
}
strncpy(tftp->server, name, server - name);
tftp->server[server - name] = 0;
tftp->file = strdup(server + 1);
if (tftp->file == NULL)
{
freeTftp(tftp);
return EMFILE;
}
file->f_data = (CYG_ADDRWORD) tftp;
return ENOERR;
}
static int fetchTftp(struct Tftp *tftp)
{
if (!tftp->readFile)
{
int err;
tftp->actual = tftp_client_get( tftp->file, tftp->server, 0, tftp->mem, tftpMaxSize, TFTP_OCTET, &err);
if (tftp->actual < 0)
{
return EMFILE;
}
tftp->readFile = 1;
}
return ENOERR;
}
// -------------------------------------------------------------------------
// tftpfs_fo_write()
// Read data from file.
static int
tftpfs_fo_read(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio)
{
struct Tftp *tftp = (struct Tftp *) fp->f_data;
if (fetchTftp(tftp) != ENOERR)
return EMFILE;
int i;
off_t pos = fp->f_offset;
int resid = 0;
for (i = 0; i < uio->uio_iovcnt; i++)
{
cyg_iovec *iov = &uio->uio_iov[i];
char *buf = (char *) iov->iov_base;
off_t len = iov->iov_len;
if (len + pos > tftp->actual)
{
len = tftp->actual - pos;
}
resid += iov->iov_len - len;
memcpy(buf, tftp->mem + pos, len);
pos += len;
}
uio->uio_resid = resid;
fp->f_offset = pos;
return ENOERR;
}
static int
tftpfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio)
{
struct Tftp *tftp = (struct Tftp *) fp->f_data;
int i;
off_t pos = fp->f_offset;
int resid = 0;
for (i = 0; i < uio->uio_iovcnt; i++)
{
cyg_iovec *iov = &uio->uio_iov[i];
char *buf = (char *) iov->iov_base;
off_t len = iov->iov_len;
if (len + pos > tftpMaxSize)
{
len = tftpMaxSize - pos;
}
resid += iov->iov_len - len;
memcpy(tftp->mem + pos, buf, len);
pos += len;
}
uio->uio_resid = resid;
fp->f_offset = pos;
tftp->write = 1;
return ENOERR;
}
static int
tftpfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode)
{
int error = ENOERR;
return error;
}
// -------------------------------------------------------------------------
// romfs_fo_close()
// Close a file. We just clear out the data pointer.
static int tftpfs_fo_close(struct CYG_FILE_TAG *fp)
{
struct Tftp *tftp = (struct Tftp *) fp->f_data;
int error = ENOERR;
if (tftp->write)
{
tftp_client_put( tftp->file, tftp->server, 0, tftp->mem, fp->f_offset, TFTP_OCTET, &error);
}
freeTftp(tftp);
fp->f_data = 0;
return error;
}
// -------------------------------------------------------------------------
// romfs_fo_lseek()
// Seek to a new file position.
static int tftpfs_fo_lseek(struct CYG_FILE_TAG *fp, off_t *apos, int whence)
{
struct Tftp *tftp = (struct Tftp *) fp->f_data;
off_t pos = *apos;
if (fetchTftp(tftp) != ENOERR)
return EMFILE;
switch (whence)
{
case SEEK_SET:
// Pos is already where we want to be.
break;
case SEEK_CUR:
// Add pos to current offset.
pos += fp->f_offset;
break;
case SEEK_END:
// Add pos to file size.
pos += tftp->actual;
break;
default:
return EINVAL;
}
// Check that pos is still within current file size, or at the
// very end.
if (pos < 0 || pos > tftp->actual)
return EINVAL;
// All OK, set fp offset and return new position.
*apos = fp->f_offset = pos;
return ENOERR;
}
void usleep(int us)
{
if (us > 10000)
cyg_thread_delay(us / 10000 + 1);
else
HAL_DELAY_US(us);
}
// Chunked version.
cyg_int32
show_log_entry(CYG_HTTPD_STATE *phttpstate)
{
cyg_httpd_start_chunked("text");
if (logCount >= logSize)
{
cyg_httpd_write_chunked(logBuffer+logCount%logSize, logSize-logCount%logSize);
}
cyg_httpd_write_chunked(logBuffer, writePtr);
cyg_httpd_end_chunked();
return -1;
}
CYG_HTTPD_HANDLER_TABLE_ENTRY(show_log, "/ram/log", show_log_entry);
// Filesystem operations
static int logfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte);
static int logfs_umount(cyg_mtab_entry *mte);
static int logfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
int mode, cyg_file *fte);
static int
logfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio);
// File operations
static int logfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode);
static int logfs_fo_close(struct CYG_FILE_TAG *fp);
//==========================================================================
// Filesystem table entries
// -------------------------------------------------------------------------
// Fstab entry.
// This defines the entry in the filesystem table.
// For simplicity we use _FILESYSTEM synchronization for all accesses since
// we should never block in any filesystem operations.
FSTAB_ENTRY( logfs_fste, "logfs", 0,
CYG_SYNCMODE_FILE_FILESYSTEM|CYG_SYNCMODE_IO_FILESYSTEM,
logfs_mount,
logfs_umount,
logfs_open,
(cyg_fsop_unlink *)cyg_fileio_erofs,
(cyg_fsop_mkdir *)cyg_fileio_erofs,
(cyg_fsop_rmdir *)cyg_fileio_erofs,
(cyg_fsop_rename *)cyg_fileio_erofs,
(cyg_fsop_link *)cyg_fileio_erofs,
(cyg_fsop_opendir *)cyg_fileio_erofs,
(cyg_fsop_chdir *)cyg_fileio_erofs,
(cyg_fsop_stat *)cyg_fileio_erofs,
(cyg_fsop_getinfo *)cyg_fileio_erofs,
(cyg_fsop_setinfo *)cyg_fileio_erofs);
// -------------------------------------------------------------------------
// File operations.
// This set of file operations are used for normal open files.
static cyg_fileops logfs_fileops =
{
(cyg_fileop_read *)cyg_fileio_erofs,
(cyg_fileop_write *)logfs_fo_write,
(cyg_fileop_lseek *) cyg_fileio_erofs,
(cyg_fileop_ioctl *)cyg_fileio_erofs,
cyg_fileio_seltrue,
logfs_fo_fsync,
logfs_fo_close,
(cyg_fileop_fstat *)cyg_fileio_erofs,
(cyg_fileop_getinfo *) cyg_fileio_erofs,
(cyg_fileop_setinfo *)cyg_fileio_erofs,
};
// -------------------------------------------------------------------------
// logfs_mount()
// Process a mount request. This mainly finds root for the
// filesystem.
static int logfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte)
{
return ENOERR;
}
static int logfs_umount(cyg_mtab_entry *mte)
{
return ENOERR;
}
static int logfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
int mode, cyg_file *file)
{
file->f_flag |= mode & CYG_FILE_MODE_MASK;
file->f_type = CYG_FILE_TYPE_FILE;
file->f_ops = &logfs_fileops;
file->f_offset = 0;
file->f_data = 0;
file->f_xops = 0;
return ENOERR;
}
// -------------------------------------------------------------------------
// logfs_fo_write()
// Write data to file.
static int
logfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio)
{
int i;
for (i = 0; i < uio->uio_iovcnt; i++)
{
cyg_iovec *iov = &uio->uio_iov[i];
char *buf = (char *) iov->iov_base;
off_t len = iov->iov_len;
diag_write(buf, len);
}
uio->uio_resid = 0;
return ENOERR;
}
static int
logfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode)
{
return ENOERR;
}
// -------------------------------------------------------------------------
// romfs_fo_close()
// Close a file. We just clear out the data pointer.
static int logfs_fo_close(struct CYG_FILE_TAG *fp)
{
return ENOERR;
}