extern struct target_type arm9tdmi_target;
extern struct target_type arm920t_target;
extern struct target_type arm966e_target;
+extern struct target_type arm946e_target;
extern struct target_type arm926ejs_target;
extern struct target_type fa526_target;
extern struct target_type feroceon_target;
extern struct target_type avr_target;
extern struct target_type dsp563xx_target;
extern struct target_type testee_target;
+extern struct target_type avr32_ap7k_target;
static struct target_type *target_types[] =
{
&arm920t_target,
&arm720t_target,
&arm966e_target,
+ &arm946e_target,
&arm926ejs_target,
&fa526_target,
&feroceon_target,
&avr_target,
&dsp563xx_target,
&testee_target,
+ &avr32_ap7k_target,
NULL,
};
struct target *all_targets = NULL;
static struct target_event_callback *target_event_callbacks = NULL;
static struct target_timer_callback *target_timer_callbacks = NULL;
+static const int polling_interval = 100;
static const Jim_Nvp nvp_assert[] = {
{ .name = "assert", NVP_ASSERT },
jtag_poll_set_enabled(save_poll);
if (retval != JIM_OK) {
- Jim_PrintErrorMessage(cmd_ctx->interp);
+ Jim_MakeErrorMessage(cmd_ctx->interp);
+ command_print(NULL,"%s\n", Jim_GetString(Jim_GetResult(cmd_ctx->interp), NULL));
return ERROR_FAIL;
}
return retval;
retval = target_register_timer_callback(&handle_target,
- 100, 1, cmd_ctx->interp);
+ polling_interval, 1, cmd_ctx->interp);
if (ERROR_OK != retval)
return retval;
return ERROR_OK;
}
+static int backoff_times = 0;
+static int backoff_count = 0;
+
/* process target state changes */
static int handle_target(void *priv)
{
recursive = 0;
}
+ if (backoff_times > backoff_count)
+ {
+ /* do not poll this time as we failed previously */
+ backoff_count++;
+ return ERROR_OK;
+ }
+ backoff_count = 0;
+
/* Poll targets for state changes unless that's globally disabled.
* Skip targets that are currently disabled.
*/
/* polling may fail silently until the target has been examined */
if ((retval = target_poll(target)) != ERROR_OK)
{
- /* FIX!!!!! If we add a LOG_INFO() here to output a line in GDB
- * *why* we are aborting GDB, then we'll spam telnet when the
- * poll is failing persistently.
- *
- * If we could implement an event that detected the
- * target going from non-pollable to pollable, we could issue
- * an error only upon the transition.
+ /* 100ms polling interval. Increase interval between polling up to 5000ms */
+ if (backoff_times * polling_interval < 5000)
+ {
+ backoff_times *= 2;
+ backoff_times++;
+ }
+ LOG_USER("Polling target failed, GDB will be halted. Polling again in %dms", backoff_times * polling_interval);
+
+ /* Tell GDB to halt the debugger. This allows the user to
+ * run monitor commands to handle the situation.
*/
target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
return retval;
}
+ /* Since we succeeded, we reset backoff count */
+ if (backoff_times > 0)
+ {
+ LOG_USER("Polling succeeded again");
+ }
+ backoff_times = 0;
}
}
COMMAND_HANDLER(handle_dump_image_command)
{
struct fileio fileio;
-
uint8_t buffer[560];
- int retvaltemp;
-
-
+ int retval, retvaltemp;
+ uint32_t address, size;
+ struct duration bench;
struct target *target = get_current_target(CMD_CTX);
if (CMD_ARGC != 3)
- {
- command_print(CMD_CTX, "usage: dump_image <filename> <address> <size>");
- return ERROR_OK;
- }
+ return ERROR_COMMAND_SYNTAX_ERROR;
- uint32_t address;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address);
- uint32_t size;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size);
- if (fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
- {
- return ERROR_OK;
- }
+ retval = fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY);
+ if (retval != ERROR_OK)
+ return retval;
- struct duration bench;
duration_start(&bench);
- int retval = ERROR_OK;
+ retval = ERROR_OK;
while (size > 0)
{
size_t size_written;
address += this_run_size;
}
- if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
- return retvaltemp;
-
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
{
+ int filesize;
+ retval = fileio_size(&fileio, &filesize);
+ if (retval != ERROR_OK)
+ return retval;
command_print(CMD_CTX,
- "dumped %ld bytes in %fs (%0.3f KiB/s)", (long)fileio.size,
- duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
+ "dumped %ld bytes in %fs (%0.3f KiB/s)", (long)filesize,
+ duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
+ if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
+ return retvaltemp;
+
return retval;
}
int addressSpace = (max-min + 1);
- static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
+ static const uint32_t maxBuckets = 16 * 1024; /* maximum buckets. */
uint32_t length = addressSpace;
if (length > maxBuckets)
{
writeLong(f, min); /* low_pc */
writeLong(f, max); /* high_pc */
writeLong(f, length); /* # of samples */
- writeLong(f, 64000000); /* 64MHz */
+ writeLong(f, 100); /* KLUDGE! We lie, ca. 100Hz best case. */
writeString(f, "seconds");
for (i = 0; i < (15-strlen("seconds")); i++)
writeData(f, &zero, 1);
Jim_GetString(teap->body, NULL));
if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK)
{
- Jim_PrintErrorMessage(teap->interp);
+ Jim_MakeErrorMessage(teap->interp);
+ command_print(NULL,"%s\n", Jim_GetString(Jim_GetResult(teap->interp), NULL));
}
}
}
case TCFG_TYPE:
/* not setable */
if (goi->isconfigure) {
- Jim_SetResult_sprintf(goi->interp,
+ Jim_SetResultFormatted(goi->interp,
"not settable: %s", n->name);
return JIM_ERR;
} else {
case TCFG_VARIANT:
if (goi->isconfigure) {
if (goi->argc < 1) {
- Jim_SetResult_sprintf(goi->interp,
+ Jim_SetResultFormatted(goi->interp,
"%s ?STRING?",
n->name);
return JIM_ERR;
if (goi.argc < 2 || goi.argc > 4)
{
- Jim_SetResult_sprintf(goi.interp,
+ Jim_SetResultFormatted(goi.interp,
"usage: %s [phys] <address> <data> [<count>]", cmd_name);
return JIM_ERR;
}
if ((goi.argc < 1) || (goi.argc > 3))
{
- Jim_SetResult_sprintf(goi.interp,
+ Jim_SetResultFormatted(goi.interp,
"usage: %s [phys] <address> [<count>]", cmd_name);
return JIM_ERR;
}
}
e = fn(target, a, b, y / b, target_buf);
if (e != ERROR_OK) {
- Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
+ char tmp[10];
+ snprintf(tmp, sizeof(tmp), "%08lx", (long)a);
+ Jim_SetResultFormatted(interp, "error reading target @ 0x%s", tmp);
return JIM_ERR;
}
- Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a));
+ command_print(NULL, "0x%08x ", (int)(a));
switch (b) {
case 4:
for (x = 0; x < 16 && x < y; x += 4)
{
z = target_buffer_get_u32(target, &(target_buf[ x ]));
- Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
+ command_print(NULL, "%08x ", (int)(z));
}
for (; (x < 16) ; x += 4) {
- Jim_fprintf(interp, interp->cookie_stdout, " ");
+ command_print(NULL, " ");
}
break;
case 2:
for (x = 0; x < 16 && x < y; x += 2)
{
z = target_buffer_get_u16(target, &(target_buf[ x ]));
- Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
+ command_print(NULL, "%04x ", (int)(z));
}
for (; (x < 16) ; x += 2) {
- Jim_fprintf(interp, interp->cookie_stdout, " ");
+ command_print(NULL, " ");
}
break;
case 1:
default:
for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
z = target_buffer_get_u8(target, &(target_buf[ x ]));
- Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
+ command_print(NULL, "%02x ", (int)(z));
}
for (; (x < 16) ; x += 1) {
- Jim_fprintf(interp, interp->cookie_stdout, " ");
+ command_print(NULL, " ");
}
break;
}
/* terminate */
target_buf[16] = 0;
/* print - with a newline */
- Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
+ command_print(NULL, "%s\n", target_buf);
/* NEXT... */
c -= 16;
a += 16;
static int jim_target_tap_disabled(Jim_Interp *interp)
{
- Jim_SetResult_sprintf(interp, "[TAP is disabled]");
+ Jim_SetResultFormatted(interp, "[TAP is disabled]");
return JIM_ERR;
}
int e = target->type->examine(target);
if (e != ERROR_OK)
{
- Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
+ Jim_Obj *eObj = Jim_NewIntObj(interp, e);
+ Jim_SetResultFormatted(interp, "examine-fails: %#s", eObj);
+ Jim_FreeNewObj(interp, eObj);
return JIM_ERR;
}
return JIM_OK;
}
if (e != ERROR_OK)
{
- Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
+ Jim_Obj *eObj = Jim_NewIntObj(interp, e);
+ Jim_SetResultFormatted(interp, "poll-fails: %#s", eObj);
+ Jim_FreeNewObj(interp, eObj);
return JIM_ERR;
}
return JIM_OK;
}
if (!target->type->assert_reset || !target->type->deassert_reset)
{
- Jim_SetResult_sprintf(interp,
+ Jim_SetResultFormatted(interp,
"No target-specific reset for %s",
target_name(target));
return JIM_ERR;
if (goi.argc != 2)
{
const char *cmd_name = Jim_GetString(argv[0], NULL);
- Jim_SetResult_sprintf(goi.interp,
+ Jim_SetResultFormatted(goi.interp,
"%s <state_name> <timeout_in_msec>", cmd_name);
return JIM_ERR;
}
e = target_wait_state(target, n->value, a);
if (e != ERROR_OK)
{
- Jim_SetResult_sprintf(goi.interp,
- "target: %s wait %s fails (%d) %s",
+ Jim_Obj *eObj = Jim_NewIntObj(interp, e);
+ Jim_SetResultFormatted(goi.interp,
+ "target: %s wait %s fails (%#s) %s",
target_name(target), n->name,
- e, target_strerror_safe(e));
+ eObj, target_strerror_safe(e));
+ Jim_FreeNewObj(interp, eObj);
return JIM_ERR;
}
return JIM_OK;
if (goi.argc != 1)
{
const char *cmd_name = Jim_GetString(argv[0], NULL);
- Jim_SetResult_sprintf(goi.interp, "%s <eventname>", cmd_name);
+ Jim_SetResultFormatted(goi.interp, "%s <eventname>", cmd_name);
return JIM_ERR;
}
Jim_Nvp *n;
cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
if (cmd) {
cp = Jim_GetString(new_cmd, NULL);
- Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
+ Jim_SetResultFormatted(goi->interp, "Command/target: %s Exists", cp);
return JIM_ERR;
}
}
}
if (target_types[x] == NULL) {
- Jim_SetResult_sprintf(goi->interp, "Unknown target type %s, try one of ", cp);
+ Jim_SetResultFormatted(goi->interp, "Unknown target type %s, try one of ", cp);
for (x = 0 ; target_types[x] ; x++) {
if (target_types[x + 1]) {
Jim_AppendStrings(goi->interp,
LOG_WARNING("don't use numbers as target identifiers; use names");
if (goi.argc != 1)
{
- Jim_SetResult_sprintf(goi.interp, "usage: target number <number>");
+ Jim_SetResultFormatted(goi.interp, "usage: target number <number>");
return JIM_ERR;
}
jim_wide w;
Jim_SetResultString(goi.interp, target_name(target), -1);
return JIM_OK;
}
- Jim_SetResult_sprintf(goi.interp,
- "Target: number %d does not exist", (int)(w));
+ {
+ Jim_Obj *wObj = Jim_NewIntObj(goi.interp, w);
+ Jim_SetResultFormatted(goi.interp,
+ "Target: number %#s does not exist", wObj);
+ Jim_FreeNewObj(interp, wObj);
+ }
return JIM_ERR;
}
struct duration bench;
duration_start(&bench);
- if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
+ retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL);
+ if (retval != ERROR_OK)
{
- return ERROR_OK;
+ return retval;
}
image_size = 0x0;
fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
if (fastload == NULL)
{
+ command_print(CMD_CTX, "out of memory");
image_close(&image);
return ERROR_FAIL;
}
{
command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
(int)(image.sections[i].size));
+ retval = ERROR_FAIL;
break;
}
if (fastload[i].data == NULL)
{
free(buffer);
+ command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
+ length);
+ retval = ERROR_FAIL;
break;
}
memcpy(fastload[i].data, buffer + offset, length);
command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
(unsigned int)(fastload[i].address),
(unsigned int)(fastload[i].length));
- if (retval == ERROR_OK)
+ retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
+ if (retval != ERROR_OK)
{
- retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
+ break;
}
size += fastload[i].length;
}
- int after = timeval_ms();
- command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
+ if (retval == ERROR_OK)
+ {
+ int after = timeval_ms();
+ command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
+ }
return retval;
}
.usage = "filename [offset [type]]",
},
{
- .name = "ocd_mem2array",
+ .name = "mem2array",
.mode = COMMAND_EXEC,
.jim_handler = jim_mem2array,
.help = "read 8/16/32 bit memory and return as a TCL array "
.usage = "arrayname bitwidth address count",
},
{
- .name = "ocd_array2mem",
+ .name = "array2mem",
.mode = COMMAND_EXEC,
.jim_handler = jim_array2mem,
.help = "convert a TCL array to memory locations "
projects / fw / openocd / blobdiff