1 /***************************************************************************
2 * Copyright (C) 2007-2010 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 ***************************************************************************/
20 /* This file supports the zy1000 debugger: http://www.zylin.com/zy1000.html
22 * The zy1000 is a standalone debugger that has a web interface and
23 * requires no drivers on the developer host as all communication
24 * is via TCP/IP. The zy1000 gets it performance(~400-700kBytes/s
25 * DCC downloads @ 16MHz target) as it has an FPGA to hardware
26 * accelerate the JTAG commands, while offering *very* low latency
27 * between OpenOCD and the FPGA registers.
29 * The disadvantage of the zy1000 is that it has a feeble CPU compared to
30 * a PC(ca. 50-500 DMIPS depending on how one counts it), whereas a PC
31 * is on the order of 10000 DMIPS(i.e. at a factor of 20-200).
33 * The zy1000 revc hardware is using an Altera Nios CPU, whereas the
34 * revb is using ARM7 + Xilinx.
36 * See Zylin web pages or contact Zylin for more information.
38 * The reason this code is in OpenOCD rather than OpenOCD linked with the
39 * ZY1000 code is that OpenOCD is the long road towards getting
40 * libopenocd into place. libopenocd will support both low performance,
41 * low latency systems(embedded) and high performance high latency
48 #include <target/embeddedice.h>
49 #include <jtag/minidriver.h>
50 #include <jtag/interface.h>
52 #include <helper/time_support.h>
54 #include <netinet/tcp.h>
57 #include "zy1000_version.h"
59 #include <cyg/hal/hal_io.h> // low level i/o
60 #include <cyg/hal/hal_diag.h>
62 #ifdef CYGPKG_HAL_NIOS2
63 #include <cyg/hal/io.h>
64 #include <cyg/firmwareutil/firmwareutil.h>
67 #define ZYLIN_VERSION GIT_ZY1000_VERSION
68 #define ZYLIN_DATE __DATE__
69 #define ZYLIN_TIME __TIME__
70 #define ZYLIN_OPENOCD GIT_OPENOCD_VERSION
71 #define ZYLIN_OPENOCD_VERSION "ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE
75 static int zy1000_khz(int khz
, int *jtag_speed
)
83 *jtag_speed
= 64000/khz
;
88 static int zy1000_speed_div(int speed
, int *khz
)
102 static bool readPowerDropout(void)
105 // sample and clear power dropout
106 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x80);
107 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0x10, state
);
109 powerDropout
= (state
& 0x80) != 0;
114 static bool readSRST(void)
117 // sample and clear SRST sensing
118 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x00000040);
119 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0x10, state
);
121 srstAsserted
= (state
& 0x40) != 0;
125 static int zy1000_srst_asserted(int *srst_asserted
)
127 *srst_asserted
= readSRST();
131 static int zy1000_power_dropout(int *dropout
)
133 *dropout
= readPowerDropout();
137 void zy1000_reset(int trst
, int srst
)
139 LOG_DEBUG("zy1000 trst=%d, srst=%d", trst
, srst
);
141 /* flush the JTAG FIFO. Not flushing the queue before messing with
142 * reset has such interesting bugs as causing hard to reproduce
143 * RCLK bugs as RCLK will stop responding when TRST is asserted
149 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x00000001);
153 /* Danger!!! if clk != 0 when in
154 * idle in TAP_IDLE, reset halt on str912 will fail.
156 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x00000001);
161 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x00000002);
166 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x00000002);
169 if (trst
||(srst
&& (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
171 /* we're now in the RESET state until trst is deasserted */
172 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x20, TAP_RESET
);
175 /* We'll get RCLK failure when we assert TRST, so clear any false positives here */
176 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x400);
179 /* wait for srst to float back up */
180 if ((!srst
&& ((jtag_get_reset_config() & RESET_TRST_PULLS_SRST
) == 0))||
181 (!srst
&& !trst
&& (jtag_get_reset_config() & RESET_TRST_PULLS_SRST
)))
188 // We don't want to sense our own reset, so we clear here.
189 // There is of course a timing hole where we could loose
195 LOG_USER("SRST took %dms to deassert", (int)total
);
203 start
= timeval_ms();
206 total
= timeval_ms() - start
;
210 LOG_ERROR("SRST took too long to deassert: %dms", (int)total
);
218 int zy1000_speed(int speed
)
220 /* flush JTAG master FIFO before setting speed */
227 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x100);
228 LOG_DEBUG("jtag_speed using RCLK");
232 if (speed
> 8190 || speed
< 2)
234 LOG_USER("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
235 return ERROR_INVALID_ARGUMENTS
;
238 LOG_USER("jtag_speed %d => JTAG clk=%f", speed
, 64.0/(float)speed
);
239 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x100);
240 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x1c, speed
&~1);
245 static bool savePower
;
248 static void setPower(bool power
)
253 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x8);
256 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x8);
260 COMMAND_HANDLER(handle_power_command
)
266 COMMAND_PARSE_ON_OFF(CMD_ARGV
[0], enable
);
271 LOG_INFO("Target power %s", savePower
? "on" : "off");
274 return ERROR_INVALID_ARGUMENTS
;
281 static char *tcp_server
= "notspecified";
282 static int jim_zy1000_server(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
287 tcp_server
= strdup(Jim_GetString(argv
[1], NULL
));
294 /* Give TELNET a way to find out what version this is */
295 static int jim_zy1000_version(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
297 if ((argc
< 1) || (argc
> 3))
299 const char *version_str
= NULL
;
303 version_str
= ZYLIN_OPENOCD_VERSION
;
306 const char *str
= Jim_GetString(argv
[1], NULL
);
307 const char *str2
= NULL
;
309 str2
= Jim_GetString(argv
[2], NULL
);
310 if (strcmp("openocd", str
) == 0)
312 version_str
= ZYLIN_OPENOCD
;
314 else if (strcmp("zy1000", str
) == 0)
316 version_str
= ZYLIN_VERSION
;
318 else if (strcmp("date", str
) == 0)
320 version_str
= ZYLIN_DATE
;
322 else if (strcmp("time", str
) == 0)
324 version_str
= ZYLIN_TIME
;
326 else if (strcmp("pcb", str
) == 0)
328 #ifdef CYGPKG_HAL_NIOS2
334 #ifdef CYGPKG_HAL_NIOS2
335 else if (strcmp("fpga", str
) == 0)
338 /* return a list of 32 bit integers to describe the expected
341 static char *fpga_id
= "0x12345678 0x12345678 0x12345678 0x12345678";
342 uint32_t id
, timestamp
;
343 HAL_READ_UINT32(SYSID_BASE
, id
);
344 HAL_READ_UINT32(SYSID_BASE
+4, timestamp
);
345 sprintf(fpga_id
, "0x%08x 0x%08x 0x%08x 0x%08x", id
, timestamp
, SYSID_ID
, SYSID_TIMESTAMP
);
346 version_str
= fpga_id
;
347 if ((argc
>2) && (strcmp("time", str2
) == 0))
349 time_t last_mod
= timestamp
;
350 char * t
= ctime (&last_mod
) ;
363 Jim_SetResult(interp
, Jim_NewStringObj(interp
, version_str
, -1));
369 #ifdef CYGPKG_HAL_NIOS2
375 struct cyg_upgrade_info
*upgraded_file
;
378 static void report_info(void *data
, const char * format
, va_list args
)
380 char *s
= alloc_vprintf(format
, args
);
385 struct cyg_upgrade_info firmware_info
=
387 (uint8_t *)0x84000000,
393 "ZylinNiosFirmware\n",
397 static int jim_zy1000_writefirmware(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
403 const char *str
= Jim_GetString(argv
[1], &length
);
407 if ((tmpFile
= open(firmware_info
.file
, O_RDWR
| O_CREAT
| O_TRUNC
)) <= 0)
412 success
= write(tmpFile
, str
, length
) == length
;
417 if (!cyg_firmware_upgrade(NULL
, firmware_info
))
425 zylinjtag_Jim_Command_powerstatus(Jim_Interp
*interp
,
427 Jim_Obj
* const *argv
)
431 Jim_WrongNumArgs(interp
, 1, argv
, "powerstatus");
436 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0x10, status
);
438 Jim_SetResult(interp
, Jim_NewIntObj(interp
, (status
&0x80) != 0));
445 int zy1000_quit(void)
453 int interface_jtag_execute_queue(void)
458 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0x10, empty
);
459 /* clear JTAG error register */
460 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x400);
462 if ((empty
&0x400) != 0)
464 LOG_WARNING("RCLK timeout");
465 /* the error is informative only as we don't want to break the firmware if there
466 * is a false positive.
468 // return ERROR_FAIL;
477 static uint32_t getShiftValue(void)
481 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0xc, value
);
482 VERBOSE(LOG_INFO("getShiftValue %08x", value
));
486 static uint32_t getShiftValueFlip(void)
490 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0x18, value
);
491 VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value
));
497 static void shiftValueInnerFlip(const tap_state_t state
, const tap_state_t endState
, int repeat
, uint32_t value
)
499 VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state
), tap_state_name(endState
), repeat
, value
));
503 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0xc, value
);
504 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x8, (1 << 15) | (repeat
<< 8) | (a
<< 4) | b
);
505 VERBOSE(getShiftValueFlip());
509 // here we shuffle N bits out/in
510 static __inline
void scanBits(const uint8_t *out_value
, uint8_t *in_value
, int num_bits
, bool pause
, tap_state_t shiftState
, tap_state_t end_state
)
512 tap_state_t pause_state
= shiftState
;
513 for (int j
= 0; j
< num_bits
; j
+= 32)
515 int k
= num_bits
- j
;
519 /* we have more to shift out */
522 /* this was the last to shift out this time */
523 pause_state
= end_state
;
526 // we have (num_bits + 7)/8 bytes of bits to toggle out.
527 // bits are pushed out LSB to MSB
530 if (out_value
!= NULL
)
532 for (int l
= 0; l
< k
; l
+= 8)
534 value
|=out_value
[(j
+ l
)/8]<<l
;
537 /* mask away unused bits for easier debugging */
540 value
&=~(((uint32_t)0xffffffff) << k
);
543 /* Shifting by >= 32 is not defined by the C standard
544 * and will in fact shift by &0x1f bits on nios */
547 shiftValueInner(shiftState
, pause_state
, k
, value
);
549 if (in_value
!= NULL
)
551 // data in, LSB to MSB
552 value
= getShiftValue();
553 // we're shifting in data to MSB, shift data to be aligned for returning the value
556 for (int l
= 0; l
< k
; l
+= 8)
558 in_value
[(j
+ l
)/8]=(value
>> l
)&0xff;
564 static __inline
void scanFields(int num_fields
, const struct scan_field
*fields
, tap_state_t shiftState
, tap_state_t end_state
)
566 for (int i
= 0; i
< num_fields
; i
++)
568 scanBits(fields
[i
].out_value
,
577 int interface_jtag_add_ir_scan(struct jtag_tap
*active
, const struct scan_field
*fields
, tap_state_t state
)
580 struct jtag_tap
*tap
, *nextTap
;
581 tap_state_t pause_state
= TAP_IRSHIFT
;
583 for (tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= nextTap
)
585 nextTap
= jtag_tap_next_enabled(tap
);
590 scan_size
= tap
->ir_length
;
592 /* search the list */
595 scanFields(1, fields
, TAP_IRSHIFT
, pause_state
);
596 /* update device information */
597 buf_cpy(fields
[0].out_value
, tap
->cur_instr
, scan_size
);
602 /* if a device isn't listed, set it to BYPASS */
603 assert(scan_size
<= 32);
604 shiftValueInner(TAP_IRSHIFT
, pause_state
, scan_size
, 0xffffffff);
617 int interface_jtag_add_plain_ir_scan(int num_bits
, const uint8_t *out_bits
, uint8_t *in_bits
, tap_state_t state
)
619 scanBits(out_bits
, in_bits
, num_bits
, true, TAP_IRSHIFT
, state
);
623 int interface_jtag_add_dr_scan(struct jtag_tap
*active
, int num_fields
, const struct scan_field
*fields
, tap_state_t state
)
625 struct jtag_tap
*tap
, *nextTap
;
626 tap_state_t pause_state
= TAP_DRSHIFT
;
627 for (tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= nextTap
)
629 nextTap
= jtag_tap_next_enabled(tap
);
635 /* Find a range of fields to write to this tap */
638 assert(!tap
->bypass
);
640 scanFields(num_fields
, fields
, TAP_DRSHIFT
, pause_state
);
643 /* Shift out a 0 for disabled tap's */
645 shiftValueInner(TAP_DRSHIFT
, pause_state
, 1, 0);
651 int interface_jtag_add_plain_dr_scan(int num_bits
, const uint8_t *out_bits
, uint8_t *in_bits
, tap_state_t state
)
653 scanBits(out_bits
, in_bits
, num_bits
, true, TAP_DRSHIFT
, state
);
657 int interface_jtag_add_tlr()
659 setCurrentState(TAP_RESET
);
664 int interface_jtag_add_reset(int req_trst
, int req_srst
)
666 zy1000_reset(req_trst
, req_srst
);
670 static int zy1000_jtag_add_clocks(int num_cycles
, tap_state_t state
, tap_state_t clockstate
)
672 /* num_cycles can be 0 */
673 setCurrentState(clockstate
);
675 /* execute num_cycles, 32 at the time. */
677 for (i
= 0; i
< num_cycles
; i
+= 32)
681 if (num_cycles
-i
< num
)
685 shiftValueInner(clockstate
, clockstate
, num
, 0);
689 /* finish in end_state */
690 setCurrentState(state
);
692 tap_state_t t
= TAP_IDLE
;
693 /* test manual drive code on any target */
695 uint8_t tms_scan
= tap_get_tms_path(t
, state
);
696 int tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
698 for (i
= 0; i
< tms_count
; i
++)
700 tms
= (tms_scan
>> i
) & 1;
702 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, tms
);
705 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x20, state
);
711 int interface_jtag_add_runtest(int num_cycles
, tap_state_t state
)
713 return zy1000_jtag_add_clocks(num_cycles
, state
, TAP_IDLE
);
716 int interface_jtag_add_clocks(int num_cycles
)
718 return zy1000_jtag_add_clocks(num_cycles
, cmd_queue_cur_state
, cmd_queue_cur_state
);
721 int interface_add_tms_seq(unsigned num_bits
, const uint8_t *seq
, enum tap_state state
)
723 /*wait for the fifo to be empty*/
726 for (unsigned i
= 0; i
< num_bits
; i
++)
730 if (((seq
[i
/8] >> (i
% 8)) & 1) == 0)
740 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, tms
);
744 if (state
!= TAP_INVALID
)
746 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x20, state
);
749 /* this would be normal if we are switching to SWD mode */
754 int interface_jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
761 tap_state_t cur_state
= cmd_queue_cur_state
;
764 memset(seq
, 0, sizeof(seq
));
765 assert(num_states
< (int)((sizeof(seq
) * 8)));
769 if (tap_state_transition(cur_state
, false) == path
[state_count
])
773 else if (tap_state_transition(cur_state
, true) == path
[state_count
])
779 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state
), tap_state_name(path
[state_count
]));
783 seq
[state_count
/8] = seq
[state_count
/8] | (tms
<< (state_count
% 8));
785 cur_state
= path
[state_count
];
790 return interface_add_tms_seq(state_count
, seq
, cur_state
);
793 static void jtag_pre_post_bits(struct jtag_tap
*tap
, int *pre
, int *post
)
795 /* bypass bits before and after */
800 struct jtag_tap
*cur_tap
, *nextTap
;
801 for (cur_tap
= jtag_tap_next_enabled(NULL
); cur_tap
!= NULL
; cur_tap
= nextTap
)
803 nextTap
= jtag_tap_next_enabled(cur_tap
);
822 void embeddedice_write_dcc(struct jtag_tap
*tap
, int reg_addr
, uint8_t *buffer
, int little
, int count
)
827 jtag_pre_post_bits(tap
, &pre_bits
, &post_bits
);
829 if (pre_bits
+ post_bits
+ 6 > 32)
832 for (i
= 0; i
< count
; i
++)
834 embeddedice_write_reg_inner(tap
, reg_addr
, fast_target_buffer_get_u32(buffer
, little
));
839 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, pre_bits
, 0);
841 for (i
= 0; i
< count
- 1; i
++)
843 /* Fewer pokes means we get to use the FIFO more efficiently */
844 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, 32, fast_target_buffer_get_u32(buffer
, little
));
845 shiftValueInner(TAP_DRSHIFT
, TAP_IDLE
, 6 + post_bits
+ pre_bits
, (reg_addr
| (1 << 5)));
848 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, 32, fast_target_buffer_get_u32(buffer
, little
));
849 shiftValueInner(TAP_DRSHIFT
, TAP_IDLE
, 6 + post_bits
, (reg_addr
| (1 << 5)));
855 int arm11_run_instr_data_to_core_noack_inner(struct jtag_tap
* tap
, uint32_t opcode
, uint32_t * data
, size_t count
)
858 int arm11_run_instr_data_to_core_noack_inner_default(struct jtag_tap
* tap
, uint32_t opcode
, uint32_t * data
, size_t count
);
859 return arm11_run_instr_data_to_core_noack_inner_default(tap
, opcode
, data
, count
);
861 static const int bits
[] = {32, 2};
862 uint32_t values
[] = {0, 0};
864 /* FIX!!!!!! the target_write_memory() API started this nasty problem
865 * with unaligned uint32_t * pointers... */
866 const uint8_t *t
= (const uint8_t *)data
;
869 /* bypass bits before and after */
872 jtag_pre_post_bits(tap
, &pre_bits
, &post_bits
);
875 struct jtag_tap
*cur_tap
, *nextTap
;
876 for (cur_tap
= jtag_tap_next_enabled(NULL
); cur_tap
!= NULL
; cur_tap
= nextTap
)
878 nextTap
= jtag_tap_next_enabled(cur_tap
);
899 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, pre_bits
, 0);
907 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, 32, value
);
909 shiftValueInner(TAP_DRSHIFT
, TAP_DRPAUSE
, post_bits
, 0);
912 /* copy & paste from arm11_dbgtap.c */
913 //TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
916 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 1);
917 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 1);
918 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
919 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
920 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
921 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 1);
922 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
923 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
924 /* we don't have to wait for the queue to empty here. waitIdle(); */
925 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x20, TAP_DRSHIFT
);
927 static const tap_state_t arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay
[] =
929 TAP_DREXIT2
, TAP_DRUPDATE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DRSHIFT
932 jtag_add_pathmove(ARRAY_SIZE(arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay
),
933 arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay
);
938 values
[0] |= (*t
++<<8);
939 values
[0] |= (*t
++<<16);
940 values
[0] |= (*t
++<<24);
942 /* This will happen on the last iteration updating the current tap state
943 * so we don't have to track it during the common code path */
950 return jtag_execute_queue();
955 static const struct command_registration zy1000_commands
[] = {
958 .handler
= handle_power_command
,
960 .help
= "Turn power switch to target on/off. "
961 "With no arguments, prints status.",
962 .usage
= "('on'|'off)",
966 .name
= "zy1000_version",
968 .jim_handler
= jim_zy1000_version
,
969 .help
= "Print version info for zy1000.",
970 .usage
= "['openocd'|'zy1000'|'date'|'time'|'pcb'|'fpga']",
974 .name
= "zy1000_server",
976 .jim_handler
= jim_zy1000_server
,
977 .help
= "Tcpip address for ZY1000 server.",
982 .name
= "powerstatus",
984 .jim_handler
= zylinjtag_Jim_Command_powerstatus
,
985 .help
= "Returns power status of target",
987 #ifdef CYGPKG_HAL_NIOS2
989 .name
= "updatezy1000firmware",
991 .jim_handler
= jim_zy1000_writefirmware
,
992 .help
= "writes firmware to flash",
993 /* .usage = "some_string", */
996 COMMAND_REGISTRATION_DONE
1000 static int tcp_ip
= -1;
1002 /* Write large packets if we can */
1003 static size_t out_pos
;
1004 static uint8_t out_buffer
[16384];
1005 static size_t in_pos
;
1006 static size_t in_write
;
1007 static uint8_t in_buffer
[16384];
1009 static bool flush_writes(void)
1011 bool ok
= (write(tcp_ip
, out_buffer
, out_pos
) == (int)out_pos
);
1016 static bool writeLong(uint32_t l
)
1019 for (i
= 0; i
< 4; i
++)
1021 uint8_t c
= (l
>> (i
*8))&0xff;
1022 out_buffer
[out_pos
++] = c
;
1023 if (out_pos
>= sizeof(out_buffer
))
1025 if (!flush_writes())
1034 static bool readLong(uint32_t *out_data
)
1038 if (!flush_writes())
1046 for (i
= 0; i
< 4; i
++)
1049 if (in_pos
== in_write
)
1053 t
= read(tcp_ip
, in_buffer
, sizeof(in_buffer
));
1058 in_write
= (size_t) t
;
1061 c
= in_buffer
[in_pos
++];
1063 data
|= (c
<< (i
*8));
1071 ZY1000_CMD_POKE
= 0x0,
1072 ZY1000_CMD_PEEK
= 0x8,
1073 ZY1000_CMD_SLEEP
= 0x1,
1077 #if !BUILD_ECOSBOARD
1079 #include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
1080 #include <arpa/inet.h> /* for sockaddr_in and inet_addr() */
1082 /* We initialize this late since we need to know the server address
1085 static void tcpip_open(void)
1090 struct sockaddr_in echoServAddr
; /* Echo server address */
1092 /* Create a reliable, stream socket using TCP */
1093 if ((tcp_ip
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
)) < 0)
1095 fprintf(stderr
, "Failed to connect to zy1000 server\n");
1099 /* Construct the server address structure */
1100 memset(&echoServAddr
, 0, sizeof(echoServAddr
)); /* Zero out structure */
1101 echoServAddr
.sin_family
= AF_INET
; /* Internet address family */
1102 echoServAddr
.sin_addr
.s_addr
= inet_addr(tcp_server
); /* Server IP address */
1103 echoServAddr
.sin_port
= htons(7777); /* Server port */
1105 /* Establish the connection to the echo server */
1106 if (connect(tcp_ip
, (struct sockaddr
*) &echoServAddr
, sizeof(echoServAddr
)) < 0)
1108 fprintf(stderr
, "Failed to connect to zy1000 server\n");
1113 setsockopt(tcp_ip
, /* socket affected */
1114 IPPROTO_TCP
, /* set option at TCP level */
1115 TCP_NODELAY
, /* name of option */
1116 (char *)&flag
, /* the cast is historical cruft */
1117 sizeof(int)); /* length of option value */
1123 void zy1000_tcpout(uint32_t address
, uint32_t data
)
1126 if (!writeLong((ZY1000_CMD_POKE
<< 24) | address
)||
1129 fprintf(stderr
, "Could not write to zy1000 server\n");
1134 uint32_t zy1000_tcpin(uint32_t address
)
1138 if (!writeLong((ZY1000_CMD_PEEK
<< 24) | address
)||
1141 fprintf(stderr
, "Could not read from zy1000 server\n");
1147 int interface_jtag_add_sleep(uint32_t us
)
1150 if (!writeLong((ZY1000_CMD_SLEEP
<< 24))||
1153 fprintf(stderr
, "Could not read from zy1000 server\n");
1163 static char tcpip_stack
[2048];
1165 static cyg_thread tcpip_thread_object
;
1166 static cyg_handle_t tcpip_thread_handle
;
1168 /* Infinite loop peeking & poking */
1169 static void tcpipserver(void)
1174 if (!readLong(&address
))
1176 enum ZY1000_CMD c
= (address
>> 24) & 0xff;
1177 address
&= 0xffffff;
1180 case ZY1000_CMD_POKE
:
1183 if (!readLong(&data
))
1185 address
&= ~0x80000000;
1186 ZY1000_POKE(address
+ ZY1000_JTAG_BASE
, data
);
1189 case ZY1000_CMD_PEEK
:
1192 ZY1000_PEEK(address
+ ZY1000_JTAG_BASE
, data
);
1193 if (!writeLong(data
))
1197 case ZY1000_CMD_SLEEP
:
1200 if (!readLong(&data
))
1212 static void tcpip_server(cyg_addrword_t data
)
1214 int so_reuseaddr_option
= 1;
1217 if ((fd
= socket(AF_INET
, SOCK_STREAM
, 0)) == -1)
1219 LOG_ERROR("error creating socket: %s", strerror(errno
));
1223 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (void*) &so_reuseaddr_option
,
1226 struct sockaddr_in sin
;
1227 unsigned int address_size
;
1228 address_size
= sizeof(sin
);
1229 memset(&sin
, 0, sizeof(sin
));
1230 sin
.sin_family
= AF_INET
;
1231 sin
.sin_addr
.s_addr
= INADDR_ANY
;
1232 sin
.sin_port
= htons(7777);
1234 if (bind(fd
, (struct sockaddr
*) &sin
, sizeof(sin
)) == -1)
1236 LOG_ERROR("couldn't bind to socket: %s", strerror(errno
));
1240 if (listen(fd
, 1) == -1)
1242 LOG_ERROR("couldn't listen on socket: %s", strerror(errno
));
1249 tcp_ip
= accept(fd
, (struct sockaddr
*) &sin
, &address_size
);
1256 setsockopt(tcp_ip
, /* socket affected */
1257 IPPROTO_TCP
, /* set option at TCP level */
1258 TCP_NODELAY
, /* name of option */
1259 (char *)&flag
, /* the cast is historical cruft */
1260 sizeof(int)); /* length of option value */
1262 bool save_poll
= jtag_poll_get_enabled();
1264 /* polling will screw up the "connection" */
1265 jtag_poll_set_enabled(false);
1269 jtag_poll_set_enabled(save_poll
);
1278 int interface_jtag_add_sleep(uint32_t us
)
1287 int zy1000_init(void)
1290 LOG_USER("%s", ZYLIN_OPENOCD_VERSION
);
1293 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x30); // Turn on LED1 & LED2
1295 setPower(true); // on by default
1298 /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
1300 zy1000_speed(jtag_get_speed());
1304 cyg_thread_create(1, tcpip_server
, (cyg_addrword_t
) 0, "tcip/ip server",
1305 (void *) tcpip_stack
, sizeof(tcpip_stack
),
1306 &tcpip_thread_handle
, &tcpip_thread_object
);
1307 cyg_thread_resume(tcpip_thread_handle
);
1315 struct jtag_interface zy1000_interface
=
1318 .supported
= DEBUG_CAP_TMS_SEQ
,
1319 .execute_queue
= NULL
,
1320 .speed
= zy1000_speed
,
1321 .commands
= zy1000_commands
,
1322 .init
= zy1000_init
,
1323 .quit
= zy1000_quit
,
1325 .speed_div
= zy1000_speed_div
,
1326 .power_dropout
= zy1000_power_dropout
,
1327 .srst_asserted
= zy1000_srst_asserted
,
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)