1 /***************************************************************************
2 * Copyright (C) 2007-2008 by Øyvind Harboe *
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. *
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. *
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 ***************************************************************************/
27 #include "configuration.h"
36 #include "telnet_server.h"
37 #include "gdb_server.h"
39 #include <time_support.h>
41 #include <sys/types.h>
49 #include <cyg/io/flash.h>
50 #include <pkgconf/fs_jffs2.h> // Address of JFFS2
55 #include <cyg/fileio/fileio.h>
57 #include <cyg/athttpd/http.h>
58 #include <cyg/athttpd/socket.h>
59 #include <cyg/athttpd/handler.h>
60 #include <cyg/athttpd/cgi.h>
61 #include <cyg/athttpd/forms.h>
62 #include <cyg/hal/hal_diag.h>
63 #include <cyg/kernel/kapi.h>
64 #include <cyg/io/serialio.h>
65 #include <cyg/io/io.h>
66 #include <netinet/tcp.h>
68 #include <sys/ioctl.h>
69 #include <sys/socket.h>
70 #include <netinet/in.h>
72 #include <arpa/inet.h>
73 #include <sys/types.h>
74 #include <sys/socket.h>
76 #include <netinet/in.h>
78 #include <arpa/inet.h>
86 #if defined(CYGPKG_NET_FREEBSD_STACK)
87 #include <tftp_support.h>
88 /* posix compatibility broken*/
89 struct tftpd_fileops fileops
=
91 (int (*)(const char *, int))open
,
93 (int (*)(int, const void *, int))write
,
94 ( int (*)(int, void *, int))read
99 #define ZYLIN_VERSION "1.45"
100 #define ZYLIN_DATE __DATE__
101 #define ZYLIN_TIME __TIME__
102 /* hmmm.... we can't pick up the right # during build if we've checked this out
103 * in Eclipse... arrggghh...*/
104 #define ZYLIN_OPENOCD "$Revision$"
105 #define ZYLIN_OPENOCD_VERSION "Zylin JTAG ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE " " ZYLIN_TIME
106 #define ZYLIN_CONFIG_DIR "/config/settings"
108 void diag_write(char *buf
, int len
)
111 for (j
= 0; j
< len
; j
++)
113 diag_printf("%c", buf
[j
]);
117 static bool serialLog
= true;
118 static bool writeLog
= true;
129 static int fastload_num
;
130 static struct FastLoad
*fastload
;
132 static void free_fastload()
137 for (i
=0; i
<fastload_num
; i
++)
139 if (fastload
[i
].data
)
140 free(fastload
[i
].data
);
148 int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
154 u32 max_address
=0xffffffff;
163 if ((argc
< 1)||(argc
> 5))
165 return ERROR_COMMAND_SYNTAX_ERROR
;
168 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
171 image
.base_address_set
= 1;
172 image
.base_address
= strtoul(args
[1], NULL
, 0);
176 image
.base_address_set
= 0;
180 image
.start_address_set
= 0;
184 min_address
=strtoul(args
[3], NULL
, 0);
188 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
191 if (min_address
>max_address
)
193 return ERROR_COMMAND_SYNTAX_ERROR
;
196 duration_start_measure(&duration
);
198 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
205 fastload_num
=image
.num_sections
;
206 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
212 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
213 for (i
= 0; i
< image
.num_sections
; i
++)
215 buffer
= malloc(image
.sections
[i
].size
);
218 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
222 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
232 /* DANGER!!! beware of unsigned comparision here!!! */
234 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
235 (image
.sections
[i
].base_address
<max_address
))
237 if (image
.sections
[i
].base_address
<min_address
)
239 /* clip addresses below */
240 offset
+=min_address
-image
.sections
[i
].base_address
;
244 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
246 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
249 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
250 fastload
[i
].data
=malloc(length
);
251 if (fastload
[i
].data
==NULL
)
256 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
257 fastload
[i
].length
=length
;
259 image_size
+= length
;
260 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
266 duration_stop_measure(&duration
, &duration_text
);
267 if (retval
==ERROR_OK
)
269 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
270 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
276 if (retval
!=ERROR_OK
)
284 int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
287 return ERROR_COMMAND_SYNTAX_ERROR
;
290 LOG_ERROR("No image in memory");
296 for (i
=0; i
<fastload_num
;i
++)
299 target_t
*target
= get_current_target(cmd_ctx
);
300 if ((retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
)) != ERROR_OK
)
304 size
+=fastload
[i
].length
;
306 int after
=timeval_ms();
307 command_print(cmd_ctx
, "Loaded image %f kBytes/s", (float)(size
/1024.0)/((float)(after
-ms
)/1000.0));
312 /* Give TELNET a way to find out what version this is */
313 int handle_zy1000_version_command(struct command_context_s
*cmd_ctx
, char *cmd
,
314 char **args
, int argc
)
318 return ERROR_COMMAND_SYNTAX_ERROR
;
322 command_print(cmd_ctx
, ZYLIN_OPENOCD_VERSION
);
323 } else if (strcmp("openocd", args
[0])==0)
326 revision
=atol(ZYLIN_OPENOCD
+strlen("XRevision: "));
327 command_print(cmd_ctx
, "%d", revision
);
328 } else if (strcmp("zy1000", args
[0])==0)
330 command_print(cmd_ctx
, "%s", ZYLIN_VERSION
);
331 } else if (strcmp("date", args
[0])==0)
333 command_print(cmd_ctx
, "%s", ZYLIN_DATE
);
336 return ERROR_COMMAND_SYNTAX_ERROR
;
342 extern flash_driver_t
*flash_drivers
[];
343 extern target_type_t
*target_types
[];
345 #ifdef CYGPKG_PROFILE_GPROF
346 #include <cyg/profile/profile.h>
348 extern char _stext
, _etext
; // Defined by the linker
350 void start_profile(void)
352 // This starts up the system-wide profiling, gathering
353 // profile information on all of the code, with a 16 byte
354 // "bucket" size, at a rate of 100us/profile hit.
355 // Note: a bucket size of 16 will give pretty good function
356 // resolution. Much smaller and the buffer becomes
357 // much too large for very little gain.
358 // Note: a timer period of 100us is also a reasonable
359 // compromise. Any smaller and the overhead of
360 // handling the timter (profile) interrupt could
361 // swamp the system. A fast processor might get
362 // by with a smaller value, but a slow one could
363 // even be swamped by this value. If the value is
364 // too large, the usefulness of the profile is reduced.
366 // no more interrupts than 1/10ms.
367 // profile_on(&_stext, &_etext, 16, 10000); // DRAM
368 //profile_on((void *)0, (void *)0x40000, 16, 10000); // SRAM
369 profile_on(0, &_etext
, 16, 10000); // SRAM & DRAM
373 // launch GDB server if a config file exists
374 bool zylinjtag_parse_config_file(struct command_context_s
*cmd_ctx
, const char *config_file_name
)
376 bool foundFile
= false;
377 FILE *config_file
= NULL
;
378 command_print(cmd_ctx
, "executing config file %s", config_file_name
);
379 config_file
= fopen(config_file_name
, "r");
384 retval
= command_run_linef(cmd_ctx
, "script %s", config_file_name
);
385 if (retval
== ERROR_OK
)
391 command_print(cmd_ctx
, "Failed executing %s %d", config_file_name
, retval
);
396 command_print(cmd_ctx
, "No %s found", config_file_name
);
405 static char reboot_stack
[2048];
409 zylinjtag_reboot(cyg_addrword_t data
)
412 diag_printf("Rebooting in 100 ticks..\n");
413 cyg_thread_delay(100);
414 diag_printf("Unmounting /config..\n");
416 diag_printf("Rebooting..\n");
417 HAL_PLATFORM_RESET();
419 static cyg_thread zylinjtag_thread_object
;
420 static cyg_handle_t zylinjtag_thread_handle
;
428 (void *)reboot_stack
,
429 sizeof(reboot_stack
),
430 &zylinjtag_thread_handle
,
431 &zylinjtag_thread_object
);
432 cyg_thread_resume(zylinjtag_thread_handle
);
435 int configuration_output_handler(struct command_context_s
*context
, const char* line
)
437 diag_printf("%s", line
);
442 int zy1000_configuration_output_handler_log(struct command_context_s
*context
, const char* line
)
444 LOG_USER_N("%s", line
);
449 int handle_rm_command(struct command_context_s
*cmd_ctx
, char *cmd
,
450 char **args
, int argc
)
454 command_print(cmd_ctx
, "rm <filename>");
455 return ERROR_INVALID_ARGUMENTS
;
458 if (unlink(args
[0]) != 0)
460 command_print(cmd_ctx
, "failed: %d", errno
);
466 int loadFile(const char *fileName
, void **data
, int *len
);
468 int handle_cat_command(struct command_context_s
*cmd_ctx
, char *cmd
,
469 char **args
, int argc
)
473 command_print(cmd_ctx
, "cat <filename>");
474 return ERROR_INVALID_ARGUMENTS
;
477 // NOTE!!! we only have line printing capability so we print the entire file as a single line.
481 int retval
= loadFile(args
[0], &data
, &len
);
482 if (retval
== ERROR_OK
)
484 command_print(cmd_ctx
, "%s", data
);
489 command_print(cmd_ctx
, "%s not found %d", args
[0], retval
);
494 int handle_trunc_command(struct command_context_s
*cmd_ctx
, char *cmd
,
495 char **args
, int argc
)
499 command_print(cmd_ctx
, "trunc <filename>");
500 return ERROR_INVALID_ARGUMENTS
;
503 FILE *config_file
= NULL
;
504 config_file
= fopen(args
[0], "w");
505 if (config_file
!= NULL
)
512 int handle_meminfo_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
515 struct mallinfo info
;
519 command_print(cmd_ctx
, "meminfo");
520 return ERROR_INVALID_ARGUMENTS
;
527 command_print(cmd_ctx
, "Diff: %d", prev
- info
.fordblks
);
529 prev
= info
.fordblks
;
531 command_print(cmd_ctx
, "Available ram: %d", info
.fordblks
);
536 static bool savePower
;
538 static void setPower(bool power
)
543 HAL_WRITE_UINT32(0x08000014, 0x8);
546 HAL_WRITE_UINT32(0x08000010, 0x8);
550 int handle_power_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
554 return ERROR_INVALID_ARGUMENTS
;
559 if (strcmp(args
[0], "on") == 0)
563 else if (strcmp(args
[0], "off") == 0)
568 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
569 return ERROR_INVALID_ARGUMENTS
;
573 command_print(cmd_ctx
, "Target power %s", savePower
? "on" : "off");
578 int handle_append_command(struct command_context_s
*cmd_ctx
, char *cmd
,
579 char **args
, int argc
)
583 command_print(cmd_ctx
,
584 "append <filename> [<string1>, [<string2>, ...]]");
585 return ERROR_INVALID_ARGUMENTS
;
588 FILE *config_file
= NULL
;
589 config_file
= fopen(args
[0], "a");
590 if (config_file
!= NULL
)
593 fseek(config_file
, 0, SEEK_END
);
595 for (i
= 1; i
< argc
; i
++)
597 fwrite(args
[i
], strlen(args
[i
]), 1, config_file
);
600 fwrite(" ", 1, 1, config_file
);
603 fwrite("\n", 1, 1, config_file
);
610 extern int telnet_socket
;
612 int readMore(int fd
, void *data
, int length
)
614 /* used in select() */
617 /* monitor sockets for acitvity */
620 /* listen for new connections */
621 FD_SET(fd
, &read_fds
);
623 // Maximum 5 seconds.
628 int retval
= select(fd_max
+ 1, &read_fds
, NULL
, NULL
, &tv
);
631 diag_printf("Timed out waiting for binary payload\n");
637 return read_socket(fd
, data
, length
);
640 int readAll(int fd
, void *data
, int length
)
645 int actual
= readMore(fd
, ((char *) data
) + pos
, length
- pos
);
646 // diag_printf("Read %d bytes(pos=%d, length=%d)\n", actual, pos, length);
656 int handle_peek_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
661 return ERROR_INVALID_ARGUMENTS
;
663 HAL_READ_UINT32(strtoul(args
[0], NULL
, 0), value
);
664 command_print(cmd_ctx
, "0x%x : 0x%x", strtoul(args
[0], NULL
, 0), value
);
668 int handle_poke_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
672 return ERROR_INVALID_ARGUMENTS
;
674 HAL_WRITE_UINT32(strtoul(args
[0], NULL
, 0), strtoul(args
[1], NULL
, 0));
678 int handle_cp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
682 return ERROR_INVALID_ARGUMENTS
;
685 // NOTE!!! we only have line printing capability so we print the entire file as a single line.
689 int retval
= loadFile(args
[0], &data
, &len
);
690 if (retval
!= ERROR_OK
)
693 FILE *f
= fopen(args
[1], "wb");
695 retval
= ERROR_INVALID_ARGUMENTS
;
700 int chunk
= len
- pos
;
701 static const int maxChunk
= 512 * 1024; // ~1/sec
702 if (chunk
> maxChunk
)
707 if ((retval
==ERROR_OK
)&&(fwrite(((char *)data
)+pos
, 1, chunk
, f
)!=chunk
))
708 retval
= ERROR_INVALID_ARGUMENTS
;
710 if (retval
!= ERROR_OK
)
715 command_print(cmd_ctx
, "%d", len
- pos
);
723 if (retval
== ERROR_OK
)
725 command_print(cmd_ctx
, "Copied %s to %s", args
[0], args
[1]);
728 command_print(cmd_ctx
, "Failed: %d", retval
);
736 if (retval
!= ERROR_OK
)
742 #ifdef CYGPKG_PROFILE_GPROF
743 extern void start_profile();
745 int eCosBoard_handle_eCosBoard_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
747 command_print(cmd_ctx
, "Profiling started");
754 externC
void phi_init_all_network_interfaces();
756 command_context_t
*cmd_ctx
;
758 static bool webRunning
= false;
760 void keep_webserver()
762 // Target initialisation is only attempted at startup, so we sleep forever and
763 // let the http server bail us out(i.e. get config files set up).
764 diag_printf("OpenOCD has invoked exit().\n"
765 "Use web server to correct any configuration settings and reboot.\n");
769 // exit() will terminate the current thread and we we'll then sleep eternally or
770 // we'll have a reboot scheduled.
773 extern void printDccChar(char c
);
775 static char logBuffer
[128 * 1024];
776 static const int logSize
= sizeof(logBuffer
);
780 void _zylinjtag_diag_write_char(char c
, void **param
)
784 logBuffer
[writePtr
] = c
;
785 writePtr
= (writePtr
+ 1) % logSize
;
792 HAL_DIAG_WRITE_CHAR('\r');
794 HAL_DIAG_WRITE_CHAR(c
);
800 #define SHOW_RESULT(a, b) diag_printf(#a " failed %d\n", (int)b)
803 static void copyfile(char *name2
, char *name1
)
811 fd1
= open(name1
, O_WRONLY
| O_CREAT
);
813 SHOW_RESULT( open
, fd1
);
815 fd2
= open(name2
, O_RDONLY
);
817 SHOW_RESULT( open
, fd2
);
821 done
= read(fd2
, buf
, IOSIZE
);
824 SHOW_RESULT( read
, done
);
828 if( done
== 0 ) break;
830 wrote
= write(fd1
, buf
, done
);
831 if( wrote
!= done
) SHOW_RESULT( write
, wrote
);
833 if( wrote
!= done
) break;
837 if( err
< 0 ) SHOW_RESULT( close
, err
);
840 if( err
< 0 ) SHOW_RESULT( close
, err
);
843 static void copydir(char *name
, char *destdir
)
848 dirp
= opendir(destdir
);
851 mkdir(destdir
, 0777);
854 err
= closedir(dirp
);
857 dirp
= opendir(name
);
858 if( dirp
== NULL
) SHOW_RESULT( opendir
, -1 );
862 struct dirent
*entry
= readdir(dirp
);
867 if (strcmp(entry
->d_name
, ".") == 0)
869 if (strcmp(entry
->d_name
, "..") == 0)
874 char fullPath
[PATH_MAX
];
875 strncpy(fullPath
, name
, PATH_MAX
);
876 strcat(fullPath
, "/");
877 strncat(fullPath
, entry
->d_name
, PATH_MAX
- strlen(fullPath
));
879 if (stat(fullPath
, &buf
) == -1)
881 diag_printf("unable to read status from %s", fullPath
);
884 isDir
= S_ISDIR(buf
.st_mode
) != 0;
889 // diag_printf("<INFO>: entry %14s",entry->d_name);
890 char fullname
[PATH_MAX
];
891 char fullname2
[PATH_MAX
];
893 strcpy(fullname
, name
);
894 strcat(fullname
, "/");
895 strcat(fullname
, entry
->d_name
);
897 strcpy(fullname2
, destdir
);
898 strcat(fullname2
, "/");
899 strcat(fullname2
, entry
->d_name
);
900 // diag_printf("from %s to %s\n", fullname, fullname2);
901 copyfile(fullname
, fullname2
);
903 // diag_printf("\n");
906 err
= closedir(dirp
);
907 if( err
< 0 ) SHOW_RESULT( stat
, err
);
911 MTAB_ENTRY( romfs_mte1
,
915 (CYG_ADDRWORD
) &filedata
[0] );
918 void openocd_sleep_prelude()
920 cyg_mutex_unlock(&httpstate
.jim_lock
);
923 void openocd_sleep_postlude()
925 cyg_mutex_lock(&httpstate
.jim_lock
);
929 zylinjtag_Jim_Command_rm(Jim_Interp
*interp
,
931 Jim_Obj
* const *argv
)
936 Jim_WrongNumArgs(interp
, 1, argv
, "rm ?dirorfile?");
941 if (unlink(Jim_GetString(argv
[1], NULL
)) == 0)
943 if (rmdir(Jim_GetString(argv
[1], NULL
)) == 0)
946 return del
? JIM_OK
: JIM_ERR
;
949 static int zylinjtag_Jim_Command_threads(Jim_Interp
*interp
, int argc
,
950 Jim_Obj
* const *argv
)
952 cyg_handle_t thread
= 0;
954 Jim_Obj
*threads
= Jim_NewListObj(interp
, NULL
, 0);
956 /* Loop over the threads, and generate a table row for
959 while (cyg_thread_get_next(&thread
, &id
))
961 Jim_Obj
*threadObj
= Jim_NewListObj(interp
, NULL
, 0);
963 cyg_thread_info info
;
966 cyg_thread_get_info(thread
, id
, &info
);
968 if (info
.name
== NULL
)
969 info
.name
= "<no name>";
971 Jim_ListAppendElement(interp
, threadObj
, Jim_NewStringObj(interp
,
972 info
.name
, strlen(info
.name
)));
974 /* Translate the state into a string.
977 state_string
= "RUN";
978 else if (info
.state
& 0x04)
979 state_string
= "SUSP";
981 switch (info
.state
& 0x1b)
984 state_string
= "SLEEP";
987 state_string
= "CNTSLEEP";
990 state_string
= "CREATE";
993 state_string
= "EXIT";
996 state_string
= "????";
1000 Jim_ListAppendElement(interp
, threadObj
, Jim_NewStringObj(interp
,
1001 state_string
, strlen(state_string
)));
1003 Jim_ListAppendElement (interp
, threadObj
, Jim_NewIntObj(interp
, id
));
1004 Jim_ListAppendElement(interp
, threadObj
, Jim_NewIntObj(interp
, info
.set_pri
));
1005 Jim_ListAppendElement(interp
, threadObj
, Jim_NewIntObj(interp
, info
.cur_pri
));
1007 Jim_ListAppendElement(interp
, threads
, threadObj
);
1009 Jim_SetResult( interp
, threads
);
1016 zylinjtag_Jim_Command_ls(Jim_Interp
*interp
,
1018 Jim_Obj
* const *argv
)
1022 Jim_WrongNumArgs(interp
, 1, argv
, "ls ?dir?");
1026 char *name
= (char*) Jim_GetString(argv
[1], NULL
);
1029 dirp
= opendir(name
);
1034 Jim_Obj
*objPtr
= Jim_NewListObj(interp
, NULL
, 0);
1038 struct dirent
*entry
= NULL
;
1039 entry
= readdir(dirp
);
1043 if ((strcmp(".", entry
->d_name
)==0)||(strcmp("..", entry
->d_name
)==0))
1046 Jim_ListAppendElement(interp
, objPtr
, Jim_NewStringObj(interp
, entry
->d_name
, strlen(entry
->d_name
)));
1050 Jim_SetResult(interp
, objPtr
);
1057 zylinjtag_Jim_Command_getmem(Jim_Interp
*interp
,
1059 Jim_Obj
* const *argv
)
1063 Jim_WrongNumArgs(interp
, 1, argv
, "ls ?dir?");
1069 if (Jim_GetLong(interp
, argv
[1], &address
) != JIM_OK
)
1071 if (Jim_GetLong(interp
, argv
[2], &length
) != JIM_OK
)
1074 if (length
< 0 && length
> (4096 * 1024))
1076 Jim_WrongNumArgs(interp
, 1, argv
, "getmem ?dir?");
1080 void *mem
= malloc(length
);
1084 target_t
*target
= get_current_target(cmd_ctx
);
1089 if ((address
% 4 == 0) && (count
% 4 == 0))
1095 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, mem
)) != ERROR_OK
)
1101 Jim_Obj
*objPtr
= Jim_NewStringObj(interp
, mem
, length
);
1102 Jim_SetResult(interp
, objPtr
);
1110 zylinjtag_Jim_Command_peek(Jim_Interp
*interp
,
1112 Jim_Obj
* const *argv
)
1116 Jim_WrongNumArgs(interp
, 1, argv
, "peek ?address?");
1121 if (Jim_GetLong(interp
, argv
[1], &address
) != JIM_OK
)
1124 int value
= *((volatile int *) address
);
1126 Jim_SetResult(interp
, Jim_NewIntObj(interp
, value
));
1132 zylinjtag_Jim_Command_poke(Jim_Interp
*interp
,
1134 Jim_Obj
* const *argv
)
1138 Jim_WrongNumArgs(interp
, 1, argv
, "poke ?address? ?value?");
1143 if (Jim_GetLong(interp
, argv
[1], &address
) != JIM_OK
)
1146 if (Jim_GetLong(interp
, argv
[2], &value
) != JIM_OK
)
1149 *((volatile int *) address
) = value
;
1157 zylinjtag_Jim_Command_flash(Jim_Interp
*interp
,
1159 Jim_Obj
* const *argv
)
1163 flash_bank_t
*t
= get_flash_bank_by_num_noprobe(0);
1173 if (retval
== JIM_OK
)
1175 Jim_SetResult(interp
, Jim_NewIntObj(interp
, base
));
1186 zylinjtag_Jim_Command_log(Jim_Interp
*interp
,
1188 Jim_Obj
* const *argv
)
1190 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
1192 if (logCount
>= logSize
)
1194 Jim_AppendString(httpstate
.jim_interp
, tclOutput
, logBuffer
+logCount
%logSize
, logSize
-logCount
%logSize
);
1196 Jim_AppendString(httpstate
.jim_interp
, tclOutput
, logBuffer
, writePtr
);
1198 Jim_SetResult(interp
, tclOutput
);
1203 zylinjtag_Jim_Command_reboot(Jim_Interp
*interp
,
1205 Jim_Obj
* const *argv
)
1212 zylinjtag_Jim_Command_mac(Jim_Interp
*interp
,
1214 Jim_Obj
* const *argv
)
1218 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1221 strcpy(ifr
.ifr_name
, "eth0");
1223 res
= ioctl(s
, SIOCGIFHWADDR
, &ifr
);
1232 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
1235 sprintf(hwaddr
, "%02x:%02x:%02x:%02x:%02x:%02x",
1236 (int) ((unsigned char *) &ifr
.ifr_hwaddr
.sa_data
)[0],
1237 (int) ((unsigned char *) &ifr
.ifr_hwaddr
.sa_data
)[1],
1238 (int) ((unsigned char *) &ifr
.ifr_hwaddr
.sa_data
)[2],
1239 (int) ((unsigned char *) &ifr
.ifr_hwaddr
.sa_data
)[3],
1240 (int) ((unsigned char *) &ifr
.ifr_hwaddr
.sa_data
)[4],
1241 (int) ((unsigned char *) &ifr
.ifr_hwaddr
.sa_data
)[5]);
1243 Jim_AppendString(httpstate
.jim_interp
, tclOutput
, hwaddr
, strlen(hwaddr
));
1245 Jim_SetResult(interp
, tclOutput
);
1251 zylinjtag_Jim_Command_ip(Jim_Interp
*interp
,
1253 Jim_Obj
* const *argv
)
1255 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
1257 struct ifaddrs
*ifa
= NULL
, *ifp
= NULL
;
1259 if (getifaddrs(&ifp
) < 0)
1264 for (ifa
= ifp
; ifa
; ifa
= ifa
->ifa_next
)
1269 if (ifa
->ifa_addr
->sa_family
== AF_INET
)
1270 salen
= sizeof(struct sockaddr_in
);
1271 else if (ifa
->ifa_addr
->sa_family
== AF_INET6
)
1272 salen
= sizeof(struct sockaddr_in6
);
1276 if (getnameinfo(ifa
->ifa_addr
, salen
, ip
, sizeof(ip
), NULL
, 0,
1277 NI_NUMERICHOST
) < 0)
1282 Jim_AppendString(httpstate
.jim_interp
, tclOutput
, ip
, strlen(ip
));
1289 Jim_SetResult(interp
, tclOutput
);
1294 extern Jim_Interp
*interp
;
1296 static void zylinjtag_startNetwork()
1298 // Bring TCP/IP up immediately before we're ready to accept commands.
1300 // That is as soon as a PING responds, we're accepting telnet sessions.
1301 #if defined(CYGPKG_NET_FREEBSD_STACK)
1302 phi_init_all_network_interfaces();
1308 diag_printf("Network not up and running\n");
1311 #if defined(CYGPKG_NET_FREEBSD_STACK)
1313 tftpd_start(69, &fileops
);
1316 cyg_httpd_init_tcl_interpreter();
1318 interp
= httpstate
.jim_interp
;
1320 Jim_CreateCommand(httpstate
.jim_interp
, "log", zylinjtag_Jim_Command_log
, NULL
, NULL
);
1321 Jim_CreateCommand(httpstate
.jim_interp
, "reboot", zylinjtag_Jim_Command_reboot
, NULL
, NULL
);
1322 Jim_CreateCommand(httpstate
.jim_interp
, "peek", zylinjtag_Jim_Command_peek
, NULL
, NULL
);
1323 Jim_CreateCommand(httpstate
.jim_interp
, "zy1000_flash", zylinjtag_Jim_Command_flash
, NULL
, NULL
);
1324 Jim_CreateCommand(httpstate
.jim_interp
, "poke", zylinjtag_Jim_Command_poke
, NULL
, NULL
);
1325 Jim_CreateCommand(httpstate
.jim_interp
, "ls", zylinjtag_Jim_Command_ls
, NULL
, NULL
);
1326 Jim_CreateCommand(httpstate
.jim_interp
, "threads", zylinjtag_Jim_Command_threads
, NULL
, NULL
);
1327 Jim_CreateCommand(httpstate
.jim_interp
, "getmem", zylinjtag_Jim_Command_getmem
, NULL
, NULL
);
1328 Jim_CreateCommand(httpstate
.jim_interp
, "mac", zylinjtag_Jim_Command_mac
, NULL
, NULL
);
1329 Jim_CreateCommand(httpstate
.jim_interp
, "ip", zylinjtag_Jim_Command_ip
, NULL
, NULL
);
1330 Jim_CreateCommand(httpstate
.jim_interp
, "rm", zylinjtag_Jim_Command_rm
, NULL
, NULL
);
1336 diag_printf("Web server running\n");
1344 print_exception_handler(cyg_addrword_t data
, cyg_code_t exception
, cyg_addrword_t info
)
1348 char *infoStr
= "unknown";
1351 case CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION
:
1352 infoStr
= "undefined instruction";
1354 case CYGNUM_HAL_VECTOR_SOFTWARE_INTERRUPT
:
1355 infoStr
= "software interrupt";
1357 case CYGNUM_HAL_VECTOR_ABORT_PREFETCH
:
1358 infoStr
= "abort prefetch";
1360 case CYGNUM_HAL_VECTOR_ABORT_DATA
:
1361 infoStr
= "abort data";
1367 diag_printf("Exception: %08x(%s) %08x\n", exception
, infoStr
, info
);
1369 diag_printf("Dumping log\n---\n");
1370 if (logCount
>= logSize
)
1372 diag_write(logBuffer
+ logCount
% logSize
, logSize
- logCount
% logSize
);
1374 diag_write(logBuffer
, writePtr
);
1376 diag_printf("---\nLogdump complete.\n");
1377 diag_printf("Exception: %08x(%s) %08x\n", exception
, infoStr
, info
);
1378 diag_printf("\n---\nRebooting\n");
1379 HAL_PLATFORM_RESET();
1383 static void setHandler(cyg_code_t exception
)
1385 cyg_exception_handler_t
*old_handler
;
1386 cyg_addrword_t old_data
;
1388 cyg_exception_set_handler(exception
,
1389 print_exception_handler
,
1395 static cyg_thread zylinjtag_uart_thread_object
;
1396 static cyg_handle_t zylinjtag_uart_thread_handle
;
1397 static char uart_stack
[4096];
1399 static char forwardBuffer
[1024]; // NB! must be smaller than a TCP/IP packet!!!!!
1400 static char backwardBuffer
[1024];
1402 static cyg_io_handle_t serial_handle
;
1404 void setNoDelay(int session
, int flag
)
1407 // This decreases latency dramatically for e.g. GDB load which
1408 // does not have a sliding window protocol
1410 // Can cause *lots* of TCP/IP packets to be sent and it would have
1411 // to be enabled/disabled on the fly to avoid the CPU being
1413 setsockopt(session
, /* socket affected */
1414 IPPROTO_TCP
, /* set option at TCP level */
1415 TCP_NODELAY
, /* name of option */
1416 (char *) &flag
, /* the cast is historical
1418 sizeof(int)); /* length of option value */
1428 } tcpipSent
[512 * 1024];
1432 zylinjtag_uart(cyg_addrword_t data
)
1434 int so_reuseaddr_option
= 1;
1437 if ((fd
= socket(AF_INET
, SOCK_STREAM
, 0)) == -1)
1439 LOG_ERROR("error creating socket: %s", strerror(errno
));
1443 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (void*)&so_reuseaddr_option
, sizeof(int));
1445 struct sockaddr_in sin
;
1446 unsigned int address_size
;
1447 address_size
= sizeof(sin
);
1448 memset(&sin
, 0, sizeof(sin
));
1449 sin
.sin_family
= AF_INET
;
1450 sin
.sin_addr
.s_addr
= INADDR_ANY
;
1451 sin
.sin_port
= htons(5555);
1453 if (bind(fd
, (struct sockaddr
*) &sin
, sizeof(sin
)) == -1)
1455 LOG_ERROR("couldn't bind to socket: %s", strerror(errno
));
1459 if (listen(fd
, 1) == -1)
1461 LOG_ERROR("couldn't listen on socket: %s", strerror(errno
));
1464 // socket_nonblock(fd);
1469 int session
= accept(fd
, (struct sockaddr
*) &sin
, &address_size
);
1475 setNoDelay(session
, 1);
1476 int oldopts
= fcntl(session
, F_GETFL
, 0);
1477 fcntl(session
, F_SETFL
, oldopts
| O_NONBLOCK
); //
1479 int serHandle
= open("/dev/ser0", O_RDWR
| O_NONBLOCK
);
1497 FD_ZERO(&write_fds
);
1500 FD_SET(session
, &read_fds
);
1502 FD_SET(serHandle
, &read_fds
);
1503 if (serHandle
> fd_max
)
1509 cyg_thread_delay(5); // 50ms fixed delay to wait for data to be sent/received
1510 if ((actual
== 0) && (actual2
== 0))
1512 int retval
= select(fd_max
+ 1, &read_fds
, NULL
, NULL
, NULL
);
1521 memset(backwardBuffer
, 's', sizeof(backwardBuffer
));
1522 actual2
=read(serHandle
, backwardBuffer
, sizeof(backwardBuffer
));
1525 if (errno
!= EAGAIN
)
1538 int written
= write(session
, backwardBuffer
+ pos2
, actual2
);
1546 if (FD_ISSET(session
, &read_fds
)&&(sizeof(forwardBuffer
)>actual
))
1548 // NB! Here it is important that we empty the TCP/IP read buffer
1549 // to make transmission tick right
1550 memmove(forwardBuffer
, forwardBuffer
+ pos
, actual
);
1553 // this will block if there is no data at all
1554 t
=read_socket(session
, forwardBuffer
+actual
, sizeof(forwardBuffer
)-actual
);
1566 /* Do not put things into the serial buffer if it has something to send
1567 * as that can cause a single byte to be sent at the time.
1571 int written
= write(serHandle
, forwardBuffer
+ pos
, actual
);
1574 if (errno
!= EAGAIN
)
1578 // The serial buffer is full
1589 tcpipSent
[cur
].req
= x
;
1590 tcpipSent
[cur
].actual
= y
;
1591 tcpipSent
[cur
].req2
= x2
;
1592 tcpipSent
[cur
].actual2
= y2
;
1602 for (i
= 0; i
< 1024; i
++)
1604 diag_printf("%d %d %d %d\n", tcpipSent
[i
].req
, tcpipSent
[i
].actual
, tcpipSent
[i
].req2
, tcpipSent
[i
].actual2
);
1612 void startUart(void)
1614 cyg_thread_create(1,
1620 &zylinjtag_uart_thread_handle
,
1621 &zylinjtag_uart_thread_object
);
1622 cyg_thread_set_priority(zylinjtag_uart_thread_handle
, 1); // low priority as it sits in a busy loop
1623 cyg_thread_resume(zylinjtag_uart_thread_handle
);
1628 int handle_uart_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1632 command_print(cmd_ctx
, "usage: uart <baudrate>");
1633 return ERROR_INVALID_ARGUMENTS
;
1636 int baud
= atol(args
[0]);
1641 baud
= CYGNUM_SERIAL_BAUD_9600
;
1644 baud
= CYGNUM_SERIAL_BAUD_19200
;
1647 baud
= CYGNUM_SERIAL_BAUD_38400
;
1650 baud
= CYGNUM_SERIAL_BAUD_57600
;
1653 baud
= CYGNUM_SERIAL_BAUD_115200
;
1656 baud
= CYGNUM_SERIAL_BAUD_230400
;
1659 command_print(cmd_ctx
, "unsupported baudrate");
1660 return ERROR_INVALID_ARGUMENTS
;
1663 cyg_serial_info_t buf
;
1665 //get existing serial configuration
1666 len
= sizeof(cyg_serial_info_t
);
1668 err
= cyg_io_get_config(serial_handle
, CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN
, &buf
, &len
);
1669 err
= cyg_io_get_config(serial_handle
, CYG_IO_GET_CONFIG_SERIAL_INFO
, &buf
, &len
);
1672 command_print(cmd_ctx
, "Failed to get serial port settings %d", err
);
1677 err
= cyg_io_set_config(serial_handle
, CYG_IO_SET_CONFIG_SERIAL_INFO
, &buf
, &len
);
1680 command_print(cmd_ctx
, "Failed to set serial port settings %d", err
);
1687 bool logAllToSerial
= false;
1689 /* boolean parameter stored on config */
1690 bool boolParam(char *var
)
1692 bool result
= false;
1693 char *name
= alloc_printf(ZYLIN_CONFIG_DIR
"/%s", var
);
1699 if (loadFile(name
, &data
, &len
) == ERROR_OK
)
1703 result
= strncmp((char *) data
, "1", len
) == 0;
1710 command_context_t
*setup_command_handler();
1712 int add_default_dirs(void)
1714 add_script_search_dir(ZYLIN_CONFIG_DIR
);
1715 add_script_search_dir("/rom/lib/openocd");
1716 add_script_search_dir("/rom");
1720 static cyg_uint8
*ramblockdevice
;
1721 static const int ramblockdevice_size
=4096*1024;
1722 int main(int argc
, char *argv
[])
1724 /* ramblockdevice will be the same address every time. The deflate app uses a buffer 16mBytes out, so we
1725 * need to allocate towards the end of the heap. */
1727 ramblockdevice
=(cyg_uint8
*)malloc(ramblockdevice_size
);
1728 memset(ramblockdevice
, 0xff, ramblockdevice_size
);
1730 setHandler(CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION
);
1731 setHandler(CYGNUM_HAL_VECTOR_ABORT_PREFETCH
);
1732 setHandler(CYGNUM_HAL_VECTOR_ABORT_DATA
);
1735 err
= cyg_io_lookup("/dev/ser0", &serial_handle
);
1738 diag_printf("/dev/ser0 not found\n");
1742 setPower(true); // on by default
1744 atexit(keep_webserver
);
1746 err
= mount("", "/ram", "ramfs");
1749 diag_printf("unable to mount ramfs\n");
1754 sprintf(address
, "%p", &filedata
[0]);
1755 err
= mount(address
, "/rom", "romfs");
1758 diag_printf("unable to mount /rom\n");
1761 err
= mount("", "/log", "logfs");
1764 diag_printf("unable to mount logfs\n");
1767 err
= mount("", "/tftp", "tftpfs");
1770 diag_printf("unable to mount logfs\n");
1773 log
= fopen("/log/log", "w");
1776 diag_printf("Could not open log file /ram/log\n");
1780 diag_init_putc(_zylinjtag_diag_write_char
);
1782 // We want this in the log.
1783 diag_printf("Zylin ZY1000. Copyright Zylin AS 2007-2008.\n");
1784 diag_printf("%s\n", ZYLIN_OPENOCD_VERSION
);
1786 copydir("/rom", "/ram/cgi");
1788 err
= mount("/dev/flash1", "/config", "jffs2");
1791 diag_printf("unable to mount jffs\n");
1795 /* are we using a ram disk instead of a flash disk? This is used
1796 * for ZY1000 live demo...
1798 * copy over flash disk to ram block device
1800 if (boolParam("ramdisk"))
1802 diag_printf("Unmounting /config from flash and using ram instead\n");
1803 err
=umount("/config");
1806 diag_printf("unable to unmount jffs\n");
1810 err
= mount("/dev/flash1", "/config2", "jffs2");
1813 diag_printf("unable to mount jffs\n");
1817 err
= mount("/dev/ram", "/config", "jffs2");
1820 diag_printf("unable to mount ram block device\n");
1824 // copydir("/config2", "/config");
1825 copyfile("/config2/ip", "/config/ip");
1826 copydir("/config2/settings", "/config/settings");
1831 /* we're not going to use a ram block disk */
1832 free(ramblockdevice
);
1836 mkdir(ZYLIN_CONFIG_DIR
, 0777);
1837 mkdir(ZYLIN_CONFIG_DIR
"/target", 0777);
1838 mkdir(ZYLIN_CONFIG_DIR
"/event", 0777);
1840 logAllToSerial
= boolParam("logserial");
1842 // We need the network & web server in case there is something wrong with
1843 // the config files that invoke exit()
1844 zylinjtag_startNetwork();
1846 /* we're going to access the jim interpreter from here on... */
1847 openocd_sleep_postlude();
1852 /* initialize commandline interface */
1853 command_context_t
*cmd_ctx
;
1854 cmd_ctx
= setup_command_handler();
1855 command_set_output_handler(cmd_ctx
, configuration_output_handler
, NULL
);
1856 command_context_mode(cmd_ctx
, COMMAND_CONFIG
);
1859 register_command(cmd_ctx
, NULL
, "zy1000_version", handle_zy1000_version_command
,
1860 COMMAND_EXEC
, "show zy1000 version numbers");
1862 register_command(cmd_ctx
, NULL
, "rm", handle_rm_command
, COMMAND_ANY
,
1865 register_command(cmd_ctx
, NULL
, "fast_load_image", handle_fast_load_image_command
, COMMAND_ANY
,
1866 "same args as load_image, image stored in memory");
1868 register_command(cmd_ctx
, NULL
, "fast_load", handle_fast_load_command
, COMMAND_ANY
,
1869 "loads active fast load image to current target");
1871 register_command(cmd_ctx
, NULL
, "cat", handle_cat_command
, COMMAND_ANY
,
1872 "display file content");
1874 register_command(cmd_ctx
, NULL
, "trunc", handle_trunc_command
, COMMAND_ANY
,
1875 "truncate a file to 0 size");
1877 register_command(cmd_ctx
, NULL
, "append_file", handle_append_command
,
1878 COMMAND_ANY
, "append a variable number of strings to a file");
1880 register_command(cmd_ctx
, NULL
, "power", handle_power_command
, COMMAND_ANY
,
1881 "power <on/off> - turn power switch to target on/off. No arguments - print status.");
1883 register_command(cmd_ctx
, NULL
, "meminfo", handle_meminfo_command
,
1884 COMMAND_ANY
, "display available ram memory");
1886 register_command(cmd_ctx
, NULL
, "cp", handle_cp_command
,
1887 COMMAND_ANY
, "copy a file <from> <to>");
1889 #ifdef CYGPKG_PROFILE_GPROF
1890 register_command(cmd_ctx
, NULL
, "ecosboard_profile", eCosBoard_handle_eCosBoard_profile_command
,
1893 register_command(cmd_ctx
, NULL
, "uart", handle_uart_command
,
1894 COMMAND_ANY
, "uart <baud> - forward uart on port 5555");
1898 errVal
= log_init(cmd_ctx
);
1899 if (errVal
!= ERROR_OK
)
1901 diag_printf("log_init() failed %d\n", errVal
);
1905 set_log_output(cmd_ctx
, log
);
1907 LOG_DEBUG("log init complete");
1909 // diag_printf("Executing config files\n");
1913 diag_printf(ZYLIN_CONFIG_DIR
"/logserial=1 => sending log output to serial port using \"debug_level 3\" as default.\n");
1914 command_run_line(cmd_ctx
, "debug_level 3");
1917 zylinjtag_parse_config_file(cmd_ctx
, "/rom/openocd.cfg");
1920 // diag_printf() is really invoked from many more places than we trust it
1921 // not to cause instabilities(e.g. invoking fputc() from an interrupt is *BAD*).
1923 // Disabling it here is safe and gives us enough logged debug output for now. Crossing
1924 // fingers that it doesn't cause any crashes.
1925 diag_printf("Init complete, GDB & telnet servers launched.\n");
1926 command_set_output_handler(cmd_ctx
, zy1000_configuration_output_handler_log
, NULL
);
1927 if (!logAllToSerial
)
1932 /* handle network connections */
1933 server_loop(cmd_ctx
);
1934 openocd_sleep_prelude();
1936 /* shut server down */
1939 /* free commandline interface */
1940 command_done(cmd_ctx
);
1950 cyg_httpd_exec_cgi_tcl(char *file_name
);
1951 cyg_int32
homeForm(CYG_HTTPD_STATE
*p
)
1953 cyg_httpd_exec_cgi_tcl("/ram/cgi/index.tcl");
1957 CYG_HTTPD_HANDLER_TABLE_ENTRY(root_label
, "/", homeForm
);
1959 CYG_HTTPD_MIME_TABLE_ENTRY(text_mime_label
, "text", "text/plain");
1960 CYG_HTTPD_MIME_TABLE_ENTRY(bin_mime_label
, "bin", "application/octet-stream");
1962 #include <pkgconf/system.h>
1963 #include <pkgconf/hal.h>
1964 #include <pkgconf/kernel.h>
1965 #include <pkgconf/io_fileio.h>
1966 #include <pkgconf/fs_rom.h>
1968 #include <cyg/kernel/ktypes.h> // base kernel types
1969 #include <cyg/infra/cyg_trac.h> // tracing macros
1970 #include <cyg/infra/cyg_ass.h> // assertion macros
1972 #include <sys/types.h>
1974 #include <sys/stat.h>
1983 #include <cyg/fileio/fileio.h>
1985 #include <cyg/kernel/kapi.h>
1986 #include <cyg/infra/diag.h>
1988 //==========================================================================
1989 // Eventually we want to eXecute In Place from the ROM in a protected
1990 // environment, so we'll need executables to be aligned to a boundary
1991 // suitable for MMU protection. A suitable boundary would be the 4k
1992 // boundary in all the CPU architectures I am currently aware of.
1994 // Forward definitions
1996 // Filesystem operations
1997 static int tftpfs_mount(cyg_fstab_entry
*fste
, cyg_mtab_entry
*mte
);
1998 static int tftpfs_umount(cyg_mtab_entry
*mte
);
1999 static int tftpfs_open(cyg_mtab_entry
*mte
, cyg_dir dir
, const char *name
,
2000 int mode
, cyg_file
*fte
);
2001 static int tftpfs_fo_read(struct CYG_FILE_TAG
*fp
, struct CYG_UIO_TAG
*uio
);
2002 static int tftpfs_fo_write(struct CYG_FILE_TAG
*fp
, struct CYG_UIO_TAG
*uio
);
2005 static int tftpfs_fo_fsync(struct CYG_FILE_TAG
*fp
, int mode
);
2006 static int tftpfs_fo_close(struct CYG_FILE_TAG
*fp
);
2007 static int tftpfs_fo_lseek(struct CYG_FILE_TAG
*fp
, off_t
*apos
, int whence
);
2009 //==========================================================================
2010 // Filesystem table entries
2012 // -------------------------------------------------------------------------
2014 // This defines the entry in the filesystem table.
2015 // For simplicity we use _FILESYSTEM synchronization for all accesses since
2016 // we should never block in any filesystem operations.
2018 FSTAB_ENTRY( tftpfs_fste
, "tftpfs", 0,
2023 (cyg_fsop_unlink
*)cyg_fileio_erofs
,
2024 (cyg_fsop_mkdir
*)cyg_fileio_erofs
,
2025 (cyg_fsop_rmdir
*)cyg_fileio_erofs
,
2026 (cyg_fsop_rename
*)cyg_fileio_erofs
,
2027 (cyg_fsop_link
*)cyg_fileio_erofs
,
2028 (cyg_fsop_opendir
*)cyg_fileio_erofs
,
2029 (cyg_fsop_chdir
*)cyg_fileio_erofs
,
2030 (cyg_fsop_stat
*)cyg_fileio_erofs
,
2031 (cyg_fsop_getinfo
*)cyg_fileio_erofs
,
2032 (cyg_fsop_setinfo
*)cyg_fileio_erofs
);
2035 // -------------------------------------------------------------------------
2037 // This defines a single ROMFS loaded into ROM at the configured address
2039 // MTAB_ENTRY( rom_mte, // structure name
2040 // "/rom", // mount point
2041 // "romfs", // FIlesystem type
2042 // "", // hardware device
2043 // (CYG_ADDRWORD) CYGNUM_FS_ROM_BASE_ADDRESS // Address in ROM
2047 // -------------------------------------------------------------------------
2049 // This set of file operations are used for normal open files.
2051 static cyg_fileops tftpfs_fileops
=
2056 (cyg_fileop_ioctl
*)cyg_fileio_erofs
,
2060 (cyg_fileop_fstat
*) cyg_fileio_erofs
,
2061 (cyg_fileop_getinfo
*) cyg_fileio_erofs
,
2062 (cyg_fileop_setinfo
*)cyg_fileio_erofs
,
2065 // -------------------------------------------------------------------------
2067 // Process a mount request. This mainly finds root for the
2070 static int tftpfs_mount(cyg_fstab_entry
*fste
, cyg_mtab_entry
*mte
)
2075 static int tftpfs_umount(cyg_mtab_entry
*mte
)
2090 static void freeTftp(struct Tftp
*t
)
2103 static const int tftpMaxSize
= 8192 * 1024;
2104 static int tftpfs_open(cyg_mtab_entry
*mte
, cyg_dir dir
, const char *name
,
2105 int mode
, cyg_file
*file
)
2108 tftp
= malloc(sizeof(struct Tftp
));
2111 memset(tftp
, 0, sizeof(struct Tftp
));
2113 file
->f_flag
|= mode
& CYG_FILE_MODE_MASK
;
2114 file
->f_type
= CYG_FILE_TYPE_FILE
;
2115 file
->f_ops
= &tftpfs_fileops
;
2120 tftp
->mem
= malloc(tftpMaxSize
);
2121 if (tftp
->mem
== NULL
)
2127 char *server
= strchr(name
, '/');
2134 tftp
->server
= malloc(server
- name
+ 1);
2135 if (tftp
->server
== NULL
)
2140 strncpy(tftp
->server
, name
, server
- name
);
2141 tftp
->server
[server
- name
] = 0;
2143 tftp
->file
= strdup(server
+ 1);
2144 if (tftp
->file
== NULL
)
2150 file
->f_data
= (CYG_ADDRWORD
) tftp
;
2155 static int fetchTftp(struct Tftp
*tftp
)
2157 if (!tftp
->readFile
)
2160 tftp
->actual
= tftp_client_get( tftp
->file
, tftp
->server
, 0, tftp
->mem
, tftpMaxSize
, TFTP_OCTET
, &err
);
2162 if (tftp
->actual
< 0)
2171 // -------------------------------------------------------------------------
2172 // tftpfs_fo_write()
2173 // Read data from file.
2176 tftpfs_fo_read(struct CYG_FILE_TAG
*fp
, struct CYG_UIO_TAG
*uio
)
2178 struct Tftp
*tftp
= (struct Tftp
*) fp
->f_data
;
2180 if (fetchTftp(tftp
) != ENOERR
)
2184 off_t pos
= fp
->f_offset
;
2186 for (i
= 0; i
< uio
->uio_iovcnt
; i
++)
2188 cyg_iovec
*iov
= &uio
->uio_iov
[i
];
2189 char *buf
= (char *) iov
->iov_base
;
2190 off_t len
= iov
->iov_len
;
2192 if (len
+ pos
> tftp
->actual
)
2194 len
= tftp
->actual
- pos
;
2196 resid
+= iov
->iov_len
- len
;
2198 memcpy(buf
, tftp
->mem
+ pos
, len
);
2202 uio
->uio_resid
= resid
;
2210 tftpfs_fo_write(struct CYG_FILE_TAG
*fp
, struct CYG_UIO_TAG
*uio
)
2212 struct Tftp
*tftp
= (struct Tftp
*) fp
->f_data
;
2215 off_t pos
= fp
->f_offset
;
2217 for (i
= 0; i
< uio
->uio_iovcnt
; i
++)
2219 cyg_iovec
*iov
= &uio
->uio_iov
[i
];
2220 char *buf
= (char *) iov
->iov_base
;
2221 off_t len
= iov
->iov_len
;
2223 if (len
+ pos
> tftpMaxSize
)
2225 len
= tftpMaxSize
- pos
;
2227 resid
+= iov
->iov_len
- len
;
2229 memcpy(tftp
->mem
+ pos
, buf
, len
);
2233 uio
->uio_resid
= resid
;
2242 tftpfs_fo_fsync(struct CYG_FILE_TAG
*fp
, int mode
)
2248 // -------------------------------------------------------------------------
2250 // Close a file. We just clear out the data pointer.
2252 static int tftpfs_fo_close(struct CYG_FILE_TAG
*fp
)
2254 struct Tftp
*tftp
= (struct Tftp
*) fp
->f_data
;
2259 tftp_client_put( tftp
->file
, tftp
->server
, 0, tftp
->mem
, fp
->f_offset
, TFTP_OCTET
, &error
);
2267 // -------------------------------------------------------------------------
2269 // Seek to a new file position.
2271 static int tftpfs_fo_lseek(struct CYG_FILE_TAG
*fp
, off_t
*apos
, int whence
)
2273 struct Tftp
*tftp
= (struct Tftp
*) fp
->f_data
;
2276 if (fetchTftp(tftp
) != ENOERR
)
2282 // Pos is already where we want to be.
2286 // Add pos to current offset.
2287 pos
+= fp
->f_offset
;
2291 // Add pos to file size.
2292 pos
+= tftp
->actual
;
2299 // Check that pos is still within current file size, or at the
2301 if (pos
< 0 || pos
> tftp
->actual
)
2304 // All OK, set fp offset and return new position.
2305 *apos
= fp
->f_offset
= pos
;
2313 cyg_thread_delay(us
/ 10000 + 1);
2320 show_log_entry(CYG_HTTPD_STATE
*phttpstate
)
2322 cyg_httpd_start_chunked("text");
2323 if (logCount
>= logSize
)
2325 cyg_httpd_write_chunked(logBuffer
+logCount
%logSize
, logSize
-logCount
%logSize
);
2327 cyg_httpd_write_chunked(logBuffer
, writePtr
);
2328 cyg_httpd_end_chunked();
2332 CYG_HTTPD_HANDLER_TABLE_ENTRY(show_log
, "/ram/log", show_log_entry
);
2334 // Filesystem operations
2335 static int logfs_mount(cyg_fstab_entry
*fste
, cyg_mtab_entry
*mte
);
2336 static int logfs_umount(cyg_mtab_entry
*mte
);
2337 static int logfs_open(cyg_mtab_entry
*mte
, cyg_dir dir
, const char *name
,
2338 int mode
, cyg_file
*fte
);
2340 logfs_fo_write(struct CYG_FILE_TAG
*fp
, struct CYG_UIO_TAG
*uio
);
2343 static int logfs_fo_fsync(struct CYG_FILE_TAG
*fp
, int mode
);
2344 static int logfs_fo_close(struct CYG_FILE_TAG
*fp
);
2346 #include <cyg/io/devtab.h>
2348 //==========================================================================
2349 // Filesystem table entries
2351 // -------------------------------------------------------------------------
2353 // This defines the entry in the filesystem table.
2354 // For simplicity we use _FILESYSTEM synchronization for all accesses since
2355 // we should never block in any filesystem operations.
2356 FSTAB_ENTRY( logfs_fste
, "logfs", 0,
2357 CYG_SYNCMODE_FILE_FILESYSTEM
|CYG_SYNCMODE_IO_FILESYSTEM
,
2361 (cyg_fsop_unlink
*)cyg_fileio_erofs
,
2362 (cyg_fsop_mkdir
*)cyg_fileio_erofs
,
2363 (cyg_fsop_rmdir
*)cyg_fileio_erofs
,
2364 (cyg_fsop_rename
*)cyg_fileio_erofs
,
2365 (cyg_fsop_link
*)cyg_fileio_erofs
,
2366 (cyg_fsop_opendir
*)cyg_fileio_erofs
,
2367 (cyg_fsop_chdir
*)cyg_fileio_erofs
,
2368 (cyg_fsop_stat
*)cyg_fileio_erofs
,
2369 (cyg_fsop_getinfo
*)cyg_fileio_erofs
,
2370 (cyg_fsop_setinfo
*)cyg_fileio_erofs
);
2372 // -------------------------------------------------------------------------
2374 // This set of file operations are used for normal open files.
2376 static cyg_fileops logfs_fileops
=
2378 (cyg_fileop_read
*)cyg_fileio_erofs
,
2379 (cyg_fileop_write
*)logfs_fo_write
,
2380 (cyg_fileop_lseek
*) cyg_fileio_erofs
,
2381 (cyg_fileop_ioctl
*)cyg_fileio_erofs
,
2385 (cyg_fileop_fstat
*)cyg_fileio_erofs
,
2386 (cyg_fileop_getinfo
*) cyg_fileio_erofs
,
2387 (cyg_fileop_setinfo
*)cyg_fileio_erofs
,
2390 // -------------------------------------------------------------------------
2392 // Process a mount request. This mainly finds root for the
2395 static int logfs_mount(cyg_fstab_entry
*fste
, cyg_mtab_entry
*mte
)
2400 static int logfs_umount(cyg_mtab_entry
*mte
)
2405 static int logfs_open(cyg_mtab_entry
*mte
, cyg_dir dir
, const char *name
,
2406 int mode
, cyg_file
*file
)
2408 file
->f_flag
|= mode
& CYG_FILE_MODE_MASK
;
2409 file
->f_type
= CYG_FILE_TYPE_FILE
;
2410 file
->f_ops
= &logfs_fileops
;
2417 // -------------------------------------------------------------------------
2419 // Write data to file.
2422 logfs_fo_write(struct CYG_FILE_TAG
*fp
, struct CYG_UIO_TAG
*uio
)
2425 for (i
= 0; i
< uio
->uio_iovcnt
; i
++)
2427 cyg_iovec
*iov
= &uio
->uio_iov
[i
];
2428 char *buf
= (char *) iov
->iov_base
;
2429 off_t len
= iov
->iov_len
;
2431 diag_write(buf
, len
);
2438 logfs_fo_fsync(struct CYG_FILE_TAG
*fp
, int mode
)
2443 // -------------------------------------------------------------------------
2445 // Close a file. We just clear out the data pointer.
2447 static int logfs_fo_close(struct CYG_FILE_TAG
*fp
)
2453 ramiodev_init( struct cyg_devtab_entry
*tab
)
2459 ramiodev_bread( cyg_io_handle_t handle
, void *buf
, cyg_uint32
*len
,
2462 if (*len
+pos
>ramblockdevice_size
)
2464 *len
=ramblockdevice_size
-pos
;
2466 memcpy(buf
, ramblockdevice
+pos
, *len
);
2471 ramiodev_bwrite( cyg_io_handle_t handle
, const void *buf
, cyg_uint32
*len
,
2474 if (((pos
%4)!=0)||(((*len
)%4)!=0))
2476 diag_printf("Unaligned write %d %d!", pos
, *len
);
2479 memcpy(ramblockdevice
+pos
, buf
, *len
);
2484 ramiodev_get_config( cyg_io_handle_t handle
,
2490 case CYG_IO_GET_CONFIG_FLASH_ERASE
:
2492 if ( *len
!= sizeof( cyg_io_flash_getconfig_erase_t
) )
2495 cyg_io_flash_getconfig_erase_t
*e
= (cyg_io_flash_getconfig_erase_t
*)buf
;
2496 char *startpos
= ramblockdevice
+ e
->offset
;
2498 if (((e
->offset
%(64*1024))!=0)||((e
->len
%(64*1024))!=0))
2500 diag_printf("Erease is not aligned %d %d\n", e
->offset
, e
->len
);
2503 memset(startpos
, 0xff, e
->len
);
2509 case CYG_IO_GET_CONFIG_FLASH_DEVSIZE
:
2511 if ( *len
!= sizeof( cyg_io_flash_getconfig_devsize_t
) )
2514 cyg_io_flash_getconfig_devsize_t
*d
=
2515 (cyg_io_flash_getconfig_devsize_t
*)buf
;
2517 d
->dev_size
= ramblockdevice_size
;
2522 case CYG_IO_GET_CONFIG_FLASH_BLOCKSIZE
:
2524 cyg_io_flash_getconfig_blocksize_t
*b
=
2525 (cyg_io_flash_getconfig_blocksize_t
*)buf
;
2526 if ( *len
!= sizeof( cyg_io_flash_getconfig_blocksize_t
) )
2529 // offset unused for now
2530 b
->block_size
= 64*1024;
2540 ramiodev_set_config( cyg_io_handle_t handle
,
2550 } // ramiodev_set_config()
2552 // get_config/set_config should be added later to provide the other flash
2553 // operations possible, like erase etc.
2555 BLOCK_DEVIO_TABLE( cyg_io_ramdev1_ops
,
2559 &ramiodev_get_config
,
2560 &ramiodev_set_config
2564 BLOCK_DEVTAB_ENTRY( cyg_io_ramdev1
,
2567 &cyg_io_ramdev1_ops
,
2569 0, // No lookup required
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)