Code Review / openocd.git / blob
? search:


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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)