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
;
212 LOG_ERROR("SRST took too long to deassert: %dms", (int)total
);
220 int zy1000_speed(int speed
)
222 /* flush JTAG master FIFO before setting speed */
229 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x100);
230 LOG_DEBUG("jtag_speed using RCLK");
234 if (speed
> 8190 || speed
< 2)
236 LOG_USER("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
237 return ERROR_INVALID_ARGUMENTS
;
240 LOG_USER("jtag_speed %d => JTAG clk=%f", speed
, 64.0/(float)speed
);
241 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x100);
242 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x1c, speed
&~1);
247 static bool savePower
;
250 static void setPower(bool power
)
255 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x8);
258 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x8);
262 COMMAND_HANDLER(handle_power_command
)
268 COMMAND_PARSE_ON_OFF(CMD_ARGV
[0], enable
);
273 LOG_INFO("Target power %s", savePower
? "on" : "off");
276 return ERROR_INVALID_ARGUMENTS
;
283 static char *tcp_server
= "notspecified";
284 static int jim_zy1000_server(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
289 tcp_server
= strdup(Jim_GetString(argv
[1], NULL
));
296 /* Give TELNET a way to find out what version this is */
297 static int jim_zy1000_version(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
299 if ((argc
< 1) || (argc
> 3))
301 const char *version_str
= NULL
;
305 version_str
= ZYLIN_OPENOCD_VERSION
;
308 const char *str
= Jim_GetString(argv
[1], NULL
);
309 const char *str2
= NULL
;
311 str2
= Jim_GetString(argv
[2], NULL
);
312 if (strcmp("openocd", str
) == 0)
314 version_str
= ZYLIN_OPENOCD
;
316 else if (strcmp("zy1000", str
) == 0)
318 version_str
= ZYLIN_VERSION
;
320 else if (strcmp("date", str
) == 0)
322 version_str
= ZYLIN_DATE
;
324 else if (strcmp("time", str
) == 0)
326 version_str
= ZYLIN_TIME
;
328 else if (strcmp("pcb", str
) == 0)
330 #ifdef CYGPKG_HAL_NIOS2
336 #ifdef CYGPKG_HAL_NIOS2
337 else if (strcmp("fpga", str
) == 0)
340 /* return a list of 32 bit integers to describe the expected
343 static char *fpga_id
= "0x12345678 0x12345678 0x12345678 0x12345678";
344 uint32_t id
, timestamp
;
345 HAL_READ_UINT32(SYSID_BASE
, id
);
346 HAL_READ_UINT32(SYSID_BASE
+4, timestamp
);
347 sprintf(fpga_id
, "0x%08x 0x%08x 0x%08x 0x%08x", id
, timestamp
, SYSID_ID
, SYSID_TIMESTAMP
);
348 version_str
= fpga_id
;
349 if ((argc
>2) && (strcmp("time", str2
) == 0))
351 time_t last_mod
= timestamp
;
352 char * t
= ctime (&last_mod
) ;
365 Jim_SetResult(interp
, Jim_NewStringObj(interp
, version_str
, -1));
371 #ifdef CYGPKG_HAL_NIOS2
377 struct cyg_upgrade_info
*upgraded_file
;
380 static void report_info(void *data
, const char * format
, va_list args
)
382 char *s
= alloc_vprintf(format
, args
);
387 struct cyg_upgrade_info firmware_info
=
389 (uint8_t *)0x84000000,
395 "ZylinNiosFirmware\n",
399 static int jim_zy1000_writefirmware(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
405 const char *str
= Jim_GetString(argv
[1], &length
);
409 if ((tmpFile
= open(firmware_info
.file
, O_RDWR
| O_CREAT
| O_TRUNC
)) <= 0)
414 success
= write(tmpFile
, str
, length
) == length
;
419 if (!cyg_firmware_upgrade(NULL
, firmware_info
))
427 zylinjtag_Jim_Command_powerstatus(Jim_Interp
*interp
,
429 Jim_Obj
* const *argv
)
433 Jim_WrongNumArgs(interp
, 1, argv
, "powerstatus");
437 bool dropout
= readPowerDropout();
439 Jim_SetResult(interp
, Jim_NewIntObj(interp
, dropout
));
446 int zy1000_quit(void)
454 int interface_jtag_execute_queue(void)
459 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0x10, empty
);
460 /* clear JTAG error register */
461 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x14, 0x400);
463 if ((empty
&0x400) != 0)
465 LOG_WARNING("RCLK timeout");
466 /* the error is informative only as we don't want to break the firmware if there
467 * is a false positive.
469 // return ERROR_FAIL;
478 static uint32_t getShiftValue(void)
482 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0xc, value
);
483 VERBOSE(LOG_INFO("getShiftValue %08x", value
));
487 static uint32_t getShiftValueFlip(void)
491 ZY1000_PEEK(ZY1000_JTAG_BASE
+ 0x18, value
);
492 VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value
));
498 static void shiftValueInnerFlip(const tap_state_t state
, const tap_state_t endState
, int repeat
, uint32_t value
)
500 VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state
), tap_state_name(endState
), repeat
, value
));
504 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0xc, value
);
505 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x8, (1 << 15) | (repeat
<< 8) | (a
<< 4) | b
);
506 VERBOSE(getShiftValueFlip());
510 // here we shuffle N bits out/in
511 static __inline
void scanBits(const uint8_t *out_value
, uint8_t *in_value
, int num_bits
, bool pause_now
, tap_state_t shiftState
, tap_state_t end_state
)
513 tap_state_t pause_state
= shiftState
;
514 for (int j
= 0; j
< num_bits
; j
+= 32)
516 int k
= num_bits
- j
;
520 /* we have more to shift out */
521 } else if (pause_now
)
523 /* this was the last to shift out this time */
524 pause_state
= end_state
;
527 // we have (num_bits + 7)/8 bytes of bits to toggle out.
528 // bits are pushed out LSB to MSB
531 if (out_value
!= NULL
)
533 for (int l
= 0; l
< k
; l
+= 8)
535 value
|=out_value
[(j
+ l
)/8]<<l
;
538 /* mask away unused bits for easier debugging */
541 value
&=~(((uint32_t)0xffffffff) << k
);
544 /* Shifting by >= 32 is not defined by the C standard
545 * and will in fact shift by &0x1f bits on nios */
548 shiftValueInner(shiftState
, pause_state
, k
, value
);
550 if (in_value
!= NULL
)
552 // data in, LSB to MSB
553 value
= getShiftValue();
554 // we're shifting in data to MSB, shift data to be aligned for returning the value
557 for (int l
= 0; l
< k
; l
+= 8)
559 in_value
[(j
+ l
)/8]=(value
>> l
)&0xff;
565 static __inline
void scanFields(int num_fields
, const struct scan_field
*fields
, tap_state_t shiftState
, tap_state_t end_state
)
567 for (int i
= 0; i
< num_fields
; i
++)
569 scanBits(fields
[i
].out_value
,
578 int interface_jtag_add_ir_scan(struct jtag_tap
*active
, const struct scan_field
*fields
, tap_state_t state
)
581 struct jtag_tap
*tap
, *nextTap
;
582 tap_state_t pause_state
= TAP_IRSHIFT
;
584 for (tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= nextTap
)
586 nextTap
= jtag_tap_next_enabled(tap
);
591 scan_size
= tap
->ir_length
;
593 /* search the list */
596 scanFields(1, fields
, TAP_IRSHIFT
, pause_state
);
597 /* update device information */
598 buf_cpy(fields
[0].out_value
, tap
->cur_instr
, scan_size
);
603 /* if a device isn't listed, set it to BYPASS */
604 assert(scan_size
<= 32);
605 shiftValueInner(TAP_IRSHIFT
, pause_state
, scan_size
, 0xffffffff);
618 int interface_jtag_add_plain_ir_scan(int num_bits
, const uint8_t *out_bits
, uint8_t *in_bits
, tap_state_t state
)
620 scanBits(out_bits
, in_bits
, num_bits
, true, TAP_IRSHIFT
, state
);
624 int interface_jtag_add_dr_scan(struct jtag_tap
*active
, int num_fields
, const struct scan_field
*fields
, tap_state_t state
)
626 struct jtag_tap
*tap
, *nextTap
;
627 tap_state_t pause_state
= TAP_DRSHIFT
;
628 for (tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= nextTap
)
630 nextTap
= jtag_tap_next_enabled(tap
);
636 /* Find a range of fields to write to this tap */
639 assert(!tap
->bypass
);
641 scanFields(num_fields
, fields
, TAP_DRSHIFT
, pause_state
);
644 /* Shift out a 0 for disabled tap's */
646 shiftValueInner(TAP_DRSHIFT
, pause_state
, 1, 0);
652 int interface_jtag_add_plain_dr_scan(int num_bits
, const uint8_t *out_bits
, uint8_t *in_bits
, tap_state_t state
)
654 scanBits(out_bits
, in_bits
, num_bits
, true, TAP_DRSHIFT
, state
);
658 int interface_jtag_add_tlr()
660 setCurrentState(TAP_RESET
);
665 int interface_jtag_add_reset(int req_trst
, int req_srst
)
667 zy1000_reset(req_trst
, req_srst
);
671 static int zy1000_jtag_add_clocks(int num_cycles
, tap_state_t state
, tap_state_t clockstate
)
673 /* num_cycles can be 0 */
674 setCurrentState(clockstate
);
676 /* execute num_cycles, 32 at the time. */
678 for (i
= 0; i
< num_cycles
; i
+= 32)
682 if (num_cycles
-i
< num
)
686 shiftValueInner(clockstate
, clockstate
, num
, 0);
690 /* finish in end_state */
691 setCurrentState(state
);
693 tap_state_t t
= TAP_IDLE
;
694 /* test manual drive code on any target */
696 uint8_t tms_scan
= tap_get_tms_path(t
, state
);
697 int tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
699 for (i
= 0; i
< tms_count
; i
++)
701 tms
= (tms_scan
>> i
) & 1;
703 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, tms
);
706 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x20, state
);
712 int interface_jtag_add_runtest(int num_cycles
, tap_state_t state
)
714 return zy1000_jtag_add_clocks(num_cycles
, state
, TAP_IDLE
);
717 int interface_jtag_add_clocks(int num_cycles
)
719 return zy1000_jtag_add_clocks(num_cycles
, cmd_queue_cur_state
, cmd_queue_cur_state
);
722 int interface_add_tms_seq(unsigned num_bits
, const uint8_t *seq
, enum tap_state state
)
724 /*wait for the fifo to be empty*/
727 for (unsigned i
= 0; i
< num_bits
; i
++)
731 if (((seq
[i
/8] >> (i
% 8)) & 1) == 0)
741 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, tms
);
745 if (state
!= TAP_INVALID
)
747 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x20, state
);
750 /* this would be normal if we are switching to SWD mode */
755 int interface_jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
762 tap_state_t cur_state
= cmd_queue_cur_state
;
765 memset(seq
, 0, sizeof(seq
));
766 assert(num_states
< (int)((sizeof(seq
) * 8)));
770 if (tap_state_transition(cur_state
, false) == path
[state_count
])
774 else if (tap_state_transition(cur_state
, true) == path
[state_count
])
780 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state
), tap_state_name(path
[state_count
]));
784 seq
[state_count
/8] = seq
[state_count
/8] | (tms
<< (state_count
% 8));
786 cur_state
= path
[state_count
];
791 return interface_add_tms_seq(state_count
, seq
, cur_state
);
794 static void jtag_pre_post_bits(struct jtag_tap
*tap
, int *pre
, int *post
)
796 /* bypass bits before and after */
801 struct jtag_tap
*cur_tap
, *nextTap
;
802 for (cur_tap
= jtag_tap_next_enabled(NULL
); cur_tap
!= NULL
; cur_tap
= nextTap
)
804 nextTap
= jtag_tap_next_enabled(cur_tap
);
824 static const int embeddedice_num_bits[] = {32, 6};
828 values[1] = (1 << 5) | reg_addr;
832 embeddedice_num_bits,
837 void embeddedice_write_dcc(struct jtag_tap
*tap
, int reg_addr
, uint8_t *buffer
, int little
, int count
)
841 for (i
= 0; i
< count
; i
++)
843 embeddedice_write_reg_inner(tap
, reg_addr
, fast_target_buffer_get_u32(buffer
, little
));
849 jtag_pre_post_bits(tap
, &pre_bits
, &post_bits
);
851 if ((pre_bits
> 32) || (post_bits
+ 6 > 32))
854 for (i
= 0; i
< count
; i
++)
856 embeddedice_write_reg_inner(tap
, reg_addr
, fast_target_buffer_get_u32(buffer
, little
));
862 for (i
= 0; i
< count
; i
++)
864 /* Fewer pokes means we get to use the FIFO more efficiently */
865 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, pre_bits
, 0);
866 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, 32, fast_target_buffer_get_u32(buffer
, little
));
867 /* Danger! here we need to exit into the TAP_IDLE state to make
868 * DCC pick up this value.
870 shiftValueInner(TAP_DRSHIFT
, TAP_IDLE
, 6 + post_bits
, (reg_addr
| (1 << 5)));
879 int arm11_run_instr_data_to_core_noack_inner(struct jtag_tap
* tap
, uint32_t opcode
, uint32_t * data
, size_t count
)
881 /* bypass bits before and after */
884 jtag_pre_post_bits(tap
, &pre_bits
, &post_bits
);
887 if ((pre_bits
> 32) || (post_bits
> 32))
889 int arm11_run_instr_data_to_core_noack_inner_default(struct jtag_tap
* tap
, uint32_t opcode
, uint32_t * data
, size_t count
);
890 return arm11_run_instr_data_to_core_noack_inner_default(tap
, opcode
, data
, count
);
893 static const int bits
[] = {32, 2};
894 uint32_t values
[] = {0, 0};
896 /* FIX!!!!!! the target_write_memory() API started this nasty problem
897 * with unaligned uint32_t * pointers... */
898 const uint8_t *t
= (const uint8_t *)data
;
903 /* Danger! This code doesn't update cmd_queue_cur_state, so
904 * invoking jtag_add_pathmove() before jtag_add_dr_out() after
905 * this loop would fail!
907 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, pre_bits
, 0);
915 shiftValueInner(TAP_DRSHIFT
, TAP_DRSHIFT
, 32, value
);
917 shiftValueInner(TAP_DRSHIFT
, TAP_DRPAUSE
, post_bits
, 0);
919 /* copy & paste from arm11_dbgtap.c */
920 //TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
921 /* KLUDGE! we have to flush the fifo or the Nios CPU locks up.
922 * This is probably a bug in the Avalon bus(cross clocking bridge?)
923 * or in the jtag registers module.
926 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 1);
927 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 1);
928 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
929 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
930 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
931 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 1);
932 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
933 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x28, 0);
934 /* we don't have to wait for the queue to empty here */
935 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x20, TAP_DRSHIFT
);
938 static const tap_state_t arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay
[] =
940 TAP_DREXIT2
, TAP_DRUPDATE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DRSHIFT
944 values
[0] |= (*t
++<<8);
945 values
[0] |= (*t
++<<16);
946 values
[0] |= (*t
++<<24);
954 jtag_add_pathmove(ARRAY_SIZE(arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay
),
955 arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay
);
960 values
[0] |= (*t
++<<8);
961 values
[0] |= (*t
++<<16);
962 values
[0] |= (*t
++<<24);
964 /* This will happen on the last iteration updating cmd_queue_cur_state
965 * so we don't have to track it during the common code path
973 return jtag_execute_queue();
978 static const struct command_registration zy1000_commands
[] = {
981 .handler
= handle_power_command
,
983 .help
= "Turn power switch to target on/off. "
984 "With no arguments, prints status.",
985 .usage
= "('on'|'off)",
989 .name
= "zy1000_version",
991 .jim_handler
= jim_zy1000_version
,
992 .help
= "Print version info for zy1000.",
993 .usage
= "['openocd'|'zy1000'|'date'|'time'|'pcb'|'fpga']",
997 .name
= "zy1000_server",
999 .jim_handler
= jim_zy1000_server
,
1000 .help
= "Tcpip address for ZY1000 server.",
1005 .name
= "powerstatus",
1006 .mode
= COMMAND_ANY
,
1007 .jim_handler
= zylinjtag_Jim_Command_powerstatus
,
1008 .help
= "Returns power status of target",
1010 #ifdef CYGPKG_HAL_NIOS2
1012 .name
= "updatezy1000firmware",
1013 .mode
= COMMAND_ANY
,
1014 .jim_handler
= jim_zy1000_writefirmware
,
1015 .help
= "writes firmware to flash",
1016 /* .usage = "some_string", */
1019 COMMAND_REGISTRATION_DONE
1023 static int tcp_ip
= -1;
1025 /* Write large packets if we can */
1026 static size_t out_pos
;
1027 static uint8_t out_buffer
[16384];
1028 static size_t in_pos
;
1029 static size_t in_write
;
1030 static uint8_t in_buffer
[16384];
1032 static bool flush_writes(void)
1034 bool ok
= (write(tcp_ip
, out_buffer
, out_pos
) == (int)out_pos
);
1039 static bool writeLong(uint32_t l
)
1042 for (i
= 0; i
< 4; i
++)
1044 uint8_t c
= (l
>> (i
*8))&0xff;
1045 out_buffer
[out_pos
++] = c
;
1046 if (out_pos
>= sizeof(out_buffer
))
1048 if (!flush_writes())
1057 static bool readLong(uint32_t *out_data
)
1061 if (!flush_writes())
1069 for (i
= 0; i
< 4; i
++)
1072 if (in_pos
== in_write
)
1076 t
= read(tcp_ip
, in_buffer
, sizeof(in_buffer
));
1081 in_write
= (size_t) t
;
1084 c
= in_buffer
[in_pos
++];
1086 data
|= (c
<< (i
*8));
1094 ZY1000_CMD_POKE
= 0x0,
1095 ZY1000_CMD_PEEK
= 0x8,
1096 ZY1000_CMD_SLEEP
= 0x1,
1100 #if !BUILD_ECOSBOARD
1102 #include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
1103 #include <arpa/inet.h> /* for sockaddr_in and inet_addr() */
1105 /* We initialize this late since we need to know the server address
1108 static void tcpip_open(void)
1113 struct sockaddr_in echoServAddr
; /* Echo server address */
1115 /* Create a reliable, stream socket using TCP */
1116 if ((tcp_ip
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
)) < 0)
1118 fprintf(stderr
, "Failed to connect to zy1000 server\n");
1122 /* Construct the server address structure */
1123 memset(&echoServAddr
, 0, sizeof(echoServAddr
)); /* Zero out structure */
1124 echoServAddr
.sin_family
= AF_INET
; /* Internet address family */
1125 echoServAddr
.sin_addr
.s_addr
= inet_addr(tcp_server
); /* Server IP address */
1126 echoServAddr
.sin_port
= htons(7777); /* Server port */
1128 /* Establish the connection to the echo server */
1129 if (connect(tcp_ip
, (struct sockaddr
*) &echoServAddr
, sizeof(echoServAddr
)) < 0)
1131 fprintf(stderr
, "Failed to connect to zy1000 server\n");
1136 setsockopt(tcp_ip
, /* socket affected */
1137 IPPROTO_TCP
, /* set option at TCP level */
1138 TCP_NODELAY
, /* name of option */
1139 (char *)&flag
, /* the cast is historical cruft */
1140 sizeof(int)); /* length of option value */
1146 void zy1000_tcpout(uint32_t address
, uint32_t data
)
1149 if (!writeLong((ZY1000_CMD_POKE
<< 24) | address
)||
1152 fprintf(stderr
, "Could not write to zy1000 server\n");
1157 uint32_t zy1000_tcpin(uint32_t address
)
1161 if (!writeLong((ZY1000_CMD_PEEK
<< 24) | address
)||
1164 fprintf(stderr
, "Could not read from zy1000 server\n");
1170 int interface_jtag_add_sleep(uint32_t us
)
1173 if (!writeLong((ZY1000_CMD_SLEEP
<< 24))||
1176 fprintf(stderr
, "Could not read from zy1000 server\n");
1186 static char tcpip_stack
[2048];
1187 static cyg_thread tcpip_thread_object
;
1188 static cyg_handle_t tcpip_thread_handle
;
1190 static char watchdog_stack
[2048];
1191 static cyg_thread watchdog_thread_object
;
1192 static cyg_handle_t watchdog_thread_handle
;
1194 /* Infinite loop peeking & poking */
1195 static void tcpipserver(void)
1200 if (!readLong(&address
))
1202 enum ZY1000_CMD c
= (address
>> 24) & 0xff;
1203 address
&= 0xffffff;
1206 case ZY1000_CMD_POKE
:
1209 if (!readLong(&data
))
1211 address
&= ~0x80000000;
1212 ZY1000_POKE(address
+ ZY1000_JTAG_BASE
, data
);
1215 case ZY1000_CMD_PEEK
:
1218 ZY1000_PEEK(address
+ ZY1000_JTAG_BASE
, data
);
1219 if (!writeLong(data
))
1223 case ZY1000_CMD_SLEEP
:
1226 if (!readLong(&data
))
1238 static void tcpip_server(cyg_addrword_t data
)
1240 int so_reuseaddr_option
= 1;
1243 if ((fd
= socket(AF_INET
, SOCK_STREAM
, 0)) == -1)
1245 LOG_ERROR("error creating socket: %s", strerror(errno
));
1249 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (void*) &so_reuseaddr_option
,
1252 struct sockaddr_in sin
;
1253 unsigned int address_size
;
1254 address_size
= sizeof(sin
);
1255 memset(&sin
, 0, sizeof(sin
));
1256 sin
.sin_family
= AF_INET
;
1257 sin
.sin_addr
.s_addr
= INADDR_ANY
;
1258 sin
.sin_port
= htons(7777);
1260 if (bind(fd
, (struct sockaddr
*) &sin
, sizeof(sin
)) == -1)
1262 LOG_ERROR("couldn't bind to socket: %s", strerror(errno
));
1266 if (listen(fd
, 1) == -1)
1268 LOG_ERROR("couldn't listen on socket: %s", strerror(errno
));
1275 tcp_ip
= accept(fd
, (struct sockaddr
*) &sin
, &address_size
);
1282 setsockopt(tcp_ip
, /* socket affected */
1283 IPPROTO_TCP
, /* set option at TCP level */
1284 TCP_NODELAY
, /* name of option */
1285 (char *)&flag
, /* the cast is historical cruft */
1286 sizeof(int)); /* length of option value */
1288 bool save_poll
= jtag_poll_get_enabled();
1290 /* polling will screw up the "connection" */
1291 jtag_poll_set_enabled(false);
1295 jtag_poll_set_enabled(save_poll
);
1304 #ifdef WATCHDOG_BASE
1305 /* If we connect to port 8888 we must send a char every 10s or the board resets itself */
1306 static void watchdog_server(cyg_addrword_t data
)
1308 int so_reuseaddr_option
= 1;
1311 if ((fd
= socket(AF_INET
, SOCK_STREAM
, 0)) == -1)
1313 LOG_ERROR("error creating socket: %s", strerror(errno
));
1317 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (void*) &so_reuseaddr_option
,
1320 struct sockaddr_in sin
;
1321 unsigned int address_size
;
1322 address_size
= sizeof(sin
);
1323 memset(&sin
, 0, sizeof(sin
));
1324 sin
.sin_family
= AF_INET
;
1325 sin
.sin_addr
.s_addr
= INADDR_ANY
;
1326 sin
.sin_port
= htons(8888);
1328 if (bind(fd
, (struct sockaddr
*) &sin
, sizeof(sin
)) == -1)
1330 LOG_ERROR("couldn't bind to socket: %s", strerror(errno
));
1334 if (listen(fd
, 1) == -1)
1336 LOG_ERROR("couldn't listen on socket: %s", strerror(errno
));
1343 int watchdog_ip
= accept(fd
, (struct sockaddr
*) &sin
, &address_size
);
1345 /* Start watchdog, must be reset every 10 seconds. */
1346 HAL_WRITE_UINT32(WATCHDOG_BASE
+ 4, 4);
1348 if (watchdog_ip
< 0)
1350 LOG_ERROR("couldn't open watchdog socket: %s", strerror(errno
));
1355 setsockopt(watchdog_ip
, /* socket affected */
1356 IPPROTO_TCP
, /* set option at TCP level */
1357 TCP_NODELAY
, /* name of option */
1358 (char *)&flag
, /* the cast is historical cruft */
1359 sizeof(int)); /* length of option value */
1365 if (read(watchdog_ip
, &buf
, 1) == 1)
1368 HAL_WRITE_UINT32(WATCHDOG_BASE
+ 8, 0x1234);
1369 /* Echo so we can telnet in and see that resetting works */
1370 write(watchdog_ip
, &buf
, 1);
1373 /* Stop tickling the watchdog, the CPU will reset in < 10 seconds
1386 int interface_jtag_add_sleep(uint32_t us
)
1395 int zy1000_init(void)
1398 LOG_USER("%s", ZYLIN_OPENOCD_VERSION
);
1401 ZY1000_POKE(ZY1000_JTAG_BASE
+ 0x10, 0x30); // Turn on LED1 & LED2
1403 setPower(true); // on by default
1406 /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
1408 zy1000_speed(jtag_get_speed());
1412 cyg_thread_create(1, tcpip_server
, (cyg_addrword_t
) 0, "tcip/ip server",
1413 (void *) tcpip_stack
, sizeof(tcpip_stack
),
1414 &tcpip_thread_handle
, &tcpip_thread_object
);
1415 cyg_thread_resume(tcpip_thread_handle
);
1416 #ifdef WATCHDOG_BASE
1417 cyg_thread_create(1, watchdog_server
, (cyg_addrword_t
) 0, "watchdog tcip/ip server",
1418 (void *) watchdog_stack
, sizeof(watchdog_stack
),
1419 &watchdog_thread_handle
, &watchdog_thread_object
);
1420 cyg_thread_resume(watchdog_thread_handle
);
1429 struct jtag_interface zy1000_interface
=
1432 .supported
= DEBUG_CAP_TMS_SEQ
,
1433 .execute_queue
= NULL
,
1434 .speed
= zy1000_speed
,
1435 .commands
= zy1000_commands
,
1436 .init
= zy1000_init
,
1437 .quit
= zy1000_quit
,
1439 .speed_div
= zy1000_speed_div
,
1440 .power_dropout
= zy1000_power_dropout
,
1441 .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)