* Copyright (C) 2008 by Rick Altherr *
* kc8apf@kc8apf.net> *
* *
+ * Copyright (C) 2011 by Broadcom Corporation *
+ * Evan Hunter - ehunter@broadcom.com *
+ * *
* 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 *
* the Free Software Foundation; either version 2 of the License, or *
#include "register.h"
#include "trace.h"
#include "image.h"
+#include "rtos/rtos.h"
+static int target_read_buffer_default(struct target *target, uint32_t address,
+ uint32_t size, uint8_t *buffer);
+static int target_write_buffer_default(struct target *target, uint32_t address,
+ uint32_t size, const uint8_t *buffer);
static int target_array2mem(Jim_Interp *interp, struct target *target,
int argc, Jim_Obj *const *argv);
static int target_mem2array(Jim_Interp *interp, struct target *target,
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;
&arm920t_target,
&arm720t_target,
&arm966e_target,
+ &arm946e_target,
&arm926ejs_target,
&fa526_target,
&feroceon_target,
return be_to_h_u32(buffer);
}
+/* read a uint24_t from a buffer in target memory endianness */
+uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer)
+{
+ if (target->endianness == TARGET_LITTLE_ENDIAN)
+ return le_to_h_u24(buffer);
+ else
+ return be_to_h_u24(buffer);
+}
+
/* read a uint16_t from a buffer in target memory endianness */
uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
{
h_u32_to_be(buffer, value);
}
+/* write a uint24_t to a buffer in target memory endianness */
+void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value)
+{
+ if (target->endianness == TARGET_LITTLE_ENDIAN)
+ h_u24_to_le(buffer, value);
+ else
+ h_u24_to_be(buffer, value);
+}
+
/* write a uint16_t to a buffer in target memory endianness */
void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value)
{
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 target->type->name;
}
-static int target_write_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int target_write_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
{
if (!target_was_examined(target))
{
}
int target_write_memory(struct target *target,
- uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+ uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
{
return target->type->write_memory(target, address, size, count, buffer);
}
static int target_write_phys_memory(struct target *target,
- uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+ uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
{
return target->type->write_phys_memory(target, address, size, count, buffer);
}
int target_bulk_write_memory(struct target *target,
- uint32_t address, uint32_t count, uint8_t *buffer)
+ uint32_t address, uint32_t count, const uint8_t *buffer)
{
return target->type->bulk_write_memory(target, address, count, buffer);
}
static int
err_write_phys_memory(struct target *target, uint32_t address,
- uint32_t size, uint32_t count, uint8_t *buffer)
+ uint32_t size, uint32_t count, const uint8_t *buffer)
{
LOG_ERROR("Not implemented: %s", __func__);
return ERROR_FAIL;
type->read_phys_memory = type->read_memory;
type->virt2phys = identity_virt2phys;
}
+
+ if (target->type->read_buffer == NULL)
+ target->type->read_buffer = target_read_buffer_default;
+
+ if (target->type->write_buffer == NULL)
+ target->type->write_buffer = target_write_buffer_default;
+
return ERROR_OK;
}
}
/* mark as used, and return the new (reused) area */
- new_wa->free = 0;
+ new_wa->free = false;
*area = new_wa;
/* user pointer */
return retval;
}
- area->free = 1;
+ area->free = true;
/* mark user pointer invalid */
*area->user = NULL;
* mode respectively, otherwise data is handled as quickly as
* possible
*/
-int target_write_buffer(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer)
+int target_write_buffer(struct target *target, uint32_t address, uint32_t size, const uint8_t *buffer)
{
- int retval;
LOG_DEBUG("writing buffer of %i byte at 0x%8.8x",
(int)size, (unsigned)address);
return ERROR_FAIL;
}
+ return target->type->write_buffer(target, address, size, buffer);
+}
+
+static int target_write_buffer_default(struct target *target, uint32_t address, uint32_t size, const uint8_t *buffer)
+{
+ int retval = ERROR_OK;
+
if (((address % 2) == 0) && (size == 2))
{
return target_write_memory(target, address, 2, 1, buffer);
return retval;
}
- return ERROR_OK;
+ return retval;
}
/* Single aligned words are guaranteed to use 16 or 32 bit access
*/
int target_read_buffer(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer)
{
- int retval;
LOG_DEBUG("reading buffer of %i byte at 0x%8.8x",
(int)size, (unsigned)address);
return ERROR_FAIL;
}
+ return target->type->read_buffer(target, address, size, buffer);
+}
+
+static int target_read_buffer_default(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer)
+{
+ int retval = ERROR_OK;
+
if (((address % 2) == 0) && (size == 2))
{
return target_read_memory(target, address, 2, 1, buffer);
return retval;
}
- /* convert to target endianess */
+ /* convert to target endianness */
for (i = 0; i < (size/sizeof(uint32_t)); i++)
{
uint32_t target_data;
bool physical=strcmp(CMD_ARGV[0], "phys")==0;
int (*fn)(struct target *target,
- uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+ uint32_t address, uint32_t size_value, uint32_t count, uint8_t *buffer);
if (physical)
{
CMD_ARGC--;
}
typedef int (*target_write_fn)(struct target *target,
- uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+ uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
static int target_write_memory_fast(struct target *target,
- uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+ uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
{
return target_write_buffer(target, address, size * count, buffer);
}
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));
}
}
}
TCFG_WORK_AREA_BACKUP,
TCFG_ENDIAN,
TCFG_VARIANT,
+ TCFG_COREID,
TCFG_CHAIN_POSITION,
+ TCFG_DBGBASE,
+ TCFG_RTOS,
};
static Jim_Nvp nvp_config_opts[] = {
{ .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
{ .name = "-endian" , .value = TCFG_ENDIAN },
{ .name = "-variant", .value = TCFG_VARIANT },
+ { .name = "-coreid", .value = TCFG_COREID },
{ .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
-
+ { .name = "-dbgbase", .value = TCFG_DBGBASE },
+ { .name = "-rtos", .value = TCFG_RTOS },
{ .name = NULL, .value = -1 }
};
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;
Jim_SetResultString(goi->interp, target->variant,-1);
/* loop for more */
break;
+
+ case TCFG_COREID:
+ if (goi->isconfigure) {
+ e = Jim_GetOpt_Wide(goi, &w);
+ if (e != JIM_OK) {
+ return e;
+ }
+ target->coreid = (int)w;
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
+ /* loop for more */
+ break;
+
case TCFG_CHAIN_POSITION:
if (goi->isconfigure) {
Jim_Obj *o_t;
Jim_SetResultString(goi->interp, target->tap->dotted_name, -1);
/* loop for more e*/
break;
+ case TCFG_DBGBASE:
+ if (goi->isconfigure) {
+ e = Jim_GetOpt_Wide(goi, &w);
+ if (e != JIM_OK) {
+ return e;
+ }
+ target->dbgbase = (uint32_t)w;
+ target->dbgbase_set = true;
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->dbgbase));
+ /* loop for more */
+ break;
+
+ case TCFG_RTOS:
+ /* RTOS */
+ {
+ int result = rtos_create( goi, target );
+ if ( result != JIM_OK )
+ {
+ return result;
+ }
+ }
+ /* loop for more */
+ break;
}
} /* while (goi->argc) */
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);
return JIM_ERR;
}
return JIM_OK;
}
if (e != ERROR_OK)
{
- Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
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,
/* will be set by "-endian" */
target->endianness = TARGET_ENDIAN_UNKNOWN;
+ /* default to first core, override with -coreid */
+ target->coreid = 0;
+
target->working_area = 0x0;
target->working_area_size = 0x0;
target->working_areas = NULL;
target->endianness = TARGET_ENDIAN_UNKNOWN;
+ target->rtos = NULL;
+ target->rtos_auto_detect = false;
+
/* Do the rest as "configure" options */
goi->isconfigure = 1;
e = target_configure(goi, target);
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;
}
Code Review / openocd.git / blobdiff