ZY1000 code

git-svn-id: svn://svn.berlios.de/openocd/trunk@1005 b42882b7-edfa-0310-969c-e2dbd0fdcd60

1 files changed, 2403 insertions, 0 deletions

diff --git a/src/ecosboard.c b/src/ecosboard.c
new file mode 100644
index 0000000..44c0f0b
--- /dev/null
+++ b/src/ecosboard.c
@@ -0,0 +1,2403 @@
+/***************************************************************************

+ *   Copyright (C) 2007-2008 by Ø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

+

+#define ZYLIN_VERSION "1.42"

+#define ZYLIN_DATE __DATE__

+#define ZYLIN_TIME __TIME__

+#define ZYLIN_OPENOCD 921

+#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;

+}