Code Review / openocd.git / blob
? search:


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