-/***************************************************************************
+'n/***************************************************************************
* Copyright (C) 2007-2010 by Øyvind Harboe *
* *
* This program is free software; you can redistribute it and/or modify *
#endif
+
+/* The software needs to check if it's in RCLK mode or not */
+static bool zy1000_rclk = false;
+
static int zy1000_khz(int khz, int *jtag_speed)
{
if (khz == 0)
}
else
{
- *jtag_speed = 64000/khz;
+ int speed;
+ /* Round speed up to nearest divisor.
+ *
+ * E.g. 16000kHz
+ * (64000 + 15999) / 16000 = 4
+ * (4 + 1) / 2 = 2
+ * 2 * 2 = 4
+ *
+ * 64000 / 4 = 16000
+ *
+ * E.g. 15999
+ * (64000 + 15998) / 15999 = 5
+ * (5 + 1) / 2 = 3
+ * 3 * 2 = 6
+ *
+ * 64000 / 6 = 10666
+ *
+ */
+ speed = (64000 + (khz -1)) / khz;
+ speed = (speed + 1 ) / 2;
+ speed *= 2;
+ if (speed > 8190)
+ {
+ /* maximum dividend */
+ speed = 8190;
+ }
+ *jtag_speed = speed;
}
return ERROR_OK;
}
(!srst && !trst && (jtag_get_reset_config() & RESET_TRST_PULLS_SRST)))
{
bool first = true;
- long long start;
+ long long start = 0;
long total = 0;
for (;;)
{
/* flush JTAG master FIFO before setting speed */
waitIdle();
+ zy1000_rclk = false;
+
if (speed == 0)
{
/*0 means RCLK*/
- speed = 0;
ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x100);
+ zy1000_rclk = true;
LOG_DEBUG("jtag_speed using RCLK");
}
else
return ERROR_INVALID_ARGUMENTS;
}
- LOG_USER("jtag_speed %d => JTAG clk=%f", speed, 64.0/(float)speed);
+ int khz;
+ speed &= ~1;
+ zy1000_speed_div(speed, &khz);
+ LOG_USER("jtag_speed %d => JTAG clk=%d kHz", speed, khz);
ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x100);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x1c, speed&~1);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x1c, speed);
}
return ERROR_OK;
}
return JIM_ERR;
}
- uint32_t status;
- ZY1000_PEEK(ZY1000_JTAG_BASE + 0x10, status);
+ bool dropout = readPowerDropout();
- Jim_SetResult(interp, Jim_NewIntObj(interp, (status&0x80) != 0));
+ Jim_SetResult(interp, Jim_NewIntObj(interp, dropout));
return JIM_OK;
}
uint32_t empty;
waitIdle();
- ZY1000_PEEK(ZY1000_JTAG_BASE + 0x10, empty);
- /* clear JTAG error register */
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x400);
- if ((empty&0x400) != 0)
+ /* We must make sure to write data read back to memory location before we return
+ * from this fn
+ */
+ zy1000_flush_readqueue();
+
+ /* and handle any callbacks... */
+ zy1000_flush_callbackqueue();
+
+ if (zy1000_rclk)
{
- LOG_WARNING("RCLK timeout");
- /* the error is informative only as we don't want to break the firmware if there
- * is a false positive.
+ /* Only check for errors when using RCLK to speed up
+ * jtag over TCP/IP
*/
-// return ERROR_FAIL;
+ ZY1000_PEEK(ZY1000_JTAG_BASE + 0x10, empty);
+ /* clear JTAG error register */
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x400);
+
+ if ((empty&0x400) != 0)
+ {
+ LOG_WARNING("RCLK timeout");
+ /* the error is informative only as we don't want to break the firmware if there
+ * is a false positive.
+ */
+ // return ERROR_FAIL;
+ }
}
return ERROR_OK;
}
-
-static uint32_t getShiftValue(void)
-{
- uint32_t value;
- waitIdle();
- ZY1000_PEEK(ZY1000_JTAG_BASE + 0xc, value);
- VERBOSE(LOG_INFO("getShiftValue %08x", value));
- return value;
-}
-#if 0
-static uint32_t getShiftValueFlip(void)
-{
- uint32_t value;
- waitIdle();
- ZY1000_PEEK(ZY1000_JTAG_BASE + 0x18, value);
- VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value));
- return value;
-}
-#endif
-
-#if 0
-static void shiftValueInnerFlip(const tap_state_t state, const tap_state_t endState, int repeat, uint32_t value)
-{
- VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
- uint32_t a,b;
- a = state;
- b = endState;
- ZY1000_POKE(ZY1000_JTAG_BASE + 0xc, value);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x8, (1 << 15) | (repeat << 8) | (a << 4) | b);
- VERBOSE(getShiftValueFlip());
-}
-#endif
+static void writeShiftValue(uint8_t *data, int bits);
// here we shuffle N bits out/in
-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)
+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)
{
tap_state_t pause_state = shiftState;
for (int j = 0; j < num_bits; j += 32)
{
k = 32;
/* we have more to shift out */
- } else if (pause)
+ } else if (pause_now)
{
/* this was the last to shift out this time */
pause_state = end_state;
if (in_value != NULL)
{
- // data in, LSB to MSB
- value = getShiftValue();
- // we're shifting in data to MSB, shift data to be aligned for returning the value
- value >>= 32-k;
-
- for (int l = 0; l < k; l += 8)
- {
- in_value[(j + l)/8]=(value >> l)&0xff;
- }
+ writeShiftValue(in_value + (j/8), k);
}
}
}
*post = post_bits;
}
+/*
+ static const int embeddedice_num_bits[] = {32, 6};
+ uint32_t values[2];
+
+ values[0] = value;
+ values[1] = (1 << 5) | reg_addr;
+
+ jtag_add_dr_out(tap,
+ 2,
+ embeddedice_num_bits,
+ values,
+ TAP_IDLE);
+*/
+
void embeddedice_write_dcc(struct jtag_tap *tap, int reg_addr, uint8_t *buffer, int little, int count)
{
-
+#if 0
+ int i;
+ for (i = 0; i < count; i++)
+ {
+ embeddedice_write_reg_inner(tap, reg_addr, fast_target_buffer_get_u32(buffer, little));
+ buffer += 4;
+ }
+#else
int pre_bits;
int post_bits;
jtag_pre_post_bits(tap, &pre_bits, &post_bits);
- if (pre_bits + post_bits + 6 > 32)
+ if ((pre_bits > 32) || (post_bits + 6 > 32))
{
int i;
for (i = 0; i < count; i++)
}
} else
{
- shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, pre_bits, 0);
int i;
- for (i = 0; i < count - 1; i++)
+ for (i = 0; i < count; i++)
{
/* Fewer pokes means we get to use the FIFO more efficiently */
+ shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, pre_bits, 0);
shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, little));
- shiftValueInner(TAP_DRSHIFT, TAP_IDLE, 6 + post_bits + pre_bits, (reg_addr | (1 << 5)));
+ /* Danger! here we need to exit into the TAP_IDLE state to make
+ * DCC pick up this value.
+ */
+ shiftValueInner(TAP_DRSHIFT, TAP_IDLE, 6 + post_bits, (reg_addr | (1 << 5)));
buffer += 4;
}
- shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, little));
- shiftValueInner(TAP_DRSHIFT, TAP_IDLE, 6 + post_bits, (reg_addr | (1 << 5)));
}
+#endif
}
int arm11_run_instr_data_to_core_noack_inner(struct jtag_tap * tap, uint32_t opcode, uint32_t * data, size_t count)
{
-#if 0
- int arm11_run_instr_data_to_core_noack_inner_default(struct jtag_tap * tap, uint32_t opcode, uint32_t * data, size_t count);
- return arm11_run_instr_data_to_core_noack_inner_default(tap, opcode, data, count);
-#else
- static const int bits[] = {32, 2};
- uint32_t values[] = {0, 0};
-
- /* FIX!!!!!! the target_write_memory() API started this nasty problem
- * with unaligned uint32_t * pointers... */
- const uint8_t *t = (const uint8_t *)data;
-
-
/* bypass bits before and after */
int pre_bits;
int post_bits;
jtag_pre_post_bits(tap, &pre_bits, &post_bits);
-
- bool found = false;
- struct jtag_tap *cur_tap, *nextTap;
- for (cur_tap = jtag_tap_next_enabled(NULL); cur_tap!= NULL; cur_tap = nextTap)
- {
- nextTap = jtag_tap_next_enabled(cur_tap);
- if (cur_tap == tap)
- {
- found = true;
- } else
- {
- if (found)
- {
- post_bits++;
- } else
- {
- pre_bits++;
- }
- }
- }
-
post_bits+=2;
-
- while (--count > 0)
+ if ((pre_bits > 32) || (post_bits > 32))
{
- shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, pre_bits, 0);
-
- uint32_t value;
- value = *t++;
- value |= (*t++<<8);
- value |= (*t++<<16);
- value |= (*t++<<24);
+ int arm11_run_instr_data_to_core_noack_inner_default(struct jtag_tap *, uint32_t, uint32_t *, size_t);
+ return arm11_run_instr_data_to_core_noack_inner_default(tap, opcode, data, count);
+ } else
+ {
+ static const int bits[] = {32, 2};
+ uint32_t values[] = {0, 0};
- shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, value);
- /* minimum 2 bits */
- shiftValueInner(TAP_DRSHIFT, TAP_DRPAUSE, post_bits, 0);
+ /* FIX!!!!!! the target_write_memory() API started this nasty problem
+ * with unaligned uint32_t * pointers... */
+ const uint8_t *t = (const uint8_t *)data;
+ while (--count > 0)
+ {
#if 1
- /* copy & paste from arm11_dbgtap.c */
- //TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
-
- waitIdle();
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 1);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 1);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 1);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
- /* we don't have to wait for the queue to empty here. waitIdle(); */
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, TAP_DRSHIFT);
+ /* Danger! This code doesn't update cmd_queue_cur_state, so
+ * invoking jtag_add_pathmove() before jtag_add_dr_out() after
+ * this loop would fail!
+ */
+ shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, pre_bits, 0);
+
+ uint32_t value;
+ value = *t++;
+ value |= (*t++<<8);
+ value |= (*t++<<16);
+ value |= (*t++<<24);
+
+ shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, value);
+ /* minimum 2 bits */
+ shiftValueInner(TAP_DRSHIFT, TAP_DRPAUSE, post_bits, 0);
+
+ /* copy & paste from arm11_dbgtap.c */
+ //TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
+ /* KLUDGE! we have to flush the fifo or the Nios CPU locks up.
+ * This is probably a bug in the Avalon bus(cross clocking bridge?)
+ * or in the jtag registers module.
+ */
+ waitIdle();
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 1);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 1);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 1);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, 0);
+ /* we don't have to wait for the queue to empty here */
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, TAP_DRSHIFT);
+ waitIdle();
#else
- static const tap_state_t arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay[] =
- {
- TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
- };
-
- jtag_add_pathmove(ARRAY_SIZE(arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay),
- arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay);
+ static const tap_state_t arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay[] =
+ {
+ TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
+ };
+
+ values[0] = *t++;
+ values[0] |= (*t++<<8);
+ values[0] |= (*t++<<16);
+ values[0] |= (*t++<<24);
+
+ jtag_add_dr_out(tap,
+ 2,
+ bits,
+ values,
+ TAP_IDLE);
+
+ jtag_add_pathmove(ARRAY_SIZE(arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay),
+ arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay);
#endif
- }
+ }
- values[0] = *t++;
- values[0] |= (*t++<<8);
- values[0] |= (*t++<<16);
- values[0] |= (*t++<<24);
+ values[0] = *t++;
+ values[0] |= (*t++<<8);
+ values[0] |= (*t++<<16);
+ values[0] |= (*t++<<24);
- /* This will happen on the last iteration updating the current tap state
- * so we don't have to track it during the common code path */
- jtag_add_dr_out(tap,
- 2,
- bits,
- values,
- TAP_IDLE);
+ /* This will happen on the last iteration updating cmd_queue_cur_state
+ * so we don't have to track it during the common code path
+ */
+ jtag_add_dr_out(tap,
+ 2,
+ bits,
+ values,
+ TAP_IDLE);
- return jtag_execute_queue();
-#endif
+ return jtag_execute_queue();
+ }
}
ZY1000_CMD_POKE = 0x0,
ZY1000_CMD_PEEK = 0x8,
ZY1000_CMD_SLEEP = 0x1,
+ ZY1000_CMD_WAITIDLE = 2
};
}
}
+/* By sending the wait to the server, we avoid a readback
+ * of status. Radically improves performance for this operation
+ * with long ping times.
+ */
+void waitIdle(void)
+{
+ tcpip_open();
+ if (!writeLong((ZY1000_CMD_WAITIDLE << 24)))
+ {
+ fprintf(stderr, "Could not write to zy1000 server\n");
+ exit(-1);
+ }
+}
+
uint32_t zy1000_tcpin(uint32_t address)
{
tcpip_open();
+
+ zy1000_flush_readqueue();
+
uint32_t data;
if (!writeLong((ZY1000_CMD_PEEK << 24) | address)||
!readLong(&data))
return ERROR_OK;
}
+/* queue a readback */
+#define readqueue_size 16384
+static struct
+{
+ uint8_t *dest;
+ int bits;
+} readqueue[readqueue_size];
+
+static int readqueue_pos = 0;
+
+/* flush the readqueue, this means reading any data that
+ * we're expecting and store them into the final position
+ */
+void zy1000_flush_readqueue(void)
+{
+ if (readqueue_pos == 0)
+ {
+ /* simply debugging by allowing easy breakpoints when there
+ * is something to do. */
+ return;
+ }
+ int i;
+ tcpip_open();
+ for (i = 0; i < readqueue_pos; i++)
+ {
+ uint32_t value;
+ if (!readLong(&value))
+ {
+ fprintf(stderr, "Could not read from zy1000 server\n");
+ exit(-1);
+ }
+
+ uint8_t *in_value = readqueue[i].dest;
+ int k = readqueue[i].bits;
+
+ // we're shifting in data to MSB, shift data to be aligned for returning the value
+ value >>= 32-k;
+
+ for (int l = 0; l < k; l += 8)
+ {
+ in_value[l/8]=(value >> l)&0xff;
+ }
+ }
+ readqueue_pos = 0;
+}
+
+/* By queuing the callback's we avoid flushing the
+read queue until jtag_execute_queue(). This can
+reduce latency dramatically for cases where
+callbacks are used extensively.
+*/
+#define callbackqueue_size 128
+static struct callbackentry
+{
+ jtag_callback_t callback;
+ jtag_callback_data_t data0;
+ jtag_callback_data_t data1;
+ jtag_callback_data_t data2;
+ jtag_callback_data_t data3;
+} callbackqueue[callbackqueue_size];
+
+static int callbackqueue_pos = 0;
+
+void zy1000_jtag_add_callback4(jtag_callback_t callback, jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
+{
+ if (callbackqueue_pos >= callbackqueue_size)
+ {
+ zy1000_flush_callbackqueue();
+ }
+
+ callbackqueue[callbackqueue_pos].callback = callback;
+ callbackqueue[callbackqueue_pos].data0 = data0;
+ callbackqueue[callbackqueue_pos].data1 = data1;
+ callbackqueue[callbackqueue_pos].data2 = data2;
+ callbackqueue[callbackqueue_pos].data3 = data3;
+ callbackqueue_pos++;
+}
+
+static int zy1000_jtag_convert_to_callback4(jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
+{
+ ((jtag_callback1_t)data1)(data0);
+ return ERROR_OK;
+}
+
+void zy1000_jtag_add_callback(jtag_callback1_t callback, jtag_callback_data_t data0)
+{
+ zy1000_jtag_add_callback4(zy1000_jtag_convert_to_callback4, data0, (jtag_callback_data_t)callback, 0, 0);
+}
+
+void zy1000_flush_callbackqueue(void)
+{
+ /* we have to flush the read queue so we have access to
+ the data the callbacks will use
+ */
+ zy1000_flush_readqueue();
+ int i;
+ for (i = 0; i < callbackqueue_pos; i++)
+ {
+ struct callbackentry *entry = &callbackqueue[i];
+ jtag_set_error(entry->callback(entry->data0, entry->data1, entry->data2, entry->data3));
+ }
+ callbackqueue_pos = 0;
+}
+
+static void writeShiftValue(uint8_t *data, int bits)
+{
+ waitIdle();
+
+ if (!writeLong((ZY1000_CMD_PEEK << 24) | (ZY1000_JTAG_BASE + 0xc)))
+ {
+ fprintf(stderr, "Could not read from zy1000 server\n");
+ exit(-1);
+ }
+
+ if (readqueue_pos >= readqueue_size)
+ {
+ zy1000_flush_readqueue();
+ }
+
+ readqueue[readqueue_pos].dest = data;
+ readqueue[readqueue_pos].bits = bits;
+ readqueue_pos++;
+}
+
+#else
+
+static void writeShiftValue(uint8_t *data, int bits)
+{
+ uint32_t value;
+ waitIdle();
+ ZY1000_PEEK(ZY1000_JTAG_BASE + 0xc, value);
+ VERBOSE(LOG_INFO("getShiftValue %08x", value));
+
+ // data in, LSB to MSB
+ // we're shifting in data to MSB, shift data to be aligned for returning the value
+ value >>= 32 - bits;
+
+ for (int l = 0; l < bits; l += 8)
+ {
+ data[l/8]=(value >> l)&0xff;
+ }
+}
#endif
#if BUILD_ECOSBOARD
static char tcpip_stack[2048];
-
static cyg_thread tcpip_thread_object;
static cyg_handle_t tcpip_thread_handle;
+static char watchdog_stack[2048];
+static cyg_thread watchdog_thread_object;
+static cyg_handle_t watchdog_thread_handle;
+
/* Infinite loop peeking & poking */
static void tcpipserver(void)
{
jtag_sleep(data);
break;
}
+ case ZY1000_CMD_WAITIDLE:
+ {
+ waitIdle();
+ break;
+ }
default:
return;
}
}
+#ifdef WATCHDOG_BASE
+/* If we connect to port 8888 we must send a char every 10s or the board resets itself */
+static void watchdog_server(cyg_addrword_t data)
+{
+ int so_reuseaddr_option = 1;
+
+ int fd;
+ if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ LOG_ERROR("error creating socket: %s", strerror(errno));
+ exit(-1);
+ }
+
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*) &so_reuseaddr_option,
+ sizeof(int));
+
+ struct sockaddr_in sin;
+ unsigned int address_size;
+ address_size = sizeof(sin);
+ memset(&sin, 0, sizeof(sin));
+ sin.sin_family = AF_INET;
+ sin.sin_addr.s_addr = INADDR_ANY;
+ sin.sin_port = htons(8888);
+
+ if (bind(fd, (struct sockaddr *) &sin, sizeof(sin)) == -1)
+ {
+ LOG_ERROR("couldn't bind to socket: %s", strerror(errno));
+ exit(-1);
+ }
+
+ if (listen(fd, 1) == -1)
+ {
+ LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
+ exit(-1);
+ }
+
+
+ for (;;)
+ {
+ int watchdog_ip = accept(fd, (struct sockaddr *) &sin, &address_size);
+
+ /* Start watchdog, must be reset every 10 seconds. */
+ HAL_WRITE_UINT32(WATCHDOG_BASE + 4, 4);
+
+ if (watchdog_ip < 0)
+ {
+ LOG_ERROR("couldn't open watchdog socket: %s", strerror(errno));
+ exit(-1);
+ }
+
+ int flag = 1;
+ setsockopt(watchdog_ip, /* socket affected */
+ IPPROTO_TCP, /* set option at TCP level */
+ TCP_NODELAY, /* name of option */
+ (char *)&flag, /* the cast is historical cruft */
+ sizeof(int)); /* length of option value */
+
+
+ char buf;
+ for (;;)
+ {
+ if (read(watchdog_ip, &buf, 1) == 1)
+ {
+ /* Reset timer */
+ HAL_WRITE_UINT32(WATCHDOG_BASE + 8, 0x1234);
+ /* Echo so we can telnet in and see that resetting works */
+ write(watchdog_ip, &buf, 1);
+ } else
+ {
+ /* Stop tickling the watchdog, the CPU will reset in < 10 seconds
+ * now.
+ */
+ return;
+ }
+
+ }
+
+ /* Never reached */
+ }
+}
+#endif
+
int interface_jtag_add_sleep(uint32_t us)
{
jtag_sleep(us);
(void *) tcpip_stack, sizeof(tcpip_stack),
&tcpip_thread_handle, &tcpip_thread_object);
cyg_thread_resume(tcpip_thread_handle);
+#ifdef WATCHDOG_BASE
+ cyg_thread_create(1, watchdog_server, (cyg_addrword_t) 0, "watchdog tcip/ip server",
+ (void *) watchdog_stack, sizeof(watchdog_stack),
+ &watchdog_thread_handle, &watchdog_thread_object);
+ cyg_thread_resume(watchdog_thread_handle);
+#endif
#endif
return ERROR_OK;
.power_dropout = zy1000_power_dropout,
.srst_asserted = zy1000_srst_asserted,
};
-
projects / openocd-genbsdl / blobdiff