src/target/arc_cmd.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 /***************************************************************************
   4  *   Copyright (C) 2013-2015,2019-2020 Synopsys, Inc.                      *
   5  *   Frank Dols <frank.dols@synopsys.com>                                  *
   6  *   Mischa Jonker <mischa.jonker@synopsys.com>                            *
   7  *   Anton Kolesov <anton.kolesov@synopsys.com>                            *
   8  *   Evgeniy Didin <didin@synopsys.com>                                    *
   9  ***************************************************************************/
  10
  11 #ifdef HAVE_CONFIG_H
  12 #include "config.h"
  13 #endif
  14
  15 #include "arc.h"
  16 #include <helper/nvp.h>
  17
  18 /* --------------------------------------------------------------------------
  19  *
  20  *   ARC targets expose command interface.
  21  *   It can be accessed via GDB through the (gdb) monitor command.
  22  *
  23  * ------------------------------------------------------------------------- */
  24
  25
  26 enum add_reg_types {
  27         CFG_ADD_REG_TYPE_FLAG,
  28         CFG_ADD_REG_TYPE_STRUCT,
  29 };
  30 /* Add flags register data type */
  31 enum add_reg_type_flags {
  32         CFG_ADD_REG_TYPE_FLAGS_NAME,
  33         CFG_ADD_REG_TYPE_FLAGS_FLAG,
  34 };
  35
  36 static const struct nvp nvp_add_reg_type_flags_opts[] = {
  37         { .name = "-name",  .value = CFG_ADD_REG_TYPE_FLAGS_NAME },
  38         { .name = "-flag",  .value = CFG_ADD_REG_TYPE_FLAGS_FLAG },
  39         { .name = NULL,     .value = -1 }
  40 };
  41
  42 /* Helper function to check if all field required for register
  43  * are set up */
  44 static const char *validate_register(const struct arc_reg_desc * const reg, bool arch_num_set)
  45 {
  46         /* Check that required fields are set */
  47         if (!reg->name)
  48                 return "-name option is required";
  49         if (!reg->gdb_xml_feature)
  50                 return "-feature option is required";
  51         if (!arch_num_set)
  52                 return "-num option is required";
  53         if (reg->is_bcr && reg->is_core)
  54                 return "Register cannot be both -core and -bcr.";
  55         return NULL;
  56 }
  57
  58 /* Helper function to read the name of register type or register from
  59  * configure files  */
  60 static int jim_arc_read_reg_name_field(struct jim_getopt_info *goi,
  61         const char **name, int *name_len)
  62 {
  63         int e = JIM_OK;
  64
  65         if (!goi->argc) {
  66                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-name <name> ...");
  67                 return JIM_ERR;
  68         }
  69         e = jim_getopt_string(goi, name, name_len);
  70         return e;
  71 }
  72
  73 /* Helper function to read bitfields/flags of register type. */
  74 static int jim_arc_read_reg_type_field(struct jim_getopt_info *goi, const char **field_name, int *field_name_len,
  75          struct arc_reg_bitfield *bitfields, int cur_field, int type)
  76 {
  77                 jim_wide start_pos, end_pos;
  78
  79                 int e = JIM_OK;
  80                 if ((type == CFG_ADD_REG_TYPE_STRUCT && goi->argc < 3) ||
  81                  (type == CFG_ADD_REG_TYPE_FLAG && goi->argc < 2)) {
  82                         Jim_SetResultFormatted(goi->interp, "Not enough arguments after -flag/-bitfield");
  83                         return JIM_ERR;
  84                 }
  85
  86                 e = jim_getopt_string(goi, field_name, field_name_len);
  87                 if (e != JIM_OK)
  88                                         return e;
  89
  90                 /* read start position of bitfield/flag */
  91                 e = jim_getopt_wide(goi, &start_pos);
  92                 if (e != JIM_OK)
  93                                         return e;
  94
  95                 end_pos = start_pos;
  96
  97                 /* Check if any arguments remain,
  98                  * set bitfields[cur_field].end if flag is multibit */
  99                 if (goi->argc > 0)
 100                         /* Check current argv[0], if it is equal to "-flag",
 101                          * than bitfields[cur_field].end remains start */
 102                         if ((strcmp(Jim_String(goi->argv[0]), "-flag") && type == CFG_ADD_REG_TYPE_FLAG)
 103                                         || (type == CFG_ADD_REG_TYPE_STRUCT)) {
 104                                                                 e = jim_getopt_wide(goi, &end_pos);
 105                                                                 if (e != JIM_OK) {
 106                                                                         Jim_SetResultFormatted(goi->interp, "Error reading end position");
 107                                                                         return e;
 108                                                                 }
 109                                                         }
 110
 111                 bitfields[cur_field].bitfield.start = start_pos;
 112                 bitfields[cur_field].bitfield.end = end_pos;
 113                 if ((end_pos != start_pos) || (type == CFG_ADD_REG_TYPE_STRUCT))
 114                         bitfields[cur_field].bitfield.type = REG_TYPE_INT;
 115         return e;
 116 }
 117
 118 static COMMAND_HELPER(arc_handle_add_reg_type_flags_ops, struct arc_reg_data_type *type)
 119 {
 120         struct reg_data_type_flags_field *fields = type->reg_type_flags_field;
 121         struct arc_reg_bitfield *bitfields = type->bitfields;
 122         struct reg_data_type_flags *flags = &type->data_type_flags;
 123         unsigned int cur_field = 0;
 124
 125         while (CMD_ARGC) {
 126                 const struct nvp *n = nvp_name2value(nvp_add_reg_type_flags_opts, CMD_ARGV[0]);
 127                 CMD_ARGC--;
 128                 CMD_ARGV++;
 129                 switch (n->value) {
 130                 case CFG_ADD_REG_TYPE_FLAGS_NAME:
 131                         if (!CMD_ARGC)
 132                                 return ERROR_COMMAND_ARGUMENT_INVALID;
 133
 134                         const char *name = CMD_ARGV[0];
 135                         CMD_ARGC--;
 136                         CMD_ARGV++;
 137
 138                         if (strlen(name) >= REG_TYPE_MAX_NAME_LENGTH) {
 139                                 command_print(CMD, "Reg type name is too big.");
 140                                 return ERROR_COMMAND_ARGUMENT_INVALID;
 141                         }
 142
 143                         strcpy((void *)type->data_type.id, name);
 144                         break;
 145
 146                 case CFG_ADD_REG_TYPE_FLAGS_FLAG:
 147                         if (CMD_ARGC < 2)
 148                                 return ERROR_COMMAND_ARGUMENT_INVALID;
 149
 150                         uint32_t val;
 151                         const char *field_name = CMD_ARGV[0];
 152                         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], val);
 153                         CMD_ARGC -= 2;
 154                         CMD_ARGV += 2;
 155                         bitfields[cur_field].bitfield.start = val;
 156                         bitfields[cur_field].bitfield.end = val;
 157
 158                         if (strlen(field_name) >= REG_TYPE_MAX_NAME_LENGTH) {
 159                                 command_print(CMD, "Reg type field_name is too big.");
 160                                 return ERROR_COMMAND_ARGUMENT_INVALID;
 161                         }
 162
 163                         fields[cur_field].name = bitfields[cur_field].name;
 164                         strcpy(bitfields[cur_field].name, field_name);
 165
 166                         fields[cur_field].bitfield = &bitfields[cur_field].bitfield;
 167                         if (cur_field > 0)
 168                                 fields[cur_field - 1].next = &fields[cur_field];
 169                         else
 170                                 flags->fields = fields;
 171
 172                         cur_field += 1;
 173                         break;
 174
 175                 default:
 176                         nvp_unknown_command_print(CMD, nvp_add_reg_type_flags_opts, NULL, CMD_ARGV[-1]);
 177                         return ERROR_COMMAND_ARGUMENT_INVALID;
 178                 }
 179         }
 180
 181         if (!type->data_type.id) {
 182                 command_print(CMD, "-name is a required option");
 183                 return ERROR_COMMAND_ARGUMENT_INVALID;
 184         }
 185
 186         return ERROR_OK;
 187 }
 188
 189 COMMAND_HANDLER(arc_handle_add_reg_type_flags)
 190 {
 191         int retval;
 192
 193         LOG_DEBUG("-");
 194
 195         struct target *target = get_current_target(CMD_CTX);
 196         if (!target) {
 197                 command_print(CMD, "No current target");
 198                 return ERROR_FAIL;
 199         }
 200
 201         /* Check if the amount of arguments is not zero */
 202         if (CMD_ARGC == 0)
 203                 return ERROR_COMMAND_SYNTAX_ERROR;
 204
 205         /* Estimate number of registers as (argc - 2)/3 as each -flag option has 2
 206          * arguments while -name is required. */
 207         unsigned int fields_sz = (CMD_ARGC - 2) / 3;
 208
 209         /* The maximum amount of bitfields is 32 */
 210         if (fields_sz > 32) {
 211                 command_print(CMD, "The amount of bitfields exceed 32");
 212                 return ERROR_COMMAND_ARGUMENT_INVALID;
 213         }
 214
 215         struct arc_reg_data_type *type = calloc(1, sizeof(*type));
 216         struct reg_data_type_flags_field *fields = calloc(fields_sz, sizeof(*fields));
 217         struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
 218         if (!type || !fields || !bitfields) {
 219                 LOG_ERROR("Out of memory");
 220                 retval = ERROR_FAIL;
 221                 goto fail;
 222         }
 223         struct reg_data_type_flags *flags = &type->data_type_flags;
 224         type->reg_type_flags_field = fields;
 225
 226         /* Initialize type */
 227         type->bitfields = bitfields;
 228         type->data_type.id = type->data_type_id;
 229         type->data_type.type = REG_TYPE_ARCH_DEFINED;
 230         type->data_type.type_class = REG_TYPE_CLASS_FLAGS;
 231         type->data_type.reg_type_flags = flags;
 232         flags->size = 4; /* For now ARC has only 32-bit registers */
 233
 234         retval = CALL_COMMAND_HANDLER(arc_handle_add_reg_type_flags_ops, type);
 235         if (retval != ERROR_OK)
 236                 goto fail;
 237
 238         arc_reg_data_type_add(target, type);
 239
 240         LOG_DEBUG("added flags type {name=%s}", type->data_type.id);
 241
 242         return ERROR_OK;
 243
 244 fail:
 245         free(type);
 246         free(fields);
 247         free(bitfields);
 248
 249         return retval;
 250 }
 251
 252 /* Add struct register data type */
 253 enum add_reg_type_struct {
 254         CFG_ADD_REG_TYPE_STRUCT_NAME,
 255         CFG_ADD_REG_TYPE_STRUCT_BITFIELD,
 256 };
 257
 258 static struct jim_nvp nvp_add_reg_type_struct_opts[] = {
 259         { .name = "-name",     .value = CFG_ADD_REG_TYPE_STRUCT_NAME },
 260         { .name = "-bitfield", .value = CFG_ADD_REG_TYPE_STRUCT_BITFIELD },
 261         { .name = NULL,     .value = -1 }
 262 };
 263
 264 COMMAND_HANDLER(arc_handle_set_aux_reg)
 265 {
 266         if (CMD_ARGC != 2)
 267                 return ERROR_COMMAND_SYNTAX_ERROR;
 268
 269         struct target *target = get_current_target(CMD_CTX);
 270         if (!target) {
 271                 command_print(CMD, "No current target");
 272                 return ERROR_FAIL;
 273         }
 274
 275         /* Register number */
 276         uint32_t regnum;
 277         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);
 278
 279         /* Register value */
 280         uint32_t value;
 281         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
 282
 283         struct arc_common *arc = target_to_arc(target);
 284         assert(arc);
 285
 286         CHECK_RETVAL(arc_jtag_write_aux_reg_one(&arc->jtag_info, regnum, value));
 287
 288         return ERROR_OK;
 289 }
 290
 291 COMMAND_HANDLER(arc_handle_get_aux_reg)
 292 {
 293         if (CMD_ARGC != 1)
 294                 return ERROR_COMMAND_SYNTAX_ERROR;
 295
 296         struct target *target = get_current_target(CMD_CTX);
 297         if (!target) {
 298                 command_print(CMD, "No current target");
 299                 return ERROR_FAIL;
 300         }
 301
 302         /* Register number */
 303         uint32_t regnum;
 304         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);
 305
 306         struct arc_common *arc = target_to_arc(target);
 307         assert(arc);
 308
 309         uint32_t value;
 310         CHECK_RETVAL(arc_jtag_read_aux_reg_one(&arc->jtag_info, regnum, &value));
 311
 312         command_print(CMD, "0x%" PRIx32, value);
 313
 314         return ERROR_OK;
 315 }
 316
 317 COMMAND_HANDLER(arc_handle_get_core_reg)
 318 {
 319         if (CMD_ARGC != 1)
 320                 return ERROR_COMMAND_SYNTAX_ERROR;
 321
 322         struct target *target = get_current_target(CMD_CTX);
 323         if (!target) {
 324                 command_print(CMD, "No current target");
 325                 return ERROR_FAIL;
 326         }
 327
 328         /* Register number */
 329         uint32_t regnum;
 330         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);
 331         if (regnum > CORE_REG_MAX_NUMBER || regnum == ARC_R61 || regnum == ARC_R62) {
 332                 command_print(CMD, "Core register number %i "
 333                         "is invalid. Must less then 64 and not 61 and 62.", regnum);
 334                 return ERROR_COMMAND_ARGUMENT_INVALID;
 335         }
 336
 337         struct arc_common *arc = target_to_arc(target);
 338         assert(arc);
 339
 340         /* Read value */
 341         uint32_t value;
 342         CHECK_RETVAL(arc_jtag_read_core_reg_one(&arc->jtag_info, regnum, &value));
 343
 344         command_print(CMD, "0x%" PRIx32, value);
 345
 346         return ERROR_OK;
 347 }
 348
 349 COMMAND_HANDLER(arc_handle_set_core_reg)
 350 {
 351         if (CMD_ARGC != 2)
 352                 return ERROR_COMMAND_SYNTAX_ERROR;
 353
 354         struct target *target = get_current_target(CMD_CTX);
 355         if (!target) {
 356                 command_print(CMD, "No current target");
 357                 return ERROR_FAIL;
 358         }
 359
 360         /* Register number */
 361         uint32_t regnum;
 362         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);
 363         if (regnum > CORE_REG_MAX_NUMBER || regnum == ARC_R61 || regnum == ARC_R62) {
 364                 command_print(CMD, "Core register number %i "
 365                         "is invalid. Must less then 64 and not 61 and 62.", regnum);
 366                 return ERROR_COMMAND_ARGUMENT_INVALID;
 367         }
 368
 369         /* Register value */
 370         uint32_t value;
 371         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
 372
 373         struct arc_common *arc = target_to_arc(target);
 374         assert(arc);
 375
 376         CHECK_RETVAL(arc_jtag_write_core_reg_one(&arc->jtag_info, regnum, value));
 377
 378         return ERROR_OK;
 379 }
 380
 381 static const struct command_registration arc_jtag_command_group[] = {
 382         {
 383                 .name = "get-aux-reg",
 384                 .handler = arc_handle_get_aux_reg,
 385                 .mode = COMMAND_EXEC,
 386                 .help = "Get AUX register by number. This command does a "
 387                         "raw JTAG request that bypasses OpenOCD register cache "
 388                         "and thus is unsafe and can have unexpected consequences. "
 389                         "Use at your own risk.",
 390                 .usage = "<regnum>"
 391         },
 392         {
 393                 .name = "set-aux-reg",
 394                 .handler = arc_handle_set_aux_reg,
 395                 .mode = COMMAND_EXEC,
 396                 .help = "Set AUX register by number. This command does a "
 397                         "raw JTAG request that bypasses OpenOCD register cache "
 398                         "and thus is unsafe and can have unexpected consequences. "
 399                         "Use at your own risk.",
 400                 .usage = "<regnum> <value>"
 401         },
 402         {
 403                 .name = "get-core-reg",
 404                 .handler = arc_handle_get_core_reg,
 405                 .mode = COMMAND_EXEC,
 406                 .help = "Get/Set core register by number. This command does a "
 407                         "raw JTAG request that bypasses OpenOCD register cache "
 408                         "and thus is unsafe and can have unexpected consequences. "
 409                         "Use at your own risk.",
 410                 .usage = "<regnum> [<value>]"
 411         },
 412         {
 413                 .name = "set-core-reg",
 414                 .handler = arc_handle_set_core_reg,
 415                 .mode = COMMAND_EXEC,
 416                 .help = "Get/Set core register by number. This command does a "
 417                         "raw JTAG request that bypasses OpenOCD register cache "
 418                         "and thus is unsafe and can have unexpected consequences. "
 419                         "Use at your own risk.",
 420                 .usage = "<regnum> [<value>]"
 421         },
 422         COMMAND_REGISTRATION_DONE
 423 };
 424
 425
 426 /* This function supports only bitfields. */
 427 static int jim_arc_add_reg_type_struct(Jim_Interp *interp, int argc,
 428         Jim_Obj * const *argv)
 429 {
 430         struct jim_getopt_info goi;
 431         JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
 432
 433         LOG_DEBUG("-");
 434
 435         struct command_context *ctx;
 436         struct target *target;
 437
 438         ctx = current_command_context(interp);
 439         assert(ctx);
 440         target = get_current_target(ctx);
 441         if (!target) {
 442                 Jim_SetResultFormatted(goi.interp, "No current target");
 443                 return JIM_ERR;
 444         }
 445
 446         int e = JIM_OK;
 447
 448         /* Check if the amount of arguments is not zero */
 449         if (goi.argc <= 0) {
 450                 Jim_SetResultFormatted(goi.interp, "The command has no arguments");
 451                 return JIM_ERR;
 452         }
 453
 454         /* Estimate number of registers as (argc - 2)/4 as each -bitfield option has 3
 455          * arguments while -name is required. */
 456         unsigned int fields_sz = (goi.argc - 2) / 4;
 457         unsigned int cur_field = 0;
 458
 459         /* The maximum amount of bitfields is 32 */
 460         if (fields_sz > 32) {
 461                         Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
 462                         return JIM_ERR;
 463         }
 464
 465         struct arc_reg_data_type *type = calloc(1, sizeof(*type));
 466         struct reg_data_type_struct *struct_type = &type->data_type_struct;
 467         struct reg_data_type_struct_field *fields = calloc(fields_sz, sizeof(*fields));
 468         type->reg_type_struct_field = fields;
 469         struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
 470         if (!(type && fields && bitfields)) {
 471                 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
 472                 goto fail;
 473         }
 474
 475         /* Initialize type */
 476         type->data_type.id = type->data_type_id;
 477         type->bitfields = bitfields;
 478         type->data_type.type = REG_TYPE_ARCH_DEFINED;
 479         type->data_type.type_class = REG_TYPE_CLASS_STRUCT;
 480         type->data_type.reg_type_struct = struct_type;
 481         struct_type->size = 4; /* For now ARC has only 32-bit registers */
 482
 483         while (goi.argc > 0 && e == JIM_OK) {
 484                 struct jim_nvp *n;
 485                 e = jim_getopt_nvp(&goi, nvp_add_reg_type_struct_opts, &n);
 486                 if (e != JIM_OK) {
 487                         jim_getopt_nvp_unknown(&goi, nvp_add_reg_type_struct_opts, 0);
 488                         continue;
 489                 }
 490
 491                 switch (n->value) {
 492                         case CFG_ADD_REG_TYPE_STRUCT_NAME:
 493                         {
 494                                 const char *name = NULL;
 495                                 int name_len = 0;
 496
 497                                 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
 498                                 if (e != JIM_OK) {
 499                                         Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
 500                                         goto fail;
 501                                 }
 502
 503                                 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
 504                                         Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
 505                                         goto fail;
 506                                 }
 507
 508                                 strncpy((void *)type->data_type.id, name, name_len);
 509                                 if (!type->data_type.id) {
 510                                         Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
 511                                         goto fail;
 512                                 }
 513
 514                                 break;
 515                         }
 516                         case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
 517                         {
 518                                 const char *field_name = NULL;
 519                                 int field_name_len = 0;
 520                                 e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
 521                                                                         cur_field, CFG_ADD_REG_TYPE_STRUCT);
 522                                 if (e != JIM_OK) {
 523                                         Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_struct field.");
 524                                         goto fail;
 525                                 }
 526
 527                                 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
 528                                         Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
 529                                         goto fail;
 530                                 }
 531
 532                                 fields[cur_field].name = bitfields[cur_field].name;
 533                                 strncpy(bitfields[cur_field].name, field_name, field_name_len);
 534                                 if (!fields[cur_field].name) {
 535                                         Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
 536                                         goto fail;
 537                                 }
 538
 539                                 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
 540                                 fields[cur_field].use_bitfields = true;
 541                                 if (cur_field > 0)
 542                                         fields[cur_field - 1].next = &(fields[cur_field]);
 543                                 else
 544                                         struct_type->fields = fields;
 545
 546                                 cur_field += 1;
 547
 548                                 break;
 549                         }
 550                 }
 551         }
 552
 553         if (!type->data_type.id) {
 554                 Jim_SetResultFormatted(goi.interp, "-name is a required option");
 555                 goto fail;
 556         }
 557
 558         arc_reg_data_type_add(target, type);
 559         LOG_DEBUG("added struct type {name=%s}", type->data_type.id);
 560         return JIM_OK;
 561
 562 fail:
 563                         free(type);
 564                         free(fields);
 565                         free(bitfields);
 566
 567                         return JIM_ERR;
 568 }
 569
 570 /* Add register */
 571 enum opts_add_reg {
 572         CFG_ADD_REG_NAME,
 573         CFG_ADD_REG_ARCH_NUM,
 574         CFG_ADD_REG_IS_CORE,
 575         CFG_ADD_REG_IS_BCR,
 576         CFG_ADD_REG_GDB_FEATURE,
 577         CFG_ADD_REG_TYPE,
 578         CFG_ADD_REG_GENERAL,
 579 };
 580
 581 static struct jim_nvp opts_nvp_add_reg[] = {
 582         { .name = "-name",    .value = CFG_ADD_REG_NAME },
 583         { .name = "-num",     .value = CFG_ADD_REG_ARCH_NUM },
 584         { .name = "-core",    .value = CFG_ADD_REG_IS_CORE },
 585         { .name = "-bcr",     .value = CFG_ADD_REG_IS_BCR },
 586         { .name = "-feature", .value = CFG_ADD_REG_GDB_FEATURE },
 587         { .name = "-type",    .value = CFG_ADD_REG_TYPE },
 588         { .name = "-g",       .value = CFG_ADD_REG_GENERAL },
 589         { .name = NULL,       .value = -1 }
 590 };
 591
 592 void free_reg_desc(struct arc_reg_desc *r)
 593 {
 594         free(r->name);
 595         free(r->gdb_xml_feature);
 596         free(r);
 597 }
 598
 599 static int jim_arc_add_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
 600 {
 601         struct jim_getopt_info goi;
 602         JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
 603
 604         struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
 605         if (!reg) {
 606                 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
 607                 return JIM_ERR;
 608         }
 609
 610         /* There is no architecture number that we could treat as invalid, so
 611          * separate variable required to ensure that arch num has been set. */
 612         bool arch_num_set = false;
 613         const char *type_name = "int"; /* Default type */
 614         int type_name_len = strlen(type_name);
 615         int e = ERROR_OK;
 616
 617         /* At least we need to specify 4 parameters: name, number and gdb_feature,
 618          * which means there should be 6 arguments. Also there can be additional parameters
 619          * "-type <type>", "-g" and  "-core" or "-bcr" which makes maximum 10 parameters. */
 620         if (goi.argc < 6 || goi.argc > 10) {
 621                 free_reg_desc(reg);
 622                 Jim_SetResultFormatted(goi.interp,
 623                         "Should be at least 6 arguments and not greater than 10: "
 624                         " -name <name> -num <num> -feature <gdb_feature> "
 625                         " [-type <type_name>] [-core|-bcr] [-g].");
 626                 return JIM_ERR;
 627         }
 628
 629         /* Parse options. */
 630         while (goi.argc > 0) {
 631                 struct jim_nvp *n;
 632                 e = jim_getopt_nvp(&goi, opts_nvp_add_reg, &n);
 633                 if (e != JIM_OK) {
 634                         jim_getopt_nvp_unknown(&goi, opts_nvp_add_reg, 0);
 635                         free_reg_desc(reg);
 636                         return e;
 637                 }
 638
 639                 switch (n->value) {
 640                         case CFG_ADD_REG_NAME:
 641                         {
 642                                 const char *reg_name = NULL;
 643                                 int reg_name_len = 0;
 644
 645                                 e = jim_arc_read_reg_name_field(&goi, &reg_name, &reg_name_len);
 646                                 if (e != JIM_OK) {
 647                                         Jim_SetResultFormatted(goi.interp, "Unable to read register name.");
 648                                         free_reg_desc(reg);
 649                                         return e;
 650                                 }
 651
 652                                 reg->name = strndup(reg_name, reg_name_len);
 653                                 break;
 654                         }
 655                         case CFG_ADD_REG_IS_CORE:
 656                                 reg->is_core = true;
 657                                 break;
 658                         case CFG_ADD_REG_IS_BCR:
 659                                 reg->is_bcr = true;
 660                                 break;
 661                         case CFG_ADD_REG_ARCH_NUM:
 662                         {
 663                                 jim_wide archnum;
 664
 665                                 if (!goi.argc) {
 666                                         free_reg_desc(reg);
 667                                         Jim_WrongNumArgs(interp, goi.argc, goi.argv, "-num <int> ...");
 668                                         return JIM_ERR;
 669                                 }
 670
 671                                 e = jim_getopt_wide(&goi, &archnum);
 672                                 if (e != JIM_OK) {
 673                                         free_reg_desc(reg);
 674                                         return e;
 675                                 }
 676
 677                                 reg->arch_num = archnum;
 678                                 arch_num_set = true;
 679                                 break;
 680                         }
 681                         case CFG_ADD_REG_GDB_FEATURE:
 682                         {
 683                                 const char *feature = NULL;
 684                                 int feature_len = 0;
 685
 686                                 e = jim_arc_read_reg_name_field(&goi, &feature, &feature_len);
 687                                 if (e != JIM_OK) {
 688                                         Jim_SetResultFormatted(goi.interp, "Unable to read gdb_feature.");
 689                                         free_reg_desc(reg);
 690                                         return e;
 691                                 }
 692
 693                                 reg->gdb_xml_feature = strndup(feature, feature_len);
 694                                 break;
 695                         }
 696                         case CFG_ADD_REG_TYPE:
 697                                 e = jim_arc_read_reg_name_field(&goi, &type_name, &type_name_len);
 698                                 if (e != JIM_OK) {
 699                                         Jim_SetResultFormatted(goi.interp, "Unable to read register type.");
 700                                         free_reg_desc(reg);
 701                                         return e;
 702                                 }
 703
 704                                 break;
 705                         case CFG_ADD_REG_GENERAL:
 706                                 reg->is_general = true;
 707                                 break;
 708                         default:
 709                                 LOG_DEBUG("Error: Unknown parameter");
 710                                 free_reg_desc(reg);
 711                                 return JIM_ERR;
 712                 }
 713         }
 714
 715         /* Check that required fields are set */
 716         const char * const errmsg = validate_register(reg, arch_num_set);
 717         if (errmsg) {
 718                 Jim_SetResultFormatted(goi.interp, errmsg);
 719                 free_reg_desc(reg);
 720                 return JIM_ERR;
 721         }
 722
 723         /* Add new register */
 724         struct command_context *ctx;
 725         struct target *target;
 726
 727         ctx = current_command_context(interp);
 728         assert(ctx);
 729         target = get_current_target(ctx);
 730         if (!target) {
 731                 Jim_SetResultFormatted(goi.interp, "No current target");
 732                 free_reg_desc(reg);
 733                 return JIM_ERR;
 734         }
 735
 736         reg->target = target;
 737
 738         e = arc_reg_add(target, reg, type_name, type_name_len);
 739         if (e == ERROR_ARC_REGTYPE_NOT_FOUND) {
 740                 Jim_SetResultFormatted(goi.interp,
 741                         "Cannot find type `%s' for register `%s'.",
 742                         type_name, reg->name);
 743                 free_reg_desc(reg);
 744                 return JIM_ERR;
 745         }
 746
 747         return e;
 748 }
 749
 750 /* arc set-reg-exists ($reg_name)+
 751  * Accepts any amount of register names - will set them as existing in a loop.*/
 752 COMMAND_HANDLER(arc_set_reg_exists)
 753 {
 754         struct target * const target = get_current_target(CMD_CTX);
 755         if (!target) {
 756                 command_print(CMD, "Unable to get current target.");
 757                 return ERROR_FAIL;
 758         }
 759
 760         if (!CMD_ARGC) {
 761                 command_print(CMD, "At least one register name must be specified.");
 762                 return ERROR_COMMAND_SYNTAX_ERROR;
 763         }
 764
 765         for (unsigned int i = 0; i < CMD_ARGC; i++) {
 766                 const char * const reg_name = CMD_ARGV[i];
 767                 struct reg * const r = arc_reg_get_by_name(target->reg_cache, reg_name, true);
 768
 769                 if (!r) {
 770                         command_print(CMD, "Register `%s' is not found.", reg_name);
 771                         return ERROR_COMMAND_ARGUMENT_INVALID;
 772                 }
 773
 774                 r->exist = true;
 775         }
 776
 777         return ERROR_OK;
 778 }
 779
 780 /* arc reg-field  ($reg_name) ($reg_field)
 781  * Reads struct type register field */
 782 COMMAND_HANDLER(arc_handle_get_reg_field)
 783 {
 784         if (CMD_ARGC != 2)
 785                 return ERROR_COMMAND_SYNTAX_ERROR;
 786
 787         struct target *target = get_current_target(CMD_CTX);
 788         if (!target) {
 789                 command_print(CMD, "No current target");
 790                 return ERROR_FAIL;
 791         }
 792
 793         const char *reg_name = CMD_ARGV[0];
 794         const char *field_name = CMD_ARGV[1];
 795         uint32_t value;
 796         int retval = arc_reg_get_field(target, reg_name, field_name, &value);
 797
 798         switch (retval) {
 799                 case ERROR_OK:
 800                         break;
 801                 case ERROR_ARC_REGISTER_NOT_FOUND:
 802                         command_print(CMD,
 803                                 "Register `%s' has not been found.", reg_name);
 804                         return ERROR_COMMAND_ARGUMENT_INVALID;
 805                 case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
 806                         command_print(CMD,
 807                                 "Register `%s' must have 'struct' type.", reg_name);
 808                         return ERROR_COMMAND_ARGUMENT_INVALID;
 809                 case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
 810                         command_print(CMD,
 811                                 "Field `%s' has not been found in register `%s'.",
 812                                 field_name, reg_name);
 813                         return ERROR_COMMAND_ARGUMENT_INVALID;
 814                 case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
 815                         command_print(CMD,
 816                                 "Field `%s' is not a 'bitfield' field in a structure.",
 817                                 field_name);
 818                         return ERROR_COMMAND_ARGUMENT_INVALID;
 819                 default:
 820                         /* Pass through other errors. */
 821                         return retval;
 822         }
 823
 824         command_print(CMD, "0x%" PRIx32, value);
 825
 826         return ERROR_OK;
 827 }
 828
 829 COMMAND_HANDLER(arc_l1_cache_disable_auto_cmd)
 830 {
 831         bool value;
 832         int retval = 0;
 833         struct arc_common *arc = target_to_arc(get_current_target(CMD_CTX));
 834         retval = CALL_COMMAND_HANDLER(handle_command_parse_bool,
 835                 &value, "target has caches enabled");
 836         arc->has_l2cache = value;
 837         arc->has_dcache = value;
 838         arc->has_icache = value;
 839         return retval;
 840 }
 841
 842 COMMAND_HANDLER(arc_l2_cache_disable_auto_cmd)
 843 {
 844         struct arc_common *arc = target_to_arc(get_current_target(CMD_CTX));
 845         return CALL_COMMAND_HANDLER(handle_command_parse_bool,
 846                 &arc->has_l2cache, "target has l2 cache enabled");
 847 }
 848
 849 COMMAND_HANDLER(arc_handle_actionpoints_num)
 850 {
 851         LOG_DEBUG("-");
 852
 853         if (CMD_ARGC >= 2)
 854                 return ERROR_COMMAND_SYNTAX_ERROR;
 855
 856         struct target *target = get_current_target(CMD_CTX);
 857         if (!target) {
 858                 command_print(CMD, "No current target");
 859                 return ERROR_FAIL;
 860         }
 861
 862         struct arc_common *arc = target_to_arc(target);
 863         /* It is not possible to pass &arc->actionpoints_num directly to
 864          * handle_command_parse_uint, because this value should be valid during
 865          * "actionpoint reset, initiated by arc_set_actionpoints_num.  */
 866         uint32_t ap_num = arc->actionpoints_num;
 867
 868         if (CMD_ARGC == 1) {
 869                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], ap_num);
 870                 int e = arc_set_actionpoints_num(target, ap_num);
 871                 if (e != ERROR_OK) {
 872                         command_print(CMD,
 873                                 "Failed to set number of actionpoints");
 874                         return e;
 875                 }
 876         }
 877
 878         command_print(CMD, "%" PRIu32, ap_num);
 879
 880         return ERROR_OK;
 881 }
 882
 883 /* ----- Exported target commands ------------------------------------------ */
 884
 885 static const struct command_registration arc_l2_cache_group_handlers[] = {
 886         {
 887                 .name = "auto",
 888                 .handler = arc_l2_cache_disable_auto_cmd,
 889                 .mode = COMMAND_ANY,
 890                 .usage = "(1|0)",
 891                 .help = "Disable or enable L2",
 892         },
 893         COMMAND_REGISTRATION_DONE
 894 };
 895
 896 static const struct command_registration arc_cache_group_handlers[] = {
 897         {
 898                 .name = "auto",
 899                 .handler = arc_l1_cache_disable_auto_cmd,
 900                 .mode = COMMAND_ANY,
 901                 .help = "Disable or enable L1",
 902                 .usage = "(1|0)",
 903         },
 904         {
 905                 .name = "l2",
 906                 .mode = COMMAND_ANY,
 907                 .help = "L2 cache command group",
 908                 .usage = "",
 909                 .chain = arc_l2_cache_group_handlers,
 910         },
 911         COMMAND_REGISTRATION_DONE
 912 };
 913
 914
 915 static const struct command_registration arc_core_command_handlers[] = {
 916         {
 917                 .name = "add-reg-type-flags",
 918                 .handler = arc_handle_add_reg_type_flags,
 919                 .mode = COMMAND_CONFIG,
 920                 .usage = "-name <string> -flag <name> <position> "
 921                         "[-flag <name> <position>]...",
 922                 .help = "Add new 'flags' register data type. Only single bit flags "
 923                         "are supported. Type name is global. Bitsize of register is fixed "
 924                         "at 32 bits.",
 925         },
 926         {
 927                 .name = "add-reg-type-struct",
 928                 .jim_handler = jim_arc_add_reg_type_struct,
 929                 .mode = COMMAND_CONFIG,
 930                 .usage = "-name <string> -bitfield <name> <start> <end> "
 931                         "[-bitfield <name> <start> <end>]...",
 932                 .help = "Add new 'struct' register data type. Only bit-fields are "
 933                         "supported so far, which means that for each bitfield start and end "
 934                         "position bits must be specified. GDB also support type-fields, "
 935                         "where common type can be used instead. Type name is global. Bitsize of "
 936                         "register is fixed at 32 bits.",
 937         },
 938         {
 939                 .name = "add-reg",
 940                 .jim_handler = jim_arc_add_reg,
 941                 .mode = COMMAND_CONFIG,
 942                 .usage = "-name <string> -num <int> -feature <string> [-gdbnum <int>] "
 943                         "[-core|-bcr] [-type <type_name>] [-g]",
 944                 .help = "Add new register. Name, architectural number and feature name "
 945                         "are required options. GDB regnum will default to previous register "
 946                         "(gdbnum + 1) and shouldn't be specified in most cases. Type "
 947                         "defaults to default GDB 'int'.",
 948         },
 949         {
 950                 .name = "set-reg-exists",
 951                 .handler = arc_set_reg_exists,
 952                 .mode = COMMAND_ANY,
 953                 .usage = "<register-name> [<register-name>]...",
 954                 .help = "Set that register exists. Accepts multiple register names as "
 955                         "arguments.",
 956         },
 957         {
 958                 .name = "get-reg-field",
 959                 .handler = arc_handle_get_reg_field,
 960                 .mode = COMMAND_ANY,
 961                 .usage = "<regname> <field_name>",
 962                 .help = "Returns value of field in a register with 'struct' type.",
 963         },
 964         {
 965                 .name = "jtag",
 966                 .mode = COMMAND_ANY,
 967                 .help = "ARC JTAG specific commands",
 968                 .usage = "",
 969                 .chain = arc_jtag_command_group,
 970         },
 971         {
 972                 .name = "cache",
 973                 .mode = COMMAND_ANY,
 974                 .help = "cache command group",
 975                 .usage = "",
 976                 .chain = arc_cache_group_handlers,
 977         },
 978         {
 979                 .name = "num-actionpoints",
 980                 .handler = arc_handle_actionpoints_num,
 981                 .mode = COMMAND_ANY,
 982                 .usage = "[<unsigned integer>]",
 983                 .help = "Prints or sets amount of actionpoints in the processor.",
 984         },
 985         COMMAND_REGISTRATION_DONE
 986 };
 987
 988 const struct command_registration arc_monitor_command_handlers[] = {
 989         {
 990                 .name = "arc",
 991                 .mode = COMMAND_ANY,
 992                 .help = "ARC monitor command group",
 993                 .usage = "",
 994                 .chain = arc_core_command_handlers,
 995         },
 996         COMMAND_REGISTRATION_DONE
 997 };