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                                 LOG_ERROR("Error writing to connection"); /* FIXME: which connection? */
 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 (retval != ERROR_OK) {
 682                         LOG_ERROR("Cannot read TPIU register SSPSR");
 683                         return JIM_ERR;
 684                 }
 685                 if (!(value & BIT(obj->port_width - 1))) {
 686                         LOG_ERROR("TPIU does not support port-width of %d bits", obj->port_width);
 687                         return JIM_ERR;
 688                 }
 689         }
 690
 691         uint16_t prescaler = 1; /* dummy value */
 692         unsigned int swo_pin_freq = obj->swo_pin_freq; /* could be replaced */
 693
 694         if (obj->out_filename && strcmp(obj->out_filename, "external") && obj->out_filename[0]) {
 695                 if (obj->out_filename[0] == ':') {
 696                         struct arm_tpiu_swo_priv_connection *priv = malloc(sizeof(*priv));
 697                         if (!priv) {
 698                                 LOG_ERROR("Out of memory");
 699                                 return JIM_ERR;
 700                         }
 701                         priv->obj = obj;
 702                         LOG_INFO("starting trace server for %s on %s", obj->name, &obj->out_filename[1]);
 703                         retval = add_service("tpiu_swo_trace", &obj->out_filename[1],
 704                                 CONNECTION_LIMIT_UNLIMITED, arm_tpiu_swo_service_new_connection,
 705                                 arm_tpiu_swo_service_input, arm_tpiu_swo_service_connection_closed,
 706                                 priv);
 707                         if (retval != ERROR_OK) {
 708                                 LOG_ERROR("Can't configure trace TCP port %s", &obj->out_filename[1]);
 709                                 return JIM_ERR;
 710                         }
 711                 } else if (strcmp(obj->out_filename, "-")) {
 712                         obj->file = fopen(obj->out_filename, "ab");
 713                         if (!obj->file) {
 714                                 LOG_ERROR("Can't open trace destination file \"%s\"", obj->out_filename);
 715                                 return JIM_ERR;
 716                         }
 717                 }
 718
 719                 retval = adapter_config_trace(true, obj->pin_protocol, obj->port_width,
 720                         &swo_pin_freq, obj->traceclkin_freq, &prescaler);
 721                 if (retval != ERROR_OK) {
 722                         LOG_ERROR("Failed to start adapter's trace");
 723                         arm_tpiu_swo_close_output(obj);
 724                         return JIM_ERR;
 725                 }
 726
 727                 if (obj->swo_pin_freq != swo_pin_freq)
 728                         LOG_INFO("SWO pin data rate adjusted by adapter to %d Hz", swo_pin_freq);
 729                 obj->swo_pin_freq = swo_pin_freq;
 730
 731                 target_register_timer_callback(arm_tpiu_swo_poll_trace, 1,
 732                         TARGET_TIMER_TYPE_PERIODIC, obj);
 733
 734                 obj->en_capture = true;
 735         } else if (obj->pin_protocol == TPIU_SPPR_PROTOCOL_MANCHESTER || obj->pin_protocol == TPIU_SPPR_PROTOCOL_UART) {
 736                 prescaler = (obj->traceclkin_freq + obj->swo_pin_freq / 2) / obj->swo_pin_freq;
 737                 if (prescaler > TPIU_ACPR_MAX_PRESCALER)
 738                         prescaler = TPIU_ACPR_MAX_PRESCALER;
 739                 swo_pin_freq = obj->traceclkin_freq / prescaler;
 740
 741                 if (obj->swo_pin_freq != swo_pin_freq)
 742                         LOG_INFO("SWO pin data rate adjusted to %d Hz", swo_pin_freq);
 743                 obj->swo_pin_freq = swo_pin_freq;
 744         }
 745
 746         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_CSPSR_OFFSET, BIT(obj->port_width - 1));
 747         if (retval != ERROR_OK)
 748                 goto error_exit;
 749
 750         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_ACPR_OFFSET, prescaler - 1);
 751         if (retval != ERROR_OK)
 752                 goto error_exit;
 753
 754         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_SPPR_OFFSET, obj->pin_protocol);
 755         if (retval != ERROR_OK)
 756                 goto error_exit;
 757
 758         retval = wrap_read_u32(target, tpiu_ap, obj->spot.base + TPIU_FFCR_OFFSET, &value);
 759         if (retval != ERROR_OK)
 760                 goto error_exit;
 761         if (obj->en_formatter)
 762                 value |= BIT(1);
 763         else
 764                 value &= ~BIT(1);
 765         retval = wrap_write_u32(target, tpiu_ap, obj->spot.base + TPIU_FFCR_OFFSET, value);
 766         if (retval != ERROR_OK)
 767                 goto error_exit;
 768
 769         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_POST_ENABLE);
 770
 771         /* START_DEPRECATED_TPIU */
 772         target_handle_event(target, TARGET_EVENT_TRACE_CONFIG);
 773         /* END_DEPRECATED_TPIU */
 774
 775         obj->enabled = true;
 776         return JIM_OK;
 777
 778 error_exit:
 779         LOG_ERROR("Error!");
 780
 781         if (obj->en_capture) {
 782                 obj->en_capture = false;
 783
 784                 arm_tpiu_swo_close_output(obj);
 785
 786                 target_unregister_timer_callback(arm_tpiu_swo_poll_trace, obj);
 787
 788                 retval = adapter_config_trace(false, 0, 0, NULL, 0, NULL);
 789                 if (retval != ERROR_OK) {
 790                         LOG_ERROR("Failed to stop adapter's trace");
 791                         return JIM_ERR;
 792                 }
 793         }
 794         return JIM_ERR;
 795 }
 796
 797 static int jim_arm_tpiu_swo_disable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 798 {
 799         struct command *c = jim_to_command(interp);
 800         struct arm_tpiu_swo_object *obj = c->jim_handler_data;
 801
 802         if (argc != 1) {
 803                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 804                 return JIM_ERR;
 805         }
 806
 807         if (!obj->enabled)
 808                 return JIM_OK;
 809         obj->enabled = false;
 810
 811         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_PRE_DISABLE);
 812
 813         if (obj->en_capture) {
 814                 obj->en_capture = false;
 815
 816                 arm_tpiu_swo_close_output(obj);
 817
 818                 target_unregister_timer_callback(arm_tpiu_swo_poll_trace, obj);
 819
 820                 int retval = adapter_config_trace(false, 0, 0, NULL, 0, NULL);
 821                 if (retval != ERROR_OK) {
 822                         LOG_ERROR("Failed to stop adapter's trace");
 823                         return JIM_ERR;
 824                 }
 825         }
 826
 827         arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_POST_DISABLE);
 828
 829         /* START_DEPRECATED_TPIU */
 830         struct command_context *cmd_ctx = current_command_context(interp);
 831         struct target *target = get_current_target(cmd_ctx);
 832         target_handle_event(target, TARGET_EVENT_TRACE_CONFIG);
 833         /* END_DEPRECATED_TPIU */
 834
 835         return JIM_OK;
 836 }
 837
 838 static const struct command_registration arm_tpiu_swo_instance_command_handlers[] = {
 839         {
 840                 .name = "configure",
 841                 .mode = COMMAND_ANY,
 842                 .jim_handler = jim_arm_tpiu_swo_configure,
 843                 .help  = "configure a new TPIU/SWO for use",
 844                 .usage = "[attribute value ...]",
 845         },
 846         {
 847                 .name = "cget",
 848                 .mode = COMMAND_ANY,
 849                 .jim_handler = jim_arm_tpiu_swo_configure,
 850                 .help  = "returns the specified TPIU/SWO attribute",
 851                 .usage = "attribute",
 852         },
 853         {
 854                 .name = "eventlist",
 855                 .mode = COMMAND_ANY,
 856                 .handler = handle_arm_tpiu_swo_event_list,
 857                 .help = "displays a table of events defined for this TPIU/SWO",
 858                 .usage = "",
 859         },
 860         {
 861                 .name = "enable",
 862                 .mode = COMMAND_ANY,
 863                 .jim_handler = jim_arm_tpiu_swo_enable,
 864                 .usage = "",
 865                 .help = "Enables the TPIU/SWO output",
 866         },
 867         {
 868                 .name = "disable",
 869                 .mode = COMMAND_EXEC,
 870                 .jim_handler = jim_arm_tpiu_swo_disable,
 871                 .usage = "",
 872                 .help = "Disables the TPIU/SWO output",
 873         },
 874         COMMAND_REGISTRATION_DONE
 875 };
 876
 877 static int arm_tpiu_swo_create(Jim_Interp *interp, struct arm_tpiu_swo_object *obj)
 878 {
 879         struct command_context *cmd_ctx;
 880         Jim_Cmd *cmd;
 881         int e;
 882
 883         cmd_ctx = current_command_context(interp);
 884         assert(cmd_ctx);
 885
 886         /* does this command exist? */
 887         cmd = Jim_GetCommand(interp, Jim_NewStringObj(interp, obj->name, -1), JIM_NONE);
 888         if (cmd) {
 889                 Jim_SetResultFormatted(interp, "cannot create TPIU object because a command with name '%s' already exists",
 890                         obj->name);
 891                 return JIM_ERR;
 892         }
 893
 894         /* now - create the new tpiu/swo name command */
 895         const struct command_registration obj_commands[] = {
 896                 {
 897                         .name = obj->name,
 898                         .mode = COMMAND_ANY,
 899                         .help = "tpiu/swo instance command group",
 900                         .usage = "",
 901                         .chain = arm_tpiu_swo_instance_command_handlers,
 902                 },
 903                 COMMAND_REGISTRATION_DONE
 904         };
 905         e = register_commands_with_data(cmd_ctx, NULL, obj_commands, obj);
 906         if (e != ERROR_OK)
 907                 return JIM_ERR;
 908
 909         list_add_tail(&obj->lh, &all_tpiu_swo);
 910
 911         return JIM_OK;
 912 }
 913
 914 static int jim_arm_tpiu_swo_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 915 {
 916         struct jim_getopt_info goi;
 917         jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
 918         if (goi.argc < 1) {
 919                 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "?name? ..options...");
 920                 return JIM_ERR;
 921         }
 922
 923         struct arm_tpiu_swo_object *obj = calloc(1, sizeof(struct arm_tpiu_swo_object));
 924         if (!obj) {
 925                 LOG_ERROR("Out of memory");
 926                 return JIM_ERR;
 927         }
 928         INIT_LIST_HEAD(&obj->connections);
 929         adiv5_mem_ap_spot_init(&obj->spot);
 930         obj->spot.base = TPIU_SWO_DEFAULT_BASE;
 931         obj->port_width = 1;
 932
 933         Jim_Obj *n;
 934         jim_getopt_obj(&goi, &n);
 935         obj->name = strdup(Jim_GetString(n, NULL));
 936         if (!obj->name) {
 937                 LOG_ERROR("Out of memory");
 938                 free(obj);
 939                 return JIM_ERR;
 940         }
 941
 942         /* Do the rest as "configure" options */
 943         goi.isconfigure = 1;
 944         int e = arm_tpiu_swo_configure(&goi, obj);
 945         if (e != JIM_OK)
 946                 goto err_exit;
 947
 948         if (!obj->spot.dap || obj->spot.ap_num == DP_APSEL_INVALID) {
 949                 Jim_SetResultString(goi.interp, "-dap and -ap-num required when creating TPIU", -1);
 950                 goto err_exit;
 951         }
 952
 953         e = arm_tpiu_swo_create(goi.interp, obj);
 954         if (e != JIM_OK)
 955                 goto err_exit;
 956
 957         return JIM_OK;
 958
 959 err_exit:
 960         free(obj->name);
 961         free(obj->out_filename);
 962         free(obj);
 963         return JIM_ERR;
 964 }
 965
 966 static int jim_arm_tpiu_swo_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 967 {
 968         struct arm_tpiu_swo_object *obj;
 969
 970         if (argc != 1) {
 971                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 972                 return JIM_ERR;
 973         }
 974         Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
 975         list_for_each_entry(obj, &all_tpiu_swo, lh) {
 976                 Jim_ListAppendElement(interp, Jim_GetResult(interp),
 977                         Jim_NewStringObj(interp, obj->name, -1));
 978         }
 979         return JIM_OK;
 980 }
 981
 982 static int jim_arm_tpiu_swo_init(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 983 {
 984         struct command_context *cmd_ctx = current_command_context(interp);
 985         struct arm_tpiu_swo_object *obj;
 986         int retval = JIM_OK;
 987
 988         if (argc != 1) {
 989                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 990                 return JIM_ERR;
 991         }
 992         list_for_each_entry(obj, &all_tpiu_swo, lh) {
 993                 if (!obj->deferred_enable)
 994                         continue;
 995                 LOG_DEBUG("%s: running enable during init", obj->name);
 996                 int retval2 = command_run_linef(cmd_ctx, "%s enable", obj->name);
 997                 if (retval2 != ERROR_OK)
 998                         retval = JIM_ERR;
 999         }
1000         return retval;
1001 }
1002
1003 /* START_DEPRECATED_TPIU */
1004 /* DEPRECATED: emulation of old command 'tpiu config' */
1005 COMMAND_HANDLER(handle_tpiu_deprecated_config_command)
1006 {
1007         struct target *target = get_current_target(CMD_CTX);
1008         struct arm_tpiu_swo_object *obj = NULL;
1009         int retval;
1010
1011         if (strcmp(target->type->name, "cortex_m") &&
1012                 strcmp(target->type->name, "hla_target")) {
1013                 LOG_ERROR(MSG "Current target is not a Cortex-M nor a HLA");
1014                 return ERROR_FAIL;
1015         }
1016
1017         if (!list_empty(&all_tpiu_swo)) {
1018                 obj = list_first_entry(&all_tpiu_swo, typeof(*obj), lh);
1019                 LOG_INFO(MSG "Using %s", obj->name);
1020         } else {
1021                 struct cortex_m_common *cm = target_to_cm(target);
1022                 struct adiv5_private_config *pc = target->private_config;
1023                 struct adiv5_dap *dap = pc->dap;
1024                 int ap_num = pc->ap_num;
1025                 bool set_recheck_ap_cur_target = false;
1026
1027                 LOG_INFO(MSG "Adding a TPIU \'%s.tpiu\' in the configuration", target_name(target));
1028
1029                 if (ap_num == DP_APSEL_INVALID && transport_is_hla())
1030                         ap_num = 0; /* HLA should only support AP 0 */
1031
1032                 if (ap_num == DP_APSEL_INVALID && target_was_examined(target))
1033                         ap_num = cm->armv7m.debug_ap->ap_num;
1034
1035                 if (ap_num == DP_APSEL_INVALID) {
1036                         LOG_INFO(MSG "Target %s uses AP autodetection. Adding TPIU on AP 0; can be revised later",
1037                                 target_name(target));
1038                         ap_num = 0;
1039                         set_recheck_ap_cur_target = true;
1040                 }
1041
1042                 LOG_INFO(MSG "Running: \'tpiu create %s.tpiu -dap %s -ap-num %d\'",
1043                         target_name(target), adiv5_dap_name(dap), ap_num);
1044
1045                 retval = command_run_linef(CMD_CTX, "tpiu create %s.tpiu -dap %s -ap-num %d",
1046                         target_name(target), adiv5_dap_name(dap), ap_num);
1047                 if (retval != ERROR_OK)
1048                         return retval;
1049
1050                 obj = list_first_entry(&all_tpiu_swo, typeof(*obj), lh);
1051                 if (set_recheck_ap_cur_target)
1052                         obj->recheck_ap_cur_target = true;
1053         }
1054
1055         unsigned int cmd_idx = 0;
1056         if (cmd_idx == CMD_ARGC)
1057                 return ERROR_COMMAND_SYNTAX_ERROR;
1058
1059         if (!strcmp(CMD_ARGV[cmd_idx], "disable")) {
1060                 if (CMD_ARGC != cmd_idx + 1)
1061                         return ERROR_COMMAND_SYNTAX_ERROR;
1062                 LOG_INFO(MSG "Running: \'%s disable\'", obj->name);
1063                 return command_run_linef(CMD_CTX, "%s disable", obj->name);
1064         }
1065
1066         const char *output = NULL;
1067         const char *protocol;
1068         const char *formatter = NULL;
1069         const char *port_width = NULL;
1070         const char *trace_clk;
1071         const char *pin_clk = NULL;
1072         if (!strcmp(CMD_ARGV[cmd_idx], "internal")) {
1073                 cmd_idx++;
1074                 if (cmd_idx == CMD_ARGC)
1075                         return ERROR_COMMAND_SYNTAX_ERROR;
1076                 output = CMD_ARGV[cmd_idx];
1077         } else if (strcmp(CMD_ARGV[cmd_idx], "external"))
1078                 return ERROR_COMMAND_SYNTAX_ERROR;
1079         cmd_idx++;
1080         if (cmd_idx == CMD_ARGC)
1081                 return ERROR_COMMAND_SYNTAX_ERROR;
1082         if (!strcmp(CMD_ARGV[cmd_idx], "sync")) {
1083                 protocol = CMD_ARGV[cmd_idx];
1084                 cmd_idx++;
1085                 if (cmd_idx == CMD_ARGC)
1086                         return ERROR_COMMAND_SYNTAX_ERROR;
1087                 port_width = CMD_ARGV[cmd_idx];
1088         } else {
1089                 if (strcmp(CMD_ARGV[cmd_idx], "manchester") && strcmp(CMD_ARGV[cmd_idx], "uart"))
1090                         return ERROR_COMMAND_SYNTAX_ERROR;
1091                 protocol = CMD_ARGV[cmd_idx];
1092                 cmd_idx++;
1093                 if (cmd_idx == CMD_ARGC)
1094                         return ERROR_COMMAND_SYNTAX_ERROR;
1095                 formatter = CMD_ARGV[cmd_idx];
1096         }
1097         cmd_idx++;
1098         if (cmd_idx == CMD_ARGC)
1099                 return ERROR_COMMAND_SYNTAX_ERROR;
1100         trace_clk = CMD_ARGV[cmd_idx];
1101         cmd_idx++;
1102         if (cmd_idx != CMD_ARGC) {
1103                 pin_clk = CMD_ARGV[cmd_idx];
1104                 cmd_idx++;
1105         }
1106         if (cmd_idx != CMD_ARGC)
1107                 return ERROR_COMMAND_SYNTAX_ERROR;
1108
1109         LOG_INFO(MSG "Running: \'%s configure -protocol %s -traceclk %s" "%s%s" "%s%s" "%s%s" "%s%s\'",
1110                 obj->name, protocol, trace_clk,
1111                 pin_clk    ? " -pin-freq "   : "", pin_clk    ? pin_clk    : "",
1112                 output     ? " -output "     : "", output     ? output     : "",
1113                 formatter  ? " -formatter "  : "", formatter  ? formatter  : "",
1114                 port_width ? " -port-width " : "", port_width ? port_width : "");
1115
1116         retval = command_run_linef(CMD_CTX,
1117                 "%s configure -protocol %s -traceclk %s" "%s%s" "%s%s" "%s%s" "%s%s",
1118                 obj->name, protocol, trace_clk,
1119                 pin_clk    ? " -pin-freq "   : "", pin_clk    ? pin_clk    : "",
1120                 output     ? " -output "     : "", output     ? output     : "",
1121                 formatter  ? " -formatter "  : "", formatter  ? formatter  : "",
1122                 port_width ? " -port-width " : "", port_width ? port_width : "");
1123         if (retval != ERROR_OK)
1124                 return retval;
1125
1126         LOG_INFO(MSG "Running: \'%s enable\'", obj->name);
1127         retval = command_run_linef(CMD_CTX, "%s enable", obj->name);
1128         if (retval != ERROR_OK)
1129                 return retval;
1130
1131         return ERROR_OK;
1132 }
1133
1134 static const struct command_registration arm_tpiu_deprecated_subcommand_handlers[] = {
1135         {
1136                 .name = "config",
1137                 .handler = handle_tpiu_deprecated_config_command,
1138                 .mode = COMMAND_ANY,
1139                 .help = "Configure TPIU features, DEPRECATED, use \'tpiu create\'",
1140                 .usage = "(disable | "
1141                 "((external | internal (<filename> | <:port> | -)) "
1142                 "(sync <port width> | ((manchester | uart) <formatter enable>)) "
1143                 "<TRACECLKIN freq> [<trace freq>]))",
1144         },
1145         COMMAND_REGISTRATION_DONE
1146 };
1147
1148 const struct command_registration arm_tpiu_deprecated_command_handlers[] = {
1149         {
1150                 .name = "tpiu",
1151                 .chain = arm_tpiu_deprecated_subcommand_handlers,
1152                 .usage = "",
1153                 .help = "tpiu command group",
1154         },
1155         COMMAND_REGISTRATION_DONE
1156 };
1157 /* END_DEPRECATED_TPIU */
1158
1159 static const struct command_registration arm_tpiu_swo_subcommand_handlers[] = {
1160         {
1161                 .name = "create",
1162                 .mode = COMMAND_ANY,
1163                 .jim_handler = jim_arm_tpiu_swo_create,
1164                 .usage = "name [-dap dap] [-ap-num num] [-address baseaddr]",
1165                 .help = "Creates a new TPIU or SWO object",
1166         },
1167         {
1168                 .name = "names",
1169                 .mode = COMMAND_ANY,
1170                 .jim_handler = jim_arm_tpiu_swo_names,
1171                 .usage = "",
1172                 .help = "Lists all registered TPIU and SWO objects by name",
1173         },
1174         {
1175                 .name = "init",
1176                 .mode = COMMAND_EXEC,
1177                 .jim_handler = jim_arm_tpiu_swo_init,
1178                 .usage = "",
1179                 .help = "Initialize TPIU and SWO",
1180         },
1181         COMMAND_REGISTRATION_DONE
1182 };
1183
1184 static const struct command_registration arm_tpiu_swo_command_handlers[] = {
1185         {
1186                 .name = "tpiu",
1187                 .chain = arm_tpiu_swo_subcommand_handlers,
1188                 .usage = "",
1189                 .help = "tpiu command group",
1190         },
1191         {
1192                 .name = "swo",
1193                 .chain = arm_tpiu_swo_subcommand_handlers,
1194                 .usage = "",
1195                 .help = "swo command group",
1196         },
1197         COMMAND_REGISTRATION_DONE
1198 };
1199
1200 int arm_tpiu_swo_register_commands(struct command_context *cmd_ctx)
1201 {
1202         return register_commands(cmd_ctx, NULL, arm_tpiu_swo_command_handlers);
1203 }