explode tcl_target_func into many handlers
[openocd.git] / src / target / target.c
index d9552a5..3a84040 100644 (file)
@@ -3366,7 +3366,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, int argc,
         * argv[4] = count to write
         */
        if (argc != 4) {
-               Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
+               Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems");
                return JIM_ERR;
        }
        varname = Jim_GetString(argv[0], &len);
@@ -3849,422 +3849,537 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
        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)
+static int jim_target_configure(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;
-       struct target *target;
-       struct command_context *cmd_ctx;
-       int e;
+       Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+       goi.isconfigure = strcmp(Jim_GetString(argv[0], NULL), "configure") == 0;
+       int need_args = 1 + goi.isconfigure;
+       if (goi.argc < need_args)
+       {
+               Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
+                       goi.isconfigure
+                               ? "missing: -option VALUE ..."
+                               : "missing: -option ...");
+               return JIM_ERR;
+       }
+       struct target *target = Jim_CmdPrivData(goi.interp);
+       return target_configure(&goi, target);
+}
 
-       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 int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       const char *cmd_name = Jim_GetString(argv[0], NULL);
 
-       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 },
-       };
+       Jim_GetOptInfo goi;
+       Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-       /* go past the "command" */
-       Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
+       if (goi.argc != 2 && goi.argc != 3)
+       {
+               Jim_SetResult_sprintf(goi.interp,
+                               "usage: %s <address> <data> [<count>]", cmd_name);
+               return JIM_ERR;
+       }
 
-       target = Jim_CmdPrivData(goi.interp);
-       cmd_ctx = Jim_GetAssocData(goi.interp, "context");
+       jim_wide a;
+       int e = Jim_GetOpt_Wide(&goi, &a);
+       if (e != JIM_OK)
+               return e;
 
-       /* 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);
+       jim_wide b;
+       e = Jim_GetOpt_Wide(&goi, &b);
+       if (e != JIM_OK)
                return e;
+
+       jim_wide c = 1;
+       if (goi.argc == 3)
+       {
+               e = Jim_GetOpt_Wide(&goi, &c);
+               if (e != JIM_OK)
+                       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.
-                */
+       struct target *target = Jim_CmdPrivData(goi.interp);
+       uint8_t  target_buf[32];
+       if (strcasecmp(cmd_name, "mww") == 0) {
+               target_buffer_set_u32(target, target_buf, b);
+               b = 4;
+       }
+       else if (strcasecmp(cmd_name, "mwh") == 0) {
+               target_buffer_set_u16(target, target_buf, b);
+               b = 2;
+       }
+       else if (strcasecmp(cmd_name, "mwb") == 0) {
+               target_buffer_set_u8(target, target_buf, b);
+               b = 1;
+       } else {
+               LOG_ERROR("command '%s' unknown: ", cmd_name);
+               return JIM_ERR;
+       }
 
-               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);
+       for (jim_wide 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;
+}
 
-               e = Jim_GetOpt_Wide(&goi, &a);
-               if (e != JIM_OK) {
-                       goto mwx_error;
-               }
+static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       const char *cmd_name = Jim_GetString(argv[0], NULL);
 
-               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;
-               }
+       Jim_GetOptInfo goi;
+       Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 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;
+       if ((goi.argc == 2) || (goi.argc == 3))
+       {
+               Jim_SetResult_sprintf(goi.interp,
+                               "usage: %s <address> [<count>]", cmd_name);
+               return JIM_ERR;
+       }
 
-               /* 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);
+       jim_wide a;
+       int e = Jim_GetOpt_Wide(&goi, &a);
+       if (e != JIM_OK) {
+               return JIM_ERR;
+       }
+       jim_wide c;
+       if (goi.argc) {
+               e = Jim_GetOpt_Wide(&goi, &c);
                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;
+       } else {
+               c = 1;
+       }
+       jim_wide b = 1; /* shut up gcc */
+       if (strcasecmp(cmd_name, "mdw") == 0)
+               b = 4;
+       else if (strcasecmp(cmd_name, "mdh") == 0)
+               b = 2;
+       else if (strcasecmp(cmd_name, "mdb") == 0)
+               b = 1;
+       else {
+               LOG_ERROR("command '%s' unknown: ", cmd_name);
+               return JIM_ERR;
+       }
+
+       /* convert count to "bytes" */
+       c = c * b;
+
+       struct target *target = Jim_CmdPrivData(goi.interp);
+       uint8_t  target_buf[32];
+       jim_wide x, y, z;
+       while (c > 0) {
+               y = c;
+               if (y > 16) {
+                       y = 16;
                }
-               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;
+               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;
                }
 
-               /* convert to "bytes" */
-               c = c * b;
-               /* count is now in 'BYTES' */
-               while (c > 0) {
-                       y = c;
-                       if (y > 16) {
-                               y = 16;
+               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));
                        }
-                       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;
+                       for (; (x < 16) ; x += 4) {
+                               Jim_fprintf(interp, interp->cookie_stdout, "         ");
                        }
-
-                       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;
+                       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));
                        }
-                       /* 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] = '.';
-                               }
+                       for (; (x < 16) ; x += 2) {
+                               Jim_fprintf(interp, interp->cookie_stdout, "     ");
                        }
-                       /* space pad  */
-                       while (x < 16) {
-                               target_buf[x] = ' ';
-                               x++;
+                       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));
                        }
-                       /* 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_name(target));
-                       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_name(target), 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'
-                */
-               {
-                       struct target_event_action *teap;
-                       teap = target->event_action;
-                       command_print(cmd_ctx,
-                                       "Event actions for target (%d) %s\n",
-                                       target->target_number,
-                                       target_name(target));
-                       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;
+                       for (; (x < 16) ; x += 1) {
+                               Jim_fprintf(interp, interp->cookie_stdout, "   ");
                        }
-                       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;
+                       break;
                }
-               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;
+               /* 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] = '.';
+                       }
                }
-               e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
-               if (e != JIM_OK) {
-                       Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
-                       return e;
+               /* space pad  */
+               while (x < 16) {
+                       target_buf[x] = ' ';
+                       x++;
                }
-               target_handle_event(target, n->value);
-               return JIM_OK;
+               /* 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_ERR;
+       return JIM_OK;
+}
+
+static int jim_target_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       struct target *target = Jim_CmdPrivData(interp);
+       return target_mem2array(interp, target, argc - 1, argv + 1);
+}
+
+static int jim_target_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       struct target *target = Jim_CmdPrivData(interp);
+       return target_array2mem(interp, target, argc - 1, argv + 1);
+}
 
-err_tap_disabled:
+static int jim_target_tap_disabled(Jim_Interp *interp)
+{
        Jim_SetResult_sprintf(interp, "[TAP is disabled]");
        return JIM_ERR;
 }
 
+static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       if (argc != 1)
+       {
+               Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+               return JIM_ERR;
+       }
+       struct target *target = Jim_CmdPrivData(interp);
+       if (!target->tap->enabled)
+               return jim_target_tap_disabled(interp);
+
+       int e = target->type->examine(target);
+       if (e != ERROR_OK)
+       {
+               Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
+               return JIM_ERR;
+       }
+       return JIM_OK;
+}
+
+static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       if (argc != 1)
+       {
+               Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+               return JIM_ERR;
+       }
+       struct target *target = Jim_CmdPrivData(interp);
+       if (!target->tap->enabled)
+               return jim_target_tap_disabled(interp);
+
+       int e;
+       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;
+       }
+       return JIM_OK;
+}
+
+static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       Jim_GetOptInfo goi;
+       Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+
+       if (goi.argc != 2)
+       {
+               Jim_WrongNumArgs(interp, 0, argv,
+                               "([tT]|[fF]|assert|deassert) BOOL");
+               return JIM_ERR;
+       }
+
+       Jim_Nvp *n;
+       int 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 */
+       jim_wide a;
+       e = Jim_GetOpt_Wide(&goi, &a);
+       if (e != JIM_OK)
+               return e;
+
+       struct target *target = Jim_CmdPrivData(goi.interp);
+       if (!target->tap->enabled)
+               return jim_target_tap_disabled(interp);
+       if (!target->type->assert_reset || !target->type->deassert_reset)
+       {
+               Jim_SetResult_sprintf(interp,
+                               "No target-specific reset for %s",
+                               target_name(target));
+               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;
+}
+
+static int jim_target_halt(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       if (argc != 1) {
+               Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+               return JIM_ERR;
+       }
+       struct target *target = Jim_CmdPrivData(interp);
+       if (!target->tap->enabled)
+               return jim_target_tap_disabled(interp);
+       int e = target->type->halt(target);
+       return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
+}
+
+static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       Jim_GetOptInfo goi;
+       Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+
+       /* params:  <name>  statename timeoutmsecs */
+       if (goi.argc != 2)
+       {
+               const char *cmd_name = Jim_GetString(argv[0], NULL);
+               Jim_SetResult_sprintf(goi.interp,
+                               "%s <state_name> <timeout_in_msec>", cmd_name);
+               return JIM_ERR;
+       }
+
+       Jim_Nvp *n;
+       int e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
+       if (e != JIM_OK) {
+               Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
+               return e;
+       }
+       jim_wide a;
+       e = Jim_GetOpt_Wide(&goi, &a);
+       if (e != JIM_OK) {
+               return e;
+       }
+       struct target *target = Jim_CmdPrivData(interp);
+       if (!target->tap->enabled)
+               return jim_target_tap_disabled(interp);
+
+       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_name(target), n->name,
+                               e, target_strerror_safe(e));
+               return JIM_ERR;
+       }
+       return JIM_OK;
+}
+/* List for human, Events defined for this target.
+ * scripts/programs should use 'name cget -event NAME'
+ */
+static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
+       struct target *target = Jim_CmdPrivData(interp);
+       struct target_event_action *teap = target->event_action;
+       command_print(cmd_ctx, "Event actions for target (%d) %s\n",
+                                  target->target_number,
+                                  target_name(target));
+       command_print(cmd_ctx, "%-25s | Body", "Event");
+       command_print(cmd_ctx, "------------------------- | "
+                       "----------------------------------------");
+       while (teap)
+       {
+               Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
+               command_print(cmd_ctx, "%-25s | %s",
+                               opt->name, Jim_GetString(teap->body, NULL));
+               teap = teap->next;
+       }
+       command_print(cmd_ctx, "***END***");
+       return JIM_OK;
+}
+static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       if (argc != 1)
+       {
+               Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+               return JIM_ERR;
+       }
+       struct target *target = Jim_CmdPrivData(interp);
+       Jim_SetResultString(interp, target_state_name(target), -1);
+       return JIM_OK;
+}
+static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+       Jim_GetOptInfo goi;
+       Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+       if (goi.argc != 1)
+       {
+               const char *cmd_name = Jim_GetString(argv[0], NULL);
+               Jim_SetResult_sprintf(goi.interp, "%s <eventname>", cmd_name);
+               return JIM_ERR;
+       }
+       Jim_Nvp *n;
+       int e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
+       if (e != JIM_OK)
+       {
+               Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
+               return e;
+       }
+       struct target *target = Jim_CmdPrivData(interp);
+       target_handle_event(target, n->value);
+       return JIM_OK;
+}
+
+static const struct command_registration target_instance_command_handlers[] = {
+       {
+               .name = "configure",
+               .mode = COMMAND_CONFIG,
+               .jim_handler = &jim_target_configure,
+               .usage = "[<target_options> ...]",
+               .help  = "configure a new target for use",
+       },
+       {
+               .name = "cget",
+               .mode = COMMAND_ANY,
+               .jim_handler = &jim_target_configure,
+               .usage = "<target_type> [<target_options> ...]",
+               .help  = "configure a new target for use",
+       },
+       {
+               .name = "mww",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_mw,
+               .usage = "<address> <data> [<count>]",
+               .help = "Write 32-bit word(s) to target memory",
+       },
+       {
+               .name = "mwh",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_mw,
+               .usage = "<address> <data> [<count>]",
+               .help = "Write 16-bit half-word(s) to target memory",
+       },
+       {
+               .name = "mwb",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_mw,
+               .usage = "<address> <data> [<count>]",
+               .help = "Write byte(s) to target memory",
+       },
+       {
+               .name = "mdw",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_md,
+               .usage = "<address> [<count>]",
+               .help = "Display target memory as 32-bit words",
+       },
+       {
+               .name = "mdh",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_md,
+               .usage = "<address> [<count>]",
+               .help = "Display target memory as 16-bit half-words",
+       },
+       {
+               .name = "mdb",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_md,
+               .usage = "<address> [<count>]",
+               .help = "Display target memory as 8-bit bytes",
+       },
+       {
+               .name = "array2mem",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_array2mem,
+       },
+       {
+               .name = "mem2array",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_mem2array,
+       },
+       {
+               .name = "eventlist",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_event_list,
+       },
+       {
+               .name = "curstate",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_current_state,
+       },
+       {
+               .name = "arp_examine",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_examine,
+       },
+       {
+               .name = "arp_poll",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_poll,
+       },
+       {
+               .name = "arp_reset",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_reset,
+       },
+       {
+               .name = "arp_halt",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_halt,
+       },
+       {
+               .name = "arp_waitstate",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_wait_state,
+       },
+       {
+               .name = "invoke-event",
+               .mode = COMMAND_EXEC,
+               .jim_handler = &jim_target_invoke_event,
+       },
+       COMMAND_REGISTRATION_DONE
+};
+
 static int target_create(Jim_GetOptInfo *goi)
 {
        Jim_Obj *new_cmd;
@@ -4412,16 +4527,35 @@ static int target_create(Jim_GetOptInfo *goi)
                }
                *tpp = target;
        }
-
+       
        /* now - create the new target name command */
-       const struct command_registration target_command = {
-               .name = cp,
-               .jim_handler = &tcl_target_func,
-               .jim_handler_data = target,
-               .help = "target command group",
+       const const struct command_registration target_subcommands[] = {
+               {
+                       .chain = target_instance_command_handlers,
+               },
+               {
+                       .chain = target->type->commands,
+               },
+               COMMAND_REGISTRATION_DONE
        };
-       struct command *c = register_command(cmd_ctx, NULL, &target_command);
-       return (NULL != c) ? ERROR_OK : ERROR_FAIL;
+       const const struct command_registration target_commands[] = {
+               {
+                       .name = cp,
+                       .mode = COMMAND_ANY,
+                       .help = "target command group",
+                       .chain = target_subcommands,
+               },
+               COMMAND_REGISTRATION_DONE
+       };
+       e = register_commands(cmd_ctx, NULL, target_commands);
+       if (ERROR_OK != e)
+               return JIM_ERR;
+
+       struct command *c = command_find_in_context(cmd_ctx, cp);
+       assert(c);
+       command_set_handler_data(c, target);
+
+       return (ERROR_OK == e) ? JIM_OK : JIM_ERR;
 }
 
 static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)