X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Farm_adi_v5.c;h=ad4d7a7254416d0d9c87c466ad55c18e7b3ab703;hb=b987a419b41f9f2c6e0aaf0ca2ff4b6c347ae7d8;hp=7dd523ef03ae976ad8f708ea244e0e9fdc7433f3;hpb=35a503b08d145edbd81519f9471b480292062bb5;p=openocd.git

diff --git a/src/target/arm_adi_v5.c b/src/target/arm_adi_v5.c
index 7dd523ef03..ad4d7a7254 100644
--- a/src/target/arm_adi_v5.c
+++ b/src/target/arm_adi_v5.c
@@ -107,7 +107,7 @@ static int mem_ap_setup_csw(struct adiv5_ap *ap, uint32_t csw)
 
 	if (csw != ap->csw_value) {
 		/* LOG_DEBUG("DAP: Set CSW %x",csw); */
-		int retval = dap_queue_ap_write(ap, MEM_AP_REG_CSW, csw);
+		int retval = dap_queue_ap_write(ap, MEM_AP_REG_CSW(ap->dap), csw);
 		if (retval != ERROR_OK) {
 			ap->csw_value = 0;
 			return retval;
@@ -121,11 +121,11 @@ static int mem_ap_setup_tar(struct adiv5_ap *ap, target_addr_t tar)
 {
 	if (!ap->tar_valid || tar != ap->tar_value) {
 		/* LOG_DEBUG("DAP: Set TAR %x",tar); */
-		int retval = dap_queue_ap_write(ap, MEM_AP_REG_TAR, (uint32_t)(tar & 0xffffffffUL));
+		int retval = dap_queue_ap_write(ap, MEM_AP_REG_TAR(ap->dap), (uint32_t)(tar & 0xffffffffUL));
 		if (retval == ERROR_OK && is_64bit_ap(ap)) {
 			/* See if bits 63:32 of tar is different from last setting */
 			if ((ap->tar_value >> 32) != (tar >> 32))
-				retval = dap_queue_ap_write(ap, MEM_AP_REG_TAR64, (uint32_t)(tar >> 32));
+				retval = dap_queue_ap_write(ap, MEM_AP_REG_TAR64(ap->dap), (uint32_t)(tar >> 32));
 		}
 		if (retval != ERROR_OK) {
 			ap->tar_valid = false;
@@ -142,9 +142,9 @@ static int mem_ap_read_tar(struct adiv5_ap *ap, target_addr_t *tar)
 	uint32_t lower;
 	uint32_t upper = 0;
 
-	int retval = dap_queue_ap_read(ap, MEM_AP_REG_TAR, &lower);
+	int retval = dap_queue_ap_read(ap, MEM_AP_REG_TAR(ap->dap), &lower);
 	if (retval == ERROR_OK && is_64bit_ap(ap))
-		retval = dap_queue_ap_read(ap, MEM_AP_REG_TAR64, &upper);
+		retval = dap_queue_ap_read(ap, MEM_AP_REG_TAR64(ap->dap), &upper);
 
 	if (retval != ERROR_OK) {
 		ap->tar_valid = false;
@@ -252,7 +252,7 @@ int mem_ap_read_u32(struct adiv5_ap *ap, target_addr_t address,
 	if (retval != ERROR_OK)
 		return retval;
 
-	return dap_queue_ap_read(ap, MEM_AP_REG_BD0 | (address & 0xC), value);
+	return dap_queue_ap_read(ap, MEM_AP_REG_BD0(ap->dap) | (address & 0xC), value);
 }
 
 /**
@@ -304,7 +304,7 @@ int mem_ap_write_u32(struct adiv5_ap *ap, target_addr_t address,
 	if (retval != ERROR_OK)
 		return retval;
 
-	return dap_queue_ap_write(ap, MEM_AP_REG_BD0 | (address & 0xC),
+	return dap_queue_ap_write(ap, MEM_AP_REG_BD0(ap->dap) | (address & 0xC),
 			value);
 }
 
@@ -436,7 +436,7 @@ static int mem_ap_write(struct adiv5_ap *ap, const uint8_t *buffer, uint32_t siz
 
 		nbytes -= this_size;
 
-		retval = dap_queue_ap_write(ap, MEM_AP_REG_DRW, outvalue);
+		retval = dap_queue_ap_write(ap, MEM_AP_REG_DRW(dap), outvalue);
 		if (retval != ERROR_OK)
 			break;
 
@@ -533,7 +533,7 @@ static int mem_ap_read(struct adiv5_ap *ap, uint8_t *buffer, uint32_t size, uint
 		if (retval != ERROR_OK)
 			break;
 
-		retval = dap_queue_ap_read(ap, MEM_AP_REG_DRW, read_ptr++);
+		retval = dap_queue_ap_read(ap, MEM_AP_REG_DRW(dap), read_ptr++);
 		if (retval != ERROR_OK)
 			break;
 
@@ -780,7 +780,7 @@ int mem_ap_init(struct adiv5_ap *ap)
 
 	/* Set ap->cfg_reg before calling mem_ap_setup_transfer(). */
 	/* mem_ap_setup_transfer() needs to know if the MEM_AP supports LPAE. */
-	retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG, &cfg);
+	retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG(dap), &cfg);
 	if (retval != ERROR_OK)
 		return retval;
 
@@ -795,7 +795,7 @@ int mem_ap_init(struct adiv5_ap *ap)
 	if (retval != ERROR_OK)
 		return retval;
 
-	retval = dap_queue_ap_read(ap, MEM_AP_REG_CSW, &csw);
+	retval = dap_queue_ap_read(ap, MEM_AP_REG_CSW(dap), &csw);
 	if (retval != ERROR_OK)
 		return retval;
 
@@ -966,16 +966,45 @@ static const char *ap_type_to_description(enum ap_type type)
 	return "Unknown";
 }
 
+bool is_ap_num_valid(struct adiv5_dap *dap, uint64_t ap_num)
+{
+	if (!dap)
+		return false;
+
+	/* no autodetection, by now, so uninitialized is equivalent to ADIv5 for
+	 * backward compatibility */
+	if (!is_adiv6(dap)) {
+		if (ap_num > DP_APSEL_MAX)
+			return false;
+		return true;
+	}
+
+	if (is_adiv6(dap)) {
+		if (ap_num & 0x0fffULL)
+			return false;
+		if (dap->asize != 0)
+			if (ap_num & ((~0ULL) << dap->asize))
+				return false;
+		return true;
+	}
+
+	return false;
+}
+
 /*
  * This function checks the ID for each access port to find the requested Access Port type
  * It also calls dap_get_ap() to increment the AP refcount
  */
 int dap_find_get_ap(struct adiv5_dap *dap, enum ap_type type_to_find, struct adiv5_ap **ap_out)
 {
-	int ap_num;
+	if (is_adiv6(dap)) {
+		/* TODO: scan the ROM table and detect the AP available */
+		LOG_DEBUG("On ADIv6 we cannot scan all the possible AP");
+		return ERROR_FAIL;
+	}
 
 	/* Maximum AP number is 255 since the SELECT register is 8 bits */
-	for (ap_num = 0; ap_num <= DP_APSEL_MAX; ap_num++) {
+	for (unsigned int ap_num = 0; ap_num <= DP_APSEL_MAX; ap_num++) {
 		struct adiv5_ap *ap = dap_get_ap(dap, ap_num);
 		if (!ap)
 			continue;
@@ -983,7 +1012,7 @@ int dap_find_get_ap(struct adiv5_dap *dap, enum ap_type type_to_find, struct adi
 		/* read the IDR register of the Access Port */
 		uint32_t id_val = 0;
 
-		int retval = dap_queue_ap_read(ap, AP_REG_IDR, &id_val);
+		int retval = dap_queue_ap_read(ap, AP_REG_IDR(dap), &id_val);
 		if (retval != ERROR_OK) {
 			dap_put_ap(ap);
 			return retval;
@@ -1014,33 +1043,55 @@ static inline bool is_ap_in_use(struct adiv5_ap *ap)
 	return ap->refcount > 0 || ap->config_ap_never_release;
 }
 
-static struct adiv5_ap *_dap_get_ap(struct adiv5_dap *dap, unsigned int ap_num)
+static struct adiv5_ap *_dap_get_ap(struct adiv5_dap *dap, uint64_t ap_num)
 {
-	if (ap_num > DP_APSEL_MAX) {
-		LOG_ERROR("Invalid AP#%u", ap_num);
+	if (!is_ap_num_valid(dap, ap_num)) {
+		LOG_ERROR("Invalid AP#0x%" PRIx64, ap_num);
+		return NULL;
+	}
+	if (is_adiv6(dap)) {
+		for (unsigned int i = 0; i <= DP_APSEL_MAX; i++) {
+			struct adiv5_ap *ap = &dap->ap[i];
+			if (is_ap_in_use(ap) && ap->ap_num == ap_num) {
+				++ap->refcount;
+				return ap;
+			}
+		}
+		for (unsigned int i = 0; i <= DP_APSEL_MAX; i++) {
+			struct adiv5_ap *ap = &dap->ap[i];
+			if (!is_ap_in_use(ap)) {
+				ap->ap_num = ap_num;
+				++ap->refcount;
+				return ap;
+			}
+		}
+		LOG_ERROR("No more AP available!");
 		return NULL;
 	}
+
+	/* ADIv5 */
 	struct adiv5_ap *ap = &dap->ap[ap_num];
+	ap->ap_num = ap_num;
 	++ap->refcount;
 	return ap;
 }
 
 /* Return AP with specified ap_num. Increment AP refcount */
-struct adiv5_ap *dap_get_ap(struct adiv5_dap *dap, unsigned int ap_num)
+struct adiv5_ap *dap_get_ap(struct adiv5_dap *dap, uint64_t ap_num)
 {
 	struct adiv5_ap *ap = _dap_get_ap(dap, ap_num);
 	if (ap)
-		LOG_DEBUG("refcount AP#%u get %u", ap_num, ap->refcount);
+		LOG_DEBUG("refcount AP#0x%" PRIx64 " get %u", ap_num, ap->refcount);
 	return ap;
 }
 
 /* Return AP with specified ap_num. Increment AP refcount and keep it non-zero */
-struct adiv5_ap *dap_get_config_ap(struct adiv5_dap *dap, unsigned int ap_num)
+struct adiv5_ap *dap_get_config_ap(struct adiv5_dap *dap, uint64_t ap_num)
 {
 	struct adiv5_ap *ap = _dap_get_ap(dap, ap_num);
 	if (ap) {
 		ap->config_ap_never_release = true;
-		LOG_DEBUG("refcount AP#%u get_config %u", ap_num, ap->refcount);
+		LOG_DEBUG("refcount AP#0x%" PRIx64 " get_config %u", ap_num, ap->refcount);
 	}
 	return ap;
 }
@@ -1049,15 +1100,16 @@ struct adiv5_ap *dap_get_config_ap(struct adiv5_dap *dap, unsigned int ap_num)
 int dap_put_ap(struct adiv5_ap *ap)
 {
 	if (ap->refcount == 0) {
-		LOG_ERROR("BUG: refcount AP#%" PRIu8 " put underflow", ap->ap_num);
+		LOG_ERROR("BUG: refcount AP#0x%" PRIx64 " put underflow", ap->ap_num);
 		return ERROR_FAIL;
 	}
 
 	--ap->refcount;
 
-	LOG_DEBUG("refcount AP#%" PRIu8 " put %u", ap->ap_num, ap->refcount);
+	LOG_DEBUG("refcount AP#0x%" PRIx64 " put %u", ap->ap_num, ap->refcount);
 	if (!is_ap_in_use(ap)) {
 		/* defaults from dap_instance_init() */
+		ap->ap_num = DP_APSEL_INVALID;
 		ap->memaccess_tck = 255;
 		ap->tar_autoincr_block = (1 << 10);
 		ap->csw_default = CSW_AHB_DEFAULT;
@@ -1074,19 +1126,19 @@ static int dap_get_debugbase(struct adiv5_ap *ap,
 	uint32_t baseptr_upper, baseptr_lower;
 
 	if (ap->cfg_reg == MEM_AP_REG_CFG_INVALID) {
-		retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG, &ap->cfg_reg);
+		retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG(dap), &ap->cfg_reg);
 		if (retval != ERROR_OK)
 			return retval;
 	}
-	retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE, &baseptr_lower);
+	retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE(dap), &baseptr_lower);
 	if (retval != ERROR_OK)
 		return retval;
-	retval = dap_queue_ap_read(ap, AP_REG_IDR, apid);
+	retval = dap_queue_ap_read(ap, AP_REG_IDR(dap), apid);
 	if (retval != ERROR_OK)
 		return retval;
 	/* MEM_AP_REG_BASE64 is defined as 'RES0'; can be read and then ignored on 32 bits AP */
 	if (ap->cfg_reg == MEM_AP_REG_CFG_INVALID || is_64bit_ap(ap)) {
-		retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64, &baseptr_upper);
+		retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64(dap), &baseptr_upper);
 		if (retval != ERROR_OK)
 			return retval;
 	}
@@ -1102,6 +1154,32 @@ static int dap_get_debugbase(struct adiv5_ap *ap,
 	return ERROR_OK;
 }
 
+int adiv6_dap_read_baseptr(struct command_invocation *cmd, struct adiv5_dap *dap, uint64_t *baseptr)
+{
+	uint32_t baseptr_lower, baseptr_upper = 0;
+	int retval;
+
+	if (dap->asize > 32) {
+		retval = dap_queue_dp_read(dap, DP_BASEPTR1, &baseptr_upper);
+		if (retval != ERROR_OK)
+			return retval;
+	}
+
+	retval = dap_dp_read_atomic(dap, DP_BASEPTR0, &baseptr_lower);
+	if (retval != ERROR_OK)
+		return retval;
+
+	if ((baseptr_lower & DP_BASEPTR0_VALID) != DP_BASEPTR0_VALID) {
+		command_print(cmd, "System root table not present");
+		return ERROR_FAIL;
+	}
+
+	baseptr_lower &= ~0x0fff;
+	*baseptr = (((uint64_t)baseptr_upper) << 32) | baseptr_lower;
+
+	return ERROR_OK;
+}
+
 /** Holds registers and coordinates of a CoreSight component */
 struct cs_component_vals {
 	struct adiv5_ap *ap;
@@ -1500,11 +1578,12 @@ struct rtp_ops {
 	 * @param ap        Pointer to AP.
 	 * @param dbgbase   Value of MEM-AP Debug Base Address register.
 	 * @param apid      Value of MEM-AP IDR Identification Register.
+	 * @param depth     The current depth level of ROM table.
 	 * @param priv      Pointer to private data.
 	 * @return          ERROR_OK on success, else a fault code.
 	 */
 	int (*mem_ap_header)(int retval, struct adiv5_ap *ap, uint64_t dbgbase,
-			uint32_t apid, void *priv);
+			uint32_t apid, int depth, void *priv);
 	/**
 	 * Executed when a CoreSight component is parsed, typically to print
 	 * information on the component.
@@ -1538,12 +1617,12 @@ struct rtp_ops {
  * Input parameter @a retval is propagated.
  */
 static int rtp_ops_mem_ap_header(const struct rtp_ops *ops,
-		int retval, struct adiv5_ap *ap, uint64_t dbgbase, uint32_t apid)
+		int retval, struct adiv5_ap *ap, uint64_t dbgbase, uint32_t apid, int depth)
 {
 	if (!ops->mem_ap_header)
 		return retval;
 
-	int retval1 = ops->mem_ap_header(retval, ap, dbgbase, apid, ops->priv);
+	int retval1 = ops->mem_ap_header(retval, ap, dbgbase, apid, depth, ops->priv);
 	if (retval != ERROR_OK)
 		return retval;
 	return retval1;
@@ -1703,7 +1782,7 @@ static int rtp_cs_component(const struct rtp_ops *ops,
 	return ERROR_OK;
 }
 
-static int rtp_ap(const struct rtp_ops *ops, struct adiv5_ap *ap)
+static int rtp_ap(const struct rtp_ops *ops, struct adiv5_ap *ap, int depth)
 {
 	int retval;
 	uint32_t apid;
@@ -1713,7 +1792,7 @@ static int rtp_ap(const struct rtp_ops *ops, struct adiv5_ap *ap)
 	retval = dap_get_debugbase(ap, &dbgbase, &apid);
 	if (retval != ERROR_OK)
 		return retval;
-	retval = rtp_ops_mem_ap_header(ops, retval, ap, dbgbase, apid);
+	retval = rtp_ops_mem_ap_header(ops, retval, ap, dbgbase, apid, depth);
 	if (retval != ERROR_OK)
 		return retval;
 
@@ -1732,7 +1811,7 @@ static int rtp_ap(const struct rtp_ops *ops, struct adiv5_ap *ap)
 			invalid_entry = 0xFFFFFFFFul;
 
 		if (dbgbase != invalid_entry && (dbgbase & 0x3) != 0x2) {
-			retval = rtp_cs_component(ops, ap, dbgbase & 0xFFFFFFFFFFFFF000ull, 0);
+			retval = rtp_cs_component(ops, ap, dbgbase & 0xFFFFFFFFFFFFF000ull, depth);
 			if (retval == CORESIGHT_COMPONENT_FOUND)
 				return CORESIGHT_COMPONENT_FOUND;
 		}
@@ -1744,23 +1823,34 @@ static int rtp_ap(const struct rtp_ops *ops, struct adiv5_ap *ap)
 /* Actions for command "dap info" */
 
 static int dap_info_mem_ap_header(int retval, struct adiv5_ap *ap,
-		target_addr_t dbgbase, uint32_t apid, void *priv)
+		target_addr_t dbgbase, uint32_t apid, int depth, void *priv)
 {
 	struct command_invocation *cmd = priv;
 	target_addr_t invalid_entry;
+	char tabs[17] = "";
 
 	if (retval != ERROR_OK) {
 		command_print(cmd, "\t\tCan't read MEM-AP, the corresponding core might be turned off");
 		return retval;
 	}
 
-	command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid);
+	if (depth > ROM_TABLE_MAX_DEPTH) {
+		command_print(cmd, "\tTables too deep");
+		return ERROR_FAIL;
+	}
+
+	if (depth)
+		snprintf(tabs, sizeof(tabs), "\t[L%02d] ", depth);
+
+	command_print(cmd, "%sAP # 0x%" PRIx64, tabs, ap->ap_num);
+
+	command_print(cmd, "\t\tAP ID register 0x%8.8" PRIx32, apid);
 	if (apid == 0) {
-		command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num);
+		command_print(cmd, "\t\tNo AP found at this AP#0x%" PRIx64, ap->ap_num);
 		return ERROR_FAIL;
 	}
 
-	command_print(cmd, "\tType is %s", ap_type_to_description(apid & AP_TYPE_MASK));
+	command_print(cmd, "\t\tType is %s", ap_type_to_description(apid & AP_TYPE_MASK));
 
 	/* NOTE: a MEM-AP may have a single CoreSight component that's
 	 * not a ROM table ... or have no such components at all.
@@ -1773,15 +1863,15 @@ static int dap_info_mem_ap_header(int retval, struct adiv5_ap *ap,
 		else
 			invalid_entry = 0xFFFFFFFFul;
 
-		command_print(cmd, "MEM-AP BASE " TARGET_ADDR_FMT, dbgbase);
+		command_print(cmd, "%sMEM-AP BASE " TARGET_ADDR_FMT, tabs, dbgbase);
 
 		if (dbgbase == invalid_entry || (dbgbase & 0x3) == 0x2) {
-			command_print(cmd, "\tNo ROM table present");
+			command_print(cmd, "\t\tNo ROM table present");
 		} else {
 			if (dbgbase & 0x01)
-				command_print(cmd, "\tValid ROM table present");
+				command_print(cmd, "\t\tValid ROM table present");
 			else
-				command_print(cmd, "\tROM table in legacy format");
+				command_print(cmd, "\t\tROM table in legacy format");
 		}
 	}
 
@@ -1914,7 +2004,7 @@ int dap_info_command(struct command_invocation *cmd, struct adiv5_ap *ap)
 		.priv            = cmd,
 	};
 
-	return rtp_ap(&dap_info_ops, ap);
+	return rtp_ap(&dap_info_ops, ap, 0);
 }
 
 /* Actions for dap_lookup_cs_component() */
@@ -1970,7 +2060,7 @@ int dap_lookup_cs_component(struct adiv5_ap *ap, uint8_t type,
 		.priv            = &lookup,
 	};
 
-	int retval = rtp_ap(&dap_lookup_cs_component_ops, ap);
+	int retval = rtp_ap(&dap_lookup_cs_component_ops, ap, 0);
 	if (retval == CORESIGHT_COMPONENT_FOUND) {
 		LOG_DEBUG("CS lookup found at 0x%" PRIx64, lookup.component_base);
 		*addr = lookup.component_base;
@@ -2000,7 +2090,7 @@ static const struct jim_nvp nvp_config_opts[] = {
 };
 
 static int adiv5_jim_spot_configure(struct jim_getopt_info *goi,
-		struct adiv5_dap **dap_p, int *ap_num_p, uint32_t *base_p)
+		struct adiv5_dap **dap_p, uint64_t *ap_num_p, uint32_t *base_p)
 {
 	assert(dap_p && ap_num_p);
 
@@ -2055,11 +2145,13 @@ static int adiv5_jim_spot_configure(struct jim_getopt_info *goi,
 
 	case CFG_AP_NUM:
 		if (goi->isconfigure) {
+			/* jim_wide is a signed 64 bits int, ap_num is unsigned with max 52 bits */
 			jim_wide ap_num;
 			e = jim_getopt_wide(goi, &ap_num);
 			if (e != JIM_OK)
 				return e;
-			if (ap_num < 0 || ap_num > DP_APSEL_MAX) {
+			/* we still don't know dap->adi_version */
+			if (ap_num < 0 || (ap_num > DP_APSEL_MAX && (ap_num & 0xfff))) {
 				Jim_SetResultString(goi->interp, "Invalid AP number!", -1);
 				return JIM_ERR;
 			}
@@ -2164,15 +2256,27 @@ int adiv5_mem_ap_spot_init(struct adiv5_mem_ap_spot *p)
 COMMAND_HANDLER(handle_dap_info_command)
 {
 	struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
-	uint32_t apsel;
+	uint64_t apsel;
 
 	switch (CMD_ARGC) {
 	case 0:
 		apsel = dap->apsel;
 		break;
 	case 1:
-		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
-		if (apsel > DP_APSEL_MAX) {
+		if (!strcmp(CMD_ARGV[0], "root")) {
+			if (!is_adiv6(dap)) {
+				command_print(CMD, "Option \"root\" not allowed with ADIv5 DAP");
+				return ERROR_COMMAND_ARGUMENT_INVALID;
+			}
+			int retval = adiv6_dap_read_baseptr(CMD, dap, &apsel);
+			if (retval != ERROR_OK) {
+				command_print(CMD, "Failed reading DAP baseptr");
+				return retval;
+			}
+			break;
+		}
+		COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
+		if (!is_ap_num_valid(dap, apsel)) {
 			command_print(CMD, "Invalid AP number");
 			return ERROR_COMMAND_ARGUMENT_INVALID;
 		}
@@ -2195,7 +2299,8 @@ COMMAND_HANDLER(handle_dap_info_command)
 COMMAND_HANDLER(dap_baseaddr_command)
 {
 	struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
-	uint32_t apsel, baseaddr_lower, baseaddr_upper;
+	uint64_t apsel;
+	uint32_t baseaddr_lower, baseaddr_upper;
 	struct adiv5_ap *ap;
 	target_addr_t baseaddr;
 	int retval;
@@ -2207,9 +2312,8 @@ COMMAND_HANDLER(dap_baseaddr_command)
 		apsel = dap->apsel;
 		break;
 	case 1:
-		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
-		/* AP address is in bits 31:24 of DP_SELECT */
-		if (apsel > DP_APSEL_MAX) {
+		COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
+		if (!is_ap_num_valid(dap, apsel)) {
 			command_print(CMD, "Invalid AP number");
 			return ERROR_COMMAND_ARGUMENT_INVALID;
 		}
@@ -2230,14 +2334,14 @@ COMMAND_HANDLER(dap_baseaddr_command)
 		return ERROR_FAIL;
 	}
 
-	retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE, &baseaddr_lower);
+	retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE(dap), &baseaddr_lower);
 
 	if (retval == ERROR_OK && ap->cfg_reg == MEM_AP_REG_CFG_INVALID)
-		retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG, &ap->cfg_reg);
+		retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG(dap), &ap->cfg_reg);
 
 	if (retval == ERROR_OK && (ap->cfg_reg == MEM_AP_REG_CFG_INVALID || is_64bit_ap(ap))) {
 		/* MEM_AP_REG_BASE64 is defined as 'RES0'; can be read and then ignored on 32 bits AP */
-		retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64, &baseaddr_upper);
+		retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64(dap), &baseaddr_upper);
 	}
 
 	if (retval == ERROR_OK)
@@ -2294,16 +2398,15 @@ COMMAND_HANDLER(dap_memaccess_command)
 COMMAND_HANDLER(dap_apsel_command)
 {
 	struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
-	uint32_t apsel;
+	uint64_t apsel;
 
 	switch (CMD_ARGC) {
 	case 0:
-		command_print(CMD, "%" PRIu32, dap->apsel);
+		command_print(CMD, "0x%" PRIx64, dap->apsel);
 		return ERROR_OK;
 	case 1:
-		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
-		/* AP address is in bits 31:24 of DP_SELECT */
-		if (apsel > DP_APSEL_MAX) {
+		COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
+		if (!is_ap_num_valid(dap, apsel)) {
 			command_print(CMD, "Invalid AP number");
 			return ERROR_COMMAND_ARGUMENT_INVALID;
 		}
@@ -2329,7 +2432,7 @@ COMMAND_HANDLER(dap_apcsw_command)
 			command_print(CMD, "Cannot get AP");
 			return ERROR_FAIL;
 		}
-		command_print(CMD, "ap %" PRIu32 " selected, csw 0x%8.8" PRIx32,
+		command_print(CMD, "AP#0x%" PRIx64 " selected, csw 0x%8.8" PRIx32,
 			dap->apsel, ap->csw_default);
 		break;
 	case 1:
@@ -2376,7 +2479,8 @@ COMMAND_HANDLER(dap_apcsw_command)
 COMMAND_HANDLER(dap_apid_command)
 {
 	struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
-	uint32_t apsel, apid;
+	uint64_t apsel;
+	uint32_t apid;
 	int retval;
 
 	switch (CMD_ARGC) {
@@ -2384,9 +2488,8 @@ COMMAND_HANDLER(dap_apid_command)
 		apsel = dap->apsel;
 		break;
 	case 1:
-		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
-		/* AP address is in bits 31:24 of DP_SELECT */
-		if (apsel > DP_APSEL_MAX) {
+		COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
+		if (!is_ap_num_valid(dap, apsel)) {
 			command_print(CMD, "Invalid AP number");
 			return ERROR_COMMAND_ARGUMENT_INVALID;
 		}
@@ -2400,7 +2503,7 @@ COMMAND_HANDLER(dap_apid_command)
 		command_print(CMD, "Cannot get AP");
 		return ERROR_FAIL;
 	}
-	retval = dap_queue_ap_read(ap, AP_REG_IDR, &apid);
+	retval = dap_queue_ap_read(ap, AP_REG_IDR(dap), &apid);
 	if (retval != ERROR_OK) {
 		dap_put_ap(ap);
 		return retval;
@@ -2418,23 +2521,30 @@ COMMAND_HANDLER(dap_apid_command)
 COMMAND_HANDLER(dap_apreg_command)
 {
 	struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
-	uint32_t apsel, reg, value;
+	uint64_t apsel;
+	uint32_t reg, value;
 	int retval;
 
 	if (CMD_ARGC < 2 || CMD_ARGC > 3)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
-	/* AP address is in bits 31:24 of DP_SELECT */
-	if (apsel > DP_APSEL_MAX) {
+	COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
+	if (!is_ap_num_valid(dap, apsel)) {
 		command_print(CMD, "Invalid AP number");
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], reg);
-	if (reg >= 256 || (reg & 3)) {
-		command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
-		return ERROR_COMMAND_ARGUMENT_INVALID;
+	if (is_adiv6(dap)) {
+		if (reg >= 4096 || (reg & 3)) {
+			command_print(CMD, "Invalid reg value (should be less than 4096 and 4 bytes aligned)");
+			return ERROR_COMMAND_ARGUMENT_INVALID;
+		}
+	} else {	/* ADI version 5 */
+		if (reg >= 256 || (reg & 3)) {
+			command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
+			return ERROR_COMMAND_ARGUMENT_INVALID;
+		}
 	}
 
 	struct adiv5_ap *ap = dap_get_ap(dap, apsel);
@@ -2445,14 +2555,13 @@ COMMAND_HANDLER(dap_apreg_command)
 
 	if (CMD_ARGC == 3) {
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
-		switch (reg) {
-		case MEM_AP_REG_CSW:
+		/* see if user supplied register address is a match for the CSW or TAR register */
+		if (reg == MEM_AP_REG_CSW(dap)) {
 			ap->csw_value = 0;  /* invalid, in case write fails */
 			retval = dap_queue_ap_write(ap, reg, value);
 			if (retval == ERROR_OK)
 				ap->csw_value = value;
-			break;
-		case MEM_AP_REG_TAR:
+		} else if (reg == MEM_AP_REG_TAR(dap)) {
 			retval = dap_queue_ap_write(ap, reg, value);
 			if (retval == ERROR_OK)
 				ap->tar_value = (ap->tar_value & ~0xFFFFFFFFull) | value;
@@ -2463,8 +2572,7 @@ COMMAND_HANDLER(dap_apreg_command)
 				/* if tar_valid is false. */
 				ap->tar_valid = false;
 			}
-			break;
-		case MEM_AP_REG_TAR64:
+		} else if (reg == MEM_AP_REG_TAR64(dap)) {
 			retval = dap_queue_ap_write(ap, reg, value);
 			if (retval == ERROR_OK)
 				ap->tar_value = (ap->tar_value & 0xFFFFFFFFull) | (((target_addr_t)value) << 32);
@@ -2472,10 +2580,8 @@ COMMAND_HANDLER(dap_apreg_command)
 				/* See above comment for the MEM_AP_REG_TAR failed write case */
 				ap->tar_valid = false;
 			}
-			break;
-		default:
+		} else {
 			retval = dap_queue_ap_write(ap, reg, value);
-			break;
 		}
 	} else {
 		retval = dap_queue_ap_read(ap, reg, &value);
@@ -2539,9 +2645,9 @@ const struct command_registration dap_instance_commands[] = {
 		.name = "info",
 		.handler = handle_dap_info_command,
 		.mode = COMMAND_EXEC,
-		.help = "display ROM table for MEM-AP "
-			"(default currently selected AP)",
-		.usage = "[ap_num]",
+		.help = "display ROM table for specified MEM-AP (default currently selected AP) "
+			"or the ADIv6 root ROM table",
+		.usage = "[ap_num | 'root']",
 	},
 	{
 		.name = "apsel",