git.gag.com Git - fw/openocd/blob - src/target/arm_tpiu_swo.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2
   3 /**
   4  * @file
   5  * This file implements support for the ARM CoreSight components Trace Port
   6  * Interface Unit (TPIU) and Serial Wire Output (SWO). It also supports the
   7  * CoreSight TPIU-Lite and the special TPIU version present with Cortex-M3
   8  * and Cortex-M4 (that includes SWO).
   9  */
  10
  11 /*
  12  * Relevant specifications from ARM include:
  13  *
  14  * CoreSight(tm) Components Technical Reference Manual           ARM DDI 0314H
  15  * CoreSight(tm) TPIU-Lite Technical Reference Manual            ARM DDI 0317A
  16  * Cortex(tm)-M3 Technical Reference Manual                      ARM DDI 0337G
  17  * Cortex(tm)-M4 Technical Reference Manual                      ARM DDI 0439B
  18  * CoreSight(tm) SoC-400 Technical Reference Manual              ARM DDI 0480F
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <stdlib.h>
  26 #include <jim.h>
  27
  28 #include <helper/bits.h>
  29 #include <helper/command.h>
  30 #include <helper/jim-nvp.h>
  31 #include <helper/list.h>
  32 #include <helper/log.h>
  33 #include <helper/types.h>
  34 #include <jtag/interface.h>
  35 #include <server/server.h>
  36 #include <target/arm_adi_v5.h>
  37 #include <target/target.h>
  38 #include <transport/transport.h>
  39 #include "arm_tpiu_swo.h"
  40
  41 /* START_DEPRECATED_TPIU */
  42 #include <target/cortex_m.h>
  43 #include <target/target_type.h>
  44 #define MSG "DEPRECATED \'tpiu config\' command: "
  45 /* END_DEPRECATED_TPIU */
  46
  47 #define TCP_SERVICE_NAME                "tpiu_swo_trace"
  48
  49 /* default for Cortex-M3 and Cortex-M4 specific TPIU */
  50 #define TPIU_SWO_DEFAULT_BASE           0xE0040000
  51
  52 #define TPIU_SSPSR_OFFSET               0x000
  53 #define TPIU_CSPSR_OFFSET               0x004
  54 #define TPIU_ACPR_OFFSET                0x010
  55 #define TPIU_SPPR_OFFSET                0x0F0
  56 #define TPIU_FFSR_OFFSET                0x300
  57 #define TPIU_FFCR_OFFSET                0x304
  58 #define TPIU_FSCR_OFFSET                0x308
  59 #define TPIU_DEVID_OFFSET               0xfc8
  60
  61 #define TPIU_ACPR_MAX_PRESCALER         0x1fff
  62 #define TPIU_SPPR_PROTOCOL_SYNC         (TPIU_PIN_PROTOCOL_SYNC)
  63 #define TPIU_SPPR_PROTOCOL_MANCHESTER   (TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER)
  64 #define TPIU_SPPR_PROTOCOL_UART         (TPIU_PIN_PROTOCOL_ASYNC_UART)
  65 #define TPIU_DEVID_NOSUPPORT_SYNC       BIT(9)
  66 #define TPIU_DEVID_SUPPORT_MANCHESTER   BIT(10)
  67 #define TPIU_DEVID_SUPPORT_UART         BIT(11)
  68
  69 enum arm_tpiu_swo_event {
  70         TPIU_SWO_EVENT_PRE_ENABLE,
  71         TPIU_SWO_EVENT_POST_ENABLE,
  72         TPIU_SWO_EVENT_PRE_DISABLE,
  73         TPIU_SWO_EVENT_POST_DISABLE,
  74 };
  75
  76 static const struct jim_nvp nvp_arm_tpiu_swo_event[] = {
  77         { .value = TPIU_SWO_EVENT_PRE_ENABLE,   .name = "pre-enable" },
  78         { .value = TPIU_SWO_EVENT_POST_ENABLE,  .name = "post-enable" },
  79         { .value = TPIU_SWO_EVENT_PRE_DISABLE,  .name = "pre-disable" },
  80         { .value = TPIU_SWO_EVENT_POST_DISABLE, .name = "post-disable" },
  81 };
  82
  83 struct arm_tpiu_swo_event_action {
  84         enum arm_tpiu_swo_event event;
  85         Jim_Interp *interp;
  86         Jim_Obj *body;
  87         struct arm_tpiu_swo_event_action *next;
  88 };
  89
  90 struct arm_tpiu_swo_object {
  91         struct list_head lh;
  92         struct adiv5_mem_ap_spot spot;
  93         char *name;
  94         struct arm_tpiu_swo_event_action *event_action;
  95         /* record enable before init */
  96         bool deferred_enable;
  97         bool enabled;
  98         bool en_capture;
  99         /** Handle to output trace data in INTERNAL capture mode */
 100         /** Synchronous output port width */
 101         uint32_t port_width;
 102         FILE *file;
 103         /** output mode */
 104         unsigned int pin_protocol;
 105         /** Enable formatter */
 106         bool en_formatter;
 107         /** frequency of TRACECLKIN (usually matches HCLK) */
 108         unsigned int traceclkin_freq;
 109         /** SWO pin frequency */
 110         unsigned int swo_pin_freq;
 111         /** where to dump the captured output trace data */
 112         char *out_filename;
 113         /** track TCP connections */
 114         struct list_head connections;
 115         /* START_DEPRECATED_TPIU */
 116         bool recheck_ap_cur_target;
 117         /* END_DEPRECATED_TPIU */
 118 };
 119
 120 struct arm_tpiu_swo_connection {
 121         struct list_head lh;
 122         struct connection *connection;
 123 };
 124
 125 struct arm_tpiu_swo_priv_connection {
 126         struct arm_tpiu_swo_object *obj;
 127 };
 128
 129 static LIST_HEAD(all_tpiu_swo);
 130
 131 #define ARM_TPIU_SWO_TRACE_BUF_SIZE     4096
 132
 133 static int arm_tpiu_swo_poll_trace(void *priv)
 134 {
 135         struct arm_tpiu_swo_object *obj = priv;
 136         uint8_t buf[ARM_TPIU_SWO_TRACE_BUF_SIZE];
 137         size_t size = sizeof(buf);
 138         struct arm_tpiu_swo_connection *c;
 139
 140         int retval = adapter_poll_trace(buf, &size);
 141         if (retval != ERROR_OK || !size)
 142                 return retval;
 143
 144         target_call_trace_callbacks(/*target*/NULL, size, buf);
 145
 146         if (obj->file) {
 147                 if (fwrite(buf, 1, size, obj->file) == size) {
 148                         fflush(obj->file);
 149                 } else {
 150                         LOG_ERROR("Error writing to the SWO trace destination file");
 151                         return ERROR_FAIL;
 152                 }
 153         }
 154
 155         if (obj->out_filename && obj->out_filename[0] == ':')
 156                 list_for_each_entry(c, &obj->connections, lh)
 157                         if (connection_write(c->connection, buf, size) != (int)size)
 158                                 retval = ERROR_FAIL;
 159
 160         return ERROR_OK;
 161 }
 162
 163 static void arm_tpiu_swo_handle_event(struct arm_tpiu_swo_object *obj, enum arm_tpiu_swo_event event)
 164 {
 165         for (struct arm_tpiu_swo_event_action *ea = obj->event_action; ea; ea = ea->next) {
 166                 if (ea->event != event)
 167                         continue;
 168
 169                 LOG_DEBUG("TPIU/SWO: %s event: %s (%d) action : %s",
 170                         obj->name,
 171                         jim_nvp_value2name_simple(nvp_arm_tpiu_swo_event, event)->name,
 172                         event,
 173                         Jim_GetString(ea->body, NULL));
 174
 175                 /* prevent event execution to change current target */
 176                 struct command_context *cmd_ctx = current_command_context(ea->interp);
 177                 struct target *saved_target = cmd_ctx->current_target;
 178                 int retval = Jim_EvalObj(ea->interp, ea->body);
 179                 cmd_ctx->current_target = saved_target;
 180
 181                 if (retval == JIM_RETURN)
 182                         retval = ea->interp->returnCode;
 183                 if (retval == JIM_OK || retval == ERROR_COMMAND_CLOSE_CONNECTION)
 184                         return;
 185
 186                 Jim_MakeErrorMessage(ea->interp);
 187                 LOG_USER("Error executing event %s on TPIU/SWO %s:\n%s",
 188                         jim_nvp_value2name_simple(nvp_arm_tpiu_swo_event, event)->name,
 189                         obj->name,
 190                         Jim_GetString(Jim_GetResult(ea->interp), NULL));
 191                 /* clean both error code and stacktrace before return */
 192                 Jim_Eval(ea->interp, "error \"\" \"\"");
 193                 return;
 194         }
 195 }
 196
 197 static void arm_tpiu_swo_close_output(struct arm_tpiu_swo_object *obj)
 198 {
 199         if (obj->file) {
 200                 fclose(obj->file);
 201                 obj->file = NULL;
 202         }
 203         if (obj->out_filename && obj->out_filename[0] == ':')
 204                 remove_service(TCP_SERVICE_NAME, &obj->out_filename[1]);
 205 }
 206
 207 int arm_tpiu_swo_cleanup_all(void)
 208 {
 209         struct arm_tpiu_swo_object *obj, *tmp;
 210
 211         list_for_each_entry_safe(obj, tmp, &all_tpiu_swo, lh) {
 212                 if (obj->enabled)
 213                         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_PRE_DISABLE);
 214
 215                 arm_tpiu_swo_close_output(obj);
 216
 217                 if (obj->en_capture) {
 218                         target_unregister_timer_callback(arm_tpiu_swo_poll_trace, obj);
 219
 220                         int retval = adapter_config_trace(false, 0, 0, NULL, 0, NULL);
 221                         if (retval != ERROR_OK)
 222                                 LOG_ERROR("Failed to stop adapter's trace");
 223                 }
 224
 225                 if (obj->enabled)
 226                         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_POST_DISABLE);
 227
 228                 struct arm_tpiu_swo_event_action *ea = obj->event_action;
 229                 while (ea) {
 230                         struct arm_tpiu_swo_event_action *next = ea->next;
 231                         Jim_DecrRefCount(ea->interp, ea->body);
 232                         free(ea);
 233                         ea = next;
 234                 }
 235
 236                 free(obj->name);
 237                 free(obj->out_filename);
 238                 free(obj);
 239         }
 240
 241         return ERROR_OK;
 242 }
 243
 244 static int arm_tpiu_swo_service_new_connection(struct connection *connection)
 245 {
 246         struct arm_tpiu_swo_priv_connection *priv = connection->service->priv;
 247         struct arm_tpiu_swo_object *obj = priv->obj;
 248         struct arm_tpiu_swo_connection *c = malloc(sizeof(*c));
 249         if (!c) {
 250                 LOG_ERROR("Out of memory");
 251                 return ERROR_FAIL;
 252         }
 253         c->connection = connection;
 254         list_add(&c->lh, &obj->connections);
 255         return ERROR_OK;
 256 }
 257
 258 static int arm_tpiu_swo_service_input(struct connection *connection)
 259 {
 260         /* read a dummy buffer to check if the connection is still active */
 261         long dummy;
 262         int bytes_read = connection_read(connection, &dummy, sizeof(dummy));
 263
 264         if (bytes_read == 0) {
 265                 return ERROR_SERVER_REMOTE_CLOSED;
 266         } else if (bytes_read == -1) {
 267                 LOG_ERROR("error during read: %s", strerror(errno));
 268                 return ERROR_SERVER_REMOTE_CLOSED;
 269         }
 270
 271         return ERROR_OK;
 272 }
 273
 274 static int arm_tpiu_swo_service_connection_closed(struct connection *connection)
 275 {
 276         struct arm_tpiu_swo_priv_connection *priv = connection->service->priv;
 277         struct arm_tpiu_swo_object *obj = priv->obj;
 278         struct arm_tpiu_swo_connection *c, *tmp;
 279
 280         list_for_each_entry_safe(c, tmp, &obj->connections, lh)
 281                 if (c->connection == connection) {
 282                         list_del(&c->lh);
 283                         free(c);
 284                         return ERROR_OK;
 285                 }
 286         LOG_ERROR("Failed to find connection to close!");
 287         return ERROR_FAIL;
 288 }
 289
 290 COMMAND_HANDLER(handle_arm_tpiu_swo_event_list)
 291 {
 292         struct arm_tpiu_swo_object *obj = CMD_DATA;
 293
 294         command_print(CMD, "Event actions for TPIU/SWO %s\n", obj->name);
 295         command_print(CMD, "%-25s | Body", "Event");
 296         command_print(CMD, "------------------------- | "
 297                         "----------------------------------------");
 298
 299         for (struct arm_tpiu_swo_event_action *ea = obj->event_action; ea; ea = ea->next) {
 300                 struct jim_nvp *opt = jim_nvp_value2name_simple(nvp_arm_tpiu_swo_event, ea->event);
 301                 command_print(CMD, "%-25s | %s",
 302                                 opt->name, Jim_GetString(ea->body, NULL));
 303         }
 304         command_print(CMD, "***END***");
 305         return ERROR_OK;
 306 }
 307
 308 enum arm_tpiu_swo_cfg_param {
 309         CFG_PORT_WIDTH,
 310         CFG_PROTOCOL,
 311         CFG_FORMATTER,
 312         CFG_TRACECLKIN,
 313         CFG_BITRATE,
 314         CFG_OUTFILE,
 315         CFG_EVENT,
 316 };
 317
 318 static const struct jim_nvp nvp_arm_tpiu_swo_config_opts[] = {
 319         { .name = "-port-width",    .value = CFG_PORT_WIDTH },
 320         { .name = "-protocol",      .value = CFG_PROTOCOL },
 321         { .name = "-formatter",     .value = CFG_FORMATTER },
 322         { .name = "-traceclk",      .value = CFG_TRACECLKIN },
 323         { .name = "-pin-freq",      .value = CFG_BITRATE },
 324         { .name = "-output",        .value = CFG_OUTFILE },
 325         { .name = "-event",         .value = CFG_EVENT },
 326         /* handled by mem_ap_spot, added for jim_getopt_nvp_unknown() */
 327         { .name = "-dap",           .value = -1 },
 328         { .name = "-ap-num",        .value = -1 },
 329         { .name = "-baseaddr",      .value = -1 },
 330         { .name = NULL,             .value = -1 },
 331 };
 332
 333 static const struct jim_nvp nvp_arm_tpiu_swo_protocol_opts[] = {
 334         { .name = "sync",           .value = TPIU_SPPR_PROTOCOL_SYNC },
 335         { .name = "uart",           .value = TPIU_SPPR_PROTOCOL_UART },
 336         { .name = "manchester",     .value = TPIU_SPPR_PROTOCOL_MANCHESTER },
 337         { .name = NULL,             .value = -1 },
 338 };
 339
 340 static const struct jim_nvp nvp_arm_tpiu_swo_bool_opts[] = {
 341         { .name = "on",             .value = 1 },
 342         { .name = "yes",            .value = 1 },
 343         { .name = "1",              .value = 1 },
 344         { .name = "true",           .value = 1 },
 345         { .name = "off",            .value = 0 },
 346         { .name = "no",             .value = 0 },
 347         { .name = "0",              .value = 0 },
 348         { .name = "false",          .value = 0 },
 349         { .name = NULL,             .value = -1 },
 350 };
 351
 352 static int arm_tpiu_swo_configure(struct jim_getopt_info *goi, struct arm_tpiu_swo_object *obj)
 353 {
 354         assert(obj);
 355
 356         if (goi->isconfigure && obj->enabled) {
 357                 Jim_SetResultFormatted(goi->interp, "Cannot configure TPIU/SWO; %s is enabled!", obj->name);
 358                 return JIM_ERR;
 359         }
 360
 361         /* parse config or cget options ... */
 362         while (goi->argc > 0) {
 363                 Jim_SetEmptyResult(goi->interp);
 364
 365                 int e = adiv5_jim_mem_ap_spot_configure(&obj->spot, goi);
 366                 if (e == JIM_OK)
 367                         continue;
 368                 if (e == JIM_ERR)
 369                         return e;
 370
 371                 struct jim_nvp *n;
 372                 e = jim_getopt_nvp(goi, nvp_arm_tpiu_swo_config_opts, &n);
 373                 if (e != JIM_OK) {
 374                         jim_getopt_nvp_unknown(goi, nvp_arm_tpiu_swo_config_opts, 0);
 375                         return e;
 376                 }
 377
 378                 switch (n->value) {
 379                 case CFG_PORT_WIDTH:
 380                         if (goi->isconfigure) {
 381                                 jim_wide port_width;
 382                                 e = jim_getopt_wide(goi, &port_width);
 383                                 if (e != JIM_OK)
 384                                         return e;
 385                                 if (port_width < 1 || port_width > 32) {
 386                                         Jim_SetResultString(goi->interp, "Invalid port width!", -1);
 387                                         return JIM_ERR;
 388                                 }
 389                                 obj->port_width = (uint32_t)port_width;
 390                         } else {
 391                                 if (goi->argc)
 392                                         goto err_no_params;
 393                                 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, obj->port_width));
 394                         }
 395                         break;
 396                 case CFG_PROTOCOL:
 397                         if (goi->isconfigure) {
 398                                 struct jim_nvp *p;
 399                                 e = jim_getopt_nvp(goi, nvp_arm_tpiu_swo_protocol_opts, &p);
 400                                 if (e != JIM_OK)
 401                                         return e;
 402                                 obj->pin_protocol = p->value;
 403                         } else {
 404                                 if (goi->argc)
 405                                         goto err_no_params;
 406                                 struct jim_nvp *p;
 407                                 e = jim_nvp_value2name(goi->interp, nvp_arm_tpiu_swo_protocol_opts, obj->pin_protocol, &p);
 408                                 if (e != JIM_OK) {
 409                                         Jim_SetResultString(goi->interp, "protocol error", -1);
 410                                         return JIM_ERR;
 411                                 }
 412                                 Jim_SetResult(goi->interp, Jim_NewStringObj(goi->interp, p->name, -1));
 413                         }
 414                         break;
 415                 case CFG_FORMATTER:
 416                         if (goi->isconfigure) {
 417                                 struct jim_nvp *p;
 418                                 e = jim_getopt_nvp(goi, nvp_arm_tpiu_swo_bool_opts, &p);
 419                                 if (e != JIM_OK)
 420                                         return e;
 421                                 obj->en_formatter = p->value;
 422                         } else {
 423                                 if (goi->argc)
 424                                         goto err_no_params;
 425                                 struct jim_nvp *p;
 426                                 e = jim_nvp_value2name(goi->interp, nvp_arm_tpiu_swo_bool_opts, obj->en_formatter, &p);
 427                                 if (e != JIM_OK) {
 428                                         Jim_SetResultString(goi->interp, "formatter error", -1);
 429                                         return JIM_ERR;
 430                                 }
 431                                 Jim_SetResult(goi->interp, Jim_NewStringObj(goi->interp, p->name, -1));
 432                         }
 433                         break;
 434                 case CFG_TRACECLKIN:
 435                         if (goi->isconfigure) {
 436                                 jim_wide clk;
 437                                 e = jim_getopt_wide(goi, &clk);
 438                                 if (e != JIM_OK)
 439                                         return e;
 440                                 obj->traceclkin_freq = clk;
 441                         } else {
 442                                 if (goi->argc)
 443                                         goto err_no_params;
 444                                 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, obj->traceclkin_freq));
 445                         }
 446                         break;
 447                 case CFG_BITRATE:
 448                         if (goi->isconfigure) {
 449                                 jim_wide clk;
 450                                 e = jim_getopt_wide(goi, &clk);
 451                                 if (e != JIM_OK)
 452                                         return e;
 453                                 obj->swo_pin_freq = clk;
 454                         } else {
 455                                 if (goi->argc)
 456                                         goto err_no_params;
 457                                 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, obj->swo_pin_freq));
 458                         }
 459                         break;
 460                 case CFG_OUTFILE:
 461                         if (goi->isconfigure) {
 462                                 const char *s;
 463                                 e = jim_getopt_string(goi, &s, NULL);
 464                                 if (e != JIM_OK)
 465                                         return e;
 466                                 if (s[0] == ':') {
 467                                         char *end;
 468                                         long port = strtol(s + 1, &end, 0);
 469                                         if (port <= 0 || port > UINT16_MAX || *end != '\0') {
 470                                                 Jim_SetResultFormatted(goi->interp, "Invalid TCP port \'%s\'", s + 1);
 471                                                 return JIM_ERR;
 472                                         }
 473                                 }
 474                                 free(obj->out_filename);
 475                                 obj->out_filename = strdup(s);
 476                                 if (!obj->out_filename) {
 477                                         LOG_ERROR("Out of memory");
 478                                         return JIM_ERR;
 479                                 }
 480                         } else {
 481                                 if (goi->argc)
 482                                         goto err_no_params;
 483                                 if (obj->out_filename)
 484                                         Jim_SetResult(goi->interp, Jim_NewStringObj(goi->interp, obj->out_filename, -1));
 485                         }
 486                         break;
 487                 case CFG_EVENT:
 488                         if (goi->isconfigure) {
 489                                 if (goi->argc < 2) {
 490                                         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
 491                                         return JIM_ERR;
 492                                 }
 493                         } else {
 494                                 if (goi->argc != 1) {
 495                                         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
 496                                         return JIM_ERR;
 497                                 }
 498                         }
 499
 500                         {
 501                                 struct jim_nvp *p;
 502                                 Jim_Obj *o;
 503                                 struct arm_tpiu_swo_event_action *ea = obj->event_action;
 504
 505                                 e = jim_getopt_nvp(goi, nvp_arm_tpiu_swo_event, &p);
 506                                 if (e != JIM_OK) {
 507                                         jim_getopt_nvp_unknown(goi, nvp_arm_tpiu_swo_event, 1);
 508                                         return e;
 509                                 }
 510
 511                                 while (ea) {
 512                                         /* replace existing? */
 513                                         if (ea->event == (enum arm_tpiu_swo_event)p->value)
 514                                                 break;
 515                                         ea = ea->next;
 516                                 }
 517
 518                                 if (goi->isconfigure) {
 519                                         if (!ea) {
 520                                                 ea = calloc(1, sizeof(*ea));
 521                                                 if (!ea) {
 522                                                         LOG_ERROR("Out of memory");
 523                                                         return JIM_ERR;
 524                                                 }
 525                                                 ea->next = obj->event_action;
 526                                                 obj->event_action = ea;
 527                                         }
 528                                         if (ea->body)
 529                                                 Jim_DecrRefCount(ea->interp, ea->body);
 530                                         ea->event = p->value;
 531                                         ea->interp = goi->interp;
 532                                         jim_getopt_obj(goi, &o);
 533                                         ea->body = Jim_DuplicateObj(goi->interp, o);
 534                                         Jim_IncrRefCount(ea->body);
 535                                 } else {
 536                                         if (ea)
 537                                                 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, ea->body));
 538                                 }
 539                         }
 540                         break;
 541                 }
 542         }
 543
 544         return JIM_OK;
 545
 546 err_no_params:
 547         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
 548         return JIM_ERR;
 549 }
 550
 551 static int jim_arm_tpiu_swo_configure(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
 552 {
 553         struct command *c = jim_to_command(interp);
 554         struct jim_getopt_info goi;
 555
 556         jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
 557         goi.isconfigure = !strcmp(c->name, "configure");
 558         if (goi.argc < 1) {
 559                 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
 560                         "missing: -option ...");
 561                 return JIM_ERR;
 562         }
 563         struct arm_tpiu_swo_object *obj = c->jim_handler_data;
 564         return arm_tpiu_swo_configure(&goi, obj);
 565 }
 566
 567 static int wrap_write_u32(struct target *target, struct adiv5_ap *tpiu_ap,
 568                 target_addr_t address, uint32_t value)
 569 {
 570         if (transport_is_hla())
 571                 return target_write_u32(target, address, value);
 572         else
 573                 return mem_ap_write_atomic_u32(tpiu_ap, address, value);
 574 }
 575
 576 static int wrap_read_u32(struct target *target, struct adiv5_ap *tpiu_ap,
 577                 target_addr_t address, uint32_t *value)
 578 {
 579         if (transport_is_hla())
 580                 return target_read_u32(target, address, value);
 581         else
 582                 return mem_ap_read_atomic_u32(tpiu_ap, address, value);
 583 }
 584
 585 static int jim_arm_tpiu_swo_enable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 586 {
 587         struct command *c = jim_to_command(interp);
 588         struct arm_tpiu_swo_object *obj = c->jim_handler_data;
 589         struct command_context *cmd_ctx = current_command_context(interp);
 590         struct adiv5_ap *tpiu_ap = dap_ap(obj->spot.dap, obj->spot.ap_num);
 591         uint32_t value;
 592         int retval;
 593
 594         if (argc != 1) {
 595                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 596                 return JIM_ERR;
 597         }
 598
 599         if (cmd_ctx->mode == COMMAND_CONFIG) {
 600                 LOG_DEBUG("%s: enable deferred", obj->name);
 601                 obj->deferred_enable = true;
 602                 return JIM_OK;
 603         }
 604
 605         if (obj->enabled)
 606                 return JIM_OK;
 607
 608         if (transport_is_hla() && obj->spot.ap_num > 0) {
 609                 LOG_ERROR("Invalid access port %d. Only AP#0 allowed with hla transport", obj->spot.ap_num);
 610                 return JIM_ERR;
 611         }
 612
 613         if (!obj->traceclkin_freq) {
 614                 LOG_ERROR("Trace clock-in frequency not set");
 615                 return JIM_ERR;
 616         }
 617
 618         if (obj->pin_protocol == TPIU_SPPR_PROTOCOL_MANCHESTER || obj->pin_protocol == TPIU_SPPR_PROTOCOL_UART)
 619                 if (!obj->swo_pin_freq) {
 620                         LOG_ERROR("SWO pin frequency not set");
 621                         return JIM_ERR;
 622                 }
 623
 624         struct target *target = get_current_target(cmd_ctx);
 625
 626         /* START_DEPRECATED_TPIU */
 627         if (obj->recheck_ap_cur_target) {
 628                 if (strcmp(target->type->name, "cortex_m") &&
 629                         strcmp(target->type->name, "hla_target")) {
 630                         LOG_ERROR(MSG "Current target is not a Cortex-M nor a HLA");
 631                         return JIM_ERR;
 632                 }
 633                 if (!target_was_examined(target)) {
 634                         LOG_ERROR(MSG "Current target not examined yet");
 635                         return JIM_ERR;
 636                 }
 637                 struct cortex_m_common *cm = target_to_cm(target);
 638                 obj->recheck_ap_cur_target = false;
 639                 obj->spot.ap_num = cm->armv7m.debug_ap->ap_num;
 640                 tpiu_ap = dap_ap(obj->spot.dap, obj->spot.ap_num);
 641                 if (obj->spot.ap_num == 0)
 642                         LOG_INFO(MSG "Confirmed TPIU %s is on AP 0", obj->name);
 643                 else
 644                         LOG_INFO(MSG "Target %s is on AP %d. Revised command is "
 645                                 "\'tpiu create %s -dap %s -ap-num %d\'",
 646                                 target_name(target), obj->spot.ap_num,
 647                                 obj->name, adiv5_dap_name(obj->spot.dap), obj->spot.ap_num);
 648         }
 649         /* END_DEPRECATED_TPIU */
 650
 651         /* trigger the event before any attempt to R/W in the TPIU/SWO */
 652         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_PRE_ENABLE);
 653
 654         retval = wrap_read_u32(target, tpiu_ap, obj->spot.base + TPIU_DEVID_OFFSET, &value);
 655         if (retval != ERROR_OK) {
 656                 LOG_ERROR("Unable to read %s", obj->name);
 657                 return JIM_ERR;
 658         }
 659         switch (obj->pin_protocol) {
 660         case TPIU_SPPR_PROTOCOL_SYNC:
 661                 value = !(value & TPIU_DEVID_NOSUPPORT_SYNC);
 662                 break;
 663         case TPIU_SPPR_PROTOCOL_UART:
 664                 value &= TPIU_DEVID_SUPPORT_UART;
 665                 break;
 666         case TPIU_SPPR_PROTOCOL_MANCHESTER:
 667                 value &= TPIU_DEVID_SUPPORT_MANCHESTER;
 668                 break;
 669         default:
 670                 value = 0;
 671         }
 672         if (!value) {
 673                 struct jim_nvp *p;
 674                 jim_nvp_value2name(interp, nvp_arm_tpiu_swo_protocol_opts, obj->pin_protocol, &p);
 675                 LOG_ERROR("%s does not support protocol %s", obj->name, p->name);
 676                 return JIM_ERR;
 677         }
 678
 679         if (obj->pin_protocol == TPIU_SPPR_PROTOCOL_SYNC) {
 680                 retval = wrap_read_u32(target, tpiu_ap, obj->spot.base + TPIU_SSPSR_OFFSET, &value);
 681                 if (!(value & BIT(obj->port_width - 1))) {
 682                         LOG_ERROR("TPIU does not support port-width of %d bits", obj->port_width);
 683                         return JIM_ERR;
 684                 }
 685         }
 686
 687         uint16_t prescaler = 1; /* dummy value */
 688         unsigned int swo_pin_freq = obj->swo_pin_freq; /* could be replaced */
 689
 690         if (obj->out_filename && strcmp(obj->out_filename, "external") && obj->out_filename[0]) {
 691                 if (obj->out_filename[0] == ':') {
 692                         struct arm_tpiu_swo_priv_connection *priv = malloc(sizeof(*priv));
 693                         if (!priv) {
 694                                 LOG_ERROR("Out of memory");
 695                                 return JIM_ERR;
 696                         }
 697                         priv->obj = obj;
 698                         LOG_INFO("starting trace server for %s on %s", obj->name, &obj->out_filename[1]);
 699                         retval = add_service("tpiu_swo_trace", &obj->out_filename[1],
 700                                 CONNECTION_LIMIT_UNLIMITED, arm_tpiu_swo_service_new_connection,
 701                                 arm_tpiu_swo_service_input, arm_tpiu_swo_service_connection_closed,
 702                                 priv);
 703                         if (retval != ERROR_OK) {
 704                                 LOG_ERROR("Can't configure trace TCP port %s", &obj->out_filename[1]);
 705                                 return JIM_ERR;
 706                         }
 707                 } else if (strcmp(obj->out_filename, "-")) {
 708                         obj->file = fopen(obj->out_filename, "ab");
 709                         if (!obj->file) {
 710                                 LOG_ERROR("Can't open trace destination file \"%s\"", obj->out_filename);
 711                                 return JIM_ERR;
 712                         }
 713                 }
 714
 715                 retval = adapter_config_trace(true, obj->pin_protocol, obj->port_width,
 716                         &swo_pin_freq, obj->traceclkin_freq, &prescaler);
 717                 if (retval != ERROR_OK) {
 718                         LOG_ERROR("Failed to start adapter's trace");
 719                         arm_tpiu_swo_close_output(obj);
 720                         return JIM_ERR;
 721                 }
 722
 723                 if (obj->swo_pin_freq != swo_pin_freq)
 724                         LOG_INFO("SWO pin data rate adjusted by adapter to %d Hz", swo_pin_freq);
 725                 obj->swo_pin_freq = swo_pin_freq;
 726
 727                 target_register_timer_callback(arm_tpiu_swo_poll_trace, 1,
 728                         TARGET_TIMER_TYPE_PERIODIC, obj);
 729
 730                 obj->en_capture = true;
 731         } else if (obj->pin_protocol == TPIU_SPPR_PROTOCOL_MANCHESTER || obj->pin_protocol == TPIU_SPPR_PROTOCOL_UART) {
 732                 prescaler = (obj->traceclkin_freq + obj->swo_pin_freq / 2) / obj->swo_pin_freq;
 733                 if (prescaler > TPIU_ACPR_MAX_PRESCALER)
 734                         prescaler = TPIU_ACPR_MAX_PRESCALER;
 735                 swo_pin_freq = obj->traceclkin_freq / prescaler;
 736
 737                 if (obj->swo_pin_freq != swo_pin_freq)
 738                         LOG_INFO("SWO pin data rate adjusted to %d Hz", swo_pin_freq);
 739                 obj->swo_pin_freq = swo_pin_freq;
 740         }
 741
 742         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_CSPSR_OFFSET, BIT(obj->port_width - 1));
 743         if (retval != ERROR_OK)
 744                 goto error_exit;
 745
 746         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_ACPR_OFFSET, prescaler - 1);
 747         if (retval != ERROR_OK)
 748                 goto error_exit;
 749
 750         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_SPPR_OFFSET, obj->pin_protocol);
 751         if (retval != ERROR_OK)
 752                 goto error_exit;
 753
 754         retval = wrap_read_u32(target, tpiu_ap, obj->spot.base + TPIU_FFCR_OFFSET, &value);
 755         if (retval != ERROR_OK)
 756                 goto error_exit;
 757         if (obj->en_formatter)
 758                 value |= BIT(1);
 759         else
 760                 value &= ~BIT(1);
 761         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_FFCR_OFFSET, value);
 762         if (retval != ERROR_OK)
 763                 goto error_exit;
 764
 765         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_POST_ENABLE);
 766
 767         /* START_DEPRECATED_TPIU */
 768         target_handle_event(target, TARGET_EVENT_TRACE_CONFIG);
 769         /* END_DEPRECATED_TPIU */
 770
 771         obj->enabled = true;
 772         return JIM_OK;
 773
 774 error_exit:
 775         LOG_ERROR("Error!");
 776
 777         if (obj->en_capture) {
 778                 obj->en_capture = false;
 779
 780                 arm_tpiu_swo_close_output(obj);
 781
 782                 target_unregister_timer_callback(arm_tpiu_swo_poll_trace, obj);
 783
 784                 retval = adapter_config_trace(false, 0, 0, NULL, 0, NULL);
 785                 if (retval != ERROR_OK) {
 786                         LOG_ERROR("Failed to stop adapter's trace");
 787                         return JIM_ERR;
 788                 }
 789         }
 790         return JIM_ERR;
 791 }
 792
 793 static int jim_arm_tpiu_swo_disable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 794 {
 795         struct command *c = jim_to_command(interp);
 796         struct arm_tpiu_swo_object *obj = c->jim_handler_data;
 797
 798         if (argc != 1) {
 799                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 800                 return JIM_ERR;
 801         }
 802
 803         if (!obj->enabled)
 804                 return JIM_OK;
 805         obj->enabled = false;
 806
 807         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_PRE_DISABLE);
 808
 809         if (obj->en_capture) {
 810                 obj->en_capture = false;
 811
 812                 arm_tpiu_swo_close_output(obj);
 813
 814                 target_unregister_timer_callback(arm_tpiu_swo_poll_trace, obj);
 815
 816                 int retval = adapter_config_trace(false, 0, 0, NULL, 0, NULL);
 817                 if (retval != ERROR_OK) {
 818                         LOG_ERROR("Failed to stop adapter's trace");
 819                         return JIM_ERR;
 820                 }
 821         }
 822
 823         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_POST_DISABLE);
 824
 825         /* START_DEPRECATED_TPIU */
 826         struct command_context *cmd_ctx = current_command_context(interp);
 827         struct target *target = get_current_target(cmd_ctx);
 828         target_handle_event(target, TARGET_EVENT_TRACE_CONFIG);
 829         /* END_DEPRECATED_TPIU */
 830
 831         return JIM_OK;
 832 }
 833
 834 static const struct command_registration arm_tpiu_swo_instance_command_handlers[] = {
 835         {
 836                 .name = "configure",
 837                 .mode = COMMAND_ANY,
 838                 .jim_handler = jim_arm_tpiu_swo_configure,
 839                 .help  = "configure a new TPIU/SWO for use",
 840                 .usage = "[attribute value ...]",
 841         },
 842         {
 843                 .name = "cget",
 844                 .mode = COMMAND_ANY,
 845                 .jim_handler = jim_arm_tpiu_swo_configure,
 846                 .help  = "returns the specified TPIU/SWO attribute",
 847                 .usage = "attribute",
 848         },
 849         {
 850                 .name = "eventlist",
 851                 .mode = COMMAND_ANY,
 852                 .handler = handle_arm_tpiu_swo_event_list,
 853                 .help = "displays a table of events defined for this TPIU/SWO",
 854                 .usage = "",
 855         },
 856         {
 857                 .name = "enable",
 858                 .mode = COMMAND_ANY,
 859                 .jim_handler = jim_arm_tpiu_swo_enable,
 860                 .usage = "",
 861                 .help = "Enables the TPIU/SWO output",
 862         },
 863         {
 864                 .name = "disable",
 865                 .mode = COMMAND_EXEC,
 866                 .jim_handler = jim_arm_tpiu_swo_disable,
 867                 .usage = "",
 868                 .help = "Disables the TPIU/SWO output",
 869         },
 870         COMMAND_REGISTRATION_DONE
 871 };
 872
 873 static int arm_tpiu_swo_create(Jim_Interp *interp, struct arm_tpiu_swo_object *obj)
 874 {
 875         struct command_context *cmd_ctx;
 876         Jim_Cmd *cmd;
 877         int e;
 878
 879         cmd_ctx = current_command_context(interp);
 880         assert(cmd_ctx);
 881
 882         /* does this command exist? */
 883         cmd = Jim_GetCommand(interp, Jim_NewStringObj(interp, obj->name, -1), JIM_ERRMSG);
 884         if (cmd) {
 885                 Jim_SetResultFormatted(interp, "Command: %s Exists", obj->name);
 886                 return JIM_ERR;
 887         }
 888
 889         /* now - create the new tpiu/swo name command */
 890         const struct command_registration obj_commands[] = {
 891                 {
 892                         .name = obj->name,
 893                         .mode = COMMAND_ANY,
 894                         .help = "tpiu/swo instance command group",
 895                         .usage = "",
 896                         .chain = arm_tpiu_swo_instance_command_handlers,
 897                 },
 898                 COMMAND_REGISTRATION_DONE
 899         };
 900         e = register_commands_with_data(cmd_ctx, NULL, obj_commands, obj);
 901         if (e != ERROR_OK)
 902                 return JIM_ERR;
 903
 904         list_add_tail(&obj->lh, &all_tpiu_swo);
 905
 906         return JIM_OK;
 907 }
 908
 909 static int jim_arm_tpiu_swo_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 910 {
 911         struct jim_getopt_info goi;
 912         jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
 913         if (goi.argc < 1) {
 914                 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "?name? ..options...");
 915                 return JIM_ERR;
 916         }
 917
 918         struct arm_tpiu_swo_object *obj = calloc(1, sizeof(struct arm_tpiu_swo_object));
 919         if (!obj) {
 920                 LOG_ERROR("Out of memory");
 921                 return JIM_ERR;
 922         }
 923         INIT_LIST_HEAD(&obj->connections);
 924         adiv5_mem_ap_spot_init(&obj->spot);
 925         obj->spot.base = TPIU_SWO_DEFAULT_BASE;
 926         obj->port_width = 1;
 927
 928         Jim_Obj *n;
 929         jim_getopt_obj(&goi, &n);
 930         obj->name = strdup(Jim_GetString(n, NULL));
 931         if (!obj->name) {
 932                 LOG_ERROR("Out of memory");
 933                 free(obj);
 934                 return JIM_ERR;
 935         }
 936
 937         /* Do the rest as "configure" options */
 938         goi.isconfigure = 1;
 939         int e = arm_tpiu_swo_configure(&goi, obj);
 940         if (e != JIM_OK)
 941                 goto err_exit;
 942
 943         if (!obj->spot.dap || obj->spot.ap_num == DP_APSEL_INVALID) {
 944                 Jim_SetResultString(goi.interp, "-dap and -ap-num required when creating TPIU", -1);
 945                 goto err_exit;
 946         }
 947
 948         e = arm_tpiu_swo_create(goi.interp, obj);
 949         if (e != JIM_OK)
 950                 goto err_exit;
 951
 952         return JIM_OK;
 953
 954 err_exit:
 955         free(obj->name);
 956         free(obj->out_filename);
 957         free(obj);
 958         return JIM_ERR;
 959 }
 960
 961 static int jim_arm_tpiu_swo_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 962 {
 963         struct arm_tpiu_swo_object *obj;
 964
 965         if (argc != 1) {
 966                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 967                 return JIM_ERR;
 968         }
 969         Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
 970         list_for_each_entry(obj, &all_tpiu_swo, lh) {
 971                 Jim_ListAppendElement(interp, Jim_GetResult(interp),
 972                         Jim_NewStringObj(interp, obj->name, -1));
 973         }
 974         return JIM_OK;
 975 }
 976
 977 static int jim_arm_tpiu_swo_init(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 978 {
 979         struct command_context *cmd_ctx = current_command_context(interp);
 980         struct arm_tpiu_swo_object *obj;
 981         int retval = JIM_OK;
 982
 983         if (argc != 1) {
 984                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 985                 return JIM_ERR;
 986         }
 987         list_for_each_entry(obj, &all_tpiu_swo, lh) {
 988                 if (!obj->deferred_enable)
 989                         continue;
 990                 LOG_DEBUG("%s: running enable during init", obj->name);
 991                 int retval2 = command_run_linef(cmd_ctx, "%s enable", obj->name);
 992                 if (retval2 != ERROR_OK)
 993                         retval = JIM_ERR;
 994         }
 995         return retval;
 996 }
 997
 998 /* START_DEPRECATED_TPIU */
 999 /* DEPRECATED: emulation of old command 'tpiu config' */
1000 COMMAND_HANDLER(handle_tpiu_deprecated_config_command)
1001 {
1002         struct target *target = get_current_target(CMD_CTX);
1003         struct arm_tpiu_swo_object *obj = NULL;
1004         int retval;
1005
1006         if (strcmp(target->type->name, "cortex_m") &&
1007                 strcmp(target->type->name, "hla_target")) {
1008                 LOG_ERROR(MSG "Current target is not a Cortex-M nor a HLA");
1009                 return ERROR_FAIL;
1010         }
1011
1012         if (!list_empty(&all_tpiu_swo)) {
1013                 obj = list_first_entry(&all_tpiu_swo, typeof(*obj), lh);
1014                 LOG_INFO(MSG "Using %s", obj->name);
1015         } else {
1016                 struct cortex_m_common *cm = target_to_cm(target);
1017                 struct adiv5_private_config *pc = target->private_config;
1018                 struct adiv5_dap *dap = pc->dap;
1019                 int ap_num = pc->ap_num;
1020                 bool set_recheck_ap_cur_target = false;
1021
1022                 LOG_INFO(MSG "Adding a TPIU \'%s.tpiu\' in the configuration", target_name(target));
1023
1024                 if (ap_num == DP_APSEL_INVALID && transport_is_hla())
1025                         ap_num = 0; /* HLA should only support AP 0 */
1026
1027                 if (ap_num == DP_APSEL_INVALID && target_was_examined(target))
1028                         ap_num = cm->armv7m.debug_ap->ap_num;
1029
1030                 if (ap_num == DP_APSEL_INVALID) {
1031                         LOG_INFO(MSG "Target %s uses AP autodetection. Adding TPIU on AP 0; can be revised later",
1032                                 target_name(target));
1033                         ap_num = 0;
1034                         set_recheck_ap_cur_target = true;
1035                 }
1036
1037                 LOG_INFO(MSG "Running: \'tpiu create %s.tpiu -dap %s -ap-num %d\'",
1038                         target_name(target), adiv5_dap_name(dap), ap_num);
1039
1040                 retval = command_run_linef(CMD_CTX, "tpiu create %s.tpiu -dap %s -ap-num %d",
1041                         target_name(target), adiv5_dap_name(dap), ap_num);
1042                 if (retval != ERROR_OK)
1043                         return retval;
1044
1045                 obj = list_first_entry(&all_tpiu_swo, typeof(*obj), lh);
1046                 if (set_recheck_ap_cur_target)
1047                         obj->recheck_ap_cur_target = true;
1048         }
1049
1050         unsigned int cmd_idx = 0;
1051         if (cmd_idx == CMD_ARGC)
1052                 return ERROR_COMMAND_SYNTAX_ERROR;
1053
1054         if (!strcmp(CMD_ARGV[cmd_idx], "disable")) {
1055                 if (CMD_ARGC != cmd_idx + 1)
1056                         return ERROR_COMMAND_SYNTAX_ERROR;
1057                 LOG_INFO(MSG "Running: \'%s disable\'", obj->name);
1058                 return command_run_linef(CMD_CTX, "%s disable", obj->name);
1059         }
1060
1061         const char *output = NULL;
1062         const char *protocol;
1063         const char *formatter = NULL;
1064         const char *port_width = NULL;
1065         const char *trace_clk;
1066         const char *pin_clk = NULL;
1067         if (!strcmp(CMD_ARGV[cmd_idx], "internal")) {
1068                 cmd_idx++;
1069                 if (cmd_idx == CMD_ARGC)
1070                         return ERROR_COMMAND_SYNTAX_ERROR;
1071                 output = CMD_ARGV[cmd_idx];
1072         } else if (strcmp(CMD_ARGV[cmd_idx], "external"))
1073                 return ERROR_COMMAND_SYNTAX_ERROR;
1074         cmd_idx++;
1075         if (cmd_idx == CMD_ARGC)
1076                 return ERROR_COMMAND_SYNTAX_ERROR;
1077         if (!strcmp(CMD_ARGV[cmd_idx], "sync")) {
1078                 protocol = CMD_ARGV[cmd_idx];
1079                 cmd_idx++;
1080                 if (cmd_idx == CMD_ARGC)
1081                         return ERROR_COMMAND_SYNTAX_ERROR;
1082                 port_width = CMD_ARGV[cmd_idx];
1083         } else {
1084                 if (strcmp(CMD_ARGV[cmd_idx], "manchester") && strcmp(CMD_ARGV[cmd_idx], "uart"))
1085                         return ERROR_COMMAND_SYNTAX_ERROR;
1086                 protocol = CMD_ARGV[cmd_idx];
1087                 cmd_idx++;
1088                 if (cmd_idx == CMD_ARGC)
1089                         return ERROR_COMMAND_SYNTAX_ERROR;
1090                 formatter = CMD_ARGV[cmd_idx];
1091         }
1092         cmd_idx++;
1093         if (cmd_idx == CMD_ARGC)
1094                 return ERROR_COMMAND_SYNTAX_ERROR;
1095         trace_clk = CMD_ARGV[cmd_idx];
1096         cmd_idx++;
1097         if (cmd_idx != CMD_ARGC) {
1098                 pin_clk = CMD_ARGV[cmd_idx];
1099                 cmd_idx++;
1100         }
1101         if (cmd_idx != CMD_ARGC)
1102                 return ERROR_COMMAND_SYNTAX_ERROR;
1103
1104         LOG_INFO(MSG "Running: \'%s configure -protocol %s -traceclk %s" "%s%s" "%s%s" "%s%s" "%s%s\'",
1105                 obj->name, protocol, trace_clk,
1106                 pin_clk    ? " -pin-freq "   : "", pin_clk    ? pin_clk    : "",
1107                 output     ? " -output "     : "", output     ? output     : "",
1108                 formatter  ? " -formatter "  : "", formatter  ? formatter  : "",
1109                 port_width ? " -port-width " : "", port_width ? port_width : "");
1110
1111         retval = command_run_linef(CMD_CTX,
1112                 "%s configure -protocol %s -traceclk %s" "%s%s" "%s%s" "%s%s" "%s%s",
1113                 obj->name, protocol, trace_clk,
1114                 pin_clk    ? " -pin-freq "   : "", pin_clk    ? pin_clk    : "",
1115                 output     ? " -output "     : "", output     ? output     : "",
1116                 formatter  ? " -formatter "  : "", formatter  ? formatter  : "",
1117                 port_width ? " -port-width " : "", port_width ? port_width : "");
1118         if (retval != ERROR_OK)
1119                 return retval;
1120
1121         LOG_INFO(MSG "Running: \'%s enable\'", obj->name);
1122         retval = command_run_linef(CMD_CTX, "%s enable", obj->name);
1123         if (retval != ERROR_OK)
1124                 return retval;
1125
1126         return ERROR_OK;
1127 }
1128
1129 static const struct command_registration arm_tpiu_deprecated_subcommand_handlers[] = {
1130         {
1131                 .name = "config",
1132                 .handler = handle_tpiu_deprecated_config_command,
1133                 .mode = COMMAND_ANY,
1134                 .help = "Configure TPIU features, DEPRECATED, use \'tpiu create\'",
1135                 .usage = "(disable | "
1136                 "((external | internal (<filename> | <:port> | -)) "
1137                 "(sync <port width> | ((manchester | uart) <formatter enable>)) "
1138                 "<TRACECLKIN freq> [<trace freq>]))",
1139         },
1140         COMMAND_REGISTRATION_DONE
1141 };
1142
1143 const struct command_registration arm_tpiu_deprecated_command_handlers[] = {
1144         {
1145                 .name = "tpiu",
1146                 .chain = arm_tpiu_deprecated_subcommand_handlers,
1147                 .usage = "",
1148                 .help = "tpiu command group",
1149         },
1150         COMMAND_REGISTRATION_DONE
1151 };
1152 /* END_DEPRECATED_TPIU */
1153
1154 static const struct command_registration arm_tpiu_swo_subcommand_handlers[] = {
1155         {
1156                 .name = "create",
1157                 .mode = COMMAND_ANY,
1158                 .jim_handler = jim_arm_tpiu_swo_create,
1159                 .usage = "name [-dap dap] [-ap-num num] [-address baseaddr]",
1160                 .help = "Creates a new TPIU or SWO object",
1161         },
1162         {
1163                 .name = "names",
1164                 .mode = COMMAND_ANY,
1165                 .jim_handler = jim_arm_tpiu_swo_names,
1166                 .usage = "",
1167                 .help = "Lists all registered TPIU and SWO objects by name",
1168         },
1169         {
1170                 .name = "init",
1171                 .mode = COMMAND_EXEC,
1172                 .jim_handler = jim_arm_tpiu_swo_init,
1173                 .usage = "",
1174                 .help = "Initialize TPIU and SWO",
1175         },
1176         COMMAND_REGISTRATION_DONE
1177 };
1178
1179 static const struct command_registration arm_tpiu_swo_command_handlers[] = {
1180         {
1181                 .name = "tpiu",
1182                 .chain = arm_tpiu_swo_subcommand_handlers,
1183                 .usage = "",
1184                 .help = "tpiu command group",
1185         },
1186         {
1187                 .name = "swo",
1188                 .chain = arm_tpiu_swo_subcommand_handlers,
1189                 .usage = "",
1190                 .help = "swo command group",
1191         },
1192         COMMAND_REGISTRATION_DONE
1193 };
1194
1195 int arm_tpiu_swo_register_commands(struct command_context *cmd_ctx)
1196 {
1197         return register_commands(cmd_ctx, NULL, arm_tpiu_swo_command_handlers);
1198 }