+
+void target_all_handle_event(enum target_event e)
+{
+ target_t *target;
+
+ LOG_DEBUG("**all*targets: event: %d, %s",
+ (int)e,
+ Jim_Nvp_value2name_simple(nvp_target_event, e)->name);
+
+ target = all_targets;
+ while (target) {
+ target_handle_event(target, e);
+ target = target->next;
+ }
+}
+
+
+/* FIX? should we propagate errors here rather than printing them
+ * and continuing?
+ */
+void target_handle_event(target_t *target, enum target_event e)
+{
+ target_event_action_t *teap;
+
+ for (teap = target->event_action; teap != NULL; teap = teap->next) {
+ if (teap->event == e) {
+ LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
+ target->target_number,
+ target->cmd_name,
+ target_get_name(target),
+ e,
+ Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
+ Jim_GetString(teap->body, NULL));
+ if (Jim_EvalObj(interp, teap->body) != JIM_OK)
+ {
+ Jim_PrintErrorMessage(interp);
+ }
+ }
+ }
+}
+
+enum target_cfg_param {
+ TCFG_TYPE,
+ TCFG_EVENT,
+ TCFG_WORK_AREA_VIRT,
+ TCFG_WORK_AREA_PHYS,
+ TCFG_WORK_AREA_SIZE,
+ TCFG_WORK_AREA_BACKUP,
+ TCFG_ENDIAN,
+ TCFG_VARIANT,
+ TCFG_CHAIN_POSITION,
+};
+
+static Jim_Nvp nvp_config_opts[] = {
+ { .name = "-type", .value = TCFG_TYPE },
+ { .name = "-event", .value = TCFG_EVENT },
+ { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
+ { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
+ { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
+ { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
+ { .name = "-endian" , .value = TCFG_ENDIAN },
+ { .name = "-variant", .value = TCFG_VARIANT },
+ { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
+
+ { .name = NULL, .value = -1 }
+};
+
+static int target_configure(Jim_GetOptInfo *goi, target_t *target)
+{
+ Jim_Nvp *n;
+ Jim_Obj *o;
+ jim_wide w;
+ char *cp;
+ int e;
+
+ /* parse config or cget options ... */
+ while (goi->argc > 0) {
+ Jim_SetEmptyResult(goi->interp);
+ /* Jim_GetOpt_Debug(goi); */
+
+ if (target->type->target_jim_configure) {
+ /* target defines a configure function */
+ /* target gets first dibs on parameters */
+ e = (*(target->type->target_jim_configure))(target, goi);
+ if (e == JIM_OK) {
+ /* more? */
+ continue;
+ }
+ if (e == JIM_ERR) {
+ /* An error */
+ return e;
+ }
+ /* otherwise we 'continue' below */
+ }
+ e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
+ return e;
+ }
+ switch (n->value) {
+ case TCFG_TYPE:
+ /* not setable */
+ if (goi->isconfigure) {
+ Jim_SetResult_sprintf(goi->interp, "not setable: %s", n->name);
+ return JIM_ERR;
+ } else {
+ no_params:
+ if (goi->argc != 0) {
+ Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
+ return JIM_ERR;
+ }
+ }
+ Jim_SetResultString(goi->interp, target_get_name(target), -1);
+ /* loop for more */
+ break;
+ case TCFG_EVENT:
+ if (goi->argc == 0) {
+ Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
+ return JIM_ERR;
+ }
+
+ e = Jim_GetOpt_Nvp(goi, nvp_target_event, &n);
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(goi, nvp_target_event, 1);
+ return e;
+ }
+
+ if (goi->isconfigure) {
+ if (goi->argc != 1) {
+ Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
+ return JIM_ERR;
+ }
+ } else {
+ if (goi->argc != 0) {
+ Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
+ return JIM_ERR;
+ }
+ }
+
+ {
+ target_event_action_t *teap;
+
+ teap = target->event_action;
+ /* replace existing? */
+ while (teap) {
+ if (teap->event == (enum target_event)n->value) {
+ break;
+ }
+ teap = teap->next;
+ }
+
+ if (goi->isconfigure) {
+ bool replace = true;
+ if (teap == NULL) {
+ /* create new */
+ teap = calloc(1, sizeof(*teap));
+ replace = false;
+ }
+ teap->event = n->value;
+ Jim_GetOpt_Obj(goi, &o);
+ if (teap->body) {
+ Jim_DecrRefCount(interp, teap->body);
+ }
+ teap->body = Jim_DuplicateObj(goi->interp, o);
+ /*
+ * FIXME:
+ * Tcl/TK - "tk events" have a nice feature.
+ * See the "BIND" command.
+ * We should support that here.
+ * You can specify %X and %Y in the event code.
+ * The idea is: %T - target name.
+ * The idea is: %N - target number
+ * The idea is: %E - event name.
+ */
+ Jim_IncrRefCount(teap->body);
+
+ if (!replace)
+ {
+ /* add to head of event list */
+ teap->next = target->event_action;
+ target->event_action = teap;
+ }
+ Jim_SetEmptyResult(goi->interp);
+ } else {
+ /* get */
+ if (teap == NULL) {
+ Jim_SetEmptyResult(goi->interp);
+ } else {
+ Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
+ }
+ }
+ }
+ /* loop for more */
+ break;
+
+ case TCFG_WORK_AREA_VIRT:
+ if (goi->isconfigure) {
+ target_free_all_working_areas(target);
+ e = Jim_GetOpt_Wide(goi, &w);
+ if (e != JIM_OK) {
+ return e;
+ }
+ target->working_area_virt = w;
+ target->working_area_virt_spec = true;
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
+ /* loop for more */
+ break;
+
+ case TCFG_WORK_AREA_PHYS:
+ if (goi->isconfigure) {
+ target_free_all_working_areas(target);
+ e = Jim_GetOpt_Wide(goi, &w);
+ if (e != JIM_OK) {
+ return e;
+ }
+ target->working_area_phys = w;
+ target->working_area_phys_spec = true;
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
+ /* loop for more */
+ break;
+
+ case TCFG_WORK_AREA_SIZE:
+ if (goi->isconfigure) {
+ target_free_all_working_areas(target);
+ e = Jim_GetOpt_Wide(goi, &w);
+ if (e != JIM_OK) {
+ return e;
+ }
+ target->working_area_size = w;
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_size));
+ /* loop for more */
+ break;
+
+ case TCFG_WORK_AREA_BACKUP:
+ if (goi->isconfigure) {
+ target_free_all_working_areas(target);
+ e = Jim_GetOpt_Wide(goi, &w);
+ if (e != JIM_OK) {
+ return e;
+ }
+ /* make this exactly 1 or 0 */
+ target->backup_working_area = (!!w);
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
+ /* loop for more e*/
+ break;
+
+ case TCFG_ENDIAN:
+ if (goi->isconfigure) {
+ e = Jim_GetOpt_Nvp(goi, nvp_target_endian, &n);
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(goi, nvp_target_endian, 1);
+ return e;
+ }
+ target->endianness = n->value;
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
+ if (n->name == NULL) {
+ target->endianness = TARGET_LITTLE_ENDIAN;
+ n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
+ }
+ Jim_SetResultString(goi->interp, n->name, -1);
+ /* loop for more */
+ break;
+
+ case TCFG_VARIANT:
+ if (goi->isconfigure) {
+ if (goi->argc < 1) {
+ Jim_SetResult_sprintf(goi->interp,
+ "%s ?STRING?",
+ n->name);
+ return JIM_ERR;
+ }
+ if (target->variant) {
+ free((void *)(target->variant));
+ }
+ e = Jim_GetOpt_String(goi, &cp, NULL);
+ target->variant = strdup(cp);
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResultString(goi->interp, target->variant,-1);
+ /* loop for more */
+ break;
+ case TCFG_CHAIN_POSITION:
+ if (goi->isconfigure) {
+ Jim_Obj *o;
+ jtag_tap_t *tap;
+ target_free_all_working_areas(target);
+ e = Jim_GetOpt_Obj(goi, &o);
+ if (e != JIM_OK) {
+ return e;
+ }
+ tap = jtag_tap_by_jim_obj(goi->interp, o);
+ if (tap == NULL) {
+ return JIM_ERR;
+ }
+ /* make this exactly 1 or 0 */
+ target->tap = tap;
+ } else {
+ if (goi->argc != 0) {
+ goto no_params;
+ }
+ }
+ Jim_SetResultString(interp, target->tap->dotted_name, -1);
+ /* loop for more e*/
+ break;
+ }
+ } /* while (goi->argc) */
+
+
+ /* done - we return */
+ return JIM_OK;
+}
+
+/** this is the 'tcl' handler for the target specific command */
+static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+ Jim_GetOptInfo goi;
+ jim_wide a,b,c;
+ int x,y,z;
+ uint8_t target_buf[32];
+ Jim_Nvp *n;
+ target_t *target;
+ struct command_context_s *cmd_ctx;
+ int e;
+
+ enum {
+ TS_CMD_CONFIGURE,
+ TS_CMD_CGET,
+
+ TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
+ TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
+ TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
+ TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
+ TS_CMD_EXAMINE,
+ TS_CMD_POLL,
+ TS_CMD_RESET,
+ TS_CMD_HALT,
+ TS_CMD_WAITSTATE,
+ TS_CMD_EVENTLIST,
+ TS_CMD_CURSTATE,
+ TS_CMD_INVOKE_EVENT,
+ };
+
+ static const Jim_Nvp target_options[] = {
+ { .name = "configure", .value = TS_CMD_CONFIGURE },
+ { .name = "cget", .value = TS_CMD_CGET },
+ { .name = "mww", .value = TS_CMD_MWW },
+ { .name = "mwh", .value = TS_CMD_MWH },
+ { .name = "mwb", .value = TS_CMD_MWB },
+ { .name = "mdw", .value = TS_CMD_MDW },
+ { .name = "mdh", .value = TS_CMD_MDH },
+ { .name = "mdb", .value = TS_CMD_MDB },
+ { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
+ { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
+ { .name = "eventlist", .value = TS_CMD_EVENTLIST },
+ { .name = "curstate", .value = TS_CMD_CURSTATE },
+
+ { .name = "arp_examine", .value = TS_CMD_EXAMINE },
+ { .name = "arp_poll", .value = TS_CMD_POLL },
+ { .name = "arp_reset", .value = TS_CMD_RESET },
+ { .name = "arp_halt", .value = TS_CMD_HALT },
+ { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
+ { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
+
+ { .name = NULL, .value = -1 },
+ };
+
+ /* go past the "command" */
+ Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
+
+ target = Jim_CmdPrivData(goi.interp);
+ cmd_ctx = Jim_GetAssocData(goi.interp, "context");
+
+ /* commands here are in an NVP table */
+ e = Jim_GetOpt_Nvp(&goi, target_options, &n);
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(&goi, target_options, 0);
+ return e;
+ }
+ /* Assume blank result */
+ Jim_SetEmptyResult(goi.interp);
+
+ switch (n->value) {
+ case TS_CMD_CONFIGURE:
+ if (goi.argc < 2) {
+ Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
+ return JIM_ERR;
+ }
+ goi.isconfigure = 1;
+ return target_configure(&goi, target);
+ case TS_CMD_CGET:
+ // some things take params
+ if (goi.argc < 1) {
+ Jim_WrongNumArgs(goi.interp, 0, goi.argv, "missing: ?-option?");
+ return JIM_ERR;
+ }
+ goi.isconfigure = 0;
+ return target_configure(&goi, target);
+ break;
+ case TS_CMD_MWW:
+ case TS_CMD_MWH:
+ case TS_CMD_MWB:
+ /* argv[0] = cmd
+ * argv[1] = address
+ * argv[2] = data
+ * argv[3] = optional count.
+ */
+
+ if ((goi.argc == 2) || (goi.argc == 3)) {
+ /* all is well */
+ } else {
+ mwx_error:
+ Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR DATA [COUNT]", n->name);
+ return JIM_ERR;
+ }
+
+ e = Jim_GetOpt_Wide(&goi, &a);
+ if (e != JIM_OK) {
+ goto mwx_error;
+ }
+
+ e = Jim_GetOpt_Wide(&goi, &b);
+ if (e != JIM_OK) {
+ goto mwx_error;
+ }
+ if (goi.argc == 3) {
+ e = Jim_GetOpt_Wide(&goi, &c);
+ if (e != JIM_OK) {
+ goto mwx_error;
+ }
+ } else {
+ c = 1;
+ }
+
+ switch (n->value) {
+ case TS_CMD_MWW:
+ target_buffer_set_u32(target, target_buf, b);
+ b = 4;
+ break;
+ case TS_CMD_MWH:
+ target_buffer_set_u16(target, target_buf, b);
+ b = 2;
+ break;
+ case TS_CMD_MWB:
+ target_buffer_set_u8(target, target_buf, b);
+ b = 1;
+ break;
+ }
+ for (x = 0 ; x < c ; x++) {
+ e = target_write_memory(target, a, b, 1, target_buf);
+ if (e != ERROR_OK) {
+ Jim_SetResult_sprintf(interp, "Error writing @ 0x%08x: %d\n", (int)(a), e);
+ return JIM_ERR;
+ }
+ /* b = width */
+ a = a + b;
+ }
+ return JIM_OK;
+ break;
+
+ /* display */
+ case TS_CMD_MDW:
+ case TS_CMD_MDH:
+ case TS_CMD_MDB:
+ /* argv[0] = command
+ * argv[1] = address
+ * argv[2] = optional count
+ */
+ if ((goi.argc == 2) || (goi.argc == 3)) {
+ Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR [COUNT]", n->name);
+ return JIM_ERR;
+ }
+ e = Jim_GetOpt_Wide(&goi, &a);
+ if (e != JIM_OK) {
+ return JIM_ERR;
+ }
+ if (goi.argc) {
+ e = Jim_GetOpt_Wide(&goi, &c);
+ if (e != JIM_OK) {
+ return JIM_ERR;
+ }
+ } else {
+ c = 1;
+ }
+ b = 1; /* shut up gcc */
+ switch (n->value) {
+ case TS_CMD_MDW:
+ b = 4;
+ break;
+ case TS_CMD_MDH:
+ b = 2;
+ break;
+ case TS_CMD_MDB:
+ b = 1;
+ break;
+ }
+
+ /* convert to "bytes" */
+ c = c * b;
+ /* count is now in 'BYTES' */
+ while (c > 0) {
+ y = c;
+ if (y > 16) {
+ y = 16;
+ }
+ e = target_read_memory(target, a, b, y / b, target_buf);
+ if (e != ERROR_OK) {
+ Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
+ return JIM_ERR;
+ }
+
+ Jim_fprintf(interp, interp->cookie_stdout, "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 * 4 ]));
+ Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
+ }
+ for (; (x < 16) ; x += 4) {
+ Jim_fprintf(interp, interp->cookie_stdout, " ");
+ }
+ break;
+ case 2:
+ for (x = 0 ; (x < 16) && (x < y) ; x += 2) {
+ z = target_buffer_get_u16(target, &(target_buf[ x * 2 ]));
+ Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
+ }
+ for (; (x < 16) ; x += 2) {
+ Jim_fprintf(interp, interp->cookie_stdout, " ");
+ }
+ break;
+ case 1:
+ default:
+ for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
+ z = target_buffer_get_u8(target, &(target_buf[ x * 4 ]));
+ Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
+ }
+ for (; (x < 16) ; x += 1) {
+ Jim_fprintf(interp, interp->cookie_stdout, " ");
+ }
+ break;
+ }
+ /* ascii-ify the bytes */
+ for (x = 0 ; x < y ; x++) {
+ if ((target_buf[x] >= 0x20) &&
+ (target_buf[x] <= 0x7e)) {
+ /* good */
+ } else {
+ /* smack it */
+ target_buf[x] = '.';
+ }
+ }
+ /* space pad */
+ while (x < 16) {
+ target_buf[x] = ' ';
+ x++;
+ }
+ /* terminate */
+ target_buf[16] = 0;
+ /* print - with a newline */
+ Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
+ /* NEXT... */
+ c -= 16;
+ a += 16;
+ }
+ return JIM_OK;
+ case TS_CMD_MEM2ARRAY:
+ return target_mem2array(goi.interp, target, goi.argc, goi.argv);
+ break;
+ case TS_CMD_ARRAY2MEM:
+ return target_array2mem(goi.interp, target, goi.argc, goi.argv);
+ break;
+ case TS_CMD_EXAMINE:
+ if (goi.argc) {
+ Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
+ return JIM_ERR;
+ }
+ if (!target->tap->enabled)
+ goto err_tap_disabled;
+ e = target->type->examine(target);
+ if (e != ERROR_OK) {
+ Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
+ return JIM_ERR;
+ }
+ return JIM_OK;
+ case TS_CMD_POLL:
+ if (goi.argc) {
+ Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
+ return JIM_ERR;
+ }
+ if (!target->tap->enabled)
+ goto err_tap_disabled;
+ if (!(target_was_examined(target))) {
+ e = ERROR_TARGET_NOT_EXAMINED;
+ } else {
+ e = target->type->poll(target);
+ }
+ if (e != ERROR_OK) {
+ Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
+ return JIM_ERR;
+ } else {
+ return JIM_OK;
+ }
+ break;
+ case TS_CMD_RESET:
+ if (goi.argc != 2) {
+ Jim_WrongNumArgs(interp, 2, argv,
+ "([tT]|[fF]|assert|deassert) BOOL");
+ return JIM_ERR;
+ }
+ e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
+ return e;
+ }
+ /* the halt or not param */
+ e = Jim_GetOpt_Wide(&goi, &a);
+ if (e != JIM_OK) {
+ return e;
+ }
+ if (!target->tap->enabled)
+ goto err_tap_disabled;
+ if (!target->type->assert_reset
+ || !target->type->deassert_reset) {
+ Jim_SetResult_sprintf(interp,
+ "No target-specific reset for %s",
+ target->cmd_name);
+ return JIM_ERR;
+ }
+ /* determine if we should halt or not. */
+ target->reset_halt = !!a;
+ /* When this happens - all workareas are invalid. */
+ target_free_all_working_areas_restore(target, 0);
+
+ /* do the assert */
+ if (n->value == NVP_ASSERT) {
+ e = target->type->assert_reset(target);
+ } else {
+ e = target->type->deassert_reset(target);
+ }
+ return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
+ case TS_CMD_HALT:
+ if (goi.argc) {
+ Jim_WrongNumArgs(goi.interp, 0, argv, "halt [no parameters]");
+ return JIM_ERR;
+ }
+ if (!target->tap->enabled)
+ goto err_tap_disabled;
+ e = target->type->halt(target);
+ return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
+ case TS_CMD_WAITSTATE:
+ /* params: <name> statename timeoutmsecs */
+ if (goi.argc != 2) {
+ Jim_SetResult_sprintf(goi.interp, "%s STATENAME TIMEOUTMSECS", n->name);
+ return JIM_ERR;
+ }
+ e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
+ return e;
+ }
+ e = Jim_GetOpt_Wide(&goi, &a);
+ if (e != JIM_OK) {
+ return e;
+ }
+ if (!target->tap->enabled)
+ goto err_tap_disabled;
+ e = target_wait_state(target, n->value, a);
+ if (e != ERROR_OK) {
+ Jim_SetResult_sprintf(goi.interp,
+ "target: %s wait %s fails (%d) %s",
+ target->cmd_name,
+ n->name,
+ e, target_strerror_safe(e));
+ return JIM_ERR;
+ } else {
+ return JIM_OK;
+ }
+ case TS_CMD_EVENTLIST:
+ /* List for human, Events defined for this target.
+ * scripts/programs should use 'name cget -event NAME'
+ */
+ {
+ target_event_action_t *teap;
+ teap = target->event_action;
+ command_print(cmd_ctx, "Event actions for target (%d) %s\n",
+ target->target_number,
+ target->cmd_name);
+ command_print(cmd_ctx, "%-25s | Body", "Event");
+ command_print(cmd_ctx, "------------------------- | ----------------------------------------");
+ while (teap) {
+ command_print(cmd_ctx,
+ "%-25s | %s",
+ Jim_Nvp_value2name_simple(nvp_target_event, teap->event)->name,
+ Jim_GetString(teap->body, NULL));
+ teap = teap->next;
+ }
+ command_print(cmd_ctx, "***END***");
+ return JIM_OK;
+ }
+ case TS_CMD_CURSTATE:
+ if (goi.argc != 0) {
+ Jim_WrongNumArgs(goi.interp, 0, argv, "[no parameters]");
+ return JIM_ERR;
+ }
+ Jim_SetResultString(goi.interp,
+ target_state_name( target ),
+ -1);
+ return JIM_OK;
+ case TS_CMD_INVOKE_EVENT:
+ if (goi.argc != 1) {
+ Jim_SetResult_sprintf(goi.interp, "%s ?EVENTNAME?",n->name);
+ return JIM_ERR;
+ }
+ e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
+ return e;
+ }
+ target_handle_event(target, n->value);
+ return JIM_OK;
+ }
+ return JIM_ERR;
+
+err_tap_disabled:
+ Jim_SetResult_sprintf(interp, "[TAP is disabled]");
+ return JIM_ERR;
+}
+
+static int target_create(Jim_GetOptInfo *goi)
+{
+ Jim_Obj *new_cmd;
+ Jim_Cmd *cmd;
+ const char *cp;
+ char *cp2;
+ int e;
+ int x;
+ target_t *target;
+ struct command_context_s *cmd_ctx;
+
+ cmd_ctx = Jim_GetAssocData(goi->interp, "context");
+ if (goi->argc < 3) {
+ Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
+ return JIM_ERR;
+ }
+
+ /* COMMAND */
+ Jim_GetOpt_Obj(goi, &new_cmd);
+ /* does this command exist? */
+ 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);
+ return JIM_ERR;
+ }
+
+ /* TYPE */
+ e = Jim_GetOpt_String(goi, &cp2, NULL);
+ cp = cp2;
+ /* now does target type exist */
+ for (x = 0 ; target_types[x] ; x++) {
+ if (0 == strcmp(cp, target_types[x]->name)) {
+ /* found */
+ break;
+ }
+ }
+ if (target_types[x] == NULL) {
+ Jim_SetResult_sprintf(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,
+ Jim_GetResult(goi->interp),
+ target_types[x]->name,
+ ", ", NULL);
+ } else {
+ Jim_AppendStrings(goi->interp,
+ Jim_GetResult(goi->interp),
+ " or ",
+ target_types[x]->name,NULL);
+ }
+ }
+ return JIM_ERR;
+ }
+
+ /* Create it */
+ target = calloc(1,sizeof(target_t));
+ /* set target number */
+ target->target_number = new_target_number();
+
+ /* allocate memory for each unique target type */
+ target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
+
+ memcpy(target->type, target_types[x], sizeof(target_type_t));
+
+ /* will be set by "-endian" */
+ target->endianness = TARGET_ENDIAN_UNKNOWN;
+
+ target->working_area = 0x0;
+ target->working_area_size = 0x0;
+ target->working_areas = NULL;
+ target->backup_working_area = 0;
+
+ target->state = TARGET_UNKNOWN;
+ target->debug_reason = DBG_REASON_UNDEFINED;
+ target->reg_cache = NULL;
+ target->breakpoints = NULL;
+ target->watchpoints = NULL;
+ target->next = NULL;
+ target->arch_info = NULL;
+
+ target->display = 1;
+
+ target->halt_issued = false;
+
+ /* initialize trace information */
+ target->trace_info = malloc(sizeof(trace_t));
+ target->trace_info->num_trace_points = 0;
+ target->trace_info->trace_points_size = 0;
+ target->trace_info->trace_points = NULL;
+ target->trace_info->trace_history_size = 0;
+ target->trace_info->trace_history = NULL;
+ target->trace_info->trace_history_pos = 0;
+ target->trace_info->trace_history_overflowed = 0;
+
+ target->dbgmsg = NULL;
+ target->dbg_msg_enabled = 0;
+
+ target->endianness = TARGET_ENDIAN_UNKNOWN;
+
+ /* Do the rest as "configure" options */
+ goi->isconfigure = 1;
+ e = target_configure(goi, target);
+
+ if (target->tap == NULL)
+ {
+ Jim_SetResultString(interp, "-chain-position required when creating target", -1);
+ e = JIM_ERR;
+ }
+
+ if (e != JIM_OK) {
+ free(target->type);
+ free(target);
+ return e;
+ }
+
+ if (target->endianness == TARGET_ENDIAN_UNKNOWN) {
+ /* default endian to little if not specified */
+ target->endianness = TARGET_LITTLE_ENDIAN;
+ }
+
+ /* incase variant is not set */
+ if (!target->variant)
+ target->variant = strdup("");
+
+ /* create the target specific commands */
+ if (target->type->register_commands) {
+ (*(target->type->register_commands))(cmd_ctx);
+ }
+ if (target->type->target_create) {
+ (*(target->type->target_create))(target, goi->interp);
+ }
+
+ /* append to end of list */
+ {
+ target_t **tpp;
+ tpp = &(all_targets);
+ while (*tpp) {
+ tpp = &((*tpp)->next);
+ }
+ *tpp = target;
+ }
+
+ cp = Jim_GetString(new_cmd, NULL);
+ target->cmd_name = strdup(cp);
+
+ /* now - create the new target name command */
+ e = Jim_CreateCommand(goi->interp,
+ /* name */
+ cp,
+ tcl_target_func, /* C function */
+ target, /* private data */
+ NULL); /* no del proc */
+
+ return e;
+}
+
+static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+ int x,r,e;
+ jim_wide w;
+ struct command_context_s *cmd_ctx;
+ target_t *target;
+ Jim_GetOptInfo goi;
+ enum tcmd {
+ /* TG = target generic */
+ TG_CMD_CREATE,
+ TG_CMD_TYPES,
+ TG_CMD_NAMES,
+ TG_CMD_CURRENT,
+ TG_CMD_NUMBER,
+ TG_CMD_COUNT,
+ };
+ const char *target_cmds[] = {
+ "create", "types", "names", "current", "number",
+ "count",
+ NULL /* terminate */
+ };
+
+ LOG_DEBUG("Target command params:");
+ LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
+
+ cmd_ctx = Jim_GetAssocData(interp, "context");
+
+ Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
+
+ if (goi.argc == 0) {
+ Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
+ return JIM_ERR;
+ }
+
+ /* Jim_GetOpt_Debug(&goi); */
+ r = Jim_GetOpt_Enum(&goi, target_cmds, &x);
+ if (r != JIM_OK) {
+ return r;
+ }
+
+ switch (x) {
+ default:
+ Jim_Panic(goi.interp,"Why am I here?");
+ return JIM_ERR;
+ case TG_CMD_CURRENT:
+ if (goi.argc != 0) {
+ Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
+ return JIM_ERR;
+ }
+ Jim_SetResultString(goi.interp, get_current_target(cmd_ctx)->cmd_name, -1);
+ return JIM_OK;
+ case TG_CMD_TYPES:
+ if (goi.argc != 0) {
+ Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
+ return JIM_ERR;
+ }
+ Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
+ for (x = 0 ; target_types[x] ; x++) {
+ Jim_ListAppendElement(goi.interp,
+ Jim_GetResult(goi.interp),
+ Jim_NewStringObj(goi.interp, target_types[x]->name, -1));
+ }
+ return JIM_OK;
+ case TG_CMD_NAMES:
+ if (goi.argc != 0) {
+ Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
+ return JIM_ERR;
+ }
+ Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
+ target = all_targets;
+ while (target) {
+ Jim_ListAppendElement(goi.interp,
+ Jim_GetResult(goi.interp),
+ Jim_NewStringObj(goi.interp, target->cmd_name, -1));
+ target = target->next;
+ }
+ return JIM_OK;
+ case TG_CMD_CREATE:
+ if (goi.argc < 3) {
+ Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "?name ... config options ...");
+ return JIM_ERR;
+ }
+ return target_create(&goi);
+ break;
+ case TG_CMD_NUMBER:
+ /* It's OK to remove this mechanism sometime after August 2010 or so */
+ LOG_WARNING("don't use numbers as target identifiers; use names");
+ if (goi.argc != 1) {
+ Jim_SetResult_sprintf(goi.interp, "expected: target number ?NUMBER?");
+ return JIM_ERR;
+ }
+ e = Jim_GetOpt_Wide(&goi, &w);
+ if (e != JIM_OK) {
+ return JIM_ERR;
+ }
+ for (x = 0, target = all_targets; target; target = target->next, x++) {
+ if (target->target_number == w)
+ break;
+ }
+ if (target == NULL) {
+ Jim_SetResult_sprintf(goi.interp,
+ "Target: number %d does not exist", (int)(w));
+ return JIM_ERR;
+ }
+ Jim_SetResultString(goi.interp, target->cmd_name, -1);
+ return JIM_OK;
+ case TG_CMD_COUNT:
+ if (goi.argc != 0) {
+ Jim_WrongNumArgs(goi.interp, 0, goi.argv, "<no parameters>");
+ return JIM_ERR;
+ }
+ for (x = 0, target = all_targets; target; target = target->next, x++)
+ continue;
+ Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, x));
+ return JIM_OK;
+ }
+
+ return JIM_ERR;
+}
+
+
+struct FastLoad
+{
+ uint32_t address;
+ uint8_t *data;
+ int length;
+
+};
+
+static int fastload_num;
+static struct FastLoad *fastload;
+
+static void free_fastload(void)
+{
+ if (fastload != NULL)
+ {
+ int i;
+ for (i = 0; i < fastload_num; i++)
+ {
+ if (fastload[i].data)
+ free(fastload[i].data);
+ }
+ free(fastload);
+ fastload = NULL;
+ }
+}
+
+
+
+
+static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+ uint8_t *buffer;
+ uint32_t buf_cnt;
+ uint32_t image_size;
+ uint32_t min_address = 0;
+ uint32_t max_address = 0xffffffff;
+ int i;
+
+ image_t image;
+
+ int retval = parse_load_image_command_args(cmd_ctx, args, argc,
+ &image, &min_address, &max_address);
+ if (ERROR_OK != retval)
+ return retval;
+
+ struct duration bench;
+ duration_start(&bench);
+
+ if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
+ {
+ return ERROR_OK;
+ }
+
+ image_size = 0x0;
+ retval = ERROR_OK;
+ fastload_num = image.num_sections;
+ fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
+ if (fastload == NULL)
+ {
+ image_close(&image);
+ return ERROR_FAIL;
+ }
+ memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
+ for (i = 0; i < image.num_sections; i++)
+ {
+ buffer = malloc(image.sections[i].size);
+ if (buffer == NULL)
+ {
+ command_print(cmd_ctx, "error allocating buffer for section (%d bytes)",
+ (int)(image.sections[i].size));
+ break;
+ }
+
+ if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
+ {
+ free(buffer);
+ break;
+ }
+
+ uint32_t offset = 0;
+ uint32_t length = buf_cnt;
+
+
+ /* DANGER!!! beware of unsigned comparision here!!! */
+
+ if ((image.sections[i].base_address + buf_cnt >= min_address)&&
+ (image.sections[i].base_address < max_address))
+ {
+ if (image.sections[i].base_address < min_address)
+ {
+ /* clip addresses below */
+ offset += min_address-image.sections[i].base_address;
+ length -= offset;
+ }
+
+ if (image.sections[i].base_address + buf_cnt > max_address)
+ {
+ length -= (image.sections[i].base_address + buf_cnt)-max_address;
+ }
+
+ fastload[i].address = image.sections[i].base_address + offset;
+ fastload[i].data = malloc(length);
+ if (fastload[i].data == NULL)
+ {
+ free(buffer);
+ break;
+ }
+ memcpy(fastload[i].data, buffer + offset, length);
+ fastload[i].length = length;
+
+ image_size += length;
+ command_print(cmd_ctx, "%u bytes written at address 0x%8.8x",
+ (unsigned int)length,
+ ((unsigned int)(image.sections[i].base_address + offset)));
+ }
+
+ free(buffer);
+ }
+
+ if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
+ {
+ command_print(cmd_ctx, "Loaded %" PRIu32 " bytes "
+ "in %fs (%0.3f kb/s)", image_size,
+ duration_elapsed(&bench), duration_kbps(&bench, image_size));
+
+ command_print(cmd_ctx,
+ "WARNING: image has not been loaded to target!"
+ "You can issue a 'fast_load' to finish loading.");
+ }
+
+ image_close(&image);
+
+ if (retval != ERROR_OK)
+ {
+ free_fastload();
+ }
+
+ return retval;
+}
+
+static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+ if (argc > 0)
+ return ERROR_COMMAND_SYNTAX_ERROR;
+ if (fastload == NULL)
+ {
+ LOG_ERROR("No image in memory");
+ return ERROR_FAIL;
+ }
+ int i;
+ int ms = timeval_ms();
+ int size = 0;
+ int retval = ERROR_OK;
+ for (i = 0; i < fastload_num;i++)
+ {
+ target_t *target = get_current_target(cmd_ctx);
+ 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);
+ }
+ 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));
+ return retval;
+}
+
+static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+ command_context_t *context;
+ target_t *target;
+ int retval;
+
+ context = Jim_GetAssocData(interp, "context");
+ if (context == NULL) {
+ LOG_ERROR("array2mem: no command context");
+ return JIM_ERR;
+ }
+ target = get_current_target(context);
+ if (target == NULL) {
+ LOG_ERROR("array2mem: no current target");
+ return JIM_ERR;
+ }
+
+ if ((argc < 6) || (argc > 7))
+ {
+ return JIM_ERR;
+ }
+
+ int cpnum;
+ uint32_t op1;
+ uint32_t op2;
+ uint32_t CRn;
+ uint32_t CRm;
+ uint32_t value;
+
+ int e;
+ long l;
+ e = Jim_GetLong(interp, argv[1], &l);
+ if (e != JIM_OK) {
+ return e;
+ }
+ cpnum = l;
+
+ e = Jim_GetLong(interp, argv[2], &l);
+ if (e != JIM_OK) {
+ return e;
+ }
+ op1 = l;
+
+ e = Jim_GetLong(interp, argv[3], &l);
+ if (e != JIM_OK) {
+ return e;
+ }
+ CRn = l;
+
+ e = Jim_GetLong(interp, argv[4], &l);
+ if (e != JIM_OK) {
+ return e;
+ }
+ CRm = l;
+
+ e = Jim_GetLong(interp, argv[5], &l);
+ if (e != JIM_OK) {
+ return e;
+ }
+ op2 = l;
+
+ value = 0;
+
+ if (argc == 7)
+ {
+ e = Jim_GetLong(interp, argv[6], &l);
+ if (e != JIM_OK) {
+ return e;
+ }
+ value = l;
+
+ retval = target_mcr(target, cpnum, op1, op2, CRn, CRm, value);
+ if (retval != ERROR_OK)
+ return JIM_ERR;
+ } else
+ {
+ retval = target_mrc(target, cpnum, op1, op2, CRn, CRm, &value);
+ if (retval != ERROR_OK)
+ return JIM_ERR;
+
+ Jim_SetResult(interp, Jim_NewIntObj(interp, value));
+ }
+
+ return JIM_OK;
+}