riscv-openocd/src/target/arc_cmd.c

// SPDX-License-Identifier: GPL-2.0-or-later

/***************************************************************************
 *   Copyright (C) 2013-2015,2019-2020 Synopsys, Inc.                      *
 *   Frank Dols <frank.dols@synopsys.com>                                  *
 *   Mischa Jonker <mischa.jonker@synopsys.com>                            *
 *   Anton Kolesov <anton.kolesov@synopsys.com>                            *
 *   Evgeniy Didin <didin@synopsys.com>                                    *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "arc.h"
#include <helper/nvp.h>

/* --------------------------------------------------------------------------
 *
 *   ARC targets expose command interface.
 *   It can be accessed via GDB through the (gdb) monitor command.
 *
 * ------------------------------------------------------------------------- */


enum add_reg_types {
	CFG_ADD_REG_TYPE_FLAG,
	CFG_ADD_REG_TYPE_STRUCT,
};
/* Add flags register data type */
enum add_reg_type_flags {
	CFG_ADD_REG_TYPE_FLAGS_NAME,
	CFG_ADD_REG_TYPE_FLAGS_FLAG,
};

static const struct nvp nvp_add_reg_type_flags_opts[] = {
	{ .name = "-name",  .value = CFG_ADD_REG_TYPE_FLAGS_NAME },
	{ .name = "-flag",  .value = CFG_ADD_REG_TYPE_FLAGS_FLAG },
	{ .name = NULL,     .value = -1 }
};

/* Helper function to check if all field required for register
 * are set up */
static const char *validate_register(const struct arc_reg_desc * const reg, bool arch_num_set)
{
	/* Check that required fields are set */
	if (!reg->name)
		return "-name option is required";
	if (!reg->gdb_xml_feature)
		return "-feature option is required";
	if (!arch_num_set)
		return "-num option is required";
	if (reg->is_bcr && reg->is_core)
		return "Register cannot be both -core and -bcr.";
	return NULL;
}

static COMMAND_HELPER(arc_handle_add_reg_type_flags_ops, struct arc_reg_data_type *type)
{
	struct reg_data_type_flags_field *fields = type->reg_type_flags_field;
	struct arc_reg_bitfield *bitfields = type->bitfields;
	struct reg_data_type_flags *flags = &type->data_type_flags;
	unsigned int cur_field = 0;

	while (CMD_ARGC) {
		const struct nvp *n = nvp_name2value(nvp_add_reg_type_flags_opts, CMD_ARGV[0]);
		CMD_ARGC--;
		CMD_ARGV++;
		switch (n->value) {
		case CFG_ADD_REG_TYPE_FLAGS_NAME:
			if (!CMD_ARGC)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			const char *name = CMD_ARGV[0];
			CMD_ARGC--;
			CMD_ARGV++;

			if (strlen(name) >= REG_TYPE_MAX_NAME_LENGTH) {
				command_print(CMD, "Reg type name is too big.");
				return ERROR_COMMAND_ARGUMENT_INVALID;
			}

			strcpy((void *)type->data_type.id, name);
			break;

		case CFG_ADD_REG_TYPE_FLAGS_FLAG:
			if (CMD_ARGC < 2)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			uint32_t val;
			const char *field_name = CMD_ARGV[0];
			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], val);
			CMD_ARGC -= 2;
			CMD_ARGV += 2;
			bitfields[cur_field].bitfield.start = val;
			bitfields[cur_field].bitfield.end = val;

			if (strlen(field_name) >= REG_TYPE_MAX_NAME_LENGTH) {
				command_print(CMD, "Reg type field_name is too big.");
				return ERROR_COMMAND_ARGUMENT_INVALID;
			}

			fields[cur_field].name = bitfields[cur_field].name;
			strcpy(bitfields[cur_field].name, field_name);

			fields[cur_field].bitfield = &bitfields[cur_field].bitfield;
			if (cur_field > 0)
				fields[cur_field - 1].next = &fields[cur_field];
			else
				flags->fields = fields;

			cur_field += 1;
			break;

		default:
			nvp_unknown_command_print(CMD, nvp_add_reg_type_flags_opts, NULL, CMD_ARGV[-1]);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		}
	}

	if (!type->data_type.id) {
		command_print(CMD, "-name is a required option");
		return ERROR_COMMAND_ARGUMENT_INVALID;
	}

	return ERROR_OK;
}

COMMAND_HANDLER(arc_handle_add_reg_type_flags)
{
	int retval;

	LOG_DEBUG("-");

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	/* Check if the amount of arguments is not zero */
	if (CMD_ARGC == 0)
		return ERROR_COMMAND_SYNTAX_ERROR;

	/* Estimate number of registers as (argc - 2)/3 as each -flag option has 2
	 * arguments while -name is required. */
	unsigned int fields_sz = (CMD_ARGC - 2) / 3;

	/* The maximum amount of bitfields is 32 */
	if (fields_sz > 32) {
		command_print(CMD, "The amount of bitfields exceed 32");
		return ERROR_COMMAND_ARGUMENT_INVALID;
	}

	struct arc_reg_data_type *type = calloc(1, sizeof(*type));
	struct reg_data_type_flags_field *fields = calloc(fields_sz, sizeof(*fields));
	struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
	if (!type || !fields || !bitfields) {
		LOG_ERROR("Out of memory");
		retval = ERROR_FAIL;
		goto fail;
	}
	struct reg_data_type_flags *flags = &type->data_type_flags;
	type->reg_type_flags_field = fields;

	/* Initialize type */
	type->bitfields = bitfields;
	type->data_type.id = type->data_type_id;
	type->data_type.type = REG_TYPE_ARCH_DEFINED;
	type->data_type.type_class = REG_TYPE_CLASS_FLAGS;
	type->data_type.reg_type_flags = flags;
	flags->size = 4; /* For now ARC has only 32-bit registers */

	retval = CALL_COMMAND_HANDLER(arc_handle_add_reg_type_flags_ops, type);
	if (retval != ERROR_OK)
		goto fail;

	arc_reg_data_type_add(target, type);

	LOG_DEBUG("added flags type {name=%s}", type->data_type.id);

	return ERROR_OK;

fail:
	free(type);
	free(fields);
	free(bitfields);

	return retval;
}

/* Add struct register data type */
enum add_reg_type_struct {
	CFG_ADD_REG_TYPE_STRUCT_NAME,
	CFG_ADD_REG_TYPE_STRUCT_BITFIELD,
};

static const struct nvp nvp_add_reg_type_struct_opts[] = {
	{ .name = "-name",     .value = CFG_ADD_REG_TYPE_STRUCT_NAME },
	{ .name = "-bitfield", .value = CFG_ADD_REG_TYPE_STRUCT_BITFIELD },
	{ .name = NULL,     .value = -1 }
};

COMMAND_HANDLER(arc_handle_set_aux_reg)
{
	if (CMD_ARGC != 2)
		return ERROR_COMMAND_SYNTAX_ERROR;

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	/* Register number */
	uint32_t regnum;
	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);

	/* Register value */
	uint32_t value;
	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);

	struct arc_common *arc = target_to_arc(target);
	assert(arc);

	CHECK_RETVAL(arc_jtag_write_aux_reg_one(&arc->jtag_info, regnum, value));

	return ERROR_OK;
}

COMMAND_HANDLER(arc_handle_get_aux_reg)
{
	if (CMD_ARGC != 1)
		return ERROR_COMMAND_SYNTAX_ERROR;

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	/* Register number */
	uint32_t regnum;
	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);

	struct arc_common *arc = target_to_arc(target);
	assert(arc);

	uint32_t value;
	CHECK_RETVAL(arc_jtag_read_aux_reg_one(&arc->jtag_info, regnum, &value));

	command_print(CMD, "0x%" PRIx32, value);

	return ERROR_OK;
}

COMMAND_HANDLER(arc_handle_get_core_reg)
{
	if (CMD_ARGC != 1)
		return ERROR_COMMAND_SYNTAX_ERROR;

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	/* Register number */
	uint32_t regnum;
	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);
	if (regnum > CORE_REG_MAX_NUMBER || regnum == ARC_R61 || regnum == ARC_R62) {
		command_print(CMD, "Core register number %i "
			"is invalid. Must less then 64 and not 61 and 62.", regnum);
		return ERROR_COMMAND_ARGUMENT_INVALID;
	}

	struct arc_common *arc = target_to_arc(target);
	assert(arc);

	/* Read value */
	uint32_t value;
	CHECK_RETVAL(arc_jtag_read_core_reg_one(&arc->jtag_info, regnum, &value));

	command_print(CMD, "0x%" PRIx32, value);

	return ERROR_OK;
}

COMMAND_HANDLER(arc_handle_set_core_reg)
{
	if (CMD_ARGC != 2)
		return ERROR_COMMAND_SYNTAX_ERROR;

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	/* Register number */
	uint32_t regnum;
	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], regnum);
	if (regnum > CORE_REG_MAX_NUMBER || regnum == ARC_R61 || regnum == ARC_R62) {
		command_print(CMD, "Core register number %i "
			"is invalid. Must less then 64 and not 61 and 62.", regnum);
		return ERROR_COMMAND_ARGUMENT_INVALID;
	}

	/* Register value */
	uint32_t value;
	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);

	struct arc_common *arc = target_to_arc(target);
	assert(arc);

	CHECK_RETVAL(arc_jtag_write_core_reg_one(&arc->jtag_info, regnum, value));

	return ERROR_OK;
}

static const struct command_registration arc_jtag_command_group[] = {
	{
		.name = "get-aux-reg",
		.handler = arc_handle_get_aux_reg,
		.mode = COMMAND_EXEC,
		.help = "Get AUX register by number. This command does a "
			"raw JTAG request that bypasses OpenOCD register cache "
			"and thus is unsafe and can have unexpected consequences. "
			"Use at your own risk.",
		.usage = "<regnum>"
	},
	{
		.name = "set-aux-reg",
		.handler = arc_handle_set_aux_reg,
		.mode = COMMAND_EXEC,
		.help = "Set AUX register by number. This command does a "
			"raw JTAG request that bypasses OpenOCD register cache "
			"and thus is unsafe and can have unexpected consequences. "
			"Use at your own risk.",
		.usage = "<regnum> <value>"
	},
	{
		.name = "get-core-reg",
		.handler = arc_handle_get_core_reg,
		.mode = COMMAND_EXEC,
		.help = "Get/Set core register by number. This command does a "
			"raw JTAG request that bypasses OpenOCD register cache "
			"and thus is unsafe and can have unexpected consequences. "
			"Use at your own risk.",
		.usage = "<regnum> [<value>]"
	},
	{
		.name = "set-core-reg",
		.handler = arc_handle_set_core_reg,
		.mode = COMMAND_EXEC,
		.help = "Get/Set core register by number. This command does a "
			"raw JTAG request that bypasses OpenOCD register cache "
			"and thus is unsafe and can have unexpected consequences. "
			"Use at your own risk.",
		.usage = "<regnum> [<value>]"
	},
	COMMAND_REGISTRATION_DONE
};


/* This function supports only bitfields. */
static COMMAND_HELPER(arc_handle_add_reg_type_struct_opts, struct arc_reg_data_type *type)
{
	struct reg_data_type_struct_field *fields = type->reg_type_struct_field;
	struct arc_reg_bitfield *bitfields = type->bitfields;
	struct reg_data_type_struct *struct_type = &type->data_type_struct;
	unsigned int cur_field = 0;

	while (CMD_ARGC) {
		const struct nvp *n = nvp_name2value(nvp_add_reg_type_struct_opts, CMD_ARGV[0]);
		CMD_ARGC--;
		CMD_ARGV++;
		switch (n->value) {
		case CFG_ADD_REG_TYPE_STRUCT_NAME:
			if (!CMD_ARGC)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			const char *name = CMD_ARGV[0];
			CMD_ARGC--;
			CMD_ARGV++;

			if (strlen(name) >= REG_TYPE_MAX_NAME_LENGTH) {
				command_print(CMD, "Reg type name is too big.");
				return ERROR_COMMAND_ARGUMENT_INVALID;
			}

			strcpy((void *)type->data_type.id, name);
			break;

		case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
			if (CMD_ARGC < 3)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			uint32_t start_pos, end_pos;
			const char *field_name = CMD_ARGV[0];
			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], start_pos);
			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], end_pos);
			CMD_ARGC -= 3;
			CMD_ARGV += 3;
			bitfields[cur_field].bitfield.start = start_pos;
			bitfields[cur_field].bitfield.end = end_pos;
			bitfields[cur_field].bitfield.type = REG_TYPE_INT;

			if (strlen(field_name) >= REG_TYPE_MAX_NAME_LENGTH) {
				command_print(CMD, "Reg type field_name is too big.");
				return ERROR_COMMAND_ARGUMENT_INVALID;
			}

			fields[cur_field].name = bitfields[cur_field].name;
			strcpy(bitfields[cur_field].name, field_name);

			fields[cur_field].bitfield = &bitfields[cur_field].bitfield;
			fields[cur_field].use_bitfields = true;
			if (cur_field > 0)
				fields[cur_field - 1].next = &fields[cur_field];
			else
				struct_type->fields = fields;

			cur_field += 1;

			break;

		default:
			nvp_unknown_command_print(CMD, nvp_add_reg_type_struct_opts, NULL, CMD_ARGV[-1]);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		}
	}

	if (!type->data_type.id) {
		command_print(CMD, "-name is a required option");
		return ERROR_COMMAND_ARGUMENT_INVALID;
	}

	return ERROR_OK;
}

COMMAND_HANDLER(arc_handle_add_reg_type_struct)
{
	int retval;

	LOG_DEBUG("-");

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	/* Check if the amount of arguments is not zero */
	if (CMD_ARGC == 0)
		return ERROR_COMMAND_SYNTAX_ERROR;

	/* Estimate number of registers as (argc - 2)/4 as each -bitfield option has 3
	 * arguments while -name is required. */
	unsigned int fields_sz = (CMD_ARGC - 2) / 4;

	/* The maximum amount of bitfields is 32 */
	if (fields_sz > 32) {
		command_print(CMD, "The amount of bitfields exceed 32");
		return ERROR_COMMAND_ARGUMENT_INVALID;
	}

	struct arc_reg_data_type *type = calloc(1, sizeof(*type));
	struct reg_data_type_struct_field *fields = calloc(fields_sz, sizeof(*fields));
	struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
	if (!type || !fields || !bitfields) {
		LOG_ERROR("Out of memory");
		retval = ERROR_FAIL;
		goto fail;
	}
	struct reg_data_type_struct *struct_type = &type->data_type_struct;
	type->reg_type_struct_field = fields;

	/* Initialize type */
	type->data_type.id = type->data_type_id;
	type->bitfields = bitfields;
	type->data_type.type = REG_TYPE_ARCH_DEFINED;
	type->data_type.type_class = REG_TYPE_CLASS_STRUCT;
	type->data_type.reg_type_struct = struct_type;
	struct_type->size = 4; /* For now ARC has only 32-bit registers */

	retval = CALL_COMMAND_HANDLER(arc_handle_add_reg_type_struct_opts, type);
	if (retval != ERROR_OK)
		goto fail;

	arc_reg_data_type_add(target, type);

	LOG_DEBUG("added struct type {name=%s}", type->data_type.id);

	return ERROR_OK;

fail:
	free(type);
	free(fields);
	free(bitfields);

	return retval;
}

/* Add register */
enum opts_add_reg {
	CFG_ADD_REG_NAME,
	CFG_ADD_REG_ARCH_NUM,
	CFG_ADD_REG_IS_CORE,
	CFG_ADD_REG_IS_BCR,
	CFG_ADD_REG_GDB_FEATURE,
	CFG_ADD_REG_TYPE,
	CFG_ADD_REG_GENERAL,
};

static const struct nvp opts_nvp_add_reg[] = {
	{ .name = "-name",    .value = CFG_ADD_REG_NAME },
	{ .name = "-num",     .value = CFG_ADD_REG_ARCH_NUM },
	{ .name = "-core",    .value = CFG_ADD_REG_IS_CORE },
	{ .name = "-bcr",     .value = CFG_ADD_REG_IS_BCR },
	{ .name = "-feature", .value = CFG_ADD_REG_GDB_FEATURE },
	{ .name = "-type",    .value = CFG_ADD_REG_TYPE },
	{ .name = "-g",       .value = CFG_ADD_REG_GENERAL },
	{ .name = NULL,       .value = -1 }
};

void free_reg_desc(struct arc_reg_desc *r)
{
	free(r->name);
	free(r->gdb_xml_feature);
	free(r);
}

static COMMAND_HELPER(arc_handle_add_reg_do, struct arc_reg_desc *reg)
{
	/* There is no architecture number that we could treat as invalid, so
	 * separate variable required to ensure that arch num has been set. */
	bool arch_num_set = false;
	const char *type_name = "int"; /* Default type */

	/* At least we need to specify 4 parameters: name, number and gdb_feature,
	 * which means there should be 6 arguments. Also there can be additional parameters
	 * "-type <type>", "-g" and  "-core" or "-bcr" which makes maximum 10 parameters. */
	if (CMD_ARGC < 6 || CMD_ARGC > 10)
		return ERROR_COMMAND_SYNTAX_ERROR;

	/* Parse options. */
	while (CMD_ARGC) {
		const struct nvp *n = nvp_name2value(opts_nvp_add_reg, CMD_ARGV[0]);
		CMD_ARGC--;
		CMD_ARGV++;
		switch (n->value) {
		case CFG_ADD_REG_NAME:
			if (!CMD_ARGC)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			reg->name = strdup(CMD_ARGV[0]);
			if (!reg->name) {
				LOG_ERROR("Out of memory");
				return ERROR_FAIL;
			}

			CMD_ARGC--;
			CMD_ARGV++;
			break;

		case CFG_ADD_REG_IS_CORE:
			reg->is_core = true;
			break;

		case CFG_ADD_REG_IS_BCR:
			reg->is_bcr = true;
			break;

		case CFG_ADD_REG_ARCH_NUM:
			if (!CMD_ARGC)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], reg->arch_num);
			CMD_ARGC--;
			CMD_ARGV++;

			arch_num_set = true;
			break;

		case CFG_ADD_REG_GDB_FEATURE:
			if (!CMD_ARGC)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			reg->gdb_xml_feature = strdup(CMD_ARGV[0]);
			if (!reg->gdb_xml_feature) {
				LOG_ERROR("Out of memory");
				return ERROR_FAIL;
			}

			CMD_ARGC--;
			CMD_ARGV++;
			break;

		case CFG_ADD_REG_TYPE:
			if (!CMD_ARGC)
				return ERROR_COMMAND_ARGUMENT_INVALID;

			type_name = CMD_ARGV[0];
			CMD_ARGC--;
			CMD_ARGV++;
			break;

		case CFG_ADD_REG_GENERAL:
			reg->is_general = true;
			break;

		default:
			nvp_unknown_command_print(CMD, opts_nvp_add_reg, NULL, CMD_ARGV[-1]);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		}
	}

	/* Check that required fields are set */
	const char * const errmsg = validate_register(reg, arch_num_set);
	if (errmsg) {
		command_print(CMD, "%s", errmsg);
		return ERROR_COMMAND_ARGUMENT_INVALID;
	}

	/* Add new register */
	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	reg->target = target;

	int retval = arc_reg_add(target, reg, type_name, strlen(type_name));
	if (retval == ERROR_ARC_REGTYPE_NOT_FOUND) {
		command_print(CMD,
			"Cannot find type `%s' for register `%s'.",
			type_name, reg->name);
		return retval;
	}

	return ERROR_OK;
}

COMMAND_HANDLER(arc_handle_add_reg)
{
	struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
	if (!reg) {
		LOG_ERROR("Out of memory");
		return ERROR_FAIL;
	}

	int retval = CALL_COMMAND_HANDLER(arc_handle_add_reg_do, reg);
	if (retval != ERROR_OK) {
		free_reg_desc(reg);
		return retval;
	}

	return ERROR_OK;
}

/* arc set-reg-exists ($reg_name)+
 * Accepts any amount of register names - will set them as existing in a loop.*/
COMMAND_HANDLER(arc_set_reg_exists)
{
	struct target * const target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "Unable to get current target.");
		return ERROR_FAIL;
	}

	if (!CMD_ARGC) {
		command_print(CMD, "At least one register name must be specified.");
		return ERROR_COMMAND_SYNTAX_ERROR;
	}

	for (unsigned int i = 0; i < CMD_ARGC; i++) {
		const char * const reg_name = CMD_ARGV[i];
		struct reg * const r = arc_reg_get_by_name(target->reg_cache, reg_name, true);

		if (!r) {
			command_print(CMD, "Register `%s' is not found.", reg_name);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		}

		r->exist = true;
	}

	return ERROR_OK;
}

/* arc reg-field  ($reg_name) ($reg_field)
 * Reads struct type register field */
COMMAND_HANDLER(arc_handle_get_reg_field)
{
	if (CMD_ARGC != 2)
		return ERROR_COMMAND_SYNTAX_ERROR;

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	const char *reg_name = CMD_ARGV[0];
	const char *field_name = CMD_ARGV[1];
	uint32_t value;
	int retval = arc_reg_get_field(target, reg_name, field_name, &value);

	switch (retval) {
		case ERROR_OK:
			break;
		case ERROR_ARC_REGISTER_NOT_FOUND:
			command_print(CMD,
				"Register `%s' has not been found.", reg_name);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
			command_print(CMD,
				"Register `%s' must have 'struct' type.", reg_name);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
			command_print(CMD,
				"Field `%s' has not been found in register `%s'.",
				field_name, reg_name);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
			command_print(CMD,
				"Field `%s' is not a 'bitfield' field in a structure.",
				field_name);
			return ERROR_COMMAND_ARGUMENT_INVALID;
		default:
			/* Pass through other errors. */
			return retval;
	}

	command_print(CMD, "0x%" PRIx32, value);

	return ERROR_OK;
}

COMMAND_HANDLER(arc_l1_cache_disable_auto_cmd)
{
	bool value;
	int retval = 0;
	struct arc_common *arc = target_to_arc(get_current_target(CMD_CTX));
	retval = CALL_COMMAND_HANDLER(handle_command_parse_bool,
		&value, "target has caches enabled");
	arc->has_l2cache = value;
	arc->has_dcache = value;
	arc->has_icache = value;
	return retval;
}

COMMAND_HANDLER(arc_l2_cache_disable_auto_cmd)
{
	struct arc_common *arc = target_to_arc(get_current_target(CMD_CTX));
	return CALL_COMMAND_HANDLER(handle_command_parse_bool,
		&arc->has_l2cache, "target has l2 cache enabled");
}

COMMAND_HANDLER(arc_handle_actionpoints_num)
{
	LOG_DEBUG("-");

	if (CMD_ARGC >= 2)
		return ERROR_COMMAND_SYNTAX_ERROR;

	struct target *target = get_current_target(CMD_CTX);
	if (!target) {
		command_print(CMD, "No current target");
		return ERROR_FAIL;
	}

	struct arc_common *arc = target_to_arc(target);
	/* It is not possible to pass &arc->actionpoints_num directly to
	 * handle_command_parse_uint, because this value should be valid during
	 * "actionpoint reset, initiated by arc_set_actionpoints_num.  */
	uint32_t ap_num = arc->actionpoints_num;

	if (CMD_ARGC == 1) {
		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], ap_num);
		int e = arc_set_actionpoints_num(target, ap_num);
		if (e != ERROR_OK) {
			command_print(CMD,
				"Failed to set number of actionpoints");
			return e;
		}
	}

	command_print(CMD, "%" PRIu32, ap_num);

	return ERROR_OK;
}

/* ----- Exported target commands ------------------------------------------ */

static const struct command_registration arc_l2_cache_group_handlers[] = {
	{
		.name = "auto",
		.handler = arc_l2_cache_disable_auto_cmd,
		.mode = COMMAND_ANY,
		.usage = "(1|0)",
		.help = "Disable or enable L2",
	},
	COMMAND_REGISTRATION_DONE
};

static const struct command_registration arc_cache_group_handlers[] = {
	{
		.name = "auto",
		.handler = arc_l1_cache_disable_auto_cmd,
		.mode = COMMAND_ANY,
		.help = "Disable or enable L1",
		.usage = "(1|0)",
	},
	{
		.name = "l2",
		.mode = COMMAND_ANY,
		.help = "L2 cache command group",
		.usage = "",
		.chain = arc_l2_cache_group_handlers,
	},
	COMMAND_REGISTRATION_DONE
};


static const struct command_registration arc_core_command_handlers[] = {
	{
		.name = "add-reg-type-flags",
		.handler = arc_handle_add_reg_type_flags,
		.mode = COMMAND_CONFIG,
		.usage = "-name <string> -flag <name> <position> "
			"[-flag <name> <position>]...",
		.help = "Add new 'flags' register data type. Only single bit flags "
			"are supported. Type name is global. Bitsize of register is fixed "
			"at 32 bits.",
	},
	{
		.name = "add-reg-type-struct",
		.handler = arc_handle_add_reg_type_struct,
		.mode = COMMAND_CONFIG,
		.usage = "-name <string> -bitfield <name> <start> <end> "
			"[-bitfield <name> <start> <end>]...",
		.help = "Add new 'struct' register data type. Only bit-fields are "
			"supported so far, which means that for each bitfield start and end "
			"position bits must be specified. GDB also support type-fields, "
			"where common type can be used instead. Type name is global. Bitsize of "
			"register is fixed at 32 bits.",
	},
	{
		.name = "add-reg",
		.handler = arc_handle_add_reg,
		.mode = COMMAND_CONFIG,
		.usage = "-name <string> -num <int> -feature <string> [-gdbnum <int>] "
			"[-core|-bcr] [-type <type_name>] [-g]",
		.help = "Add new register. Name, architectural number and feature name "
			"are required options. GDB regnum will default to previous register "
			"(gdbnum + 1) and shouldn't be specified in most cases. Type "
			"defaults to default GDB 'int'.",
	},
	{
		.name = "set-reg-exists",
		.handler = arc_set_reg_exists,
		.mode = COMMAND_ANY,
		.usage = "<register-name> [<register-name>]...",
		.help = "Set that register exists. Accepts multiple register names as "
			"arguments.",
	},
	{
		.name = "get-reg-field",
		.handler = arc_handle_get_reg_field,
		.mode = COMMAND_ANY,
		.usage = "<regname> <field_name>",
		.help = "Returns value of field in a register with 'struct' type.",
	},
	{
		.name = "jtag",
		.mode = COMMAND_ANY,
		.help = "ARC JTAG specific commands",
		.usage = "",
		.chain = arc_jtag_command_group,
	},
	{
		.name = "cache",
		.mode = COMMAND_ANY,
		.help = "cache command group",
		.usage = "",
		.chain = arc_cache_group_handlers,
	},
	{
		.name = "num-actionpoints",
		.handler = arc_handle_actionpoints_num,
		.mode = COMMAND_ANY,
		.usage = "[<unsigned integer>]",
		.help = "Prints or sets amount of actionpoints in the processor.",
	},
	COMMAND_REGISTRATION_DONE
};

const struct command_registration arc_monitor_command_handlers[] = {
	{
		.name = "arc",
		.mode = COMMAND_ANY,
		.help = "ARC monitor command group",
		.usage = "",
		.chain = arc_core_command_handlers,
	},
	COMMAND_REGISTRATION_DONE
};