?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/xtensa: virtualize XDM registers
[openocd.git] / src / target / arc_cmd.c
blob8c859f2d4d06b6721f3166b8cfe9c0f9c3af00e1
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 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 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 };
Official OpenOCD Mirror