/***************************************************************************
- * Copyright (C) 2007-2009 by Øyvind Harboe *
+ * Copyright (C) 2007-2010 by Øyvind Harboe *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
}
}
-int interface_jtag_add_ir_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
+int interface_jtag_add_ir_scan(struct jtag_tap *active, const struct scan_field *fields, tap_state_t state)
{
-
- int j;
int scan_size = 0;
struct jtag_tap *tap, *nextTap;
+
for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
{
nextTap = jtag_tap_next_enabled(tap);
- int pause = (nextTap==NULL);
-
- int found = 0;
-
+ bool pause = (nextTap==NULL);
scan_size = tap->ir_length;
/* search the list */
- for (j = 0; j < num_fields; j++)
+ if (tap == active)
{
- if (tap == fields[j].tap)
- {
- found = 1;
-
- scanFields(1, fields + j, TAP_IRSHIFT, pause);
- /* update device information */
- buf_cpy(fields[j].out_value, tap->cur_instr, scan_size);
-
- tap->bypass = 0;
- break;
- }
- }
+ scanFields(1, fields, TAP_IRSHIFT, pause);
+ /* update device information */
+ buf_cpy(fields[0].out_value, tap->cur_instr, scan_size);
- if (!found)
+ tap->bypass = 0;
+ } else
{
/* if a device isn't listed, set it to BYPASS */
- uint8_t ones[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
+ assert(scan_size <= 32);
+ shiftValueInner(TAP_IRSHIFT, pause?TAP_IRPAUSE:TAP_IRSHIFT, scan_size, 0xffffffff);
- struct scan_field tmp;
- memset(&tmp, 0, sizeof(tmp));
- tmp.out_value = ones;
- tmp.num_bits = scan_size;
- scanFields(1, &tmp, TAP_IRSHIFT, pause);
- /* update device information */
- buf_cpy(tmp.out_value, tap->cur_instr, scan_size);
tap->bypass = 1;
}
}
-int interface_jtag_add_plain_ir_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
+int interface_jtag_add_plain_ir_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits, tap_state_t state)
{
- scanFields(num_fields, fields, TAP_IRSHIFT, 1);
+ struct scan_field field;
+ field.num_bits = num_bits;
+ field.out_value = out_bits;
+ field.in_value = in_bits;
+
+ scanFields(1, &field, TAP_IRSHIFT, 1);
gotoEndState(state);
return ERROR_OK;
}
-int interface_jtag_add_dr_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
+int interface_jtag_add_dr_scan(struct jtag_tap *active, int num_fields, const struct scan_field *fields, tap_state_t state)
{
-
- int j;
struct jtag_tap *tap, *nextTap;
for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
{
nextTap = jtag_tap_next_enabled(tap);
- int found = 0;
- int pause = (nextTap==NULL);
+ bool pause = (nextTap==NULL);
- for (j = 0; j < num_fields; j++)
+ /* Find a range of fields to write to this tap */
+ if (tap == active)
{
- /* Find a range of fields to write to this tap */
- if (tap == fields[j].tap)
- {
- found = 1;
- int i;
- for (i = j + 1; i < num_fields; i++)
- {
- if (tap != fields[j].tap)
- {
- break;
- }
- }
-
- scanFields(i - j, fields + j, TAP_DRSHIFT, pause);
-
- j = i;
- }
- }
+ assert(!tap->bypass);
- if (!found)
+ scanFields(num_fields, fields, TAP_DRSHIFT, pause);
+ } else
{
/* Shift out a 0 for disabled tap's */
+ assert(tap->bypass);
shiftValueInner(TAP_DRSHIFT, pause?TAP_DRPAUSE:TAP_DRSHIFT, 1, 0);
}
- else
- {
- }
}
gotoEndState(state);
return ERROR_OK;
}
-int interface_jtag_add_plain_dr_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
+int interface_jtag_add_plain_dr_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits, tap_state_t state)
{
- scanFields(num_fields, fields, TAP_DRSHIFT, 1);
+ struct scan_field field;
+ field.num_bits = num_bits;
+ field.out_value = out_bits;
+ field.in_value = in_bits;
+
+ scanFields(1, &field, TAP_DRSHIFT, 1);
gotoEndState(state);
return ERROR_OK;
}
-
int interface_jtag_add_tlr()
{
setCurrentState(TAP_RESET);
}
-
-
int interface_jtag_add_reset(int req_trst, int req_srst)
{
zy1000_reset(req_trst, req_srst);
ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, state);
#endif
-
return ERROR_OK;
}
return ERROR_OK;
}
+int interface_add_tms_seq(unsigned num_bits, const uint8_t *seq, enum tap_state state)
+{
+ /*wait for the fifo to be empty*/
+ waitIdle();
+
+ for (unsigned i = 0; i < num_bits; i++)
+ {
+ int tms;
+
+ if (((seq[i/8] >> (i % 8)) & 1) == 0)
+ {
+ tms = 0;
+ }
+ else
+ {
+ tms = 1;
+ }
+
+ waitIdle();
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, tms);
+ }
+
+ waitIdle();
+ if (state != TAP_INVALID)
+ {
+ ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, state);
+ } else
+ {
+ /* this would be normal if we are switching to SWD mode */
+ }
+ return ERROR_OK;
+}
+
int interface_jtag_add_pathmove(int num_states, const tap_state_t *path)
{
int state_count;
int tms = 0;
- /*wait for the fifo to be empty*/
- waitIdle();
-
state_count = 0;
tap_state_t cur_state = cmd_queue_cur_state;
+ uint8_t seq[16];
+ memset(seq, 0, sizeof(seq));
+ assert(num_states < (sizeof(seq) * 8));
+
while (num_states)
{
if (tap_state_transition(cur_state, false) == path[state_count])
exit(-1);
}
- waitIdle();
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, tms);
+ seq[state_count/8] = seq[state_count/8] | (tms << (state_count % 8));
cur_state = path[state_count];
state_count++;
num_states--;
}
- waitIdle();
- ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, cur_state);
- return ERROR_OK;
+ return interface_add_tms_seq(state_count, seq, cur_state);
}
-
-
-void embeddedice_write_dcc(struct jtag_tap *tap, int reg_addr, uint8_t *buffer, int little, int count)
+static void jtag_pre_post_bits(struct jtag_tap *tap, int *pre, int *post)
{
-// static int const reg_addr = 0x5;
- tap_state_t end_state = jtag_get_end_state();
- if (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL)) == NULL)
+ /* bypass bits before and after */
+ int pre_bits = 0;
+ int post_bits = 0;
+
+ bool found = false;
+ struct jtag_tap *cur_tap, *nextTap;
+ for (cur_tap = jtag_tap_next_enabled(NULL); cur_tap!= NULL; cur_tap = nextTap)
{
- /* better performance via code duplication */
- if (little)
+ nextTap = jtag_tap_next_enabled(cur_tap);
+ if (cur_tap == tap)
{
- int i;
- for (i = 0; i < count; i++)
- {
- shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 1));
- shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr | (1 << 5));
- buffer += 4;
- }
+ found = true;
} else
{
- int i;
- for (i = 0; i < count; i++)
+ if (found)
+ {
+ post_bits++;
+ } else
{
- shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 0));
- shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr | (1 << 5));
- buffer += 4;
+ pre_bits++;
}
}
}
- else
+ *pre = pre_bits;
+ *post = post_bits;
+}
+
+void embeddedice_write_dcc(struct jtag_tap *tap, int reg_addr, uint8_t *buffer, int little, int count)
+{
+
+ int pre_bits;
+ int post_bits;
+ jtag_pre_post_bits(tap, &pre_bits, &post_bits);
+
+ if ((pre_bits > 32) || (post_bits > 32))
{
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
+ {
+ tap_state_t end_state = jtag_get_end_state();
+ tap_state_t shift_end_state;
+ if (post_bits == 0)
+ shift_end_state = end_state;
+
+ int i;
+ for (i = 0; i < count; i++)
+ {
+ shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, pre_bits, 0);
+ shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, little));
+ shiftValueInner(TAP_DRSHIFT, shift_end_state, 6, reg_addr | (1 << 5));
+ shiftValueInner(shift_end_state, end_state, post_bits, 0);
+ buffer += 4;
+ }
}
}
-int arm11_run_instr_data_to_core_noack_inner_default(struct arm11_common * arm11, uint32_t opcode, uint32_t * data, size_t count);
-int arm11_run_instr_data_to_core_noack_inner(struct arm11_common * arm11, uint32_t opcode, uint32_t * data, size_t count)
+int arm11_run_instr_data_to_core_noack_inner(struct jtag_tap * tap, uint32_t opcode, uint32_t * data, size_t count)
{
- return arm11_run_instr_data_to_core_noack_inner_default(arm11, opcode, data, 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)
+ {
+ 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);
+
+#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);
+#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);
+#endif
+ }
+
+ 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);
+
+ return jtag_execute_queue();
+#endif
}
struct jtag_interface zy1000_interface =
{
.name = "ZY1000",
+ .supported = DEBUG_CAP_TMS_SEQ,
.execute_queue = NULL,
.speed = zy1000_speed,
.commands = zy1000_commands,
projects / fw / openocd / blobdiff