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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)