+ Jim_Nvp *n;
+ Jim_Obj *o;
+ int e;
+
+ /* parse config or cget options */
+ while (goi->argc > 0) {
+ Jim_SetEmptyResult (goi->interp);
+
+ 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 JCFG_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_jtag_tap_event, &n );
+ if (e != JIM_OK) {
+ Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_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;
+ }
+ }
+
+ {
+ jtag_tap_event_action_t *jteap;
+
+ jteap = tap->event_action;
+ /* replace existing? */
+ while (jteap) {
+ if (jteap->event == n->value) {
+ break;
+ }
+ jteap = jteap->next;
+ }
+
+ if (goi->isconfigure) {
+ if (jteap == NULL) {
+ /* create new */
+ jteap = calloc(1, sizeof (*jteap));
+ }
+ jteap->event = n->value;
+ Jim_GetOpt_Obj( goi, &o);
+ if (jteap->body) {
+ Jim_DecrRefCount(interp, jteap->body);
+ }
+ jteap->body = Jim_DuplicateObj(goi->interp, o);
+ Jim_IncrRefCount(jteap->body);
+
+ /* add to head of event list */
+ jteap->next = tap->event_action;
+ tap->event_action = jteap;
+ Jim_SetEmptyResult(goi->interp);
+ } else {
+ /* get */
+ if (jteap == NULL) {
+ Jim_SetEmptyResult(goi->interp);
+ } else {
+ Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
+ }
+ }
+ }
+ /* loop for more */
+ break;
+ }
+ } /* while (goi->argc) */
+
+ return JIM_OK;
+}
+
+static int jim_newtap_cmd( Jim_GetOptInfo *goi )
+{
+ jtag_tap_t *pTap;
+ jtag_tap_t **ppTap;
+ jim_wide w;
+ int x;
+ int e;
+ int reqbits;
+ Jim_Nvp *n;
+ char *cp;
+ const Jim_Nvp opts[] = {
+#define NTAP_OPT_IRLEN 0
+ { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
+#define NTAP_OPT_IRMASK 1
+ { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
+#define NTAP_OPT_IRCAPTURE 2
+ { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
+#define NTAP_OPT_ENABLED 3
+ { .name = "-enable" , .value = NTAP_OPT_ENABLED },
+#define NTAP_OPT_DISABLED 4
+ { .name = "-disable" , .value = NTAP_OPT_DISABLED },
+#define NTAP_OPT_EXPECTED_ID 5
+ { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
+ { .name = NULL , .value = -1 },
+ };
+
+ pTap = malloc( sizeof(jtag_tap_t) );
+ memset( pTap, 0, sizeof(*pTap) );
+ if( !pTap ){
+ Jim_SetResult_sprintf( goi->interp, "no memory");
+ return JIM_ERR;
+ }
+ /*
+ * we expect CHIP + TAP + OPTIONS
+ * */
+ if( goi->argc < 3 ){
+ Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
+ return JIM_ERR;
+ }
+ Jim_GetOpt_String( goi, &cp, NULL );
+ pTap->chip = strdup(cp);
+
+ Jim_GetOpt_String( goi, &cp, NULL );
+ pTap->tapname = strdup(cp);
+
+ /* name + dot + name + null */
+ x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
+ cp = malloc( x );
+ sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
+ pTap->dotted_name = cp;
+
+ LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
+ pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
+
+ /* default is enabled */
+ pTap->enabled = 1;
+
+ /* deal with options */
+#define NTREQ_IRLEN 1
+#define NTREQ_IRCAPTURE 2
+#define NTREQ_IRMASK 4
+
+ /* clear them as we find them */
+ reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
+
+ while( goi->argc ){
+ e = Jim_GetOpt_Nvp( goi, opts, &n );
+ if( e != JIM_OK ){
+ Jim_GetOpt_NvpUnknown( goi, opts, 0 );
+ return e;
+ }
+ LOG_DEBUG("Processing option: %s", n->name );
+ switch( n->value ){
+ case NTAP_OPT_ENABLED:
+ pTap->enabled = 1;
+ break;
+ case NTAP_OPT_DISABLED:
+ pTap->enabled = 0;
+ break;
+ case NTAP_OPT_EXPECTED_ID:
+ {
+ u32 *new_expected_ids;
+
+ e = Jim_GetOpt_Wide( goi, &w );
+ if( e != JIM_OK) {
+ Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
+ return e;
+ }
+
+ new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
+ if (new_expected_ids == NULL) {
+ Jim_SetResult_sprintf( goi->interp, "no memory");
+ return JIM_ERR;
+ }
+
+ memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
+
+ new_expected_ids[pTap->expected_ids_cnt] = w;
+
+ free(pTap->expected_ids);
+ pTap->expected_ids = new_expected_ids;
+ pTap->expected_ids_cnt++;
+ break;
+ }
+ case NTAP_OPT_IRLEN:
+ case NTAP_OPT_IRMASK:
+ case NTAP_OPT_IRCAPTURE:
+ e = Jim_GetOpt_Wide( goi, &w );
+ if( e != JIM_OK ){
+ Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
+ return e;
+ }
+ if( (w < 0) || (w > 0xffff) ){
+ /* wacky value */
+ Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
+ n->name, (int)(w), (int)(w));
+ return JIM_ERR;
+ }
+ switch(n->value){
+ case NTAP_OPT_IRLEN:
+ pTap->ir_length = w;
+ reqbits &= (~(NTREQ_IRLEN));
+ break;
+ case NTAP_OPT_IRMASK:
+ pTap->ir_capture_mask = w;
+ reqbits &= (~(NTREQ_IRMASK));
+ break;
+ case NTAP_OPT_IRCAPTURE:
+ pTap->ir_capture_value = w;
+ reqbits &= (~(NTREQ_IRCAPTURE));
+ break;
+ }
+ } /* switch(n->value) */
+ } /* while( goi->argc ) */
+
+ /* Did we get all the options? */
+ if( reqbits ){
+ // no
+ Jim_SetResult_sprintf( goi->interp,
+ "newtap: %s missing required parameters",
+ pTap->dotted_name);
+ /* TODO: Tell user what is missing :-( */
+ /* no memory leaks pelase */
+ free(((void *)(pTap->expected_ids)));
+ free(((void *)(pTap->chip)));
+ free(((void *)(pTap->tapname)));
+ free(((void *)(pTap->dotted_name)));
+ free(((void *)(pTap)));
+ return JIM_ERR;
+ }
+
+ pTap->expected = malloc( pTap->ir_length );
+ pTap->expected_mask = malloc( pTap->ir_length );
+ pTap->cur_instr = malloc( pTap->ir_length );
+
+ buf_set_u32( pTap->expected,
+ 0,
+ pTap->ir_length,
+ pTap->ir_capture_value );
+ buf_set_u32( pTap->expected_mask,
+ 0,
+ pTap->ir_length,
+ pTap->ir_capture_mask );
+ buf_set_ones( pTap->cur_instr,
+ pTap->ir_length );
+
+ pTap->bypass = 1;
+
+ jtag_register_event_callback(jtag_reset_callback, pTap );
+
+ ppTap = &(jtag_all_taps);
+ while( (*ppTap) != NULL ){
+ ppTap = &((*ppTap)->next_tap);
+ }
+ *ppTap = pTap;
+ {
+ static int n_taps = 0;
+ pTap->abs_chain_position = n_taps++;
+ }
+ LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
+ (*ppTap)->dotted_name,
+ (*ppTap)->abs_chain_position,
+ (*ppTap)->ir_length,
+ (*ppTap)->ir_capture_value,
+ (*ppTap)->ir_capture_mask );
+
+ return ERROR_OK;
+}
+
+static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
+{
+ Jim_GetOptInfo goi;
+ int e;
+ Jim_Nvp *n;
+ Jim_Obj *o;
+ struct command_context_s *context;
+
+ enum {
+ JTAG_CMD_INTERFACE,
+ JTAG_CMD_INIT_RESET,
+ JTAG_CMD_NEWTAP,
+ JTAG_CMD_TAPENABLE,
+ JTAG_CMD_TAPDISABLE,
+ JTAG_CMD_TAPISENABLED,
+ JTAG_CMD_CONFIGURE,
+ JTAG_CMD_CGET
+ };
+
+ const Jim_Nvp jtag_cmds[] = {
+ { .name = "interface" , .value = JTAG_CMD_INTERFACE },
+ { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
+ { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
+ { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
+ { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
+ { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
+ { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
+ { .name = "cget" , .value = JTAG_CMD_CGET },
+
+ { .name = NULL, .value = -1 },
+ };
+
+ context = Jim_GetAssocData(interp, "context");
+ /* go past the command */
+ Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
+
+ e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
+ if( e != JIM_OK ){
+ Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
+ return e;
+ }
+ Jim_SetEmptyResult( goi.interp );
+ switch( n->value ){
+ case JTAG_CMD_INTERFACE:
+ /* return the name of the interface */
+ /* TCL code might need to know the exact type... */
+ /* FUTURE: we allow this as a means to "set" the interface. */
+ if( goi.argc != 0 ){
+ Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
+ return JIM_ERR;
+ }
+ Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
+ return JIM_OK;
+ case JTAG_CMD_INIT_RESET:
+ if( goi.argc != 0 ){
+ Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
+ return JIM_ERR;
+ }
+ e = jtag_init_reset(context);
+ if( e != ERROR_OK ){
+ Jim_SetResult_sprintf( goi.interp, "error: %d", e);
+ return JIM_ERR;
+ }
+ return JIM_OK;
+ case JTAG_CMD_NEWTAP:
+ return jim_newtap_cmd( &goi );
+ break;
+ case JTAG_CMD_TAPISENABLED:
+ case JTAG_CMD_TAPENABLE:
+ case JTAG_CMD_TAPDISABLE:
+ if( goi.argc != 1 ){
+ Jim_SetResultString( goi.interp, "Too many parameters",-1 );
+ return JIM_ERR;
+ }
+
+ {
+ jtag_tap_t *t;
+ t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
+ if( t == NULL ){
+ return JIM_ERR;
+ }
+ switch( n->value ){
+ case JTAG_CMD_TAPISENABLED:
+ e = t->enabled;
+ break;
+ case JTAG_CMD_TAPENABLE:
+ jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
+ e = 1;
+ t->enabled = e;
+ break;
+ case JTAG_CMD_TAPDISABLE:
+ jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
+ e = 0;
+ t->enabled = e;
+ break;
+ }
+ Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
+ return JIM_OK;
+ }
+ break;
+
+ case JTAG_CMD_CGET:
+ if( goi.argc < 2 ){
+ Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
+ return JIM_ERR;
+ }
+
+ {
+ jtag_tap_t *t;
+
+ Jim_GetOpt_Obj(&goi, &o);
+ t = jtag_TapByJimObj( goi.interp, o );
+ if( t == NULL ){
+ return JIM_ERR;
+ }
+
+ goi.isconfigure = 0;
+ return jtag_tap_configure_cmd( &goi, t);
+ }
+ break;
+
+ case JTAG_CMD_CONFIGURE:
+ if( goi.argc < 3 ){
+ Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
+ return JIM_ERR;
+ }
+
+ {
+ jtag_tap_t *t;
+
+ Jim_GetOpt_Obj(&goi, &o);
+ t = jtag_TapByJimObj( goi.interp, o );
+ if( t == NULL ){
+ return JIM_ERR;
+ }
+
+ goi.isconfigure = 1;
+ return jtag_tap_configure_cmd( &goi, t);
+ }
+ }
+
+ return JIM_ERR;
+}
+
+int jtag_register_commands(struct command_context_s *cmd_ctx)
+{
+ register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
+
+ register_command(cmd_ctx, NULL, "interface", handle_interface_command,
+ COMMAND_CONFIG, "try to configure interface");
+ register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
+ COMMAND_ANY, "set jtag speed (if supported)");
+ register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
+ COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");