Adding upstream version 2.9.1.upstream/2.9.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 290 insertions, 68 deletions

diff --git a/nvme-print-json.c b/nvme-print-json.c
index 27f5c7c..fc3ba77 100644
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -16,7 +16,6 @@
 #define BUF_LEN 320
 #define VAL_LEN 4096
 #define BYTE_TO_BIT(byte) ((byte) * 8)
-#define POWER_OF_TWO(exponent) (1 << (exponent))
 #define MS_TO_SEC(time) ((time) / 1000)
 #define MS500_TO_MS(time) ((time) * 500)
 #define MS500_TO_SEC(time) (MS_TO_SEC(MS500_TO_MS(time)))
@@ -36,6 +35,9 @@ static const uint8_t zero_uuid[16] = { 0 };
 static struct print_ops json_print_ops;
 static struct json_object *json_r = NULL;
 
+static void json_feature_show_fields(enum nvme_features_id fid, unsigned int result,
+				     unsigned char *buf);
+
 static void d_json(unsigned char *buf, int len, int width, int group, struct json_object *array)
 {
 	int i;
@@ -57,6 +59,15 @@ static void d_json(unsigned char *buf, int len, int width, int group, struct jso
 	}
 }
 
+static void obj_d(struct json_object *o, const char *k, unsigned char *buf, int len, int width,
+		  int group)
+{
+	struct json_object *data = json_create_array();
+
+	d_json(buf, len, width, group, data);
+	obj_add_array(o, k, data);
+}
+
 static void obj_add_uint_x(struct json_object *o, const char *k, __u32 v)
 {
 	char str[STR_LEN];
@@ -73,7 +84,7 @@ static void obj_add_uint_0x(struct json_object *o, const char *k, __u32 v)
 	obj_add_str(o, k, str);
 }
 
-static void obj_add_uint_02x(struct json_object *o, const char *k, __u32 v)
+static void obj_add_uint_0nx(struct json_object *o, const char *k, __u32 v, int width)
 {
 	char str[STR_LEN];
 
@@ -81,6 +92,11 @@ static void obj_add_uint_02x(struct json_object *o, const char *k, __u32 v)
 	obj_add_str(o, k, str);
 }
 
+static void obj_add_uint_02x(struct json_object *o, const char *k, __u32 v)
+{
+	obj_add_uint_0nx(o, k, v, 2);
+}
+
 static void obj_add_uint_nx(struct json_object *o, const char *k, __u32 v)
 {
 	char str[STR_LEN];
@@ -179,6 +195,12 @@ static void json_print(struct json_object *r)
 	json_free_object(r);
 }
 
+static void obj_print(struct json_object *o)
+{
+	if (!json_r)
+		json_print(o);
+}
+
 static bool human(void)
 {
 	return json_print_ops.flags & VERBOSE;
@@ -759,7 +781,7 @@ static void json_select_result(enum nvme_features_id fid, __u32 result)
 	sprintf(json_str, "Feature: %#0*x: select", fid ? 4 : 2, fid);
 	obj_add_array(r, json_str, feature);
 
-	json_print(r);
+	obj_print(r);
 }
 
 static void json_self_test_log(struct nvme_self_test_log *self_test, __u8 dst_entries,
@@ -880,7 +902,7 @@ static void json_registers_version(__u32 vs, struct json_object *r)
 	sprintf(json_str, "%x", vs);
 	obj_add_str(r, "Version", json_str);
 
-	sprintf(json_str, "%d.%d", (vs & 0xffff0000) >> 16, (vs & 0x0000ff00) >> 8);
+	sprintf(json_str, "%d.%d.%d", NVME_MAJOR(vs), NVME_MINOR(vs), NVME_TERTIARY(vs));
 	obj_add_str(r, "NVMe specification", json_str);
 }
 
@@ -903,13 +925,13 @@ static void json_registers_cc_ams(__u8 ams, struct json_object *r)
 	char json_str[STR_LEN];
 
 	switch (ams) {
-	case 0:
+	case NVME_CC_AMS_RR:
 		sprintf(json_str, "Round Robin");
 		break;
-	case 1:
+	case NVME_CC_AMS_WRRU:
 		sprintf(json_str, "Weighted Round Robin with Urgent Priority Class");
 		break;
-	case 7:
+	case NVME_CC_AMS_VS:
 		sprintf(json_str, "Vendor Specific");
 		break;
 	default:
@@ -925,13 +947,13 @@ static void json_registers_cc_shn(__u8 shn, struct json_object *r)
 	char json_str[STR_LEN];
 
 	switch (shn) {
-	case 0:
+	case NVME_CC_SHN_NONE:
 		sprintf(json_str, "No notification; no effect");
 		break;
-	case 1:
+	case NVME_CC_SHN_NORMAL:
 		sprintf(json_str, "Normal shutdown notification");
 		break;
-	case 2:
+	case NVME_CC_SHN_ABRUPT:
 		sprintf(json_str, "Abrupt shutdown notification");
 		break;
 	default:
@@ -952,22 +974,23 @@ static void json_registers_cc(__u32 cc, struct json_object *r)
 	obj_add_str(r, "Controller Ready Independent of Media Enable (CRIME)",
 		     NVME_CC_CRIME(cc) ? "Enabled" : "Disabled");
 
-	sprintf(json_str, "%u bytes", POWER_OF_TWO(NVME_GET(cc, CC_IOCQES)));
+	sprintf(json_str, "%u bytes", POWER_OF_TWO(NVME_CC_IOCQES(cc)));
 	obj_add_str(r, "I/O Completion Queue Entry Size (IOCQES): ", json_str);
 
-	sprintf(json_str, "%u bytes", POWER_OF_TWO(NVME_GET(cc, CC_IOSQES)));
+	sprintf(json_str, "%u bytes", POWER_OF_TWO(NVME_CC_IOSQES(cc)));
 	obj_add_str(r, "I/O Submission Queue Entry Size (IOSQES)", json_str);
 
-	json_registers_cc_shn((cc & 0xc000) >> NVME_CC_SHN_SHIFT, r);
-	json_registers_cc_ams((cc & 0x3800) >> NVME_CC_AMS_SHIFT, r);
+	json_registers_cc_shn(NVME_CC_SHN(cc), r);
+	json_registers_cc_ams(NVME_CC_AMS(cc), r);
 
-	sprintf(json_str, "%u bytes", POWER_OF_TWO(12 + NVME_GET(cc, CC_MPS)));
+	sprintf(json_str, "%u bytes", POWER_OF_TWO(12 + NVME_CC_MPS(cc)));
 	obj_add_str(r, "Memory Page Size (MPS)", json_str);
 
-	obj_add_str(r, "I/O Command Set Selected (CSS)", (cc & 0x70) == 0x00 ? "NVM Command Set" :
-		     (cc & 0x70) == 0x60 ? "All supported I/O Command Sets" :
-		     (cc & 0x70) == 0x70 ? "Admin Command Set only" : "Reserved");
-	obj_add_str(r, "Enable (EN)", cc & 1 ? "Yes" : "No");
+	obj_add_str(r, "I/O Command Set Selected (CSS)",
+		    NVME_CC_CSS(cc) == NVME_CC_CSS_NVM ? "NVM Command Set" :
+		    NVME_CC_CSS(cc) == NVME_CC_CSS_CSI ? "All supported I/O Command Sets" :
+		    NVME_CC_CSS(cc) == NVME_CC_CSS_ADMIN ? "Admin Command Set only" : "Reserved");
+	obj_add_str(r, "Enable (EN)", NVME_CC_EN(cc) ? "Yes" : "No");
 }
 
 static void json_registers_csts_shst(__u8 shst, struct json_object *r)
@@ -975,13 +998,13 @@ static void json_registers_csts_shst(__u8 shst, struct json_object *r)
 	char json_str[STR_LEN];
 
 	switch (shst) {
-	case 0:
+	case NVME_CSTS_SHST_NORMAL:
 		sprintf(json_str, "Normal operation (no shutdown has been requested)");
 		break;
-	case 1:
+	case NVME_CSTS_SHST_OCCUR:
 		sprintf(json_str, "Shutdown processing occurring");
 		break;
-	case 2:
+	case NVME_CSTS_SHST_CMPLT:
 		sprintf(json_str, "Shutdown processing complete");
 		break;
 	default:
@@ -996,13 +1019,15 @@ static void json_registers_csts(__u32 csts, struct json_object *r)
 {
 	obj_add_uint_x(r, "csts", csts);
 
-	obj_add_str(r, "Processing Paused (PP)", csts & 0x20 ? "Yes" : "No");
-	obj_add_str(r, "NVM Subsystem Reset Occurred (NSSRO)", csts & 0x10 ? "Yes" : "No");
+	obj_add_str(r, "Shutdown Type (ST)", NVME_CSTS_ST(csts) ? "Subsystem" : "Controller");
+	obj_add_str(r, "Processing Paused (PP)", NVME_CSTS_PP(csts) ? "Yes" : "No");
+	obj_add_str(r, "NVM Subsystem Reset Occurred (NSSRO)",
+		    NVME_CSTS_NSSRO(csts) ? "Yes" : "No");
 
-	json_registers_csts_shst((csts & 0xc) >> 2, r);
+	json_registers_csts_shst(NVME_CSTS_SHST(csts), r);
 
-	obj_add_str(r, "Controller Fatal Status (CFS)", csts & 2 ? "True" : "False");
-	obj_add_str(r, "Ready (RDY)", csts & 1 ? "Yes" : "No");
+	obj_add_str(r, "Controller Fatal Status (CFS)", NVME_CSTS_CFS(csts) ? "True" : "False");
+	obj_add_str(r, "Ready (RDY)", NVME_CSTS_RDY(csts) ? "Yes" : "No");
 }
 
 static void json_registers_nssr(__u32 nssr, struct json_object *r)
@@ -1011,6 +1036,11 @@ static void json_registers_nssr(__u32 nssr, struct json_object *r)
 	obj_add_uint(r, "NVM Subsystem Reset Control (NSSRC)", nssr);
 }
 
+static void json_registers_nssd(__u32 nssd, struct json_object *r)
+{
+	obj_add_uint_nx(r, "NVM Subsystem Shutdown Control (NSSC)", nssd);
+}
+
 static void json_registers_crto(__u32 crto, struct json_object *r)
 {
 	obj_add_uint_x(r, "crto", crto);
@@ -1022,8 +1052,8 @@ static void json_registers_crto(__u32 crto, struct json_object *r)
 static void json_registers_aqa(uint32_t aqa, struct json_object *r)
 {
 	obj_add_uint_x(r, "aqa", aqa);
-	obj_add_uint(r, "Admin Completion Queue Size (ACQS)", ((aqa & 0xfff0000) >> 16) + 1);
-	obj_add_uint(r, "Admin Submission Queue Size (ASQS)", (aqa & 0xfff) + 1);
+	obj_add_uint(r, "Admin Completion Queue Size (ACQS)", NVME_AQA_ACQS(aqa) + 1);
+	obj_add_uint(r, "Admin Submission Queue Size (ASQS)", NVME_AQA_ASQS(aqa) + 1);
 }
 
 static void json_registers_asq(uint64_t asq, struct json_object *r)
@@ -1038,13 +1068,11 @@ static void json_registers_acq(uint64_t acq, struct json_object *r)
 	obj_add_prix64(r, "Admin Completion Queue Base (ACQB)", acq);
 }
 
-static void json_registers_cmbloc(uint32_t cmbloc, void *bar, struct json_object *r)
+static void json_registers_cmbloc(uint32_t cmbloc, bool support, struct json_object *r)
 {
-	uint32_t cmbsz = mmio_read32(bar + NVME_REG_CMBSZ);
-
 	obj_add_uint_x(r, "cmbloc", cmbloc);
 
-	if (!cmbsz) {
+	if (!support) {
 		obj_add_result(r, "Controller Memory Buffer feature is not supported");
 		return;
 	}
@@ -1173,17 +1201,15 @@ static void json_registers_pmrctl(uint32_t pmrctl, struct json_object *r)
 	obj_add_str(r, "Enable (EN)", pmrctl & 1 ? "Ready" : "Disabled");
 }
 
-static void json_registers_pmrsts(uint32_t pmrsts, void *bar, struct json_object *r)
+static void json_registers_pmrsts(uint32_t pmrsts, bool ready, struct json_object *r)
 {
-	uint32_t pmrctl = mmio_read32(bar + NVME_REG_PMRCTL);
-
 	obj_add_uint_x(r, "pmrsts", pmrsts);
 
 	obj_add_uint_x(r, "Controller Base Address Invalid (CBAI)", (pmrsts & 0x1000) >> 12);
 	obj_add_str(r, "Health Status (HSTS)",
-		     nvme_register_pmr_hsts_to_string((pmrsts & 0xe00) >> 9));
+		    nvme_register_pmr_hsts_to_string((pmrsts & 0xe00) >> 9));
 	obj_add_str(r, "Not Ready (NRDY)",
-		     !(pmrsts & 0x100) && (pmrctl & 1) ? "Ready" : "Not ready");
+		    !(pmrsts & 0x100) && ready ? "Ready" : "Not ready");
 	obj_add_uint_x(r, "Error (ERR)", pmrsts & 0xff);
 }
 
@@ -1194,7 +1220,7 @@ static void json_registers_pmrebs(uint32_t pmrebs, struct json_object *r)
 	obj_add_uint_x(r, "PMR Elasticity Buffer Size Base (PMRWBZ)", (pmrebs & 0xffffff00) >> 8);
 	obj_add_str(r, "Read Bypass Behavior", pmrebs & 0x10 ? "Shall" : "May");
 	obj_add_str(r, "PMR Elasticity Buffer Size Units (PMRSZU)",
-		     nvme_register_pmr_pmrszu_to_string(pmrebs & 0xf));
+		    nvme_register_unit_to_string(pmrebs & 0xf));
 }
 
 static void json_registers_pmrswtp(uint32_t pmrswtp, struct json_object *r)
@@ -1203,7 +1229,7 @@ static void json_registers_pmrswtp(uint32_t pmrswtp, struct json_object *r)
 
 	obj_add_uint_x(r, "PMR Sustained Write Throughput (PMRSWTV)", (pmrswtp & 0xffffff00) >> 8);
 	obj_add_key(r, "PMR Sustained Write Throughput Units (PMRSWTU)", "%s/second",
-		     nvme_register_pmr_pmrszu_to_string(pmrswtp & 0xf));
+		    nvme_register_unit_to_string(pmrswtp & 0xf));
 }
 
 static void json_registers_pmrmscl(uint32_t pmrmscl, struct json_object *r)
@@ -1248,6 +1274,9 @@ static void json_single_property_human(int offset, uint64_t value64, struct json
 	case NVME_REG_NSSR:
 		json_registers_nssr(value32, r);
 		break;
+	case NVME_REG_NSSD:
+		json_registers_nssd(value32, r);
+		break;
 	case NVME_REG_CRTO:
 		json_registers_crto(value32, r);
 		break;
@@ -1321,7 +1350,7 @@ struct json_object* json_effects_log(enum nvme_csi csi,
 static void json_effects_log_list(struct list_head *list)
 {
 	struct json_object *r = json_create_array();
-	nvme_effects_log_node_t *node;
+	nvme_effects_log_node_t *node = NULL;
 
 	list_for_each(list, node, node) {
 		struct json_object *json_page =
@@ -1351,7 +1380,7 @@ static void json_sanitize_log(struct nvme_sanitize_log_page *sanitize_log,
 	status_str = nvme_sstat_status_to_string(status);
 	sprintf(str, "(%d) %s", status & NVME_SANITIZE_SSTAT_STATUS_MASK,
 		status_str);
-	obj_add_str(sstat, status_str, str);
+	obj_add_str(sstat, "status", str);
 
 	obj_add_obj(dev, "sstat", sstat);
 	obj_add_uint(dev, "cdw10_info", le32_to_cpu(sanitize_log->scdw10));
@@ -1416,12 +1445,12 @@ static void json_add_bitmap(int i, __u8 seb, struct json_object *r)
 	char evt_str[50];
 	char key[128];
 
-	for (int bit = 0; bit < 8; bit++) {
-		if (nvme_pel_event_to_string(bit + i * 8)) {
-			sprintf(key, "bitmap_%x", (bit + i * 8));
+	for (int bit = 0; bit < CHAR_BIT; bit++) {
+		if (nvme_pel_event_to_string(bit + i * CHAR_BIT)) {
+			sprintf(key, "bitmap_%x", (bit + i * CHAR_BIT));
 			if ((seb >> bit) & 0x1)
 				snprintf(evt_str, sizeof(evt_str), "Support %s",
-					 nvme_pel_event_to_string(bit + i * 8));
+					 nvme_pel_event_to_string(bit + i * CHAR_BIT));
 			obj_add_str(r, key, evt_str);
 		}
 	}
@@ -1644,6 +1673,31 @@ static void json_pel_sanitize_completion(void *pevent_log_info, __u32 offset,
 	obj_add_uint(valid_attrs, "cmpln_info", le16_to_cpu(sanitize_cmpln_event->cmpln_info));
 }
 
+static void json_pel_set_feature(void *pevent_log_info, __u32 offset,
+				 struct json_object *valid_attrs)
+{
+	struct nvme_set_feature_event *set_feat_event = pevent_log_info + offset;
+	int fid = NVME_GET(le32_to_cpu(set_feat_event->cdw_mem[0]), FEATURES_CDW10_FID);
+	int cdw11 = le32_to_cpu(set_feat_event->cdw_mem[1]);
+	int dword_cnt = NVME_SET_FEAT_EVENT_DW_COUNT(set_feat_event->layout);
+	unsigned char *mem_buf;
+
+	obj_add_uint_02x(valid_attrs, "feature", fid);
+	obj_add_str(valid_attrs, "name", nvme_feature_to_string(fid));
+	obj_add_uint_0nx(valid_attrs, "value", cdw11, 8);
+
+	if (NVME_SET_FEAT_EVENT_MB_COUNT(set_feat_event->layout)) {
+		mem_buf = (unsigned char *)(set_feat_event + 4 + dword_cnt * 4);
+		json_feature_show_fields(fid, cdw11, mem_buf);
+	}
+}
+
+static void json_pel_telemetry_crt(void *pevent_log_info, __u32 offset,
+				   struct json_object *valid_attrs)
+{
+	obj_d(valid_attrs, "create", pevent_log_info + offset, 512, 16, 1);
+}
+
 static void json_pel_thermal_excursion(void *pevent_log_info, __u32 offset,
 				       struct json_object *valid_attrs)
 {
@@ -1720,6 +1774,12 @@ static void json_pevent_entry(void *pevent_log_info, __u8 action, __u32 size, co
 		case NVME_PEL_SANITIZE_COMPLETION_EVENT:
 			json_pel_sanitize_completion(pevent_log_info, offset, valid_attrs);
 			break;
+		case NVME_PEL_SET_FEATURE_EVENT:
+			json_pel_set_feature(pevent_log_info, offset, valid_attrs);
+			break;
+		case NVME_PEL_TELEMETRY_CRT:
+			json_pel_telemetry_crt(pevent_log_info, offset, valid_attrs);
+			break;
 		case NVME_PEL_THERMAL_EXCURSION_EVENT:
 			json_pel_thermal_excursion(pevent_log_info, offset, valid_attrs);
 			break;
@@ -1942,8 +2002,8 @@ static void json_boot_part_log(void *bp_log, const char *devname,
 	struct json_object *r = json_create_object();
 
 	obj_add_uint(r, "count", hdr->lid);
-	obj_add_uint(r, "abpid", (le32_to_cpu(hdr->bpinfo) >> 31) & 0x1);
-	obj_add_uint(r, "bpsz", le32_to_cpu(hdr->bpinfo) & 0x7fff);
+	obj_add_uint(r, "abpid", NVME_BOOT_PARTITION_INFO_ABPID(le32_to_cpu(hdr->bpinfo)));
+	obj_add_uint(r, "bpsz", NVME_BOOT_PARTITION_INFO_BPSZ(le32_to_cpu(hdr->bpinfo)));
 
 	json_print(r);
 }
@@ -1997,7 +2057,7 @@ static void json_phy_rx_eom_descs(struct nvme_phy_rx_eom_log *log,
 		obj_add_uint(jdesc, "ncols", le16_to_cpu(desc->ncols));
 		obj_add_uint(jdesc, "edlen", le16_to_cpu(desc->edlen));
 
-		if (log->odp & NVME_EOM_PRINTABLE_EYE_PRESENT)
+		if (NVME_EOM_ODP_PEFP(log->odp))
 			allocated_eyes[i] = json_eom_printable_eye(desc, r);
 
 		/* Eye Data field is vendor specific, doesn't map to JSON */
@@ -2476,6 +2536,16 @@ static void json_ctrl_registers_nssr(void *bar, struct json_object *r)
 		obj_add_int(r, "nssr", nssr);
 }
 
+static void json_ctrl_registers_nssd(void *bar, struct json_object *r)
+{
+	uint32_t nssd = mmio_read32(bar + NVME_REG_NSSD);
+
+	if (human())
+		json_registers_nssd(nssd, obj_create_array_obj(r, "nssd"));
+	else
+		obj_add_int(r, "nssd", nssd);
+}
+
 static void json_ctrl_registers_crto(void *bar, struct json_object *r)
 {
 	uint32_t crto = mmio_read32(bar + NVME_REG_CRTO);
@@ -2519,11 +2589,16 @@ static void json_ctrl_registers_acq(void *bar, struct json_object *r)
 static void json_ctrl_registers_cmbloc(void *bar, struct json_object *r)
 {
 	uint32_t cmbloc = mmio_read32(bar + NVME_REG_CMBLOC);
+	uint32_t cmbsz;
+	bool support;
 
-	if (human())
-		json_registers_cmbloc(cmbloc, bar, obj_create_array_obj(r, "cmbloc"));
-	else
+	if (human()) {
+		cmbsz = mmio_read32(bar + NVME_REG_CMBSZ);
+		support = nvme_registers_cmbloc_support(cmbsz);
+		json_registers_cmbloc(cmbloc, support, obj_create_array_obj(r, "cmbloc"));
+	} else {
 		obj_add_int(r, "cmbloc", cmbloc);
+	}
 }
 
 static void json_ctrl_registers_cmbsz(void *bar, struct json_object *r)
@@ -2609,11 +2684,16 @@ static void json_ctrl_registers_pmrctl(void *bar, struct json_object *r)
 static void json_ctrl_registers_pmrsts(void *bar, struct json_object *r)
 {
 	uint32_t pmrsts = mmio_read32(bar + NVME_REG_PMRSTS);
+	uint32_t pmrctl;
+	bool ready;
 
-	if (human())
-		json_registers_pmrsts(pmrsts, bar, obj_create_array_obj(r, "pmrsts"));
-	else
+	if (human()) {
+		pmrctl = mmio_read32(bar + NVME_REG_PMRCTL);
+		ready = nvme_registers_pmrctl_ready(pmrctl);
+		json_registers_pmrsts(pmrsts, ready, obj_create_array_obj(r, "pmrsts"));
+	} else {
 		obj_add_int(r, "pmrsts", pmrsts);
+	}
 }
 
 static void json_ctrl_registers_pmrebs(void *bar, struct json_object *r)
@@ -2667,6 +2747,7 @@ static void json_ctrl_registers(void *bar, bool fabrics)
 	json_ctrl_registers_cc(bar, r);
 	json_ctrl_registers_csts(bar, r);
 	json_ctrl_registers_nssr(bar, r);
+	json_ctrl_registers_nssd(bar, r);
 	json_ctrl_registers_crto(bar, r);
 	json_ctrl_registers_aqa(bar, r);
 	json_ctrl_registers_asq(bar, r);
@@ -2689,6 +2770,149 @@ static void json_ctrl_registers(void *bar, bool fabrics)
 	json_print(r);
 }
 
+static void json_registers_cmbebs(__u32 cmbebs, struct json_object *r)
+{
+	char buffer[BUF_LEN];
+
+	obj_add_uint_nx(r, "cmbebs", cmbebs);
+
+	obj_add_uint_nx(r, "CMB Elasticity Buffer Size Base (CMBWBZ)", cmbebs >> 8);
+	sprintf(buffer, "%s", cmbebs & 0x10 ? "shall" : "may");
+	obj_add_str(r, "Read Bypass Behavior", buffer);
+	obj_add_str(r, "CMB Elasticity Buffer Size Units (CMBSZU)",
+		    nvme_register_unit_to_string(cmbebs & 0xf));
+}
+
+static void json_registers_cmbswtp(__u32 cmbswtp, struct json_object *r)
+{
+	char str[STR_LEN];
+
+	obj_add_uint_nx(r, "cmbswtp", cmbswtp);
+
+	obj_add_uint_nx(r, "CMB Sustained Write Throughput (CMBSWTV)", cmbswtp >> 8);
+	sprintf(str, "%s", nvme_register_unit_to_string(cmbswtp & 0xf));
+	obj_add_str(r, "CMB Sustained Write Throughput Units (CMBSWTU)", str);
+}
+
+static void json_ctrl_register_human(int offset, uint64_t value, struct json_object *r)
+{
+	char buffer[BUF_LEN];
+	struct json_object *array_obj = NULL;
+
+	switch (offset) {
+	case NVME_REG_CAP:
+		array_obj = obj_create_array_obj(r, "cap");
+		break;
+	case NVME_REG_VS:
+		array_obj = obj_create_array_obj(r, "vs");
+		break;
+	case NVME_REG_INTMS:
+		obj_add_nprix64(r, "Interrupt Vector Mask Set (IVMS)", value);
+		break;
+	case NVME_REG_INTMC:
+		obj_add_nprix64(r, "Interrupt Vector Mask Clear (IVMC)", value);
+		break;
+	case NVME_REG_CC:
+		array_obj = obj_create_array_obj(r, "cc");
+		break;
+	case NVME_REG_CSTS:
+		array_obj = obj_create_array_obj(r, "csts");
+		break;
+	case NVME_REG_NSSR:
+		obj_add_uint64(r, "NVM Subsystem Reset Control (NSSRC)", value);
+		break;
+	case NVME_REG_AQA:
+		json_registers_aqa(value, obj_create_array_obj(r, "aqa"));
+		break;
+	case NVME_REG_ASQ:
+		obj_add_nprix64(r, "Admin Submission Queue Base (ASQB)", value);
+		break;
+	case NVME_REG_ACQ:
+		obj_add_nprix64(r, "Admin Completion Queue Base (ACQB)", value);
+		break;
+	case NVME_REG_CMBLOC:
+		json_registers_cmbloc(value, true, obj_create_array_obj(r, "cmbloc"));
+		break;
+	case NVME_REG_CMBSZ:
+		json_registers_cmbsz(value, obj_create_array_obj(r, "cmbsz"));
+		break;
+	case NVME_REG_BPINFO:
+		json_registers_bpinfo(value, obj_create_array_obj(r, "bpinfo"));
+		break;
+	case NVME_REG_BPRSEL:
+		json_registers_bprsel(value, obj_create_array_obj(r, "bprsel"));
+		break;
+	case NVME_REG_BPMBL:
+		json_registers_bpmbl(value, obj_create_array_obj(r, "bpmbl"));
+		break;
+	case NVME_REG_CMBMSC:
+		json_registers_cmbmsc(value, obj_create_array_obj(r, "cmbmsc"));
+		break;
+	case NVME_REG_CMBSTS:
+		json_registers_cmbsts(value, obj_create_array_obj(r, "cmbsts"));
+		break;
+	case NVME_REG_CMBEBS:
+		json_registers_cmbebs(value, obj_create_array_obj(r, "cmbebs"));
+		break;
+	case NVME_REG_CMBSWTP:
+		json_registers_cmbswtp(value, obj_create_array_obj(r, "cmbswtp"));
+		break;
+	case NVME_REG_NSSD:
+		json_registers_nssd(value, obj_create_array_obj(r, "nssd"));
+		break;
+	case NVME_REG_CRTO:
+		array_obj = obj_create_array_obj(r, "crto");
+		break;
+	case NVME_REG_PMRCAP:
+		json_registers_pmrcap(value, obj_create_array_obj(r, "pmrcap"));
+		break;
+	case NVME_REG_PMRCTL:
+		json_registers_pmrctl(value, obj_create_array_obj(r, "pmrctl"));
+		break;
+	case NVME_REG_PMRSTS:
+		json_registers_pmrsts(value, true, obj_create_array_obj(r, "pmrsts"));
+		break;
+	case NVME_REG_PMREBS:
+		json_registers_pmrebs(value, obj_create_array_obj(r, "pmrebs"));
+		break;
+	case NVME_REG_PMRSWTP:
+		json_registers_pmrswtp(value, obj_create_array_obj(r, "pmrswtp"));
+		break;
+	case NVME_REG_PMRMSCL:
+		json_registers_pmrmscl(value, obj_create_array_obj(r, "pmrmscl"));
+		break;
+	case NVME_REG_PMRMSCU:
+		json_registers_pmrmscu(value, obj_create_array_obj(r, "pmrmscu"));
+		break;
+	default:
+		sprintf(buffer, "%#04x (%s)", offset, nvme_register_to_string(offset));
+		obj_add_str(r, "register", buffer);
+		obj_add_nprix64(r, "value", value);
+		break;
+	}
+
+	if (array_obj)
+		json_single_property_human(offset, value, array_obj);
+}
+
+static void json_ctrl_register(int offset, uint64_t value)
+{
+	bool human = json_print_ops.flags & VERBOSE;
+	struct json_object *r;
+	char json_str[STR_LEN];
+
+	sprintf(json_str, "register: %#04x", offset);
+	r = obj_create(json_str);
+
+	if (human) {
+		obj_add_uint64(r, nvme_register_to_string(offset), value);
+		json_ctrl_register_human(offset, value, r);
+	} else {
+		obj_add_str(r, "name", nvme_register_symbol_to_string(offset));
+		obj_add_uint64(r, "value", value);
+	}
+}
+
 static void json_nvme_cmd_set_independent_id_ns(struct nvme_id_independent_id_ns *ns,
 						unsigned int nsid)
 {
@@ -3433,7 +3657,7 @@ static void json_feature_show(enum nvme_features_id fid, int sel, unsigned int r
 	sprintf(json_str, "%#0*x", result ? 10 : 8, result);
 	obj_add_str(r, nvme_select_to_string(sel), json_str);
 
-	json_print(r);
+	obj_print(r);
 }
 
 static void json_feature_show_fields(enum nvme_features_id fid, unsigned int result,
@@ -3525,9 +3749,7 @@ static void json_feature_show_fields(enum nvme_features_id fid, unsigned int res
 		json_feature_show_fields_spinup_control(r, result);
 		break;
 	case NVME_FEAT_FID_ENH_CTRL_METADATA:
-		fallthrough;
 	case NVME_FEAT_FID_CTRL_METADATA:
-		fallthrough;
 	case NVME_FEAT_FID_NS_METADATA:
 		json_feature_show_fields_ns_metadata(r, fid, buf);
 		break;
@@ -3556,7 +3778,7 @@ static void json_feature_show_fields(enum nvme_features_id fid, unsigned int res
 		break;
 	}
 
-	json_print(r);
+	obj_print(r);
 }
 
 void json_id_ctrl_rpmbs(__le32 ctrl_rpmbs)
@@ -3604,13 +3826,11 @@ void json_d(unsigned char *buf, int len, int width, int group)
 {
 	struct json_object *r = json_r ? json_r : json_create_object();
 	char json_str[STR_LEN];
-	struct json_object *data = json_create_array();
 
 	sprintf(json_str, "data: buf=%p len=%d width=%d group=%d", buf, len, width, group);
-	d_json(buf, len, width, group, data);
-	obj_add_array(r, json_str, data);
+	obj_d(r, json_str, buf, len, width, group);
 
-	json_print(r);
+	obj_print(r);
 }
 
 static void json_nvme_list_ctrl(struct nvme_ctrl_list *ctrl_list)
@@ -3876,6 +4096,7 @@ static void json_detail_list(nvme_root_t t)
 				struct json_object *jpaths = json_create_array();
 
 				obj_add_str(jctrl, "Controller", nvme_ctrl_get_name(c));
+				obj_add_str(jctrl, "Cntlid", nvme_ctrl_get_cntlid(c));
 				obj_add_str(jctrl, "SerialNumber", nvme_ctrl_get_serial(c));
 				obj_add_str(jctrl, "ModelNumber", nvme_ctrl_get_model(c));
 				obj_add_str(jctrl, "Firmware", nvme_ctrl_get_firmware(c));
@@ -4311,7 +4532,7 @@ static void json_output_status(int status)
 
 	if (status < 0) {
 		obj_add_str(r, "error", nvme_strerror(errno));
-		json_print(r);
+		obj_print(r);
 		return;
 	}
 
@@ -4332,7 +4553,7 @@ static void json_output_status(int status)
 		break;
 	}
 
-	json_print(r);
+	obj_print(r);
 }
 
 static void json_output_error_status(int status, const char *msg, va_list ap)
@@ -4353,7 +4574,7 @@ static void json_output_error_status(int status, const char *msg, va_list ap)
 
 	if (status < 0) {
 		obj_add_str(r, "error", nvme_strerror(errno));
-		json_print(r);
+		obj_print(r);
 		return;
 	}
 
@@ -4376,7 +4597,7 @@ static void json_output_error_status(int status, const char *msg, va_list ap)
 
 	obj_add_int(r, "value", val);
 
-	json_print(r);
+	obj_print(r);
 }
 
 static void json_output_message(bool error, const char *msg, va_list ap)
@@ -4391,7 +4612,7 @@ static void json_output_message(bool error, const char *msg, va_list ap)
 
 	free(value);
 
-	json_print(r);
+	obj_print(r);
 }
 
 static void json_output_perror(const char *msg)
@@ -4432,6 +4653,7 @@ static struct print_ops json_print_ops = {
 	.phy_rx_eom_log			= json_phy_rx_eom_log,
 	.ctrl_list			= json_nvme_list_ctrl,
 	.ctrl_registers			= json_ctrl_registers,
+	.ctrl_register			= json_ctrl_register,
 	.directive			= json_directive_show,
 	.discovery_log			= json_discovery_log,
 	.effects_log_list		= json_effects_log_list,