arm_adi_v5: Rewrite dap_rom_display

Simplify by printing one component per call, instead of one complete ROM
Table per call. Print common information the same way for all components,
including ROM tables, because ROM tables (at least the top level) contain
useful information in their identification registers, such as the
manufacturer of the SoC.

Print component designer name using the JEP106 helper when available.

Change-Id: Ic51bccd98acfae6886243500153fbdd567be2fae
Signed-off-by: Andreas Fritiofson <andreas.fritiofson@gmail.com>
Reviewed-on: http://openocd.zylin.com/3182
Tested-by: jenkins
Reviewed-by: Jiri Kastner <cz172638@gmail.com>
Reviewed-by: James Mastros <james@mastros.biz>

src/target/arm_adi_v5.c

@@ -75,6 +75,7 @@
 #include "jtag/interface.h"
 #include "arm.h"
 #include "arm_adi_v5.h"
+#include <helper/jep106.h>
 #include <helper/time_support.h>
 #include <helper/list.h>
 
@@ -739,10 +740,9 @@ static const char *class_description[16] = {
 	"Generic IP component", "PrimeCell or System component"
 };
 
-static bool is_dap_cid_ok(uint32_t cid3, uint32_t cid2, uint32_t cid1, uint32_t cid0)
+static bool is_dap_cid_ok(uint32_t cid)
 {
-	return cid3 == 0xb1 && cid2 == 0x05
+	return (cid & 0xffff0fff) == 0xb105000d;
-			&& ((cid1 & 0x0f) == 0) && cid0 == 0x0d;
 }
 
 /*
@@ -876,6 +876,61 @@ int dap_lookup_cs_component(struct adiv5_ap *ap,
 	return ERROR_OK;
 }
 
+static int dap_read_part_id(struct adiv5_ap *ap, uint32_t component_base, uint32_t *cid, uint64_t *pid)
+{
+	assert((component_base & 0xFFF) == 0);
+	assert(ap != NULL && cid != NULL && pid != NULL);
+
+	uint32_t cid0, cid1, cid2, cid3;
+	uint32_t pid0, pid1, pid2, pid3, pid4;
+	int retval;
+
+	/* IDs are in last 4K section */
+	retval = mem_ap_read_u32(ap, component_base + 0xFE0, &pid0);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFE4, &pid1);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFE8, &pid2);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFEC, &pid3);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFD0, &pid4);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFF0, &cid0);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFF4, &cid1);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFF8, &cid2);
+	if (retval != ERROR_OK)
+		return retval;
+	retval = mem_ap_read_u32(ap, component_base + 0xFFC, &cid3);
+	if (retval != ERROR_OK)
+		return retval;
+
+	retval = dap_run(ap->dap);
+	if (retval != ERROR_OK)
+		return retval;
+
+	*cid = (cid3 & 0xff) << 24
+			| (cid2 & 0xff) << 16
+			| (cid1 & 0xff) << 8
+			| (cid0 & 0xff);
+	*pid = (uint64_t)(pid4 & 0xff) << 32
+			| (pid3 & 0xff) << 24
+			| (pid2 & 0xff) << 16
+			| (pid1 & 0xff) << 8
+			| (pid0 & 0xff);
+
+	return ERROR_OK;
+}
+
 /* The designer identity code is encoded as:
  * bits 11:8 : JEP106 Bank (number of continuation codes), only valid when bit 7 is 1.
  * bit 7     : Set when bits 6:0 represent a JEP106 ID and cleared when bits 6:0 represent
@@ -976,10 +1031,9 @@ static const struct {
 static int dap_rom_display(struct command_context *cmd_ctx,
 				struct adiv5_ap *ap, uint32_t dbgbase, int depth)
 {
-	struct adiv5_dap *dap = ap->dap;
 	int retval;
-	uint32_t cid0, cid1, cid2, cid3, memtype, romentry;
+	uint64_t pid;
-	uint16_t entry_offset;
+	uint32_t cid;
 	char tabs[7] = "";
 
 	if (depth > 16) {
@@ -990,124 +1044,102 @@ static int dap_rom_display(struct command_context *cmd_ctx,
 	if (depth)
 		snprintf(tabs, sizeof(tabs), "[L%02d] ", depth);
 
-	/* bit 16 of apid indicates a memory access port */
+	uint32_t base_addr = dbgbase & 0xFFFFF000;
-	if (dbgbase & 0x02)
+	command_print(cmd_ctx, "\t\tComponent base address 0x%08" PRIx32, base_addr);
-		command_print(cmd_ctx, "\t%sValid ROM table present", tabs);
-	else
-		command_print(cmd_ctx, "\t%sROM table in legacy format", tabs);
 
-	/* Now we read ROM table ID registers, ref. ARM IHI 0029B sec  */
+	retval = dap_read_part_id(ap, base_addr, &cid, &pid);
-	retval = mem_ap_read_u32(ap, (dbgbase&0xFFFFF000) | 0xFF0, &cid0);
+	if (retval != ERROR_OK) {
-	if (retval != ERROR_OK)
+		command_print(cmd_ctx, "\t\tCan't read component, the corresponding core might be turned off");
-		return retval;
+		return ERROR_OK; /* Don't abort recursion */
-	retval = mem_ap_read_u32(ap, (dbgbase&0xFFFFF000) | 0xFF4, &cid1);
+	}
-	if (retval != ERROR_OK)
+
-		return retval;
+	if (!is_dap_cid_ok(cid)) {
-	retval = mem_ap_read_u32(ap, (dbgbase&0xFFFFF000) | 0xFF8, &cid2);
+		command_print(cmd_ctx, "\t\tInvalid CID 0x%08" PRIx32, cid);
-	if (retval != ERROR_OK)
+		return ERROR_OK; /* Don't abort recursion */
-		return retval;
+	}
-	retval = mem_ap_read_u32(ap, (dbgbase&0xFFFFF000) | 0xFFC, &cid3);
+
-	if (retval != ERROR_OK)
+	/* component may take multiple 4K pages */
-		return retval;
+	uint32_t size = (pid >> 36) & 0xf;
-	retval = mem_ap_read_u32(ap, (dbgbase&0xFFFFF000) | 0xFCC, &memtype);
+	if (size > 0)
-	if (retval != ERROR_OK)
+		command_print(cmd_ctx, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size));
-		return retval;
+
-	retval = dap_run(dap);
+	command_print(cmd_ctx, "\t\tPeripheral ID 0x%010" PRIx64, pid);
+
+	uint8_t class = (cid >> 12) & 0xf;
+	uint16_t part_num = pid & 0xfff;
+	uint16_t designer_id = ((pid >> 32) & 0xf) << 8 | ((pid >> 12) & 0xff);
+
+	if (designer_id & 0x80) {
+		/* JEP106 code */
+		command_print(cmd_ctx, "\t\tDesigner is 0x%03" PRIx16 ", %s",
+				designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f));
+	} else {
+		/* Legacy ASCII ID, clear invalid bits */
+		designer_id &= 0x7f;
+		command_print(cmd_ctx, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
+				designer_id, designer_id == 0x41 ? "ARM" : "<unknown>");
+	}
+
+	/* default values to be overwritten upon finding a match */
+	const char *type = "Unrecognized";
+	const char *full = "";
+
+	/* search dap_partnums[] array for a match */
+	for (unsigned entry = 0; entry < ARRAY_SIZE(dap_partnums); entry++) {
+
+		if ((dap_partnums[entry].designer_id != designer_id) && (dap_partnums[entry].designer_id != ANY_ID))
+			continue;
+
+		if (dap_partnums[entry].part_num != part_num)
+			continue;
+
+		type = dap_partnums[entry].type;
+		full = dap_partnums[entry].full;
+		break;
+	}
+
+	command_print(cmd_ctx, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
+	command_print(cmd_ctx, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
+
+	if (class == 1) { /* ROM Table */
+		uint32_t memtype;
+		retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &memtype);
 		if (retval != ERROR_OK)
 			return retval;
 
-	if (!is_dap_cid_ok(cid3, cid2, cid1, cid0))
-		command_print(cmd_ctx, "\t%sCID3 0x%02x"
-				", CID2 0x%02x"
-				", CID1 0x%02x"
-				", CID0 0x%02x",
-				tabs,
-				(unsigned)cid3, (unsigned)cid2,
-				(unsigned)cid1, (unsigned)cid0);
 		if (memtype & 0x01)
-		command_print(cmd_ctx, "\t%sMEMTYPE system memory present on bus", tabs);
+			command_print(cmd_ctx, "\t\tMEMTYPE system memory present on bus");
 		else
-		command_print(cmd_ctx, "\t%sMEMTYPE system memory not present: dedicated debug bus", tabs);
+			command_print(cmd_ctx, "\t\tMEMTYPE system memory not present: dedicated debug bus");
 
-	/* Now we read ROM table entries from dbgbase&0xFFFFF000) | 0x000 until we get 0x00000000 */
+		/* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */
-	for (entry_offset = 0; ; entry_offset += 4) {
+		for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) {
-		retval = mem_ap_read_atomic_u32(ap, (dbgbase&0xFFFFF000) | entry_offset, &romentry);
+			uint32_t romentry;
+			retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry);
 			if (retval != ERROR_OK)
 				return retval;
 			command_print(cmd_ctx, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
 					tabs, entry_offset, romentry);
 			if (romentry & 0x01) {
-			uint32_t c_cid0, c_cid1, c_cid2, c_cid3;
+				/* Recurse */
-			uint32_t c_pid0, c_pid1, c_pid2, c_pid3, c_pid4;
+				retval = dap_rom_display(cmd_ctx, ap, base_addr + (romentry & 0xFFFFF000), depth + 1);
-			uint32_t component_base;
+				if (retval != ERROR_OK)
-			uint16_t part_num, designer_id;
+					return retval;
-			const char *type, *full;
+			} else if (romentry != 0) {
-
+				command_print(cmd_ctx, "\t\tComponent not present");
-			component_base = (dbgbase & 0xFFFFF000) + (romentry & 0xFFFFF000);
+			} else {
-
+				command_print(cmd_ctx, "\t%s\tEnd of ROM table", tabs);
-			/* IDs are in last 4K section */
+				break;
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFE0, &c_pid0);
-			if (retval != ERROR_OK) {
-				command_print(cmd_ctx, "\t%s\tCan't read component with base address 0x%" PRIx32
-					      ", the corresponding core might be turned off", tabs, component_base);
-				continue;
 			}
-			c_pid0 &= 0xff;
+		}
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFE4, &c_pid1);
+	} else if (class == 9) { /* CoreSight component */
-			if (retval != ERROR_OK)
-				return retval;
-			c_pid1 &= 0xff;
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFE8, &c_pid2);
-			if (retval != ERROR_OK)
-				return retval;
-			c_pid2 &= 0xff;
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFEC, &c_pid3);
-			if (retval != ERROR_OK)
-				return retval;
-			c_pid3 &= 0xff;
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFD0, &c_pid4);
-			if (retval != ERROR_OK)
-				return retval;
-			c_pid4 &= 0xff;
-
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFF0, &c_cid0);
-			if (retval != ERROR_OK)
-				return retval;
-			c_cid0 &= 0xff;
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFF4, &c_cid1);
-			if (retval != ERROR_OK)
-				return retval;
-			c_cid1 &= 0xff;
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFF8, &c_cid2);
-			if (retval != ERROR_OK)
-				return retval;
-			c_cid2 &= 0xff;
-			retval = mem_ap_read_atomic_u32(ap, component_base + 0xFFC, &c_cid3);
-			if (retval != ERROR_OK)
-				return retval;
-			c_cid3 &= 0xff;
-
-			command_print(cmd_ctx, "\t\tComponent base address 0x%" PRIx32 ", "
-				      "start address 0x%" PRIx32, component_base,
-				      /* component may take multiple 4K pages */
-				      (uint32_t)(component_base - 0x1000*(c_pid4 >> 4)));
-			command_print(cmd_ctx, "\t\tComponent class is 0x%" PRIx8 ", %s",
-					(uint8_t)((c_cid1 >> 4) & 0xf),
-					/* See ARM IHI 0029B Table 3-3 */
-					class_description[(c_cid1 >> 4) & 0xf]);
-
-			/* CoreSight component? */
-			if (((c_cid1 >> 4) & 0x0f) == 9) {
-				uint32_t devtype;
-				unsigned minor;
 		const char *major = "Reserved", *subtype = "Reserved";
 
-				retval = mem_ap_read_atomic_u32(ap,
+		uint32_t devtype;
-						(component_base & 0xfffff000) | 0xfcc,
+		retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &devtype);
-						&devtype);
 		if (retval != ERROR_OK)
 			return retval;
-				minor = (devtype >> 4) & 0x0f;
+		unsigned minor = (devtype >> 4) & 0x0f;
 		switch (devtype & 0x0f) {
 		case 0:
 			major = "Miscellaneous";
@@ -1247,73 +1279,6 @@ static int dap_rom_display(struct command_context *cmd_ctx,
 		/* REVISIT also show 0xfc8 DevId */
 	}
 
-			if (!is_dap_cid_ok(cid3, cid2, cid1, cid0))
-				command_print(cmd_ctx,
-						"\t\tCID3 0%02x"
-						", CID2 0%02x"
-						", CID1 0%02x"
-						", CID0 0%02x",
-						(int)c_cid3,
-						(int)c_cid2,
-						(int)c_cid1,
-						(int)c_cid0);
-			command_print(cmd_ctx,
-				"\t\tPeripheral ID[4..0] = hex "
-				"%02x %02x %02x %02x %02x",
-				(int)c_pid4, (int)c_pid3, (int)c_pid2,
-				(int)c_pid1, (int)c_pid0);
-
-			part_num = (c_pid0 & 0xff);
-			part_num |= (c_pid1 & 0x0f) << 8;
-			designer_id = (c_pid1 & 0xf0) >> 4;
-			designer_id |= (c_pid2 & 0x0f) << 4;
-			designer_id |= (c_pid4 & 0x0f) << 8;
-			if ((designer_id & 0x80) == 0) {
-				/* Legacy ASCII ID, clear invalid bits */
-				designer_id &= 0x7f;
-			}
-
-			/* default values to be overwritten upon finding a match */
-			type = NULL;
-			full = "";
-
-			/* search dap_partnums[] array for a match */
-			unsigned entry;
-			for (entry = 0; entry < ARRAY_SIZE(dap_partnums); entry++) {
-
-				if ((dap_partnums[entry].designer_id != designer_id) && (dap_partnums[entry].designer_id != ANY_ID))
-					continue;
-
-				if (dap_partnums[entry].part_num != part_num)
-					continue;
-
-				type = dap_partnums[entry].type;
-				full = dap_partnums[entry].full;
-				break;
-			}
-
-			if (type) {
-				command_print(cmd_ctx, "\t\tPart is %s %s",
-						type, full);
-			} else {
-				command_print(cmd_ctx, "\t\tUnrecognized (Part 0x%" PRIx16 ", designer 0x%" PRIx16 ")",
-						part_num, designer_id);
-			}
-
-			/* ROM Table? */
-			if (((c_cid1 >> 4) & 0x0f) == 1) {
-				retval = dap_rom_display(cmd_ctx, ap, component_base, depth + 1);
-				if (retval != ERROR_OK)
-					return retval;
-			}
-		} else {
-			if (romentry)
-				command_print(cmd_ctx, "\t\tComponent not present");
-			else
-				break;
-		}
-	}
-	command_print(cmd_ctx, "\t%s\tEnd of ROM table", tabs);
 	return ERROR_OK;
 }
 
@@ -1322,7 +1287,6 @@ static int dap_info_command(struct command_context *cmd_ctx,
 {
 	int retval;
 	uint32_t dbgbase, apid;
-	int romtable_present = 0;
 	uint8_t mem_ap;
 
 	/* Now we read ROM table ID registers, ref. ARM IHI 0029B sec  */
@@ -1361,11 +1325,16 @@ static int dap_info_command(struct command_context *cmd_ctx,
 	if (mem_ap) {
 		command_print(cmd_ctx, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase);
 
-		romtable_present = dbgbase != 0xFFFFFFFF;
+		if (dbgbase == 0xFFFFFFFF || (dbgbase & 0x3) == 0x2) {
-		if (romtable_present)
-			dap_rom_display(cmd_ctx, ap, dbgbase, 0);
-		else
 			command_print(cmd_ctx, "\tNo ROM table present");
+		} else {
+			if (dbgbase & 0x01)
+				command_print(cmd_ctx, "\tValid ROM table present");
+			else
+				command_print(cmd_ctx, "\tROM table in legacy format");
+
+			dap_rom_display(cmd_ctx, ap, dbgbase & 0xFFFFF000, 0);
+		}
 	}
 
 	return ERROR_OK;