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

   1 /***************************************************************************
   2  *   Copyright (C) 2016 by Matthias Welwarsky                              *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *                                                                         *
  18  ***************************************************************************/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <stdint.h>
  26 #include "target/arm_adi_v5.h"
  27 #include "target/arm.h"
  28 #include "helper/list.h"
  29 #include "helper/command.h"
  30 #include "transport/transport.h"
  31 #include "jtag/interface.h"
  32
  33 static LIST_HEAD(all_dap);
  34
  35 extern const struct dap_ops swd_dap_ops;
  36 extern const struct dap_ops jtag_dp_ops;
  37 extern struct adapter_driver *adapter_driver;
  38
  39 /* DAP command support */
  40 struct arm_dap_object {
  41         struct list_head lh;
  42         struct adiv5_dap dap;
  43         char *name;
  44         const struct swd_driver *swd;
  45 };
  46
  47 static void dap_instance_init(struct adiv5_dap *dap)
  48 {
  49         int i;
  50         /* Set up with safe defaults */
  51         for (i = 0; i <= DP_APSEL_MAX; i++) {
  52                 dap->ap[i].dap = dap;
  53                 dap->ap[i].ap_num = i;
  54                 /* memaccess_tck max is 255 */
  55                 dap->ap[i].memaccess_tck = 255;
  56                 /* Number of bits for tar autoincrement, impl. dep. at least 10 */
  57                 dap->ap[i].tar_autoincr_block = (1<<10);
  58                 /* default CSW value */
  59                 dap->ap[i].csw_default = CSW_AHB_DEFAULT;
  60         }
  61         INIT_LIST_HEAD(&dap->cmd_journal);
  62         INIT_LIST_HEAD(&dap->cmd_pool);
  63 }
  64
  65 const char *adiv5_dap_name(struct adiv5_dap *self)
  66 {
  67         struct arm_dap_object *obj = container_of(self, struct arm_dap_object, dap);
  68         return obj->name;
  69 }
  70
  71 const struct swd_driver *adiv5_dap_swd_driver(struct adiv5_dap *self)
  72 {
  73         struct arm_dap_object *obj = container_of(self, struct arm_dap_object, dap);
  74         return obj->swd;
  75 }
  76
  77 struct adiv5_dap *adiv5_get_dap(struct arm_dap_object *obj)
  78 {
  79         return &obj->dap;
  80 }
  81 struct adiv5_dap *dap_instance_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
  82 {
  83         struct arm_dap_object *obj = NULL;
  84         const char *name;
  85         bool found = false;
  86
  87         name = Jim_GetString(o, NULL);
  88
  89         list_for_each_entry(obj, &all_dap, lh) {
  90                 if (!strcmp(name, obj->name)) {
  91                         found = true;
  92                         break;
  93                 }
  94         }
  95
  96         if (found)
  97                 return &obj->dap;
  98         return NULL;
  99 }
 100
 101 static int dap_init_all(void)
 102 {
 103         struct arm_dap_object *obj;
 104         int retval;
 105
 106         LOG_DEBUG("Initializing all DAPs ...");
 107
 108         list_for_each_entry(obj, &all_dap, lh) {
 109                 struct adiv5_dap *dap = &obj->dap;
 110
 111                 /* with hla, dap is just a dummy */
 112                 if (transport_is_hla())
 113                         continue;
 114
 115                 /* skip taps that are disabled */
 116                 if (!dap->tap->enabled)
 117                         continue;
 118
 119                 if (transport_is_swd()) {
 120                         dap->ops = &swd_dap_ops;
 121                         obj->swd = adapter_driver->swd_ops;
 122                 } else if (transport_is_dapdirect_swd()) {
 123                         dap->ops = adapter_driver->dap_swd_ops;
 124                 } else if (transport_is_dapdirect_jtag()) {
 125                         dap->ops = adapter_driver->dap_jtag_ops;
 126                 } else
 127                         dap->ops = &jtag_dp_ops;
 128
 129                 retval = dap->ops->connect(dap);
 130                 if (retval != ERROR_OK)
 131                         return retval;
 132         }
 133
 134         return ERROR_OK;
 135 }
 136
 137 int dap_cleanup_all(void)
 138 {
 139         struct arm_dap_object *obj, *tmp;
 140         struct adiv5_dap *dap;
 141
 142         list_for_each_entry_safe(obj, tmp, &all_dap, lh) {
 143                 dap = &obj->dap;
 144                 if (dap->ops && dap->ops->quit)
 145                         dap->ops->quit(dap);
 146
 147                 free(obj->name);
 148                 free(obj);
 149         }
 150
 151         return ERROR_OK;
 152 }
 153
 154 enum dap_cfg_param {
 155         CFG_CHAIN_POSITION,
 156         CFG_IGNORE_SYSPWRUPACK,
 157 };
 158
 159 static const struct jim_nvp nvp_config_opts[] = {
 160         { .name = "-chain-position",   .value = CFG_CHAIN_POSITION },
 161         { .name = "-ignore-syspwrupack", .value = CFG_IGNORE_SYSPWRUPACK },
 162         { .name = NULL, .value = -1 }
 163 };
 164
 165 static int dap_configure(struct jim_getopt_info *goi, struct arm_dap_object *dap)
 166 {
 167         struct jtag_tap *tap = NULL;
 168         struct jim_nvp *n;
 169         int e;
 170
 171         /* parse config or cget options ... */
 172         while (goi->argc > 0) {
 173                 Jim_SetEmptyResult(goi->interp);
 174
 175                 e = jim_getopt_nvp(goi, nvp_config_opts, &n);
 176                 if (e != JIM_OK) {
 177                         jim_getopt_nvp_unknown(goi, nvp_config_opts, 0);
 178                         return e;
 179                 }
 180                 switch (n->value) {
 181                 case CFG_CHAIN_POSITION: {
 182                         Jim_Obj *o_t;
 183                         e = jim_getopt_obj(goi, &o_t);
 184                         if (e != JIM_OK)
 185                                 return e;
 186                         tap = jtag_tap_by_jim_obj(goi->interp, o_t);
 187                         if (tap == NULL) {
 188                                 Jim_SetResultString(goi->interp, "-chain-position is invalid", -1);
 189                                 return JIM_ERR;
 190                         }
 191                         /* loop for more */
 192                         break;
 193                 }
 194                 case CFG_IGNORE_SYSPWRUPACK:
 195                         dap->dap.ignore_syspwrupack = true;
 196                         break;
 197                 default:
 198                         break;
 199                 }
 200         }
 201
 202         if (tap == NULL) {
 203                 Jim_SetResultString(goi->interp, "-chain-position required when creating DAP", -1);
 204                 return JIM_ERR;
 205         }
 206
 207         dap_instance_init(&dap->dap);
 208         dap->dap.tap = tap;
 209
 210         return JIM_OK;
 211 }
 212
 213 static int dap_create(struct jim_getopt_info *goi)
 214 {
 215         struct command_context *cmd_ctx;
 216         static struct arm_dap_object *dap;
 217         Jim_Obj *new_cmd;
 218         Jim_Cmd *cmd;
 219         const char *cp;
 220         int e;
 221
 222         cmd_ctx = current_command_context(goi->interp);
 223         assert(cmd_ctx != NULL);
 224
 225         if (goi->argc < 3) {
 226                 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ..options...");
 227                 return JIM_ERR;
 228         }
 229         /* COMMAND */
 230         jim_getopt_obj(goi, &new_cmd);
 231         /* does this command exist? */
 232         cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
 233         if (cmd) {
 234                 cp = Jim_GetString(new_cmd, NULL);
 235                 Jim_SetResultFormatted(goi->interp, "Command: %s Exists", cp);
 236                 return JIM_ERR;
 237         }
 238
 239         /* Create it */
 240         dap = calloc(1, sizeof(struct arm_dap_object));
 241         if (dap == NULL)
 242                 return JIM_ERR;
 243
 244         e = dap_configure(goi, dap);
 245         if (e != JIM_OK) {
 246                 free(dap);
 247                 return e;
 248         }
 249
 250         cp = Jim_GetString(new_cmd, NULL);
 251         dap->name = strdup(cp);
 252
 253         struct command_registration dap_commands[] = {
 254                 {
 255                         .name = cp,
 256                         .mode = COMMAND_ANY,
 257                         .help = "dap instance command group",
 258                         .usage = "",
 259                         .chain = dap_instance_commands,
 260                 },
 261                 COMMAND_REGISTRATION_DONE
 262         };
 263
 264         /* don't expose the instance commands when using hla */
 265         if (transport_is_hla())
 266                 dap_commands[0].chain = NULL;
 267
 268         e = register_commands_with_data(cmd_ctx, NULL, dap_commands, dap);
 269         if (ERROR_OK != e)
 270                 return JIM_ERR;
 271
 272         list_add_tail(&dap->lh, &all_dap);
 273
 274         return JIM_OK;
 275 }
 276
 277 static int jim_dap_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 278 {
 279         struct jim_getopt_info goi;
 280         jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
 281         if (goi.argc < 2) {
 282                 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
 283                         "<name> [<dap_options> ...]");
 284                 return JIM_ERR;
 285         }
 286         return dap_create(&goi);
 287 }
 288
 289 static int jim_dap_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 290 {
 291         struct arm_dap_object *obj;
 292
 293         if (argc != 1) {
 294                 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 295                 return JIM_ERR;
 296         }
 297         Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
 298         list_for_each_entry(obj, &all_dap, lh) {
 299                 Jim_ListAppendElement(interp, Jim_GetResult(interp),
 300                         Jim_NewStringObj(interp, obj->name, -1));
 301         }
 302         return JIM_OK;
 303 }
 304
 305 COMMAND_HANDLER(handle_dap_init)
 306 {
 307         return dap_init_all();
 308 }
 309
 310 COMMAND_HANDLER(handle_dap_info_command)
 311 {
 312         struct target *target = get_current_target(CMD_CTX);
 313         struct arm *arm = target_to_arm(target);
 314         struct adiv5_dap *dap = arm->dap;
 315         uint32_t apsel;
 316
 317         if (dap == NULL) {
 318                 LOG_ERROR("DAP instance not available. Probably a HLA target...");
 319                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 320         }
 321
 322         switch (CMD_ARGC) {
 323                 case 0:
 324                         apsel = dap->apsel;
 325                         break;
 326                 case 1:
 327                         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
 328                         if (apsel > DP_APSEL_MAX)
 329                                 return ERROR_COMMAND_SYNTAX_ERROR;
 330                         break;
 331                 default:
 332                         return ERROR_COMMAND_SYNTAX_ERROR;
 333         }
 334
 335         return dap_info_command(CMD, &dap->ap[apsel]);
 336 }
 337
 338 static const struct command_registration dap_subcommand_handlers[] = {
 339         {
 340                 .name = "create",
 341                 .mode = COMMAND_ANY,
 342                 .jim_handler = jim_dap_create,
 343                 .usage = "name '-chain-position' name",
 344                 .help = "Creates a new DAP instance",
 345         },
 346         {
 347                 .name = "names",
 348                 .mode = COMMAND_ANY,
 349                 .jim_handler = jim_dap_names,
 350                 .usage = "",
 351                 .help = "Lists all registered DAP instances by name",
 352         },
 353         {
 354                 .name = "init",
 355                 .mode = COMMAND_ANY,
 356                 .handler = handle_dap_init,
 357                 .usage = "",
 358                 .help = "Initialize all registered DAP instances"
 359         },
 360         {
 361                 .name = "info",
 362                 .handler = handle_dap_info_command,
 363                 .mode = COMMAND_EXEC,
 364                 .help = "display ROM table for MEM-AP of current target "
 365                 "(default currently selected AP)",
 366                 .usage = "[ap_num]",
 367         },
 368         COMMAND_REGISTRATION_DONE
 369 };
 370
 371 static const struct command_registration dap_commands[] = {
 372         {
 373                 .name = "dap",
 374                 .mode = COMMAND_CONFIG,
 375                 .help = "DAP commands",
 376                 .chain = dap_subcommand_handlers,
 377                 .usage = "",
 378         },
 379         COMMAND_REGISTRATION_DONE
 380 };
 381
 382 int dap_register_commands(struct command_context *cmd_ctx)
 383 {
 384         return register_commands(cmd_ctx, NULL, dap_commands);
 385 }