Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
jtag: linuxgpiod: drop extra parenthesis
[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 static int jim_arc_get_aux_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
322 {
323 struct command_context *context;
324 struct target *target;
325 uint32_t regnum;
326 uint32_t value;
327
328 struct jim_getopt_info goi;
329 JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
330
331 if (goi.argc != 1) {
332 Jim_SetResultFormatted(goi.interp,
333 "usage: %s <aux_reg_num>", Jim_GetString(argv[0], NULL));
334 return JIM_ERR;
335 }
336
337 context = current_command_context(interp);
338 assert(context);
339
340 target = get_current_target(context);
341 if (!target) {
342 Jim_SetResultFormatted(goi.interp, "No current target");
343 return JIM_ERR;
344 }
345
346 /* Register number */
347 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
348
349 struct arc_common *arc = target_to_arc(target);
350 assert(arc);
351
352 CHECK_RETVAL(arc_jtag_read_aux_reg_one(&arc->jtag_info, regnum, &value));
353 Jim_SetResultInt(interp, value);
354
355 return ERROR_OK;
356 }
357
358 static int jim_arc_get_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
359 {
360 struct command_context *context;
361 struct target *target;
362 uint32_t regnum;
363 uint32_t value;
364
365 struct jim_getopt_info goi;
366 JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
367
368 if (goi.argc != 1) {
369 Jim_SetResultFormatted(goi.interp,
370 "usage: %s <core_reg_num>", Jim_GetString(argv[0], NULL));
371 return JIM_ERR;
372 }
373
374 context = current_command_context(interp);
375 assert(context);
376
377 target = get_current_target(context);
378 if (!target) {
379 Jim_SetResultFormatted(goi.interp, "No current target");
380 return JIM_ERR;
381 }
382
383 /* Register number */
384 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
385 if (regnum > CORE_REG_MAX_NUMBER || regnum == ARC_R61 || regnum == ARC_R62) {
386 Jim_SetResultFormatted(goi.interp, "Core register number %i "
387 "is invalid. Must less then 64 and not 61 and 62.", regnum);
388 return JIM_ERR;
389 }
390
391 struct arc_common *arc = target_to_arc(target);
392 assert(arc);
393
394 /* Read value */
395 CHECK_RETVAL(arc_jtag_read_core_reg_one(&arc->jtag_info, regnum, &value));
396 Jim_SetResultInt(interp, value);
397
398 return ERROR_OK;
399 }
400
401 static int jim_arc_set_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
402 {
403 struct command_context *context;
404 struct target *target;
405 uint32_t regnum;
406 uint32_t value;
407
408 struct jim_getopt_info goi;
409 JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
410
411 if (goi.argc != 2) {
412 Jim_SetResultFormatted(goi.interp,
413 "usage: %s <core_reg_num> <core_reg_value>", Jim_GetString(argv[0], NULL));
414 return JIM_ERR;
415 }
416
417 context = current_command_context(interp);
418 assert(context);
419
420 target = get_current_target(context);
421 if (!target) {
422 Jim_SetResultFormatted(goi.interp, "No current target");
423 return JIM_ERR;
424 }
425
426 /* Register number */
427 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
428 if (regnum > CORE_REG_MAX_NUMBER || regnum == ARC_R61 || regnum == ARC_R62) {
429 Jim_SetResultFormatted(goi.interp, "Core register number %i "
430 "is invalid. Must less then 64 and not 61 and 62.", regnum);
431 return JIM_ERR;
432 }
433
434 /* Register value */
435 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &value));
436
437 struct arc_common *arc = target_to_arc(target);
438 assert(arc);
439
440 CHECK_RETVAL(arc_jtag_write_core_reg_one(&arc->jtag_info, regnum, value));
441
442 return ERROR_OK;
443 }
444
445 static const struct command_registration arc_jtag_command_group[] = {
446 {
447 .name = "get-aux-reg",
448 .jim_handler = jim_arc_get_aux_reg,
449 .mode = COMMAND_EXEC,
450 .help = "Get AUX register by number. This command does a "
451 "raw JTAG request that bypasses OpenOCD register cache "
452 "and thus is unsafe and can have unexpected consequences. "
453 "Use at your own risk.",
454 .usage = "<regnum>"
455 },
456 {
457 .name = "set-aux-reg",
458 .jim_handler = jim_arc_set_aux_reg,
459 .mode = COMMAND_EXEC,
460 .help = "Set AUX register by number. This command does a "
461 "raw JTAG request that bypasses OpenOCD register cache "
462 "and thus is unsafe and can have unexpected consequences. "
463 "Use at your own risk.",
464 .usage = "<regnum> <value>"
465 },
466 {
467 .name = "get-core-reg",
468 .jim_handler = jim_arc_get_core_reg,
469 .mode = COMMAND_EXEC,
470 .help = "Get/Set core register by number. This command does a "
471 "raw JTAG request that bypasses OpenOCD register cache "
472 "and thus is unsafe and can have unexpected consequences. "
473 "Use at your own risk.",
474 .usage = "<regnum> [<value>]"
475 },
476 {
477 .name = "set-core-reg",
478 .jim_handler = jim_arc_set_core_reg,
479 .mode = COMMAND_EXEC,
480 .help = "Get/Set core register by number. This command does a "
481 "raw JTAG request that bypasses OpenOCD register cache "
482 "and thus is unsafe and can have unexpected consequences. "
483 "Use at your own risk.",
484 .usage = "<regnum> [<value>]"
485 },
486 COMMAND_REGISTRATION_DONE
487 };
488
489
490 /* This function supports only bitfields. */
491 static int jim_arc_add_reg_type_struct(Jim_Interp *interp, int argc,
492 Jim_Obj * const *argv)
493 {
494 struct jim_getopt_info goi;
495 JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
496
497 LOG_DEBUG("-");
498
499 struct command_context *ctx;
500 struct target *target;
501
502 ctx = current_command_context(interp);
503 assert(ctx);
504 target = get_current_target(ctx);
505 if (!target) {
506 Jim_SetResultFormatted(goi.interp, "No current target");
507 return JIM_ERR;
508 }
509
510 int e = JIM_OK;
511
512 /* Check if the amount of arguments is not zero */
513 if (goi.argc <= 0) {
514 Jim_SetResultFormatted(goi.interp, "The command has no arguments");
515 return JIM_ERR;
516 }
517
518 /* Estimate number of registers as (argc - 2)/4 as each -bitfield option has 3
519 * arguments while -name is required. */
520 unsigned int fields_sz = (goi.argc - 2) / 4;
521 unsigned int cur_field = 0;
522
523 /* The maximum amount of bitfields is 32 */
524 if (fields_sz > 32) {
525 Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
526 return JIM_ERR;
527 }
528
529 struct arc_reg_data_type *type = calloc(1, sizeof(*type));
530 struct reg_data_type_struct *struct_type = &type->data_type_struct;
531 struct reg_data_type_struct_field *fields = calloc(fields_sz, sizeof(*fields));
532 type->reg_type_struct_field = fields;
533 struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
534 if (!(type && fields && bitfields)) {
535 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
536 goto fail;
537 }
538
539 /* Initialize type */
540 type->data_type.id = type->data_type_id;
541 type->bitfields = bitfields;
542 type->data_type.type = REG_TYPE_ARCH_DEFINED;
543 type->data_type.type_class = REG_TYPE_CLASS_STRUCT;
544 type->data_type.reg_type_struct = struct_type;
545 struct_type->size = 4; /* For now ARC has only 32-bit registers */
546
547 while (goi.argc > 0 && e == JIM_OK) {
548 struct jim_nvp *n;
549 e = jim_getopt_nvp(&goi, nvp_add_reg_type_struct_opts, &n);
550 if (e != JIM_OK) {
551 jim_getopt_nvp_unknown(&goi, nvp_add_reg_type_struct_opts, 0);
552 continue;
553 }
554
555 switch (n->value) {
556 case CFG_ADD_REG_TYPE_STRUCT_NAME:
557 {
558 const char *name = NULL;
559 int name_len = 0;
560
561 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
562 if (e != JIM_OK) {
563 Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
564 goto fail;
565 }
566
567 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
568 Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
569 goto fail;
570 }
571
572 strncpy((void *)type->data_type.id, name, name_len);
573 if (!type->data_type.id) {
574 Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
575 goto fail;
576 }
577
578 break;
579 }
580 case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
581 {
582 const char *field_name = NULL;
583 int field_name_len = 0;
584 e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
585 cur_field, CFG_ADD_REG_TYPE_STRUCT);
586 if (e != JIM_OK) {
587 Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_struct field.");
588 goto fail;
589 }
590
591 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
592 Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
593 goto fail;
594 }
595
596 fields[cur_field].name = bitfields[cur_field].name;
597 strncpy(bitfields[cur_field].name, field_name, field_name_len);
598 if (!fields[cur_field].name) {
599 Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
600 goto fail;
601 }
602
603 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
604 fields[cur_field].use_bitfields = true;
605 if (cur_field > 0)
606 fields[cur_field - 1].next = &(fields[cur_field]);
607 else
608 struct_type->fields = fields;
609
610 cur_field += 1;
611
612 break;
613 }
614 }
615 }
616
617 if (!type->data_type.id) {
618 Jim_SetResultFormatted(goi.interp, "-name is a required option");
619 goto fail;
620 }
621
622 arc_reg_data_type_add(target, type);
623 LOG_DEBUG("added struct type {name=%s}", type->data_type.id);
624 return JIM_OK;
625
626 fail:
627 free(type);
628 free(fields);
629 free(bitfields);
630
631 return JIM_ERR;
632 }
633
634 /* Add register */
635 enum opts_add_reg {
636 CFG_ADD_REG_NAME,
637 CFG_ADD_REG_ARCH_NUM,
638 CFG_ADD_REG_IS_CORE,
639 CFG_ADD_REG_IS_BCR,
640 CFG_ADD_REG_GDB_FEATURE,
641 CFG_ADD_REG_TYPE,
642 CFG_ADD_REG_GENERAL,
643 };
644
645 static struct jim_nvp opts_nvp_add_reg[] = {
646 { .name = "-name", .value = CFG_ADD_REG_NAME },
647 { .name = "-num", .value = CFG_ADD_REG_ARCH_NUM },
648 { .name = "-core", .value = CFG_ADD_REG_IS_CORE },
649 { .name = "-bcr", .value = CFG_ADD_REG_IS_BCR },
650 { .name = "-feature", .value = CFG_ADD_REG_GDB_FEATURE },
651 { .name = "-type", .value = CFG_ADD_REG_TYPE },
652 { .name = "-g", .value = CFG_ADD_REG_GENERAL },
653 { .name = NULL, .value = -1 }
654 };
655
656 void free_reg_desc(struct arc_reg_desc *r)
657 {
658 free(r->name);
659 free(r->gdb_xml_feature);
660 free(r);
661 }
662
663 static int jim_arc_add_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
664 {
665 struct jim_getopt_info goi;
666 JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
667
668 struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
669 if (!reg) {
670 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
671 return JIM_ERR;
672 }
673
674 /* There is no architecture number that we could treat as invalid, so
675 * separate variable required to ensure that arch num has been set. */
676 bool arch_num_set = false;
677 const char *type_name = "int"; /* Default type */
678 int type_name_len = strlen(type_name);
679 int e = ERROR_OK;
680
681 /* At least we need to specify 4 parameters: name, number and gdb_feature,
682 * which means there should be 6 arguments. Also there can be additional parameters
683 * "-type <type>", "-g" and "-core" or "-bcr" which makes maximum 10 parameters. */
684 if (goi.argc < 6 || goi.argc > 10) {
685 free_reg_desc(reg);
686 Jim_SetResultFormatted(goi.interp,
687 "Should be at least 6 arguments and not greater than 10: "
688 " -name <name> -num <num> -feature <gdb_feature> "
689 " [-type <type_name>] [-core|-bcr] [-g].");
690 return JIM_ERR;
691 }
692
693 /* Parse options. */
694 while (goi.argc > 0) {
695 struct jim_nvp *n;
696 e = jim_getopt_nvp(&goi, opts_nvp_add_reg, &n);
697 if (e != JIM_OK) {
698 jim_getopt_nvp_unknown(&goi, opts_nvp_add_reg, 0);
699 free_reg_desc(reg);
700 return e;
701 }
702
703 switch (n->value) {
704 case CFG_ADD_REG_NAME:
705 {
706 const char *reg_name = NULL;
707 int reg_name_len = 0;
708
709 e = jim_arc_read_reg_name_field(&goi, &reg_name, &reg_name_len);
710 if (e != JIM_OK) {
711 Jim_SetResultFormatted(goi.interp, "Unable to read register name.");
712 free_reg_desc(reg);
713 return e;
714 }
715
716 reg->name = strndup(reg_name, reg_name_len);
717 break;
718 }
719 case CFG_ADD_REG_IS_CORE:
720 reg->is_core = true;
721 break;
722 case CFG_ADD_REG_IS_BCR:
723 reg->is_bcr = true;
724 break;
725 case CFG_ADD_REG_ARCH_NUM:
726 {
727 jim_wide archnum;
728
729 if (!goi.argc) {
730 free_reg_desc(reg);
731 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "-num <int> ...");
732 return JIM_ERR;
733 }
734
735 e = jim_getopt_wide(&goi, &archnum);
736 if (e != JIM_OK) {
737 free_reg_desc(reg);
738 return e;
739 }
740
741 reg->arch_num = archnum;
742 arch_num_set = true;
743 break;
744 }
745 case CFG_ADD_REG_GDB_FEATURE:
746 {
747 const char *feature = NULL;
748 int feature_len = 0;
749
750 e = jim_arc_read_reg_name_field(&goi, &feature, &feature_len);
751 if (e != JIM_OK) {
752 Jim_SetResultFormatted(goi.interp, "Unable to read gdb_feature.");
753 free_reg_desc(reg);
754 return e;
755 }
756
757 reg->gdb_xml_feature = strndup(feature, feature_len);
758 break;
759 }
760 case CFG_ADD_REG_TYPE:
761 e = jim_arc_read_reg_name_field(&goi, &type_name, &type_name_len);
762 if (e != JIM_OK) {
763 Jim_SetResultFormatted(goi.interp, "Unable to read register type.");
764 free_reg_desc(reg);
765 return e;
766 }
767
768 break;
769 case CFG_ADD_REG_GENERAL:
770 reg->is_general = true;
771 break;
772 default:
773 LOG_DEBUG("Error: Unknown parameter");
774 free_reg_desc(reg);
775 return JIM_ERR;
776 }
777 }
778
779 /* Check that required fields are set */
780 const char * const errmsg = validate_register(reg, arch_num_set);
781 if (errmsg) {
782 Jim_SetResultFormatted(goi.interp, errmsg);
783 free_reg_desc(reg);
784 return JIM_ERR;
785 }
786
787 /* Add new register */
788 struct command_context *ctx;
789 struct target *target;
790
791 ctx = current_command_context(interp);
792 assert(ctx);
793 target = get_current_target(ctx);
794 if (!target) {
795 Jim_SetResultFormatted(goi.interp, "No current target");
796 free_reg_desc(reg);
797 return JIM_ERR;
798 }
799
800 reg->target = target;
801
802 e = arc_reg_add(target, reg, type_name, type_name_len);
803 if (e == ERROR_ARC_REGTYPE_NOT_FOUND) {
804 Jim_SetResultFormatted(goi.interp,
805 "Cannot find type `%s' for register `%s'.",
806 type_name, reg->name);
807 free_reg_desc(reg);
808 return JIM_ERR;
809 }
810
811 return e;
812 }
813
814 /* arc set-reg-exists ($reg_name)+
815 * Accepts any amount of register names - will set them as existing in a loop.*/
816 COMMAND_HANDLER(arc_set_reg_exists)
817 {
818 struct target * const target = get_current_target(CMD_CTX);
819 if (!target) {
820 command_print(CMD, "Unable to get current target.");
821 return JIM_ERR;
822 }
823
824 if (!CMD_ARGC) {
825 command_print(CMD, "At least one register name must be specified.");
826 return ERROR_COMMAND_SYNTAX_ERROR;
827 }
828
829 for (unsigned int i = 0; i < CMD_ARGC; i++) {
830 const char * const reg_name = CMD_ARGV[i];
831 struct reg * const r = arc_reg_get_by_name(target->reg_cache, reg_name, true);
832
833 if (!r) {
834 command_print(CMD, "Register `%s' is not found.", reg_name);
835 return ERROR_COMMAND_ARGUMENT_INVALID;
836 }
837
838 r->exist = true;
839 }
840
841 return JIM_OK;
842 }
843
844 /* arc reg-field ($reg_name) ($reg_field)
845 * Reads struct type register field */
846 static int jim_arc_get_reg_field(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
847 {
848 struct jim_getopt_info goi;
849 const char *reg_name, *field_name;
850 uint32_t value;
851 int retval;
852
853 JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
854
855 LOG_DEBUG("Reading register field");
856 if (goi.argc != 2) {
857 if (!goi.argc)
858 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
859 else if (goi.argc == 1)
860 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<fieldname>");
861 else
862 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
863 return ERROR_COMMAND_SYNTAX_ERROR;
864 }
865
866 JIM_CHECK_RETVAL(jim_getopt_string(&goi, &reg_name, NULL));
867 JIM_CHECK_RETVAL(jim_getopt_string(&goi, &field_name, NULL));
868 assert(reg_name);
869 assert(field_name);
870
871 struct command_context * const ctx = current_command_context(interp);
872 assert(ctx);
873 struct target * const target = get_current_target(ctx);
874 if (!target) {
875 Jim_SetResultFormatted(goi.interp, "No current target");
876 return JIM_ERR;
877 }
878
879 retval = arc_reg_get_field(target, reg_name, field_name, &value);
880
881 switch (retval) {
882 case ERROR_OK:
883 break;
884 case ERROR_ARC_REGISTER_NOT_FOUND:
885 Jim_SetResultFormatted(goi.interp,
886 "Register `%s' has not been found.", reg_name);
887 return ERROR_COMMAND_ARGUMENT_INVALID;
888 case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
889 Jim_SetResultFormatted(goi.interp,
890 "Register `%s' must have 'struct' type.", reg_name);
891 return ERROR_COMMAND_ARGUMENT_INVALID;
892 case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
893 Jim_SetResultFormatted(goi.interp,
894 "Field `%s' has not been found in register `%s'.",
895 field_name, reg_name);
896 return ERROR_COMMAND_ARGUMENT_INVALID;
897 case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
898 Jim_SetResultFormatted(goi.interp,
899 "Field `%s' is not a 'bitfield' field in a structure.",
900 field_name);
901 return ERROR_COMMAND_ARGUMENT_INVALID;
902 default:
903 /* Pass through other errors. */
904 return retval;
905 }
906
907 Jim_SetResultInt(interp, value);
908
909 return JIM_OK;
910 }
911
912 COMMAND_HANDLER(arc_l1_cache_disable_auto_cmd)
913 {
914 bool value;
915 int retval = 0;
916 struct arc_common *arc = target_to_arc(get_current_target(CMD_CTX));
917 retval = CALL_COMMAND_HANDLER(handle_command_parse_bool,
918 &value, "target has caches enabled");
919 arc->has_l2cache = value;
920 arc->has_dcache = value;
921 arc->has_icache = value;
922 return retval;
923 }
924
925 COMMAND_HANDLER(arc_l2_cache_disable_auto_cmd)
926 {
927 struct arc_common *arc = target_to_arc(get_current_target(CMD_CTX));
928 return CALL_COMMAND_HANDLER(handle_command_parse_bool,
929 &arc->has_l2cache, "target has l2 cache enabled");
930 }
931
932 static int jim_handle_actionpoints_num(Jim_Interp *interp, int argc,
933 Jim_Obj * const *argv)
934 {
935 struct jim_getopt_info goi;
936 jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
937
938 LOG_DEBUG("-");
939
940 if (goi.argc >= 2) {
941 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "[<unsigned integer>]");
942 return JIM_ERR;
943 }
944
945 struct command_context *context = current_command_context(interp);
946 assert(context);
947
948 struct target *target = get_current_target(context);
949
950 if (!target) {
951 Jim_SetResultFormatted(goi.interp, "No current target");
952 return JIM_ERR;
953 }
954
955 struct arc_common *arc = target_to_arc(target);
956 /* It is not possible to pass &arc->actionpoints_num directly to
957 * handle_command_parse_uint, because this value should be valid during
958 * "actionpoint reset, initiated by arc_set_actionpoints_num. */
959 uint32_t ap_num = arc->actionpoints_num;
960
961 if (goi.argc == 1) {
962 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &ap_num));
963 int e = arc_set_actionpoints_num(target, ap_num);
964 if (e != ERROR_OK) {
965 Jim_SetResultFormatted(goi.interp,
966 "Failed to set number of actionpoints");
967 return JIM_ERR;
968 }
969 }
970
971 Jim_SetResultInt(interp, ap_num);
972
973 return JIM_OK;
974 }
975
976 /* ----- Exported target commands ------------------------------------------ */
977
978 static const struct command_registration arc_l2_cache_group_handlers[] = {
979 {
980 .name = "auto",
981 .handler = arc_l2_cache_disable_auto_cmd,
982 .mode = COMMAND_ANY,
983 .usage = "(1|0)",
984 .help = "Disable or enable L2",
985 },
986 COMMAND_REGISTRATION_DONE
987 };
988
989 static const struct command_registration arc_cache_group_handlers[] = {
990 {
991 .name = "auto",
992 .handler = arc_l1_cache_disable_auto_cmd,
993 .mode = COMMAND_ANY,
994 .help = "Disable or enable L1",
995 .usage = "(1|0)",
996 },
997 {
998 .name = "l2",
999 .mode = COMMAND_ANY,
1000 .help = "L2 cache command group",
1001 .usage = "",
1002 .chain = arc_l2_cache_group_handlers,
1003 },
1004 COMMAND_REGISTRATION_DONE
1005 };
1006
1007
1008 static const struct command_registration arc_core_command_handlers[] = {
1009 {
1010 .name = "add-reg-type-flags",
1011 .jim_handler = jim_arc_add_reg_type_flags,
1012 .mode = COMMAND_CONFIG,
1013 .usage = "-name <string> -flag <name> <position> "
1014 "[-flag <name> <position>]...",
1015 .help = "Add new 'flags' register data type. Only single bit flags "
1016 "are supported. Type name is global. Bitsize of register is fixed "
1017 "at 32 bits.",
1018 },
1019 {
1020 .name = "add-reg-type-struct",
1021 .jim_handler = jim_arc_add_reg_type_struct,
1022 .mode = COMMAND_CONFIG,
1023 .usage = "-name <string> -bitfield <name> <start> <end> "
1024 "[-bitfield <name> <start> <end>]...",
1025 .help = "Add new 'struct' register data type. Only bit-fields are "
1026 "supported so far, which means that for each bitfield start and end "
1027 "position bits must be specified. GDB also support type-fields, "
1028 "where common type can be used instead. Type name is global. Bitsize of "
1029 "register is fixed at 32 bits.",
1030 },
1031 {
1032 .name = "add-reg",
1033 .jim_handler = jim_arc_add_reg,
1034 .mode = COMMAND_CONFIG,
1035 .usage = "-name <string> -num <int> -feature <string> [-gdbnum <int>] "
1036 "[-core|-bcr] [-type <type_name>] [-g]",
1037 .help = "Add new register. Name, architectural number and feature name "
1038 "are required options. GDB regnum will default to previous register "
1039 "(gdbnum + 1) and shouldn't be specified in most cases. Type "
1040 "defaults to default GDB 'int'.",
1041 },
1042 {
1043 .name = "set-reg-exists",
1044 .handler = arc_set_reg_exists,
1045 .mode = COMMAND_ANY,
1046 .usage = "<register-name> [<register-name>]...",
1047 .help = "Set that register exists. Accepts multiple register names as "
1048 "arguments.",
1049 },
1050 {
1051 .name = "get-reg-field",
1052 .jim_handler = jim_arc_get_reg_field,
1053 .mode = COMMAND_ANY,
1054 .usage = "<regname> <field_name>",
1055 .help = "Returns value of field in a register with 'struct' type.",
1056 },
1057 {
1058 .name = "jtag",
1059 .mode = COMMAND_ANY,
1060 .help = "ARC JTAG specific commands",
1061 .usage = "",
1062 .chain = arc_jtag_command_group,
1063 },
1064 {
1065 .name = "cache",
1066 .mode = COMMAND_ANY,
1067 .help = "cache command group",
1068 .usage = "",
1069 .chain = arc_cache_group_handlers,
1070 },
1071 {
1072 .name = "num-actionpoints",
1073 .jim_handler = jim_handle_actionpoints_num,
1074 .mode = COMMAND_ANY,
1075 .usage = "[<unsigned integer>]",
1076 .help = "Prints or sets amount of actionpoints in the processor.",
1077 },
1078 COMMAND_REGISTRATION_DONE
1079 };
1080
1081 const struct command_registration arc_monitor_command_handlers[] = {
1082 {
1083 .name = "arc",
1084 .mode = COMMAND_ANY,
1085 .help = "ARC monitor command group",
1086 .usage = "",
1087 .chain = arc_core_command_handlers,
1088 },
1089 COMMAND_REGISTRATION_DONE
1090 };
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)