src/ecosboard.c

   1 /***************************************************************************
   2  *   Copyright (C) 2007-2008 by Øyvind Harboe                              *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  18  ***************************************************************************/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "types.h"
  25 #include "jtag.h"
  26 #include "configuration.h"
  27 #include "xsvf.h"
  28 #include "svf.h"
  29 #include "nand.h"
  30 #include "pld.h"
  31
  32 #include "server.h"
  33 #include "telnet_server.h"
  34 #include "gdb_server.h"
  35 #include "openocd.h"
  36
  37 #include <time_support.h>
  38 #include <sys/time.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <errno.h>
  44
  45 #include <cyg/io/flash.h>
  46 #include <pkgconf/fs_jffs2.h>   // Address of JFFS2
  47 #include <network.h>
  48
  49 #include <fcntl.h>
  50 #include <sys/stat.h>
  51 #include <cyg/fileio/fileio.h>
  52 #include <dirent.h>
  53 #include <cyg/athttpd/http.h>
  54 #include <cyg/athttpd/socket.h>
  55 #include <cyg/athttpd/handler.h>
  56 #include <cyg/athttpd/cgi.h>
  57 #include <cyg/athttpd/forms.h>
  58 #include <cyg/discover/discover.h>
  59 #include <cyg/hal/hal_diag.h>
  60 #include <cyg/kernel/kapi.h>
  61 #include <cyg/io/serialio.h>
  62 #include <cyg/io/io.h>
  63 #include <netinet/tcp.h>
  64 #include "rom.h"
  65 #include <sys/ioctl.h>
  66 #include <sys/socket.h>
  67 #include <netinet/in.h>
  68 #include <net/if.h>
  69 #include <arpa/inet.h>
  70 #include <sys/types.h>
  71 #include <sys/socket.h>
  72 #include <netdb.h>
  73 #include <netinet/in.h>
  74 #include <unistd.h>
  75 #include <arpa/inet.h>
  76 #include <stdio.h>
  77 #include <ifaddrs.h>
  78 #include <string.h>
  79
  80 #include <unistd.h>
  81 #include <stdio.h>
  82
  83
  84 #define MAX_IFS 64
  85 #if defined(CYGPKG_NET_FREEBSD_STACK)
  86 #include <tftp_support.h>
  87 /* posix compatibility broken*/
  88 struct tftpd_fileops fileops =
  89 {
  90         (int (*)(const char *, int))open,
  91         close,
  92         (int (*)(int, const void *, int))write,
  93         (int (*)(int, void *, int))read
  94 };
  95
  96 #endif
  97
  98
  99 void diag_write(char *buf, int len)
 100 {
 101         int j;
 102         for (j = 0; j < len; j++)
 103         {
 104                 diag_printf("%c", buf[j]);
 105         }
 106 }
 107
 108 static bool serialLog = true;
 109 static bool writeLog = true;
 110
 111 char hwaddr[512];
 112
 113
 114 extern struct flash_driver *flash_drivers[];
 115 extern struct target_type *target_types[];
 116
 117 #ifdef CYGPKG_PROFILE_GPROF
 118 #include <cyg/profile/profile.h>
 119
 120 extern char _stext, _etext; // Defined by the linker
 121
 122 static char *start_of_code=&_stext;
 123 static char *end_of_code=&_etext;
 124
 125 void start_profile(void)
 126 {
 127         // This starts up the system-wide profiling, gathering
 128         // profile information on all of the code, with a 16 byte
 129         // "bucket" size, at a rate of 100us/profile hit.
 130         // Note: a bucket size of 16 will give pretty good function
 131         //       resolution.  Much smaller and the buffer becomes
 132         //       much too large for very little gain.
 133         // Note: a timer period of 100us is also a reasonable
 134         //       compromise.  Any smaller and the overhead of
 135         //       handling the timter (profile) interrupt could
 136         //       swamp the system.  A fast processor might get
 137         //       by with a smaller value, but a slow one could
 138         //       even be swamped by this value.  If the value is
 139         //       too large, the usefulness of the profile is reduced.
 140
 141         // no more interrupts than 1/10ms.
 142         //profile_on((void *)0, (void *)0x40000, 16, 10000); // SRAM
 143         //      profile_on(0, &_etext, 16, 10000); // SRAM & DRAM
 144         profile_on(start_of_code, end_of_code, 16, 10000); // Nios DRAM
 145 }
 146 #endif
 147
 148 static FILE *log;
 149
 150 static char reboot_stack[2048];
 151
 152 static void zylinjtag_reboot(cyg_addrword_t data)
 153 {
 154         serialLog = true;
 155         diag_printf("Rebooting in 500 ticks..\n");
 156         cyg_thread_delay(500);
 157         diag_printf("Unmounting /config..\n");
 158         umount("/config");
 159         diag_printf("Rebooting..\n");
 160         HAL_PLATFORM_RESET();
 161 }
 162 static cyg_thread zylinjtag_thread_object;
 163 static cyg_handle_t zylinjtag_thread_handle;
 164
 165 void reboot(void)
 166 {
 167         cyg_thread_create(1, zylinjtag_reboot, (cyg_addrword_t) 0, "reboot Thread",
 168                         (void *) reboot_stack, sizeof(reboot_stack),
 169                         &zylinjtag_thread_handle, &zylinjtag_thread_object);
 170         cyg_thread_resume(zylinjtag_thread_handle);
 171 }
 172
 173 static char zylinjtag_reboot_port_stack[2048];
 174 static cyg_thread zylinjtag_reboot_port_thread_object;
 175 static cyg_handle_t zylinjtag_reboot_port_thread_handle;
 176
 177 static void zylinjtag_reboot_port_task(cyg_addrword_t data)
 178 {
 179         int so_reuseaddr_option = 1;
 180
 181         int fd;
 182         if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
 183         {
 184                 LOG_ERROR("error creating socket: %s", strerror(errno));
 185                 exit(-1);
 186         }
 187
 188         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*) &so_reuseaddr_option,
 189                         sizeof(int));
 190
 191         struct sockaddr_in sin;
 192         unsigned int address_size;
 193         address_size = sizeof(sin);
 194         memset(&sin, 0, sizeof(sin));
 195         sin.sin_family = AF_INET;
 196         sin.sin_addr.s_addr = INADDR_ANY;
 197         sin.sin_port = htons(1234);
 198
 199         if (bind(fd, (struct sockaddr *) &sin, sizeof(sin)) == -1)
 200         {
 201                 LOG_ERROR("couldn't bind to socket: %s", strerror(errno));
 202                 exit(-1);
 203         }
 204
 205         if (listen(fd, 1) == -1)
 206         {
 207                 LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
 208                 exit(-1);
 209         }
 210         //      socket_nonblock(fd);
 211
 212
 213         accept(fd, (struct sockaddr *) &sin, &address_size);
 214
 215         diag_printf("Got reboot signal on port 1234");
 216
 217         reboot();
 218
 219 }
 220
 221 void reboot_port(void)
 222 {
 223         cyg_thread_create(1, zylinjtag_reboot_port_task, (cyg_addrword_t) 0, "wait for reboot signal on port 1234",
 224                         (void *) zylinjtag_reboot_port_stack, sizeof(zylinjtag_reboot_port_stack),
 225                         &zylinjtag_reboot_port_thread_handle, &zylinjtag_reboot_port_thread_object);
 226         cyg_thread_resume(zylinjtag_reboot_port_thread_handle);
 227 }
 228
 229 int configuration_output_handler(struct command_context *context,
 230                 const char* line)
 231 {
 232         diag_printf("%s", line);
 233
 234         return ERROR_OK;
 235 }
 236
 237 int zy1000_configuration_output_handler_log(struct command_context *context,
 238                 const char* line)
 239 {
 240         LOG_USER_N("%s", line);
 241
 242         return ERROR_OK;
 243 }
 244
 245 #ifdef CYGPKG_PROFILE_GPROF
 246
 247 int eCosBoard_handle_eCosBoard_profile_command(struct command_context *cmd_ctx, char *cmd, char **args, int argc)
 248 {
 249         command_print(cmd_ctx, "Profiling started");
 250         start_profile();
 251         return ERROR_OK;
 252 }
 253
 254 #endif
 255
 256 externC void phi_init_all_network_interfaces(void);
 257
 258 struct command_context *cmd_ctx;
 259
 260 static bool webRunning = false;
 261
 262 void keep_webserver(void)
 263 {
 264         // Target initialisation is only attempted at startup, so we sleep forever and
 265         // let the http server bail us out(i.e. get config files set up).
 266         diag_printf("OpenOCD has invoked exit().\n"
 267                 "Use web server to correct any configuration settings and reboot.\n");
 268         if (!webRunning)
 269                 reboot();
 270
 271         // exit() will terminate the current thread and we we'll then sleep eternally or
 272         // we'll have a reboot scheduled.
 273 }
 274
 275 extern void printDccChar(char c);
 276
 277 static char logBuffer[128 * 1024];
 278 static const int logSize = sizeof(logBuffer);
 279 int writePtr = 0;
 280 int logCount = 0;
 281
 282 void _zylinjtag_diag_write_char(char c, void **param)
 283 {
 284         if (writeLog)
 285         {
 286                 logBuffer[writePtr] = c;
 287                 writePtr = (writePtr + 1) % logSize;
 288                 logCount++;
 289         }
 290         if (serialLog)
 291         {
 292                 if (c == '\n')
 293                 {
 294                         HAL_DIAG_WRITE_CHAR('\r');
 295                 }
 296                 HAL_DIAG_WRITE_CHAR(c);
 297         }
 298
 299 #ifdef CYGPKG_HAL_ZYLIN_PHI
 300         printDccChar(c);
 301 #endif
 302 }
 303
 304 void copyfile(char *name2, char *name1);
 305
 306 void copydir(char *name, char *destdir);
 307
 308 #if 0
 309 MTAB_ENTRY(romfs_mte1,
 310                 "/rom",
 311                 "romfs",
 312                 "",
 313                 (CYG_ADDRWORD) &filedata[0]);
 314 #endif
 315
 316 void openocd_sleep_prelude(void)
 317 {
 318         cyg_mutex_unlock(&httpstate.jim_lock);
 319 }
 320
 321 void openocd_sleep_postlude(void)
 322 {
 323         cyg_mutex_lock(&httpstate.jim_lock);
 324 }
 325
 326 void format(void)
 327 {
 328 #ifdef CYGDAT_IO_FLASH_BLOCK_DEVICE_NAME_1
 329         diag_printf("Formatting JFFS2...\n");
 330
 331         cyg_io_handle_t handle;
 332
 333         Cyg_ErrNo err;
 334         err = cyg_io_lookup(CYGDAT_IO_FLASH_BLOCK_DEVICE_NAME_1, &handle);
 335         if (err != ENOERR)
 336         {
 337                 diag_printf("Flash Error cyg_io_lookup: %d\n", err);
 338                 reboot();
 339         }
 340
 341         cyg_uint32 len;
 342         cyg_io_flash_getconfig_devsize_t ds;
 343         len = sizeof(ds);
 344         err = cyg_io_get_config(handle, CYG_IO_GET_CONFIG_FLASH_DEVSIZE, &ds, &len);
 345         if (err != ENOERR)
 346         {
 347                 diag_printf("Flash error cyg_io_get_config %d\n", err);
 348                 reboot();
 349         }
 350
 351         cyg_io_flash_getconfig_erase_t e;
 352         len = sizeof(e);
 353
 354         e.offset = 0;
 355         e.len = ds.dev_size;
 356
 357         diag_printf("Formatting 0x%08x bytes\n", (int)ds.dev_size);
 358         err = cyg_io_get_config(handle, CYG_IO_GET_CONFIG_FLASH_ERASE, &e, &len);
 359         if (err != ENOERR)
 360         {
 361                 diag_printf("Flash erase error %d offset 0x%08x\n", err, e.err_address);
 362                 reboot();
 363         }
 364
 365         diag_printf("Flash formatted successfully\n");
 366 #endif
 367
 368         reboot();
 369 }
 370
 371 static int zylinjtag_Jim_Command_format_jffs2(Jim_Interp *interp, int argc,
 372                 Jim_Obj * const *argv)
 373 {
 374         if (argc != 1)
 375         {
 376                 return JIM_ERR;
 377         }
 378
 379         format();
 380         for (;;)
 381                 ;
 382 }
 383
 384 static int zylinjtag_Jim_Command_threads(Jim_Interp *interp, int argc,
 385                 Jim_Obj * const *argv)
 386 {
 387         cyg_handle_t thread = 0;
 388         cyg_uint16 id = 0;
 389         Jim_Obj *threads = Jim_NewListObj(interp, NULL, 0);
 390
 391         /* Loop over the threads, and generate a table row for
 392          * each.
 393          */
 394         while (cyg_thread_get_next(&thread, &id))
 395         {
 396                 Jim_Obj *threadObj = Jim_NewListObj(interp, NULL, 0);
 397
 398                 cyg_thread_info info;
 399                 char *state_string;
 400
 401                 cyg_thread_get_info(thread, id, &info);
 402
 403                 if (info.name == NULL)
 404                         info.name = "<no name>";
 405
 406                 Jim_ListAppendElement(interp, threadObj, Jim_NewStringObj(interp,
 407                                 info.name, strlen(info.name)));
 408
 409                 /* Translate the state into a string.
 410                  */
 411                 if (info.state == 0)
 412                         state_string = "RUN";
 413                 else if (info.state & 0x04)
 414                         state_string = "SUSP";
 415                 else
 416                         switch (info.state & 0x1b)
 417                         {
 418                         case 0x01:
 419                                 state_string = "SLEEP";
 420                                 break;
 421                         case 0x02:
 422                                 state_string = "CNTSLEEP";
 423                                 break;
 424                         case 0x08:
 425                                 state_string = "CREATE";
 426                                 break;
 427                         case 0x10:
 428                                 state_string = "EXIT";
 429                                 break;
 430                         default:
 431                                 state_string = "????";
 432                                 break;
 433                         }
 434
 435                 Jim_ListAppendElement(interp, threadObj, Jim_NewStringObj(interp,
 436                                 state_string, strlen(state_string)));
 437
 438                 Jim_ListAppendElement(interp, threadObj, Jim_NewIntObj(interp, id));
 439                 Jim_ListAppendElement(interp, threadObj, Jim_NewIntObj(interp,
 440                                 info.set_pri));
 441                 Jim_ListAppendElement(interp, threadObj, Jim_NewIntObj(interp,
 442                                 info.cur_pri));
 443
 444                 Jim_ListAppendElement(interp, threads, threadObj);
 445         }
 446         Jim_SetResult(interp, threads);
 447
 448         return JIM_OK;
 449 }
 450
 451 static int zylinjtag_Jim_Command_log(Jim_Interp *interp, int argc,
 452                 Jim_Obj * const *argv)
 453 {
 454         Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
 455
 456         if (logCount >= logSize)
 457         {
 458                 Jim_AppendString(httpstate.jim_interp, tclOutput, logBuffer + logCount
 459                                 % logSize, logSize - logCount % logSize);
 460         }
 461         Jim_AppendString(httpstate.jim_interp, tclOutput, logBuffer, writePtr);
 462
 463         Jim_SetResult(interp, tclOutput);
 464         return JIM_OK;
 465 }
 466
 467 static int zylinjtag_Jim_Command_reboot(Jim_Interp *interp, int argc,
 468                 Jim_Obj * const *argv)
 469 {
 470         reboot();
 471         return JIM_OK;
 472 }
 473
 474 static void zylinjtag_startNetwork(void)
 475 {
 476         // Bring TCP/IP up immediately before we're ready to accept commands.
 477         //
 478         // That is as soon as a PING responds, we're accepting telnet sessions.
 479 #if defined(CYGPKG_NET_FREEBSD_STACK)
 480         phi_init_all_network_interfaces();
 481 #else
 482         lwip_init();
 483 #endif
 484         if (!eth0_up)
 485         {
 486                 diag_printf("Network not up and running\n");
 487                 exit(-1);
 488         }
 489
 490         /* very first thing we want is a reboot capability */
 491         reboot_port();
 492
 493 #if defined(CYGPKG_NET_FREEBSD_STACK)
 494         /*start TFTP*/
 495         tftpd_start(69, &fileops);
 496 #endif
 497
 498         cyg_httpd_init_tcl_interpreter();
 499
 500         interp = httpstate.jim_interp;
 501
 502         Jim_CreateCommand(httpstate.jim_interp, "log", zylinjtag_Jim_Command_log,
 503                         NULL, NULL);
 504         Jim_CreateCommand(httpstate.jim_interp, "zy1000_reboot",
 505                         zylinjtag_Jim_Command_reboot, NULL, NULL);
 506         Jim_CreateCommand(httpstate.jim_interp, "threads",
 507                         zylinjtag_Jim_Command_threads, NULL, NULL);
 508         Jim_CreateCommand(httpstate.jim_interp, "format_jffs2",
 509                         zylinjtag_Jim_Command_format_jffs2, NULL, NULL);
 510
 511         cyg_httpd_start();
 512
 513         webRunning = true;
 514
 515         diag_printf("Web server running\n");
 516
 517         int s;
 518         struct ifreq ifr;
 519         s = socket(AF_INET, SOCK_DGRAM, 0);
 520         if (s >= 0)
 521         {
 522                 strcpy(ifr.ifr_name, "eth0");
 523                 int res;
 524                 res = ioctl(s, SIOCGIFHWADDR, &ifr);
 525                 close(s);
 526
 527                 if (res < 0)
 528                 {
 529                         diag_printf("Can't obtain MAC address\n");
 530                         reboot();
 531                 }
 532         }
 533
 534         sprintf(hwaddr, "%02x:%02x:%02x:%02x:%02x:%02x",
 535                         (int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[0],
 536                         (int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[1],
 537                         (int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[2],
 538                         (int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[3],
 539                         (int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[4],
 540                         (int) ((unsigned char *) &ifr.ifr_hwaddr.sa_data)[5]);
 541
 542         discover_message
 543                         = alloc_printf("ZY1000 Zylin JTAG debugger MAC %s", hwaddr);
 544
 545         discover_launch();
 546 }
 547
 548 static void print_exception_handler(cyg_addrword_t data, cyg_code_t exception,
 549                 cyg_addrword_t info)
 550 {
 551         writeLog = false;
 552         serialLog = true;
 553         char *infoStr = "unknown";
 554         switch (exception)
 555         {
 556 #ifdef CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION
 557         case CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION:
 558         infoStr = "undefined instruction";
 559         break;
 560         case CYGNUM_HAL_VECTOR_SOFTWARE_INTERRUPT:
 561         infoStr = "software interrupt";
 562         break;
 563         case CYGNUM_HAL_VECTOR_ABORT_PREFETCH:
 564         infoStr = "abort prefetch";
 565         break;
 566         case CYGNUM_HAL_VECTOR_ABORT_DATA:
 567         infoStr = "abort data";
 568         break;
 569 #endif
 570         default:
 571                 break;
 572         }
 573
 574         diag_printf("Exception: %08x(%s) %08x\n", exception, infoStr, info);
 575
 576         diag_printf("Dumping log\n---\n");
 577         if (logCount >= logSize)
 578         {
 579                 diag_write(logBuffer + logCount % logSize, logSize - logCount % logSize);
 580         }
 581         diag_write(logBuffer, writePtr);
 582
 583         diag_printf("---\nLogdump complete.\n");
 584         diag_printf("Exception: %08x(%s) %08x\n", exception, infoStr, info);
 585         diag_printf("\n---\nRebooting\n");
 586         HAL_PLATFORM_RESET();
 587
 588 }
 589
 590 #ifdef CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION
 591 static void setHandler(cyg_code_t exception)
 592 {
 593         cyg_exception_handler_t *old_handler;
 594         cyg_addrword_t old_data;
 595
 596         cyg_exception_set_handler(exception, print_exception_handler, 0,
 597                         &old_handler, &old_data);
 598 }
 599 #endif
 600
 601 static cyg_thread zylinjtag_uart_thread_object;
 602 static cyg_handle_t zylinjtag_uart_thread_handle;
 603 static char uart_stack[4096];
 604
 605 static char forwardBuffer[1024]; // NB! must be smaller than a TCP/IP packet!!!!!
 606 static char backwardBuffer[1024];
 607
 608 void setNoDelay(int session, int flag)
 609 {
 610 #if 1
 611         // This decreases latency dramatically for e.g. GDB load which
 612         // does not have a sliding window protocol
 613         //
 614         // Can cause *lots* of TCP/IP packets to be sent and it would have
 615         // to be enabled/disabled on the fly to avoid the CPU being
 616         // overloaded...
 617         setsockopt(session, /* socket affected */
 618         IPPROTO_TCP, /* set option at TCP level */
 619         TCP_NODELAY, /* name of option */
 620         (char *) &flag, /* the cast is historical
 621          cruft */
 622         sizeof(int)); /* length of option value */
 623 #endif
 624 }
 625
 626 #define TEST_TCPIP() 0
 627
 628 #if TEST_TCPIP
 629 struct
 630 {
 631         int req;
 632         int actual;
 633         int req2;
 634         int actual2;
 635 } tcpipSent[512 * 1024];
 636 int cur;
 637 #endif
 638
 639 static void zylinjtag_uart(cyg_addrword_t data)
 640 {
 641         int so_reuseaddr_option = 1;
 642
 643         int fd;
 644         if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
 645         {
 646                 LOG_ERROR("error creating socket: %s", strerror(errno));
 647                 exit(-1);
 648         }
 649
 650         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*) &so_reuseaddr_option,
 651                         sizeof(int));
 652
 653         struct sockaddr_in sin;
 654         unsigned int address_size;
 655         address_size = sizeof(sin);
 656         memset(&sin, 0, sizeof(sin));
 657         sin.sin_family = AF_INET;
 658         sin.sin_addr.s_addr = INADDR_ANY;
 659         sin.sin_port = htons(5555);
 660
 661         if (bind(fd, (struct sockaddr *) &sin, sizeof(sin)) == -1)
 662         {
 663                 LOG_ERROR("couldn't bind to socket: %s", strerror(errno));
 664                 exit(-1);
 665         }
 666
 667         if (listen(fd, 1) == -1)
 668         {
 669                 LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
 670                 exit(-1);
 671         }
 672         //      socket_nonblock(fd);
 673
 674
 675         for (;;)
 676         {
 677                 int session = accept(fd, (struct sockaddr *) &sin, &address_size);
 678                 if (session < 0)
 679                 {
 680                         continue;
 681                 }
 682
 683                 setNoDelay(session, 1);
 684                 int oldopts = fcntl(session, F_GETFL, 0);
 685                 fcntl(session, F_SETFL, oldopts | O_NONBLOCK); //
 686
 687                 int serHandle = open("/dev/ser0", O_RDWR | O_NONBLOCK);
 688                 if (serHandle < 0)
 689                 {
 690                         close(session);
 691                         continue;
 692                 }
 693
 694 #ifdef CYGPKG_PROFILE_GPROF
 695                 start_profile();
 696 #endif
 697                 size_t actual = 0;
 698                 size_t actual2 = 0;
 699                 size_t pos, pos2;
 700                 pos = 0;
 701                 pos2 = 0;
 702 #if TEST_TCPIP
 703                 cur = 0;
 704 #endif
 705                 for (;;)
 706                 {
 707                         fd_set write_fds;
 708                         fd_set read_fds;
 709                         FD_ZERO(&write_fds);
 710                         FD_ZERO(&read_fds);
 711                         int fd_max = -1;
 712                         FD_SET(session, &read_fds);
 713                         fd_max = session;
 714                         FD_SET(serHandle, &read_fds);
 715                         if (serHandle > fd_max)
 716                         {
 717                                 fd_max = serHandle;
 718                         }
 719                         /* Wait... */
 720
 721                         cyg_thread_delay(5); // 50ms fixed delay to wait for data to be sent/received
 722                         if ((actual == 0) && (actual2 == 0))
 723                         {
 724                                 int retval = select(fd_max + 1, &read_fds, NULL, NULL, NULL);
 725                                 if (retval <= 0)
 726                                 {
 727                                         break;
 728                                 }
 729                         }
 730
 731                         if (actual2 <= 0)
 732                         {
 733                                 memset(backwardBuffer, 's', sizeof(backwardBuffer));
 734                                 int t;
 735                                 t = read(serHandle, backwardBuffer,
 736                                                 sizeof(backwardBuffer));
 737                                 actual2 = t;
 738                                 if (t < 0)
 739                                 {
 740                                         if (errno != EAGAIN)
 741                                         {
 742                                                 goto closeSession;
 743                                         }
 744                                         actual2 = 0;
 745                                 }
 746                                 pos2 = 0;
 747                         }
 748
 749                         size_t y = 0;
 750                         if (actual2 > 0)
 751                         {
 752                                 int written = write(session, backwardBuffer + pos2, actual2);
 753                                 if (written <= 0)
 754                                         goto closeSession;
 755                                 actual2 -= written;
 756                                 pos2 += written;
 757                                 y = written;
 758                         }
 759
 760                         if (FD_ISSET(session, &read_fds)
 761                                         && (sizeof(forwardBuffer) > actual))
 762                         {
 763                                 // NB! Here it is important that we empty the TCP/IP read buffer
 764                                 // to make transmission tick right
 765                                 memmove(forwardBuffer, forwardBuffer + pos, actual);
 766                                 pos = 0;
 767                                 int t;
 768                                 // this will block if there is no data at all
 769                                 t = read_socket(session, forwardBuffer + actual,
 770                                                 sizeof(forwardBuffer) - actual);
 771                                 if (t <= 0)
 772                                 {
 773                                         goto closeSession;
 774                                 }
 775                                 actual += t;
 776                         }
 777
 778                         int y2 = 0;
 779                         if (actual > 0)
 780                         {
 781                                 /* Do not put things into the serial buffer if it has something to send
 782                                  * as that can cause a single byte to be sent at the time.
 783                                  *
 784                                  *
 785                                  */
 786                                 int written = write(serHandle, forwardBuffer + pos, actual);
 787                                 if (written < 0)
 788                                 {
 789                                         if (errno != EAGAIN)
 790                                         {
 791                                                 goto closeSession;
 792                                         }
 793                                         // The serial buffer is full
 794                                         written = 0;
 795                                 }
 796                                 else
 797                                 {
 798                                         actual -= written;
 799                                         pos += written;
 800                                 }
 801                                 y2 = written;
 802                         }
 803 #if TEST_TCPIP
 804                         if (cur < 1024)
 805                         {
 806                                 tcpipSent[cur].req = x;
 807                                 tcpipSent[cur].actual = y;
 808                                 tcpipSent[cur].req2 = x2;
 809                                 tcpipSent[cur].actual2 = y2;
 810                                 cur++;
 811                         }
 812 #endif
 813                 }
 814                 closeSession: close(session);
 815                 close(serHandle);
 816
 817 #if TEST_TCPIP
 818                 int i;
 819                 for (i = 0; i < 1024; i++)
 820                 {
 821                         diag_printf("%d %d %d %d\n", tcpipSent[i].req, tcpipSent[i].actual,
 822                                         tcpipSent[i].req2, tcpipSent[i].actual2);
 823
 824                 }
 825 #endif
 826         }
 827         close(fd);
 828
 829 }
 830
 831 void startUart(void)
 832 {
 833         cyg_thread_create(1, zylinjtag_uart, (cyg_addrword_t) 0, "uart thread",
 834                         (void *) uart_stack, sizeof(uart_stack),
 835                         &zylinjtag_uart_thread_handle, &zylinjtag_uart_thread_object);
 836         cyg_thread_set_priority(zylinjtag_uart_thread_handle, 1); // low priority as it sits in a busy loop
 837         cyg_thread_resume(zylinjtag_uart_thread_handle);
 838 }
 839
 840 int handle_uart_command(struct command_context *cmd_ctx, char *cmd,
 841                 char **args, int argc)
 842 {
 843         static int current_baud = 38400;
 844         if (argc == 0)
 845         {
 846                 command_print(cmd_ctx, "%d", current_baud);
 847                 return ERROR_OK;
 848         }
 849         else if (argc != 1)
 850         {
 851                 return ERROR_INVALID_ARGUMENTS;
 852         }
 853
 854         current_baud = atol(args[0]);
 855
 856         int baud;
 857         switch (current_baud)
 858         {
 859         case 9600:
 860                 baud = CYGNUM_SERIAL_BAUD_9600;
 861                 break;
 862         case 19200:
 863                 baud = CYGNUM_SERIAL_BAUD_19200;
 864                 break;
 865         case 38400:
 866                 baud = CYGNUM_SERIAL_BAUD_38400;
 867                 break;
 868         case 57600:
 869                 baud = CYGNUM_SERIAL_BAUD_57600;
 870                 break;
 871         case 115200:
 872                 baud = CYGNUM_SERIAL_BAUD_115200;
 873                 break;
 874         case 230400:
 875                 baud = CYGNUM_SERIAL_BAUD_230400;
 876                 break;
 877         default:
 878                 command_print(cmd_ctx, "unsupported baudrate");
 879                 return ERROR_INVALID_ARGUMENTS;
 880         }
 881
 882         cyg_serial_info_t buf;
 883         cyg_uint32 len = 1;
 884         //get existing serial configuration
 885         len = sizeof(cyg_serial_info_t);
 886         int err;
 887         cyg_io_handle_t serial_handle;
 888
 889         err = cyg_io_lookup("/dev/ser0", &serial_handle);
 890         if (err != ENOERR)
 891         {
 892                 LOG_ERROR("/dev/ser0 not found\n");
 893                 return ERROR_FAIL;
 894         }
 895
 896         err = cyg_io_get_config(serial_handle,
 897                         CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN, &buf, &len);
 898         err = cyg_io_get_config(serial_handle, CYG_IO_GET_CONFIG_SERIAL_INFO, &buf,
 899                         &len);
 900         if (err != ENOERR)
 901         {
 902                 command_print(cmd_ctx, "Failed to get serial port settings %d", err);
 903                 return ERROR_OK;
 904         }
 905         buf.baud = baud;
 906
 907         err = cyg_io_set_config(serial_handle, CYG_IO_SET_CONFIG_SERIAL_INFO, &buf,
 908                         &len);
 909         if (err != ENOERR)
 910         {
 911                 command_print(cmd_ctx, "Failed to set serial port settings %d", err);
 912                 return ERROR_OK;
 913         }
 914
 915         return ERROR_OK;
 916 }
 917
 918 bool logAllToSerial = false;
 919
 920
 921 int boolParam(char *var);
 922
 923
 924 struct command_context *setup_command_handler(void);
 925
 926 static const char *zylin_config_dir="/config/settings";
 927
 928 static int add_default_dirs(void)
 929 {
 930         add_script_search_dir(zylin_config_dir);
 931         add_script_search_dir("/rom/lib/openocd");
 932         add_script_search_dir("/rom");
 933         return ERROR_OK;
 934 }
 935
 936 int ioutil_init(struct command_context *cmd_ctx);
 937
 938 int main(int argc, char *argv[])
 939 {
 940         /* ramblockdevice will be the same address every time. The deflate app uses a buffer 16mBytes out, so we
 941          * need to allocate towards the end of the heap.  */
 942
 943 #ifdef CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION
 944         setHandler(CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION);
 945         setHandler(CYGNUM_HAL_VECTOR_ABORT_PREFETCH);
 946         setHandler(CYGNUM_HAL_VECTOR_ABORT_DATA);
 947 #endif
 948
 949         int err;
 950
 951         atexit(keep_webserver);
 952
 953         diag_init_putc(_zylinjtag_diag_write_char);
 954         // We want this in the log.
 955         diag_printf("Zylin ZY1000.\n");
 956
 957         err = mount("", "/ram", "ramfs");
 958         if (err < 0)
 959         {
 960                 diag_printf("unable to mount ramfs\n");
 961         }
 962         chdir("/ram");
 963
 964         char address[16];
 965         sprintf(address, "%p", &filedata[0]);
 966         err = mount(address, "/rom", "romfs");
 967         if (err < 0)
 968         {
 969                 diag_printf("unable to mount /rom\n");
 970         }
 971
 972         err = mount("", "/log", "logfs");
 973         if (err < 0)
 974         {
 975                 diag_printf("unable to mount logfs\n");
 976         }
 977
 978         err = mount("", "/tftp", "tftpfs");
 979         if (err < 0)
 980         {
 981                 diag_printf("unable to mount logfs\n");
 982         }
 983
 984         log = fopen("/log/log", "w");
 985         if (log == NULL)
 986         {
 987                 diag_printf("Could not open log file /ram/log\n");
 988                 exit(-1);
 989         }
 990
 991
 992         copydir("/rom", "/ram/cgi");
 993
 994         err = mount("/dev/flash1", "/config", "jffs2");
 995         if (err < 0)
 996         {
 997                 diag_printf("unable to mount jffs2, falling back to ram disk..\n");
 998                 err = mount("", "/config", "ramfs");
 999                 if (err < 0)
1000                 {
1001                         diag_printf("unable to mount /config as ramdisk.\n");
1002                         reboot();
1003                 }
1004         }
1005         else
1006         {
1007                 /* are we using a ram disk instead of a flash disk? This is used
1008                  * for ZY1000 live demo...
1009                  *
1010                  * copy over flash disk to ram block device
1011                  */
1012                 if (boolParam("ramdisk"))
1013                 {
1014                         diag_printf("Unmounting /config from flash and using ram instead\n");
1015                         err = umount("/config");
1016                         if (err < 0)
1017                         {
1018                                 diag_printf("unable to unmount jffs\n");
1019                                 reboot();
1020                         }
1021
1022                         err = mount("/dev/flash1", "/config2", "jffs2");
1023                         if (err < 0)
1024                         {
1025                                 diag_printf("unable to mount jffs\n");
1026                                 reboot();
1027                         }
1028
1029                         err = mount("", "/config", "ramfs");
1030                         if (err < 0)
1031                         {
1032                                 diag_printf("unable to mount ram block device\n");
1033                                 reboot();
1034                         }
1035
1036                         //              copydir("/config2", "/config");
1037                         copyfile("/config2/ip", "/config/ip");
1038                         copydir("/config2/settings", "/config/settings");
1039
1040                         umount("/config2");
1041                 }
1042         }
1043
1044         mkdir(zylin_config_dir, 0777);
1045         char *dirname = alloc_printf("%s/target", zylin_config_dir);
1046         mkdir(dirname, 0777);
1047         free(dirname);
1048         dirname = alloc_printf("%s/board", zylin_config_dir);
1049         mkdir(dirname, 0777);
1050         free(dirname);
1051         dirname = alloc_printf("%s/event", zylin_config_dir);
1052         mkdir(dirname, 0777);
1053         free(dirname);
1054
1055         logAllToSerial = boolParam("logserial");
1056
1057         // We need the network & web server in case there is something wrong with
1058         // the config files that invoke exit()
1059         zylinjtag_startNetwork();
1060
1061         /* we're going to access the jim interpreter from here on... */
1062         openocd_sleep_postlude();
1063         startUart();
1064
1065         add_default_dirs();
1066
1067         /* initialize commandline interface */
1068         struct command_context * cmd_ctx;
1069         cmd_ctx = setup_command_handler();
1070         command_set_output_handler(cmd_ctx, configuration_output_handler, NULL);
1071         command_context_mode(cmd_ctx, COMMAND_CONFIG);
1072
1073 #if BUILD_IOUTIL
1074         if (ioutil_init(cmd_ctx) != ERROR_OK)
1075         {
1076                 return EXIT_FAILURE;
1077         }
1078 #endif
1079
1080
1081 #ifdef CYGPKG_PROFILE_GPROF
1082         register_command(cmd_ctx, NULL, "ecosboard_profile", eCosBoard_handle_eCosBoard_profile_command,
1083                         COMMAND_ANY, NULL);
1084 #endif
1085
1086         register_command(cmd_ctx, NULL, "uart", handle_uart_command, COMMAND_ANY,
1087                         "uart <baud>  - forward uart on port 5555");
1088
1089         int errVal;
1090         errVal = log_init(cmd_ctx);
1091         if (errVal != ERROR_OK)
1092         {
1093                 diag_printf("log_init() failed %d\n", errVal);
1094                 exit(-1);
1095         }
1096
1097         set_log_output(cmd_ctx, log);
1098
1099         LOG_DEBUG("log init complete");
1100
1101         //      diag_printf("Executing config files\n");
1102
1103         if (logAllToSerial)
1104         {
1105                 diag_printf(
1106                                  "%s/logserial = 1 => sending log output to serial port using \"debug_level 3\" as default.\n", zylin_config_dir);
1107                 command_run_line(cmd_ctx, "debug_level 3");
1108         }
1109
1110         command_run_linef(cmd_ctx, "script /rom/openocd.cfg");
1111
1112         /* we MUST always run the init command as it will launch telnet sessions */
1113         command_run_line(cmd_ctx, "init");
1114
1115         // FIX!!!  Yuk!
1116         // diag_printf() is really invoked from many more places than we trust it
1117         // not to cause instabilities(e.g. invoking fputc() from an interrupt is *BAD*).
1118         //
1119         // Disabling it here is safe and gives us enough logged debug output for now. Crossing
1120         // fingers that it doesn't cause any crashes.
1121         diag_printf("Init complete, GDB & telnet servers launched.\n");
1122         command_set_output_handler(cmd_ctx,
1123                         zy1000_configuration_output_handler_log, NULL);
1124         if (!logAllToSerial)
1125         {
1126                 serialLog = false;
1127         }
1128
1129         /* handle network connections */
1130         server_loop(cmd_ctx);
1131         openocd_sleep_prelude();
1132
1133         /* shut server down */
1134         server_quit();
1135
1136         /* free commandline interface */
1137         command_done(cmd_ctx);
1138         umount("/config");
1139
1140         exit(0);
1141         for (;;)
1142                 ;
1143 }
1144
1145 cyg_int32 cyg_httpd_exec_cgi_tcl(char *file_name);
1146 cyg_int32 homeForm(CYG_HTTPD_STATE *p)
1147 {
1148         cyg_httpd_exec_cgi_tcl("/ram/cgi/index.tcl");
1149         return 0;
1150 }
1151
1152 CYG_HTTPD_HANDLER_TABLE_ENTRY(root_label, "/", homeForm);
1153
1154 CYG_HTTPD_MIME_TABLE_ENTRY(text_mime_label, "text", "text/plain");
1155 CYG_HTTPD_MIME_TABLE_ENTRY(bin_mime_label, "bin", "application/octet-stream");
1156
1157 #include <pkgconf/system.h>
1158 #include <pkgconf/hal.h>
1159 #include <pkgconf/kernel.h>
1160 #include <pkgconf/io_fileio.h>
1161 #include <pkgconf/fs_rom.h>
1162
1163 #include <cyg/kernel/ktypes.h>         // base kernel types
1164 #include <cyg/infra/cyg_trac.h>        // tracing macros
1165 #include <cyg/infra/cyg_ass.h>         // assertion macros
1166 #include <cyg/fileio/fileio.h>
1167 #include <cyg/kernel/kapi.h>
1168 #include <cyg/infra/diag.h>
1169
1170 //==========================================================================
1171 // Eventually we want to eXecute In Place from the ROM in a protected
1172 // environment, so we'll need executables to be aligned to a boundary
1173 // suitable for MMU protection. A suitable boundary would be the 4k
1174 // boundary in all the CPU architectures I am currently aware of.
1175
1176 // Forward definitions
1177
1178 // Filesystem operations
1179 static int tftpfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte);
1180 static int tftpfs_umount(cyg_mtab_entry *mte);
1181 static int tftpfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
1182                 int mode, cyg_file *fte);
1183 static int tftpfs_fo_read(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio);
1184 static int tftpfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio);
1185
1186 // File operations
1187 static int tftpfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode);
1188 static int tftpfs_fo_close(struct CYG_FILE_TAG *fp);
1189 static int tftpfs_fo_lseek(struct CYG_FILE_TAG *fp, off_t *apos, int whence);
1190
1191 //==========================================================================
1192 // Filesystem table entries
1193
1194 // -------------------------------------------------------------------------
1195 // Fstab entry.
1196 // This defines the entry in the filesystem table.
1197 // For simplicity we use _FILESYSTEM synchronization for all accesses since
1198 // we should never block in any filesystem operations.
1199 #if 1
1200 FSTAB_ENTRY(tftpfs_fste, "tftpfs", 0,
1201                 CYG_SYNCMODE_NONE,
1202                 tftpfs_mount,
1203                 tftpfs_umount,
1204                 tftpfs_open,
1205                 (cyg_fsop_unlink *)cyg_fileio_erofs,
1206                 (cyg_fsop_mkdir *)cyg_fileio_erofs,
1207                 (cyg_fsop_rmdir *)cyg_fileio_erofs,
1208                 (cyg_fsop_rename *)cyg_fileio_erofs,
1209                 (cyg_fsop_link *)cyg_fileio_erofs,
1210                 (cyg_fsop_opendir *)cyg_fileio_erofs,
1211                 (cyg_fsop_chdir *)cyg_fileio_erofs,
1212                 (cyg_fsop_stat *)cyg_fileio_erofs,
1213                 (cyg_fsop_getinfo *)cyg_fileio_erofs,
1214                 (cyg_fsop_setinfo *)cyg_fileio_erofs);
1215 #endif
1216
1217 // -------------------------------------------------------------------------
1218 // mtab entry.
1219 // This defines a single ROMFS loaded into ROM at the configured address
1220 //
1221 // MTAB_ENTRY(rom_mte,  // structure name
1222 //              "/rom",         // mount point
1223 //              "romfs",        // FIlesystem type
1224 //              "",             // hardware device
1225 //  (CYG_ADDRWORD) CYGNUM_FS_ROM_BASE_ADDRESS   // Address in ROM
1226 //);
1227
1228
1229 // -------------------------------------------------------------------------
1230 // File operations.
1231 // This set of file operations are used for normal open files.
1232
1233 static cyg_fileops tftpfs_fileops =
1234 { tftpfs_fo_read, tftpfs_fo_write, tftpfs_fo_lseek,
1235                 (cyg_fileop_ioctl *) cyg_fileio_erofs, cyg_fileio_seltrue,
1236                 tftpfs_fo_fsync, tftpfs_fo_close,
1237                 (cyg_fileop_fstat *) cyg_fileio_erofs,
1238                 (cyg_fileop_getinfo *) cyg_fileio_erofs,
1239                 (cyg_fileop_setinfo *) cyg_fileio_erofs, };
1240
1241 // -------------------------------------------------------------------------
1242 // tftpfs_mount()
1243 // Process a mount request. This mainly finds root for the
1244 // filesystem.
1245
1246 static int tftpfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte)
1247 {
1248         return ENOERR;
1249 }
1250
1251 static int tftpfs_umount(cyg_mtab_entry *mte)
1252 {
1253         return ENOERR;
1254 }
1255
1256 struct Tftp
1257 {
1258         int write;
1259         int readFile;
1260         cyg_uint8 *mem;
1261         int actual;
1262         char *server;
1263         char *file;
1264 };
1265
1266 static void freeTftp(struct Tftp *t)
1267 {
1268         if (t == NULL)
1269                 return;
1270         if (t->mem)
1271                 free(t->mem);
1272         if (t->server)
1273                 free(t->server);
1274         if (t->file)
1275                 free(t->file);
1276         free(t);
1277 }
1278
1279 static const int tftpMaxSize = 8192 * 1024;
1280 static int tftpfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
1281                 int mode, cyg_file *file)
1282 {
1283         struct Tftp *tftp;
1284         tftp = malloc(sizeof(struct Tftp));
1285         if (tftp == NULL)
1286                 return EMFILE;
1287         memset(tftp, 0, sizeof(struct Tftp));
1288
1289         file->f_flag |= mode & CYG_FILE_MODE_MASK;
1290         file->f_type = CYG_FILE_TYPE_FILE;
1291         file->f_ops = &tftpfs_fileops;
1292         file->f_offset = 0;
1293         file->f_data = 0;
1294         file->f_xops = 0;
1295
1296         tftp->mem = malloc(tftpMaxSize);
1297         if (tftp->mem == NULL)
1298         {
1299                 freeTftp(tftp);
1300                 return EMFILE;
1301         }
1302
1303         char *server = strchr(name, '/');
1304         if (server == NULL)
1305         {
1306                 freeTftp(tftp);
1307                 return EMFILE;
1308         }
1309
1310         tftp->server = malloc(server - name + 1);
1311         if (tftp->server == NULL)
1312         {
1313                 freeTftp(tftp);
1314                 return EMFILE;
1315         }
1316         strncpy(tftp->server, name, server - name);
1317         tftp->server[server - name] = 0;
1318
1319         tftp->file = strdup(server + 1);
1320         if (tftp->file == NULL)
1321         {
1322                 freeTftp(tftp);
1323                 return EMFILE;
1324         }
1325
1326         file->f_data = (CYG_ADDRWORD) tftp;
1327
1328         return ENOERR;
1329 }
1330
1331 static int fetchTftp(struct Tftp *tftp)
1332 {
1333         if (!tftp->readFile)
1334         {
1335                 int err;
1336                 tftp->actual = tftp_client_get(tftp->file, tftp->server, 0, tftp->mem,
1337                                 tftpMaxSize, TFTP_OCTET, &err);
1338
1339                 if (tftp->actual < 0)
1340                 {
1341                         return EMFILE;
1342                 }
1343                 tftp->readFile = 1;
1344         }
1345         return ENOERR;
1346 }
1347
1348 // -------------------------------------------------------------------------
1349 // tftpfs_fo_write()
1350 // Read data from file.
1351
1352 static int tftpfs_fo_read(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio)
1353 {
1354         struct Tftp *tftp = (struct Tftp *) fp->f_data;
1355
1356         if (fetchTftp(tftp) != ENOERR)
1357                 return EMFILE;
1358
1359         int i;
1360         off_t pos = fp->f_offset;
1361         int resid = 0;
1362         for (i = 0; i < uio->uio_iovcnt; i++)
1363         {
1364                 cyg_iovec *iov = &uio->uio_iov[i];
1365                 char *buf = (char *) iov->iov_base;
1366                 off_t len = iov->iov_len;
1367
1368                 if (len + pos > tftp->actual)
1369                 {
1370                         len = tftp->actual - pos;
1371                 }
1372                 resid += iov->iov_len - len;
1373
1374                 memcpy(buf, tftp->mem + pos, len);
1375                 pos += len;
1376
1377         }
1378         uio->uio_resid = resid;
1379         fp->f_offset = pos;
1380
1381         return ENOERR;
1382 }
1383
1384 static int tftpfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio)
1385 {
1386         struct Tftp *tftp = (struct Tftp *) fp->f_data;
1387
1388         int i;
1389         off_t pos = fp->f_offset;
1390         int resid = 0;
1391         for (i = 0; i < uio->uio_iovcnt; i++)
1392         {
1393                 cyg_iovec *iov = &uio->uio_iov[i];
1394                 char *buf = (char *) iov->iov_base;
1395                 off_t len = iov->iov_len;
1396
1397                 if (len + pos > tftpMaxSize)
1398                 {
1399                         len = tftpMaxSize - pos;
1400                 }
1401                 resid += iov->iov_len - len;
1402
1403                 memcpy(tftp->mem + pos, buf, len);
1404                 pos += len;
1405
1406         }
1407         uio->uio_resid = resid;
1408         fp->f_offset = pos;
1409
1410         tftp->write = 1;
1411
1412         return ENOERR;
1413 }
1414
1415 static int tftpfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode)
1416 {
1417         int error = ENOERR;
1418         return error;
1419 }
1420
1421 // -------------------------------------------------------------------------
1422 // romfs_fo_close()
1423 // Close a file. We just clear out the data pointer.
1424
1425 static int tftpfs_fo_close(struct CYG_FILE_TAG *fp)
1426 {
1427         struct Tftp *tftp = (struct Tftp *) fp->f_data;
1428         int error = ENOERR;
1429
1430         if (tftp->write)
1431         {
1432                 tftp_client_put(tftp->file, tftp->server, 0, tftp->mem, fp->f_offset,
1433                                 TFTP_OCTET, &error);
1434         }
1435
1436         freeTftp(tftp);
1437         fp->f_data = 0;
1438         return error;
1439 }
1440
1441 // -------------------------------------------------------------------------
1442 // romfs_fo_lseek()
1443 // Seek to a new file position.
1444
1445 static int tftpfs_fo_lseek(struct CYG_FILE_TAG *fp, off_t *apos, int whence)
1446 {
1447         struct Tftp *tftp = (struct Tftp *) fp->f_data;
1448         off_t pos = *apos;
1449
1450         if (fetchTftp(tftp) != ENOERR)
1451                 return EMFILE;
1452
1453         switch (whence)
1454         {
1455         case SEEK_SET:
1456                 // Pos is already where we want to be.
1457                 break;
1458
1459         case SEEK_CUR:
1460                 // Add pos to current offset.
1461                 pos += fp->f_offset;
1462                 break;
1463
1464         case SEEK_END:
1465                 // Add pos to file size.
1466                 pos += tftp->actual;
1467                 break;
1468
1469         default:
1470                 return EINVAL;
1471         }
1472
1473         // Check that pos is still within current file size, or at the
1474         // very end.
1475         if (pos < 0 || pos > tftp->actual)
1476                 return EINVAL;
1477
1478         // All OK, set fp offset and return new position.
1479         *apos = fp->f_offset = pos;
1480
1481         return ENOERR;
1482 }
1483
1484 void usleep(int us)
1485 {
1486         if (us > 10000)
1487                 cyg_thread_delay(us / 10000 + 1);
1488         else
1489                 HAL_DELAY_US(us);
1490 }
1491
1492 // Chunked version.
1493 cyg_int32 show_log_entry(CYG_HTTPD_STATE *phttpstate)
1494 {
1495         cyg_httpd_start_chunked("text");
1496         if (logCount >= logSize)
1497         {
1498                 cyg_httpd_write_chunked(logBuffer + logCount % logSize, logSize
1499                                 - logCount % logSize);
1500         }
1501         cyg_httpd_write_chunked(logBuffer, writePtr);
1502         cyg_httpd_end_chunked();
1503         return -1;
1504 }
1505
1506 CYG_HTTPD_HANDLER_TABLE_ENTRY(show_log, "/ram/log", show_log_entry);
1507
1508 // Filesystem operations
1509 static int logfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte);
1510 static int logfs_umount(cyg_mtab_entry *mte);
1511 static int logfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
1512                 int mode, cyg_file *fte);
1513 static int logfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio);
1514
1515 // File operations
1516 static int logfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode);
1517 static int logfs_fo_close(struct CYG_FILE_TAG *fp);
1518
1519 #include <cyg/io/devtab.h>
1520
1521 //==========================================================================
1522 // Filesystem table entries
1523
1524 // -------------------------------------------------------------------------
1525 // Fstab entry.
1526 // This defines the entry in the filesystem table.
1527 // For simplicity we use _FILESYSTEM synchronization for all accesses since
1528 // we should never block in any filesystem operations.
1529 FSTAB_ENTRY(logfs_fste, "logfs", 0,
1530                 CYG_SYNCMODE_FILE_FILESYSTEM | CYG_SYNCMODE_IO_FILESYSTEM,
1531                 logfs_mount,
1532                 logfs_umount,
1533                 logfs_open,
1534                 (cyg_fsop_unlink *)cyg_fileio_erofs,
1535                 (cyg_fsop_mkdir *)cyg_fileio_erofs,
1536                 (cyg_fsop_rmdir *)cyg_fileio_erofs,
1537                 (cyg_fsop_rename *)cyg_fileio_erofs,
1538                 (cyg_fsop_link *)cyg_fileio_erofs,
1539                 (cyg_fsop_opendir *)cyg_fileio_erofs,
1540                 (cyg_fsop_chdir *)cyg_fileio_erofs,
1541                 (cyg_fsop_stat *)cyg_fileio_erofs,
1542                 (cyg_fsop_getinfo *)cyg_fileio_erofs,
1543                 (cyg_fsop_setinfo *)cyg_fileio_erofs);
1544
1545 // -------------------------------------------------------------------------
1546 // File operations.
1547 // This set of file operations are used for normal open files.
1548
1549 static cyg_fileops logfs_fileops =
1550 { (cyg_fileop_read *) cyg_fileio_erofs, (cyg_fileop_write *) logfs_fo_write,
1551                 (cyg_fileop_lseek *) cyg_fileio_erofs,
1552                 (cyg_fileop_ioctl *) cyg_fileio_erofs, cyg_fileio_seltrue,
1553                 logfs_fo_fsync, logfs_fo_close, (cyg_fileop_fstat *) cyg_fileio_erofs,
1554                 (cyg_fileop_getinfo *) cyg_fileio_erofs,
1555                 (cyg_fileop_setinfo *) cyg_fileio_erofs, };
1556
1557 // -------------------------------------------------------------------------
1558 // logfs_mount()
1559 // Process a mount request. This mainly finds root for the
1560 // filesystem.
1561
1562 static int logfs_mount(cyg_fstab_entry *fste, cyg_mtab_entry *mte)
1563 {
1564         return ENOERR;
1565 }
1566
1567 static int logfs_umount(cyg_mtab_entry *mte)
1568 {
1569         return ENOERR;
1570 }
1571
1572 static int logfs_open(cyg_mtab_entry *mte, cyg_dir dir, const char *name,
1573                 int mode, cyg_file *file)
1574 {
1575         file->f_flag |= mode & CYG_FILE_MODE_MASK;
1576         file->f_type = CYG_FILE_TYPE_FILE;
1577         file->f_ops = &logfs_fileops;
1578         file->f_offset = 0;
1579         file->f_data = 0;
1580         file->f_xops = 0;
1581         return ENOERR;
1582 }
1583
1584 // -------------------------------------------------------------------------
1585 // logfs_fo_write()
1586 // Write data to file.
1587
1588 static int logfs_fo_write(struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio)
1589 {
1590         int i;
1591         for (i = 0; i < uio->uio_iovcnt; i++)
1592         {
1593                 cyg_iovec *iov = &uio->uio_iov[i];
1594                 char *buf = (char *) iov->iov_base;
1595                 off_t len = iov->iov_len;
1596
1597                 diag_write(buf, len);
1598         }
1599         uio->uio_resid = 0;
1600
1601         return ENOERR;
1602 }
1603 static int logfs_fo_fsync(struct CYG_FILE_TAG *fp, int mode)
1604 {
1605         return ENOERR;
1606 }
1607
1608 // -------------------------------------------------------------------------
1609 // romfs_fo_close()
1610 // Close a file. We just clear out the data pointer.
1611
1612 static int logfs_fo_close(struct CYG_FILE_TAG *fp)
1613 {
1614         return ENOERR;
1615 }
1616
1617 int loadFile(const char *fileName, void **data, int *len);
1618
1619 /* boolean parameter stored on config */
1620 int boolParam(char *var)
1621 {
1622         bool result = false;
1623         char *name = alloc_printf("%s/%s", zylin_config_dir, var);
1624         if (name == NULL)
1625                 return result;
1626
1627         void *data;
1628         int len;
1629         if (loadFile(name, &data, &len) == ERROR_OK)
1630         {
1631                 if (len > 1)
1632                         len = 1;
1633                 result = strncmp((char *) data, "1", len) == 0;
1634                 free(data);
1635         }
1636         free(name);
1637         return result;
1638 }
1639