diff --git a/SOURCES/0011-Revert-nvme-print-json-display-only-verbose-output.patch b/SOURCES/0011-Revert-nvme-print-json-display-only-verbose-output.patch
new file mode 100644
index 0000000..f846d2c
--- /dev/null
+++ b/SOURCES/0011-Revert-nvme-print-json-display-only-verbose-output.patch
@@ -0,0 +1,538 @@
+diff --git a/nvme-print-json.c b/nvme-print-json.c
+index 412eb20..cadb67a 100644
+--- a/nvme-print-json.c
++++ b/nvme-print-json.c
+@@ -203,6 +203,11 @@ static void obj_print(struct json_object *o)
+ 		json_print(o);
+ }
+ 
++static bool human(void)
++{
++	return json_print_ops.flags & VERBOSE;
++}
++
+ static void json_id_iocs(struct nvme_id_iocs *iocs)
+ {
+ 	struct json_object *r = json_create_object();
+@@ -664,17 +669,21 @@ static void json_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
+ 	nvme_uint128_t media_errors = le128_to_cpu(smart->media_errors);
+ 	nvme_uint128_t num_err_log_entries = le128_to_cpu(smart->num_err_log_entries);
+ 
+-	struct json_object *crt = json_create_object();
++	if (human()) {
++		struct json_object *crt = json_create_object();
+ 
+-	obj_add_int(crt, "value", smart->critical_warning);
+-	obj_add_int(crt, "available_spare", smart->critical_warning & 1);
+-	obj_add_int(crt, "temp_threshold", (smart->critical_warning & 2) >> 1);
+-	obj_add_int(crt, "reliability_degraded", (smart->critical_warning & 4) >> 2);
+-	obj_add_int(crt, "ro", (smart->critical_warning & 8) >> 3);
+-	obj_add_int(crt, "vmbu_failed", (smart->critical_warning & 0x10) >> 4);
+-	obj_add_int(crt, "pmr_ro", (smart->critical_warning & 0x20) >> 5);
++		obj_add_int(crt, "value", smart->critical_warning);
++		obj_add_int(crt, "available_spare", smart->critical_warning & 1);
++		obj_add_int(crt, "temp_threshold", (smart->critical_warning & 2) >> 1);
++		obj_add_int(crt, "reliability_degraded", (smart->critical_warning & 4) >> 2);
++		obj_add_int(crt, "ro", (smart->critical_warning & 8) >> 3);
++		obj_add_int(crt, "vmbu_failed", (smart->critical_warning & 0x10) >> 4);
++		obj_add_int(crt, "pmr_ro", (smart->critical_warning & 0x20) >> 5);
+ 
+-	obj_add_obj(r, "critical_warning", crt);
++		obj_add_obj(r, "critical_warning", crt);
++	} else {
++		obj_add_int(r, "critical_warning", smart->critical_warning);
++	}
+ 
+ 	obj_add_int(r, "temperature", temperature);
+ 	obj_add_int(r, "avail_spare", smart->avail_spare);
+@@ -1313,8 +1322,24 @@ static void json_single_property_human(int offset, uint64_t value64, struct json
+ static void json_single_property(int offset, uint64_t value64)
+ {
+ 	struct json_object *r = json_create_object();
++	char json_str[STR_LEN];
++	uint32_t value32 = (uint32_t)value64;
++
++	if (human()) {
++		json_single_property_human(offset, value64, r);
++	} else {
++		sprintf(json_str, "0x%02x", offset);
++		obj_add_str(r, "property", json_str);
+ 
+-	json_single_property_human(offset, value64, r);
++		obj_add_str(r, "name", nvme_register_to_string(offset));
++
++		if (nvme_is_64bit_reg(offset))
++			sprintf(json_str, "%"PRIx64"", value64);
++		else
++			sprintf(json_str, "%x", value32);
++
++		obj_add_str(r, "value", json_str);
++	}
+ 
+ 	json_print(r);
+ }
+@@ -2466,10 +2491,12 @@ static void json_print_nvme_subsystem_list(nvme_root_t r, bool show_ana)
+ 			obj_add_str(subsystem_attrs, "Name", nvme_subsystem_get_name(s));
+ 			obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_nqn(s));
+ 
+-			obj_add_str(subsystem_attrs, "IOPolicy",
+-					nvme_subsystem_get_iopolicy(s));
+-			obj_add_str(subsystem_attrs, "Type",
+-					nvme_subsystem_get_type(s));
++			if (json_print_ops.flags & VERBOSE) {
++				obj_add_str(subsystem_attrs, "IOPolicy",
++						nvme_subsystem_get_iopolicy(s));
++				obj_add_str(subsystem_attrs, "Type",
++						nvme_subsystem_get_type(s));
++			}
+ 
+ 			array_add_obj(subsystems, subsystem_attrs);
+ 			paths = json_create_array();
+@@ -2490,84 +2517,120 @@ static void json_ctrl_registers_cap(void *bar, struct json_object *r)
+ {
+ 	uint64_t cap = mmio_read64(bar + NVME_REG_CAP);
+ 
+-	json_registers_cap((struct nvme_bar_cap *)&cap, obj_create_array_obj(r, "cap"));
++	if (human())
++		json_registers_cap((struct nvme_bar_cap *)&cap, obj_create_array_obj(r, "cap"));
++	else
++		obj_add_uint64(r, "cap", cap);
+ }
+ 
+ static void json_ctrl_registers_vs(void *bar, struct json_object *r)
+ {
+ 	uint32_t vs = mmio_read32(bar + NVME_REG_VS);
+ 
+-	json_registers_version(vs, obj_create_array_obj(r, "vs"));
++	if (human())
++		json_registers_version(vs, obj_create_array_obj(r, "vs"));
++	else
++		obj_add_int(r, "vs", vs);
+ }
+ 
+ static void json_ctrl_registers_intms(void *bar, struct json_object *r)
+ {
+ 	uint32_t intms = mmio_read32(bar + NVME_REG_INTMS);
+ 
+-	json_registers_intms(intms, obj_create_array_obj(r, "intms"));
++	if (human())
++		json_registers_intms(intms, obj_create_array_obj(r, "intms"));
++	else
++		obj_add_int(r, "intms", intms);
+ }
+ 
+ static void json_ctrl_registers_intmc(void *bar, struct json_object *r)
+ {
+ 	uint32_t intmc = mmio_read32(bar + NVME_REG_INTMC);
+ 
+-	json_registers_intmc(intmc, obj_create_array_obj(r, "intmc"));
++	if (human())
++		json_registers_intmc(intmc, obj_create_array_obj(r, "intmc"));
++	else
++		obj_add_int(r, "intmc", intmc);
+ }
+ 
+ static void json_ctrl_registers_cc(void *bar, struct json_object *r)
+ {
+ 	uint32_t cc = mmio_read32(bar + NVME_REG_CC);
+ 
+-	json_registers_cc(cc, obj_create_array_obj(r, "cc"));
++	if (human())
++		json_registers_cc(cc, obj_create_array_obj(r, "cc"));
++	else
++		obj_add_int(r, "cc", cc);
+ }
+ 
+ static void json_ctrl_registers_csts(void *bar, struct json_object *r)
+ {
+ 	uint32_t csts = mmio_read32(bar + NVME_REG_CSTS);
+ 
+-	json_registers_csts(csts, obj_create_array_obj(r, "csts"));
++	if (human())
++		json_registers_csts(csts, obj_create_array_obj(r, "csts"));
++	else
++		obj_add_int(r, "csts", csts);
+ }
+ 
+ static void json_ctrl_registers_nssr(void *bar, struct json_object *r)
+ {
+ 	uint32_t nssr = mmio_read32(bar + NVME_REG_NSSR);
+ 
+-	json_registers_nssr(nssr, obj_create_array_obj(r, "nssr"));
++	if (human())
++		json_registers_nssr(nssr, obj_create_array_obj(r, "nssr"));
++	else
++		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);
+ 
+-	json_registers_nssd(nssd, obj_create_array_obj(r, "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);
+ 
+-	json_registers_crto(crto, obj_create_array_obj(r, "crto"));
++	if (human())
++		json_registers_crto(crto, obj_create_array_obj(r, "crto"));
++	else
++		obj_add_int(r, "crto", crto);
+ }
+ 
+ static void json_ctrl_registers_aqa(void *bar, struct json_object *r)
+ {
+ 	uint32_t aqa = mmio_read32(bar + NVME_REG_AQA);
+ 
+-	json_registers_aqa(aqa, obj_create_array_obj(r, "aqa"));
++	if (human())
++		json_registers_aqa(aqa, obj_create_array_obj(r, "aqa"));
++	else
++		obj_add_int(r, "aqa", aqa);
+ }
+ 
+ static void json_ctrl_registers_asq(void *bar, struct json_object *r)
+ {
+ 	uint64_t asq = mmio_read64(bar + NVME_REG_ASQ);
+ 
+-	json_registers_asq(asq, obj_create_array_obj(r, "asq"));
++	if (human())
++		json_registers_asq(asq, obj_create_array_obj(r, "asq"));
++	else
++		obj_add_uint64(r, "asq", asq);
+ }
+ 
+ static void json_ctrl_registers_acq(void *bar, struct json_object *r)
+ {
+ 	uint64_t acq = mmio_read64(bar + NVME_REG_ACQ);
+ 
+-	json_registers_acq(acq, obj_create_array_obj(r, "acq"));
++	if (human())
++		json_registers_acq(acq, obj_create_array_obj(r, "acq"));
++	else
++		obj_add_uint64(r, "acq", acq);
+ }
+ 
+ static void json_ctrl_registers_cmbloc(void *bar, struct json_object *r)
+@@ -2576,79 +2639,113 @@ static void json_ctrl_registers_cmbloc(void *bar, struct json_object *r)
+ 	uint32_t cmbsz;
+ 	bool support;
+ 
+-	cmbsz = mmio_read32(bar + NVME_REG_CMBSZ);
+-	support = nvme_registers_cmbloc_support(cmbsz);
+-	json_registers_cmbloc(cmbloc, support, obj_create_array_obj(r, "cmbloc"));
++	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)
+ {
+ 	uint32_t cmbsz = mmio_read32(bar + NVME_REG_CMBSZ);
+ 
+-	json_registers_cmbsz(cmbsz, obj_create_array_obj(r, "cmbsz"));
++	if (human())
++		json_registers_cmbsz(cmbsz, obj_create_array_obj(r, "cmbsz"));
++	else
++		obj_add_int(r, "cmbsz", cmbsz);
+ }
+ 
+ static void json_ctrl_registers_bpinfo(void *bar, struct json_object *r)
+ {
+ 	uint32_t bpinfo = mmio_read32(bar + NVME_REG_BPINFO);
+ 
+-	json_registers_bpinfo(bpinfo, obj_create_array_obj(r, "bpinfo"));
++	if (human())
++		json_registers_bpinfo(bpinfo, obj_create_array_obj(r, "bpinfo"));
++	else
++		obj_add_int(r, "bpinfo", bpinfo);
+ }
+ 
+ static void json_ctrl_registers_bprsel(void *bar, struct json_object *r)
+ {
+ 	uint32_t bprsel = mmio_read32(bar + NVME_REG_BPRSEL);
+ 
+-	json_registers_bprsel(bprsel, obj_create_array_obj(r, "bprsel"));
++	if (human())
++		json_registers_bprsel(bprsel, obj_create_array_obj(r, "bprsel"));
++	else
++		obj_add_int(r, "bprsel", bprsel);
+ }
+ 
+ static void json_ctrl_registers_bpmbl(void *bar, struct json_object *r)
+ {
+ 	uint64_t bpmbl = mmio_read64(bar + NVME_REG_BPMBL);
+ 
+-	json_registers_bpmbl(bpmbl, obj_create_array_obj(r, "bpmbl"));
++	if (human())
++		json_registers_bpmbl(bpmbl, obj_create_array_obj(r, "bpmbl"));
++	else
++		obj_add_uint64(r, "bpmbl", bpmbl);
+ }
+ 
+ static void json_ctrl_registers_cmbmsc(void *bar, struct json_object *r)
+ {
+ 	uint64_t cmbmsc = mmio_read64(bar + NVME_REG_CMBMSC);
+ 
+-	json_registers_cmbmsc(cmbmsc, obj_create_array_obj(r, "cmbmsc"));
++	if (human())
++		json_registers_cmbmsc(cmbmsc, obj_create_array_obj(r, "cmbmsc"));
++	else
++		obj_add_uint64(r, "cmbmsc", cmbmsc);
+ }
+ 
+ static void json_ctrl_registers_cmbsts(void *bar, struct json_object *r)
+ {
+ 	uint32_t cmbsts = mmio_read32(bar + NVME_REG_CMBSTS);
+ 
+-	json_registers_cmbsts(cmbsts, obj_create_array_obj(r, "cmbsts"));
++	if (human())
++		json_registers_cmbsts(cmbsts, obj_create_array_obj(r, "cmbsts"));
++	else
++		obj_add_int(r, "cmbsts", cmbsts);
+ }
+ 
+ static void json_ctrl_registers_cmbebs(void *bar, struct json_object *r)
+ {
+ 	uint32_t cmbebs = mmio_read32(bar + NVME_REG_CMBEBS);
+ 
+-	json_registers_cmbebs(cmbebs, obj_create_array_obj(r, "cmbebs"));
++	if (human())
++		json_registers_cmbebs(cmbebs, obj_create_array_obj(r, "cmbebs"));
++	else
++		obj_add_int(r, "cmbebs", cmbebs);
+ }
+ 
+ static void json_ctrl_registers_cmbswtp(void *bar, struct json_object *r)
+ {
+ 	uint32_t cmbswtp = mmio_read32(bar + NVME_REG_CMBSWTP);
+ 
+-	json_registers_cmbswtp(cmbswtp, obj_create_array_obj(r, "cmbswtp"));
++	if (human())
++		json_registers_cmbswtp(cmbswtp, obj_create_array_obj(r, "cmbswtp"));
++	else
++		obj_add_int(r, "cmbswtp", cmbswtp);
+ }
+ 
+ static void json_ctrl_registers_pmrcap(void *bar, struct json_object *r)
+ {
+ 	uint32_t pmrcap = mmio_read32(bar + NVME_REG_PMRCAP);
+ 
+-	json_registers_pmrcap(pmrcap, obj_create_array_obj(r, "pmrcap"));
++	if (human())
++		json_registers_pmrcap(pmrcap, obj_create_array_obj(r, "pmrcap"));
++	else
++		obj_add_int(r, "pmrcap", pmrcap);
+ }
+ 
+ static void json_ctrl_registers_pmrctl(void *bar, struct json_object *r)
+ {
+ 	uint32_t pmrctl = mmio_read32(bar + NVME_REG_PMRCTL);
+ 
+-	json_registers_pmrctl(pmrctl, obj_create_array_obj(r, "pmrctl"));
++	if (human())
++		json_registers_pmrctl(pmrctl, obj_create_array_obj(r, "pmrctl"));
++	else
++		obj_add_int(r, "pmrctl", pmrctl);
+ }
+ 
+ static void json_ctrl_registers_pmrsts(void *bar, struct json_object *r)
+@@ -2657,37 +2754,53 @@ static void json_ctrl_registers_pmrsts(void *bar, struct json_object *r)
+ 	uint32_t pmrctl;
+ 	bool ready;
+ 
+-	pmrctl = mmio_read32(bar + NVME_REG_PMRCTL);
+-	ready = nvme_registers_pmrctl_ready(pmrctl);
+-	json_registers_pmrsts(pmrsts, ready, obj_create_array_obj(r, "pmrsts"));
++	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)
+ {
+ 	uint32_t pmrebs = mmio_read32(bar + NVME_REG_PMREBS);
+ 
+-	json_registers_pmrebs(pmrebs, obj_create_array_obj(r, "pmrebs"));
++	if (human())
++		json_registers_pmrebs(pmrebs, obj_create_array_obj(r, "pmrebs"));
++	else
++		obj_add_int(r, "pmrebs", pmrebs);
+ }
+ 
+ static void json_ctrl_registers_pmrswtp(void *bar, struct json_object *r)
+ {
+ 	uint32_t pmrswtp = mmio_read32(bar + NVME_REG_PMRSWTP);
+ 
+-	json_registers_pmrswtp(pmrswtp, obj_create_array_obj(r, "pmrswtp"));
++	if (human())
++		json_registers_pmrswtp(pmrswtp, obj_create_array_obj(r, "pmrswtp"));
++	else
++		obj_add_int(r, "pmrswtp", pmrswtp);
+ }
+ 
+ static void json_ctrl_registers_pmrmscl(void *bar, struct json_object *r)
+ {
+ 	uint32_t pmrmscl = mmio_read32(bar + NVME_REG_PMRMSCL);
+ 
+-	json_registers_pmrmscl(pmrmscl, obj_create_array_obj(r, "pmrmscl"));
++	if (human())
++		json_registers_pmrmscl(pmrmscl, obj_create_array_obj(r, "pmrmscl"));
++	else
++		obj_add_uint(r, "pmrmscl", pmrmscl);
+ }
+ 
+ static void json_ctrl_registers_pmrmscu(void *bar, struct json_object *r)
+ {
+ 	uint32_t pmrmscu = mmio_read32(bar + NVME_REG_PMRMSCU);
+ 
+-	json_registers_pmrmscu(pmrmscu, obj_create_array_obj(r, "pmrmscu"));
++	if (human())
++		json_registers_pmrmscu(pmrmscu, obj_create_array_obj(r, "pmrmscu"));
++	else
++		obj_add_uint(r, "pmrmscu", pmrmscu);
+ }
+ 
+ static void json_ctrl_registers(void *bar, bool fabrics)
+@@ -2829,14 +2942,20 @@ static void json_ctrl_register_human(int offset, uint64_t value, struct json_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);
+ 
+-	obj_add_uint64(r, nvme_register_to_string(offset), value);
+-	json_ctrl_register_human(offset, value, r);
++	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,
+@@ -2956,9 +3075,14 @@ static void json_nvme_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm)
+ 	__u16 rsvd = (ctrl_nvm->aocs & 0xfffe) >> 1;
+ 	__u8 ralbas = ctrl_nvm->aocs & 0x1;
+ 
+-	if (rsvd)
+-		obj_add_uint(r, "[15:1]: Reserved", rsvd);
+-	obj_add_uint(r, "[0:0]: Reporting Allocated LBA Supported", ralbas);
++	if (json_print_ops.flags & VERBOSE) {
++		__u16 rsvd = (ctrl_nvm->aocs & 0xfffe) >> 1;
++		__u8 ralbas = ctrl_nvm->aocs & 0x1;
++
++		if (rsvd)
++			obj_add_uint(r, "[15:1]: Reserved", rsvd);
++		obj_add_uint(r, "[0:0]: Reporting Allocated LBA Supported", ralbas);
++	}
+ 
+ 	json_print(r);
+ }
+@@ -4150,6 +4274,33 @@ static struct json_object *json_list_item_obj(nvme_ns_t n)
+ 	return r;
+ }
+ 
++static void json_simple_list(nvme_root_t t)
++{
++	struct json_object *r = json_create_object();
++	struct json_object *jdevices = json_create_array();
++
++	nvme_host_t h;
++	nvme_subsystem_t s;
++	nvme_ctrl_t c;
++	nvme_ns_t n;
++
++	nvme_for_each_host(t, h) {
++		nvme_for_each_subsystem(h, s) {
++			nvme_subsystem_for_each_ns(s, n)
++				array_add_obj(jdevices, json_list_item_obj(n));
++
++			nvme_subsystem_for_each_ctrl(s, c) {
++				nvme_ctrl_for_each_ns(c, n)
++					array_add_obj(jdevices, json_list_item_obj(n));
++			}
++		}
++	}
++
++	obj_add_array(r, "Devices", jdevices);
++
++	json_print(r);
++}
++
+ static void json_list_item(nvme_ns_t n)
+ {
+ 	struct json_object *r = json_list_item_obj(n);
+@@ -4159,7 +4310,10 @@ static void json_list_item(nvme_ns_t n)
+ 
+ static void json_print_list_items(nvme_root_t t)
+ {
+-	json_detail_list(t);
++	if (json_print_ops.flags & VERBOSE)
++		json_detail_list(t);
++	else
++		json_simple_list(t);
+ }
+ 
+ static unsigned int json_subsystem_topology_multipath(nvme_subsystem_t s,
+@@ -4253,10 +4407,12 @@ static void json_simple_topology(nvme_root_t r)
+ 			obj_add_str(subsystem_attrs, "Name", nvme_subsystem_get_name(s));
+ 			obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_nqn(s));
+ 
+-			obj_add_str(subsystem_attrs, "IOPolicy",
+-					nvme_subsystem_get_iopolicy(s));
+-			obj_add_str(subsystem_attrs, "Type",
+-					nvme_subsystem_get_type(s));
++			if (json_print_ops.flags & VERBOSE) {
++				obj_add_str(subsystem_attrs, "IOPolicy",
++						nvme_subsystem_get_iopolicy(s));
++				obj_add_str(subsystem_attrs, "Type",
++						nvme_subsystem_get_type(s));
++			}
+ 
+ 			array_add_obj(subsystems, subsystem_attrs);
+ 			namespaces = json_create_array();
+@@ -4371,6 +4527,7 @@ static void json_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __
+ 				void *buf, __u32 len)
+ {
+ 	struct json_object *r = json_create_object();
++	struct json_object *data;
+ 	char json_str[STR_LEN];
+ 
+ 	sprintf(json_str, "%#x", type);
+@@ -4384,7 +4541,13 @@ static void json_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __
+ 	sprintf(json_str, "%#x", result);
+ 	obj_add_result(r, json_str);
+ 
+-	json_directive_show_fields(type, oper, result, buf, r);
++	if (json_print_ops.flags & VERBOSE) {
++		json_directive_show_fields(type, oper, result, buf, r);
++	} else if (buf) {
++		data = json_create_array();
++		d_json((unsigned char *)buf, len, 16, 1, data);
++		obj_add_array(r, "data", data);
++	}
+ 
+ 	json_print(r);
+ }
diff --git a/SPECS/nvme-cli.spec b/SPECS/nvme-cli.spec
index e7bf09e..e8358d7 100644
--- a/SPECS/nvme-cli.spec
+++ b/SPECS/nvme-cli.spec
@@ -5,7 +5,7 @@
 
 Name:           nvme-cli
 Version:        2.11
-Release:        6%{?dist}
+Release:        7%{?dist}
 Summary:        NVMe management command line interface
 
 License:        GPL-2.0-only
@@ -23,6 +23,7 @@ Patch6:         0007-netapp-smdev-add-verbose-output.patch
 Patch7:         0008-netapp-smdev-doc-add-verbose-details.patch
 Patch8:         0009-nvme-set-eds-to-true-if-controller-supports-128-bit-.patch
 Patch9:         0010-udev-rules-ontap-switch-to-queue-depth-iopolicy.patch
+Patch10:        0011-Revert-nvme-print-json-display-only-verbose-output.patch
 
 BuildRequires:  meson >= 0.50.0
 BuildRequires:  gcc gcc-c++
@@ -107,6 +108,9 @@ if [ $1 -eq 1 ] || [ $1 -eq 2 ]; then
 fi
 
 %changelog
+* Tue Oct 14 2025 Maurizio Lombardi <mlombard@redhat.com> - 2.11-7
+- Fix for RHEL-121216
+
 * Wed Jun 04 2025 Maurizio Lombardi <mlombard@redhat.com> - 2.11-6
 - Fix for RHEL-95009