src/target/arm_dap.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 /***************************************************************************
   4  *   Copyright (C) 2016 by Matthias Welwarsky                              *
   5  *                                                                         *
   6  ***************************************************************************/
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif
  11
  12 #include <stdlib.h>
  13 #include <stdint.h>
  14 #include "target/arm_adi_v5.h"
  15 #include "target/arm.h"
  16 #include "helper/list.h"
  17 #include "helper/command.h"
  18 #include "transport/transport.h"
  19 #include "jtag/interface.h"
  20
  21 static LIST_HEAD(all_dap);
  22
  23 extern struct adapter_driver *adapter_driver;
  24
  25 /* DAP command support */
  26 struct arm_dap_object {
  27         struct list_head lh;
  28         struct adiv5_dap dap;
  29         char *name;
  30         const struct swd_driver *swd;
  31 };
  32
  33 static void dap_instance_init(struct adiv5_dap *dap)
  34 {
  35         int i;
  36         /* Set up with safe defaults */
  37         for (i = 0; i <= DP_APSEL_MAX; i++) {
  38                 dap->ap[i].dap = dap;
  39                 dap->ap[i].ap_num = DP_APSEL_INVALID;
  40                 /* memaccess_tck max is 255 */
  41                 dap->ap[i].memaccess_tck = 255;
  42                 /* Number of bits for tar autoincrement, impl. dep. at least 10 */
  43                 dap->ap[i].tar_autoincr_block = (1<<10);
  44                 /* default CSW value */
  45                 dap->ap[i].csw_default = CSW_AHB_DEFAULT;
  46                 dap->ap[i].cfg_reg = MEM_AP_REG_CFG_INVALID; /* mem_ap configuration reg (large physical addr, etc.) */
  47                 dap->ap[i].refcount = 0;
  48                 dap->ap[i].config_ap_never_release = false;
  49         }
  50         INIT_LIST_HEAD(&dap->cmd_journal);
  51         INIT_LIST_HEAD(&dap->cmd_pool);
  52 }
  53
  54 const char *adiv5_dap_name(struct adiv5_dap *self)
  55 {
  56         struct arm_dap_object *obj = container_of(self, struct arm_dap_object, dap);
  57         return obj->name;
  58 }
  59
  60 const struct swd_driver *adiv5_dap_swd_driver(struct adiv5_dap *self)
  61 {
  62         struct arm_dap_object *obj = container_of(self, struct arm_dap_object, dap);
  63         return obj->swd;
  64 }
  65
  66 struct adiv5_dap *adiv5_get_dap(struct arm_dap_object *obj)
  67 {
  68         return &obj->dap;
  69 }
  70 struct adiv5_dap *dap_instance_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
  71 {
  72         struct arm_dap_object *obj = NULL;
  73         const char *name;
  74         bool found = false;
  75
  76         name = Jim_GetString(o, NULL);
  77
  78         list_for_each_entry(obj, &all_dap, lh) {
  79                 if (!strcmp(name, obj->name)) {
  80                         found = true;
  81                         break;
  82                 }
  83         }
  84
  85         if (found)
  86                 return &obj->dap;
  87         return NULL;
  88 }
  89
  90 static int dap_init_all(void)
  91 {
  92         struct arm_dap_object *obj;
  93         int retval;
  94
  95         LOG_DEBUG("Initializing all DAPs ...");
  96
  97         list_for_each_entry(obj, &all_dap, lh) {
  98                 struct adiv5_dap *dap = &obj->dap;
  99
 100                 /* with hla, dap is just a dummy */
 101                 if (transport_is_hla())
 102                         continue;
 103
 104                 /* skip taps that are disabled */
 105                 if (!dap->tap->enabled)
 106                         continue;
 107
 108                 if (transport_is_swd()) {
 109                         dap->ops = &swd_dap_ops;
 110                         obj->swd = adapter_driver->swd_ops;
 111                 } else if (transport_is_dapdirect_swd()) {
 112                         dap->ops = adapter_driver->dap_swd_ops;
 113                 } else if (transport_is_dapdirect_jtag()) {
 114                         dap->ops = adapter_driver->dap_jtag_ops;
 115                 } else
 116                         dap->ops = &jtag_dp_ops;
 117
 118                 if (dap->adi_version == 0) {
 119                         LOG_DEBUG("DAP %s configured by default to use ADIv5 protocol", jtag_tap_name(dap->tap));
 120                         dap->adi_version = 5;
 121                 } else {
 122                         LOG_DEBUG("DAP %s configured to use %s protocol by user cfg file", jtag_tap_name(dap->tap),
 123                                 is_adiv6(dap) ? "ADIv6" : "ADIv5");
 124                 }
 125
 126                 retval = dap->ops->connect(dap);
 127                 if (retval != ERROR_OK)
 128                         return retval;
 129
 130                 /* see if address size of ROM Table is greater than 32-bits */
 131                 if (is_adiv6(dap)) {
 132                         uint32_t dpidr1;
 133
 134                         retval = dap->ops->queue_dp_read(dap, DP_DPIDR1, &dpidr1);
 135                         if (retval != ERROR_OK) {
 136                                 LOG_ERROR("DAP read of DPIDR1 failed...");
 137                                 return retval;
 138                         }
 139                         retval = dap_run(dap);
 140                         if (retval != ERROR_OK) {
 141                                 LOG_ERROR("DAP read of DPIDR1 failed...");
 142                                 return retval;
 143                         }
 144                         dap->asize = dpidr1 & DP_DPIDR1_ASIZE_MASK;
 145                 }
 146         }
 147
 148         return ERROR_OK;
 149 }
 150
 151 int dap_cleanup_all(void)
 152 {
 153         struct arm_dap_object *obj, *tmp;
 154         struct adiv5_dap *dap;
 155
 156         list_for_each_entry_safe(obj, tmp, &all_dap, lh) {
 157                 dap = &obj->dap;
 158                 for (unsigned int i = 0; i <= DP_APSEL_MAX; i++) {
 159                         if (dap->ap[i].refcount != 0)
 160                                 LOG_ERROR("BUG: refcount AP#%u still %u at exit", i, dap->ap[i].refcount);
 161                 }
 162                 if (dap->ops && dap->ops->quit)
 163                         dap->ops->quit(dap);
 164
 165                 free(obj->name);
 166                 free(obj);
 167         }
 168
 169         return ERROR_OK;
 170 }
 171
 172 enum dap_cfg_param {
 173         CFG_CHAIN_POSITION,
 174         CFG_IGNORE_SYSPWRUPACK,
 175         CFG_DP_ID,
 176         CFG_INSTANCE_ID,
 177         CFG_ADIV6,
 178         CFG_ADIV5,
 179 };
 180
 181 static const struct jim_nvp nvp_config_opts[] = {
 182         { .name = "-chain-position",     .value = CFG_CHAIN_POSITION },
 183         { .name = "-ignore-syspwrupack", .value = CFG_IGNORE_SYSPWRUPACK },
 184         { .name = "-dp-id",              .value = CFG_DP_ID },
 185         { .name = "-instance-id",        .value = CFG_INSTANCE_ID },
 186         { .name = "-adiv6",              .value = CFG_ADIV6 },
 187         { .name = "-adiv5",              .value = CFG_ADIV5 },
 188         { .name = NULL, .value = -1 }
 189 };
 190
 191 static int dap_configure(struct jim_getopt_info *goi, struct arm_dap_object *dap)
 192 {
 193         struct jim_nvp *n;
 194         int e;
 195
 196         /* parse config ... */
 197         while (goi->argc > 0) {
 198                 Jim_SetEmptyResult(goi->interp);
 199
 200                 e = jim_getopt_nvp(goi, nvp_config_opts, &n);
 201                 if (e != JIM_OK) {
 202                         jim_getopt_nvp_unknown(goi, nvp_config_opts, 0);
 203                         return e;
 204                 }
 205                 switch (n->value) {
 206                 case CFG_CHAIN_POSITION: {
 207                         Jim_Obj *o_t;
 208                         e = jim_getopt_obj(goi, &o_t);
 209                         if (e != JIM_OK)
 210                                 return e;
 211
 212                         struct jtag_tap *tap;
 213                         tap = jtag_tap_by_jim_obj(goi->interp, o_t);
 214                         if (!tap) {
 215                                 Jim_SetResultString(goi->interp, "-chain-position is invalid", -1);
 216                                 return JIM_ERR;
 217                         }
 218                         dap->dap.tap = tap;
 219                         /* loop for more */
 220                         break;
 221                 }
 222                 case CFG_IGNORE_SYSPWRUPACK:
 223                         dap->dap.ignore_syspwrupack = true;
 224                         break;
 225                 case CFG_DP_ID: {
 226                         jim_wide w;
 227                         e = jim_getopt_wide(goi, &w);
 228                         if (e != JIM_OK) {
 229                                 Jim_SetResultFormatted(goi->interp,
 230                                                 "create %s: bad parameter %s",
 231                                                 dap->name, n->name);
 232                                 return JIM_ERR;
 233                         }
 234                         if (w < 0 || w > DP_TARGETSEL_DPID_MASK) {
 235                                 Jim_SetResultFormatted(goi->interp,
 236                                                 "create %s: %s out of range",
 237                                                 dap->name, n->name);
 238                                 return JIM_ERR;
 239                         }
 240                         dap->dap.multidrop_targetsel =
 241                                 (dap->dap.multidrop_targetsel & DP_TARGETSEL_INSTANCEID_MASK)
 242                                 | (w & DP_TARGETSEL_DPID_MASK);
 243                         dap->dap.multidrop_dp_id_valid = true;
 244                         break;
 245                 }
 246                 case CFG_INSTANCE_ID: {
 247                         jim_wide w;
 248                         e = jim_getopt_wide(goi, &w);
 249                         if (e != JIM_OK) {
 250                                 Jim_SetResultFormatted(goi->interp,
 251                                                 "create %s: bad parameter %s",
 252                                                 dap->name, n->name);
 253                                 return JIM_ERR;
 254                         }
 255                         if (w < 0 || w > 15) {
 256                                 Jim_SetResultFormatted(goi->interp,
 257                                                 "create %s: %s out of range",
 258                                                 dap->name, n->name);
 259                                 return JIM_ERR;
 260                         }
 261                         dap->dap.multidrop_targetsel =
 262                                 (dap->dap.multidrop_targetsel & DP_TARGETSEL_DPID_MASK)
 263                                 | ((w << DP_TARGETSEL_INSTANCEID_SHIFT) & DP_TARGETSEL_INSTANCEID_MASK);
 264                         dap->dap.multidrop_instance_id_valid = true;
 265                         break;
 266                 }
 267                 case CFG_ADIV6:
 268                         dap->dap.adi_version = 6;
 269                         break;
 270                 case CFG_ADIV5:
 271                         dap->dap.adi_version = 5;
 272                         break;
 273                 default:
 274                         break;
 275                 }
 276         }
 277
 278         return JIM_OK;
 279 }
 280
 281 static int dap_check_config(struct adiv5_dap *dap)
 282 {
 283         if (transport_is_jtag() || transport_is_dapdirect_jtag() || transport_is_hla())
 284                 return ERROR_OK;
 285
 286         struct arm_dap_object *obj;
 287         bool new_multidrop = dap_is_multidrop(dap);
 288         bool had_multidrop = new_multidrop;
 289         uint32_t targetsel = dap->multidrop_targetsel;
 290         unsigned int non_multidrop_count = had_multidrop ? 0 : 1;
 291
 292         list_for_each_entry(obj, &all_dap, lh) {
 293                 struct adiv5_dap *dap_it = &obj->dap;
 294
 295                 if (transport_is_swd()) {
 296                         if (dap_is_multidrop(dap_it)) {
 297                                 had_multidrop = true;
 298                                 if (new_multidrop && dap_it->multidrop_targetsel == targetsel) {
 299                                         uint32_t dp_id = targetsel & DP_TARGETSEL_DPID_MASK;
 300                                         uint32_t instance_id = targetsel >> DP_TARGETSEL_INSTANCEID_SHIFT;
 301                                         LOG_ERROR("%s and %s have the same multidrop selectors -dp-id 0x%08"
 302                                                           PRIx32 " and -instance-id 0x%" PRIx32,
 303                                                           obj->name, adiv5_dap_name(dap),
 304                                                           dp_id, instance_id);
 305                                         return ERROR_FAIL;
 306                                 }
 307                         } else {
 308                                 non_multidrop_count++;
 309                         }
 310                 } else if (transport_is_dapdirect_swd()) {
 311                         non_multidrop_count++;
 312                 }
 313         }
 314
 315         if (non_multidrop_count > 1) {
 316                 LOG_ERROR("Two or more SWD non multidrop DAPs are not supported");
 317                 return ERROR_FAIL;
 318         }
 319         if (had_multidrop && non_multidrop_count) {
 320                 LOG_ERROR("Mixing of SWD multidrop DAPs and non multidrop DAPs is not supported");
 321                 return ERROR_FAIL;
 322         }
 323
 324         return ERROR_OK;
 325 }
 326
 327 static int dap_create(struct jim_getopt_info *goi)
 328 {
 329         struct command_context *cmd_ctx;
 330         static struct arm_dap_object *dap;
 331         Jim_Obj *new_cmd;
 332         Jim_Cmd *cmd;
 333         const char *cp;
 334         int e;
 335
 336         cmd_ctx = current_command_context(goi->interp);
 337         assert(cmd_ctx);
 338
 339         if (goi->argc < 3) {
 340                 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ..options...");
 341                 return JIM_ERR;
 342         }
 343         /* COMMAND */
 344         jim_getopt_obj(goi, &new_cmd);
 345         /* does this command exist? */
 346         cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_NONE);
 347         if (cmd) {
 348                 cp = Jim_GetString(new_cmd, NULL);
 349                 Jim_SetResultFormatted(goi->interp, "Command: %s Exists", cp);
 350                 return JIM_ERR;
 351         }
 352
 353         /* Create it */
 354         dap = calloc(1, sizeof(struct arm_dap_object));
 355         if (!dap)
 356                 return JIM_ERR;
 357
 358         dap_instance_init(&dap->dap);
 359
 360         cp = Jim_GetString(new_cmd, NULL);
 361         dap->name = strdup(cp);
 362
 363         e = dap_configure(goi, dap);
 364         if (e != JIM_OK)
 365                 goto err;
 366
 367         if (!dap->dap.tap) {
 368                 Jim_SetResultString(goi->interp, "-chain-position required when creating DAP", -1);
 369                 e = JIM_ERR;
 370                 goto err;
 371         }
 372
 373         e = dap_check_config(&dap->dap);
 374         if (e != ERROR_OK) {
 375                 e = JIM_ERR;
 376                 goto err;
 377         }
 378
 379         struct command_registration dap_create_commands[] = {
 380                 {
 381                         .name = cp,
 382                         .mode = COMMAND_ANY,
 383                         .help = "dap instance command group",
 384                         .usage = "",
 385                         .chain = dap_instance_commands,
 386                 },
 387                 COMMAND_REGISTRATION_DONE
 388         };
 389
 390         /* don't expose the instance commands when using hla */
 391         if (transport_is_hla())
 392                 dap_create_commands[0].chain = NULL;
 393
 394         e = register_commands_with_data(cmd_ctx, NULL, dap_create_commands, dap);
 395         if (e != ERROR_OK) {
 396                 e = JIM_ERR;
 397                 goto err;
 398         }
 399
 400         list_add_tail(&dap->lh, &all_dap);
 401
 402         return JIM_OK;
 403
 404 err:
 405         free(dap->name);
 406         free(dap);
 407         return e;
 408 }
 409
 410 static int jim_dap_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 411 {
 412         struct jim_getopt_info goi;
 413         jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
 414         if (goi.argc < 2) {
 415                 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
 416                         "<name> [<dap_options> ...]");
 417                 return JIM_ERR;
 418         }
 419         return dap_create(&goi);
 420 }
 421
 422 COMMAND_HANDLER(handle_dap_names)
 423 {
 424         if (CMD_ARGC != 0)
 425                 return ERROR_COMMAND_SYNTAX_ERROR;
 426
 427         struct arm_dap_object *obj;
 428         list_for_each_entry(obj, &all_dap, lh)
 429                 command_print(CMD, "%s", obj->name);
 430
 431         return ERROR_OK;
 432 }
 433
 434 COMMAND_HANDLER(handle_dap_init)
 435 {
 436         return dap_init_all();
 437 }
 438
 439 COMMAND_HANDLER(handle_dap_info_command)
 440 {
 441         struct target *target = get_current_target(CMD_CTX);
 442         struct arm *arm = target_to_arm(target);
 443         struct adiv5_dap *dap = arm->dap;
 444         uint64_t apsel;
 445
 446         if (!dap) {
 447                 LOG_ERROR("DAP instance not available. Probably a HLA target...");
 448                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 449         }
 450
 451         switch (CMD_ARGC) {
 452                 case 0:
 453                         apsel = dap->apsel;
 454                         break;
 455                 case 1:
 456                         if (!strcmp(CMD_ARGV[0], "root")) {
 457                                 if (!is_adiv6(dap)) {
 458                                         command_print(CMD, "Option \"root\" not allowed with ADIv5 DAP");
 459                                         return ERROR_COMMAND_ARGUMENT_INVALID;
 460                                 }
 461                                 int retval = adiv6_dap_read_baseptr(CMD, dap, &apsel);
 462                                 if (retval != ERROR_OK) {
 463                                         command_print(CMD, "Failed reading DAP baseptr");
 464                                         return retval;
 465                                 }
 466                                 break;
 467                         }
 468                         COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
 469                         if (!is_ap_num_valid(dap, apsel))
 470                                 return ERROR_COMMAND_SYNTAX_ERROR;
 471                         break;
 472                 default:
 473                         return ERROR_COMMAND_SYNTAX_ERROR;
 474         }
 475
 476         struct adiv5_ap *ap = dap_get_ap(dap, apsel);
 477         if (!ap) {
 478                 command_print(CMD, "Cannot get AP");
 479                 return ERROR_FAIL;
 480         }
 481         int retval = dap_info_command(CMD, ap);
 482         dap_put_ap(ap);
 483         return retval;
 484 }
 485
 486 static const struct command_registration dap_subcommand_handlers[] = {
 487         {
 488                 .name = "create",
 489                 .mode = COMMAND_ANY,
 490                 .jim_handler = jim_dap_create,
 491                 .usage = "name '-chain-position' name",
 492                 .help = "Creates a new DAP instance",
 493         },
 494         {
 495                 .name = "names",
 496                 .mode = COMMAND_ANY,
 497                 .handler = handle_dap_names,
 498                 .usage = "",
 499                 .help = "Lists all registered DAP instances by name",
 500         },
 501         {
 502                 .name = "init",
 503                 .mode = COMMAND_ANY,
 504                 .handler = handle_dap_init,
 505                 .usage = "",
 506                 .help = "Initialize all registered DAP instances"
 507         },
 508         {
 509                 .name = "info",
 510                 .handler = handle_dap_info_command,
 511                 .mode = COMMAND_EXEC,
 512                 .help = "display ROM table for specified MEM-AP (default MEM-AP of current target) "
 513                         "or the ADIv6 root ROM table of current target's DAP",
 514                 .usage = "[ap_num | 'root']",
 515         },
 516         COMMAND_REGISTRATION_DONE
 517 };
 518
 519 static const struct command_registration dap_commands[] = {
 520         {
 521                 .name = "dap",
 522                 .mode = COMMAND_CONFIG,
 523                 .help = "DAP commands",
 524                 .chain = dap_subcommand_handlers,
 525                 .usage = "",
 526         },
 527         COMMAND_REGISTRATION_DONE
 528 };
 529
 530 int dap_register_commands(struct command_context *cmd_ctx)
 531 {
 532         return register_commands(cmd_ctx, NULL, dap_commands);
 533 }