[v9,5/5] nvme: LightNVM support
diff mbox

Message ID 1444833738-8961-6-git-send-email-m@bjorling.me
State New
Headers show

Commit Message

Matias Bjorling Oct. 14, 2015, 2:42 p.m. UTC
The first generation of Open-Channel SSDs is based on NVMe. The
integration requires that a NVMe device register itself as a LightNVM
device.

Detection is made through PCI IDs. Current supported devices are the
qemu nvme simulator and CNEX Labs Westlake SSD. The qemu nvme enables
support through vendor specific bits in the namespace identification and
the CNEX card is configured for LightNVM upon boot and does not need
detection other than PCI id.

After detection, vendor specific codes are used to identify the device
and enumerate supported features.

Signed-off-by: Javier González <jg@lightnvm.io>
Signed-off-by: Matias Bjørling <m@bjorling.me>
---
 drivers/nvme/host/Makefile   |   2 +-
 drivers/nvme/host/lightnvm.c | 597 +++++++++++++++++++++++++++++++++++++++++++
 drivers/nvme/host/nvme.h     |  10 +
 drivers/nvme/host/pci.c      |  39 ++-
 4 files changed, 636 insertions(+), 12 deletions(-)
 create mode 100644 drivers/nvme/host/lightnvm.c

Comments

kernel test robot Oct. 14, 2015, 3:03 p.m. UTC | #1
Hi Matias,

[auto build test ERROR on block/for-next -- if it's inappropriate base, please suggest rules for selecting the more suitable base]

url:    https://github.com/0day-ci/linux/commits/Matias-Bj-rling/Support-for-Open-Channel-SSDs/20151014-224617
config: x86_64-randconfig-s0-10141707 (attached as .config)
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All errors (new ones prefixed by >>):

>> drivers/nvme/host/lightnvm.c:592:6: error: conflicting types for 'nvme_nvm_unregister'
    void nvme_nvm_unregister(char *disk_name) {};
         ^
   In file included from drivers/nvme/host/lightnvm.c:23:0:
   drivers/nvme/host/nvme.h:141:6: note: previous declaration of 'nvme_nvm_unregister' was here
    void nvme_nvm_unregister(struct request_queue *q, char *disk_name);
         ^

vim +/nvme_nvm_unregister +592 drivers/nvme/host/lightnvm.c

   586	}
   587	#else
   588	int nvme_nvm_register(struct request_queue *q, char *disk_name)
   589	{
   590		return 0;
   591	}
 > 592	void nvme_nvm_unregister(char *disk_name) {};
   593	int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id)
   594	{
   595		return 0;

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
kernel test robot Oct. 15, 2015, 2:46 a.m. UTC | #2
Hi Matias,

[auto build test WARNING on block/for-next -- if it's inappropriate base, please suggest rules for selecting the more suitable base]

url:    https://github.com/0day-ci/linux/commits/Matias-Bj-rling/Support-for-Open-Channel-SSDs/20151014-224617
reproduce:
        # apt-get install sparse
        make ARCH=x86_64 allmodconfig
        make C=1 CF=-D__CHECK_ENDIAN__


sparse warnings: (new ones prefixed by >>)

>> drivers/nvme/host/lightnvm.c:282:23: sparse: incorrect type in assignment (different base types)
   drivers/nvme/host/lightnvm.c:282:23:    expected restricted __le32 [assigned] [usertype] nsid
   drivers/nvme/host/lightnvm.c:282:23:    got unsigned int [unsigned] ns_id
>> drivers/nvme/host/lightnvm.c:291:19: sparse: cast to restricted __le64
   drivers/nvme/host/lightnvm.c:292:19: sparse: cast to restricted __le64
>> drivers/nvme/host/lightnvm.c:331:28: sparse: incorrect type in assignment (different base types)
   drivers/nvme/host/lightnvm.c:331:28:    expected restricted __le64 [assigned] [usertype] slba
   drivers/nvme/host/lightnvm.c:331:28:    got unsigned long long [unsigned] [usertype] cmd_slba
>> drivers/nvme/host/lightnvm.c:332:27: sparse: incorrect type in assignment (different base types)
   drivers/nvme/host/lightnvm.c:332:27:    expected restricted __le32 [assigned] [usertype] nlb
   drivers/nvme/host/lightnvm.c:332:27:    got unsigned long long [unsigned] [usertype] cmd_nlb

vim +282 drivers/nvme/host/lightnvm.c

   276		struct nvme_nvm_command c = {};
   277		int sz = sizeof(struct nvm_get_features);
   278		int ret;
   279		u64 *resp;
   280	
   281		c.common.opcode = nvme_nvm_admin_get_features;
 > 282		c.common.nsid = ns->ns_id;
   283		resp = kmalloc(sz, GFP_KERNEL);
   284		if (!resp)
   285			return -ENOMEM;
   286	
   287		ret = nvme_submit_sync_cmd(q, (struct nvme_command *)&c, resp, sz);
   288		if (ret)
   289			goto done;
   290	
 > 291		gf->rsp = le64_to_cpu(resp[0]);
   292		gf->ext = le64_to_cpu(resp[1]);
   293	
   294	done:
   295		kfree(resp);
   296		return ret;
   297	}
   298	
   299	static int nvme_nvm_set_resp(struct request_queue *q, u64 resp)
   300	{
   301		struct nvme_ns *ns = q->queuedata;
   302		struct nvme_nvm_command c = {};
   303	
   304		c.resp.opcode = nvme_nvm_admin_set_resp;
   305		c.resp.nsid = cpu_to_le32(ns->ns_id);
   306		c.resp.resp = cpu_to_le64(resp);
   307		return nvme_submit_sync_cmd(q, (struct nvme_command *)&c, NULL, 0);
   308	}
   309	
   310	static int nvme_nvm_get_l2p_tbl(struct request_queue *q, u64 slba, u64 nlb,
   311					nvm_l2p_update_fn *update_l2p, void *priv)
   312	{
   313		struct nvme_ns *ns = q->queuedata;
   314		struct nvme_dev *dev = ns->dev;
   315		struct nvme_nvm_command c = {};
   316		u32 len = queue_max_hw_sectors(q) << 9;
   317		u64 nlb_pr_rq = len / sizeof(u64);
   318		u64 cmd_slba = slba;
   319		void *entries;
   320		int ret = 0;
   321	
   322		c.l2p.opcode = nvme_nvm_admin_get_l2p_tbl;
   323		c.l2p.nsid = cpu_to_le32(ns->ns_id);
   324		entries = kmalloc(len, GFP_KERNEL);
   325		if (!entries)
   326			return -ENOMEM;
   327	
   328		while (nlb) {
   329			u64 cmd_nlb = min_t(u64, nlb_pr_rq, nlb);
   330	
 > 331			c.l2p.slba = cmd_slba;
 > 332			c.l2p.nlb = cmd_nlb;
   333	
   334			ret = nvme_submit_sync_cmd(q, (struct nvme_command *)&c,
   335									entries, len);

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Patch
diff mbox

diff --git a/drivers/nvme/host/Makefile b/drivers/nvme/host/Makefile
index cfb6679..219dc206 100644
--- a/drivers/nvme/host/Makefile
+++ b/drivers/nvme/host/Makefile
@@ -1,4 +1,4 @@ 
 
 obj-$(CONFIG_BLK_DEV_NVME)     += nvme.o
 
-nvme-y		+= pci.o scsi.o
+nvme-y		+= pci.o scsi.o lightnvm.o
diff --git a/drivers/nvme/host/lightnvm.c b/drivers/nvme/host/lightnvm.c
new file mode 100644
index 0000000..36925f4
--- /dev/null
+++ b/drivers/nvme/host/lightnvm.c
@@ -0,0 +1,597 @@ 
+/*
+ * nvme-lightnvm.c - LightNVM NVMe device
+ *
+ * Copyright (C) 2014-2015 IT University of Copenhagen
+ * Initial release: Matias Bjorling <mb@lightnvm.io>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
+ * USA.
+ *
+ */
+
+#include "nvme.h"
+
+#ifdef CONFIG_NVM
+
+#include <linux/nvme.h>
+#include <linux/bitops.h>
+#include <linux/lightnvm.h>
+#include <linux/vmalloc.h>
+
+enum nvme_nvm_opcode {
+	nvme_nvm_cmd_hb_write	= 0x81,
+	nvme_nvm_cmd_hb_read	= 0x02,
+	nvme_nvm_cmd_ph_write	= 0x91,
+	nvme_nvm_cmd_ph_read	= 0x92,
+	nvme_nvm_cmd_erase	= 0x90,
+};
+
+enum nvme_nvm_admin_opcode {
+	nvme_nvm_admin_identify		= 0xe2,
+	nvme_nvm_admin_get_features	= 0xe6,
+	nvme_nvm_admin_set_resp		= 0xe5,
+	nvme_nvm_admin_get_l2p_tbl	= 0xea,
+	nvme_nvm_admin_get_bb_tbl	= 0xf2,
+	nvme_nvm_admin_set_bb_tbl	= 0xf1,
+};
+
+struct nvme_nvm_hb_rw {
+	__u8			opcode;
+	__u8			flags;
+	__u16			command_id;
+	__le32			nsid;
+	__u64			rsvd2;
+	__le64			metadata;
+	__le64			prp1;
+	__le64			prp2;
+	__le64			spba;
+	__le16			length;
+	__le16			control;
+	__le32			dsmgmt;
+	__le64			slba;
+};
+
+struct nvme_nvm_ph_rw {
+	__u8			opcode;
+	__u8			flags;
+	__u16			command_id;
+	__le32			nsid;
+	__u64			rsvd2;
+	__le64			metadata;
+	__le64			prp1;
+	__le64			prp2;
+	__le64			spba;
+	__le16			length;
+	__le16			control;
+	__le32			dsmgmt;
+	__le64			resv;
+};
+
+struct nvme_nvm_identify {
+	__u8			opcode;
+	__u8			flags;
+	__u16			command_id;
+	__le32			nsid;
+	__u64			rsvd[2];
+	__le64			prp1;
+	__le64			prp2;
+	__le32			chnl_off;
+	__u32			rsvd11[5];
+};
+
+struct nvme_nvm_l2ptbl {
+	__u8			opcode;
+	__u8			flags;
+	__u16			command_id;
+	__le32			nsid;
+	__le32			cdw2[4];
+	__le64			prp1;
+	__le64			prp2;
+	__le64			slba;
+	__le32			nlb;
+	__le16			cdw14[6];
+};
+
+struct nvme_nvm_bbtbl {
+	__u8			opcode;
+	__u8			flags;
+	__u16			command_id;
+	__le32			nsid;
+	__u64			rsvd[2];
+	__le64			prp1;
+	__le64			prp2;
+	__le32			prp1_len;
+	__le32			prp2_len;
+	__le32			lbb;
+	__u32			rsvd11[3];
+};
+
+struct nvme_nvm_set_resp {
+	__u8			opcode;
+	__u8			flags;
+	__u16			command_id;
+	__le32			nsid;
+	__u64			rsvd[2];
+	__le64			prp1;
+	__le64			prp2;
+	__le64			resp;
+	__u32			rsvd11[4];
+};
+
+struct nvme_nvm_erase_blk {
+	__u8			opcode;
+	__u8			flags;
+	__u16			command_id;
+	__le32			nsid;
+	__u64			rsvd[2];
+	__le64			prp1;
+	__le64			prp2;
+	__le64			spba;
+	__le16			length;
+	__le16			control;
+	__le32			dsmgmt;
+	__le64			resv;
+};
+
+struct nvme_nvm_command {
+	union {
+		struct nvme_common_command common;
+		struct nvme_nvm_identify identify;
+		struct nvme_nvm_hb_rw hb_rw;
+		struct nvme_nvm_ph_rw ph_rw;
+		struct nvme_nvm_l2ptbl l2p;
+		struct nvme_nvm_bbtbl get_bb;
+		struct nvme_nvm_bbtbl set_bb;
+		struct nvme_nvm_set_resp resp;
+		struct nvme_nvm_erase_blk erase;
+	};
+};
+
+/*
+ * Check we didin't inadvertently grow the command struct
+ */
+static inline void _nvme_nvm_check_size(void)
+{
+	BUILD_BUG_ON(sizeof(struct nvme_nvm_identify) != 64);
+	BUILD_BUG_ON(sizeof(struct nvme_nvm_hb_rw) != 64);
+	BUILD_BUG_ON(sizeof(struct nvme_nvm_ph_rw) != 64);
+	BUILD_BUG_ON(sizeof(struct nvme_nvm_l2ptbl) != 64);
+	BUILD_BUG_ON(sizeof(struct nvme_nvm_bbtbl) != 64);
+	BUILD_BUG_ON(sizeof(struct nvme_nvm_set_resp) != 64);
+	BUILD_BUG_ON(sizeof(struct nvme_nvm_erase_blk) != 64);
+}
+
+struct nvme_nvm_id_group {
+	__le64			laddr_begin;
+	__le32			queue_size;
+	__le32			channels;
+	__le32			luns_per_chnl;
+	__le32			sec_per_pg;
+	__le32			pgs_per_blk;
+	__le32			blks;
+	__le32			planes;
+	__le32			sec_size;
+	__le32			oob_size;
+	__le32			t_r;
+	__le32			t_sqr;
+	__le32			t_w;
+	__le32			t_sqw;
+	__le32			t_e;
+	__le16			chnl_parallelism;
+	__u8			plane_mode;
+	__u8			addr_mode;
+	__u8			reserved[124];
+} __packed;
+
+struct nvme_nvm_id {
+	__le16			ver_id;
+	__le16			ngroups;
+	__le16			nvm_vendor;
+	__u8			reserved[250];
+	struct nvme_nvm_id_group groups[20];
+} __packed;
+
+
+
+static int init_chnls(struct nvm_id *nvm_id, struct nvme_nvm_id *nvme_nvm_id)
+{
+	struct nvme_nvm_id_group *src;
+	struct nvm_id_group *dst;
+	int i, end;
+
+	end = min_t(u32, 20, nvm_id->ngroups);
+
+	for (i = 0; i < end; i++) {
+		src = &nvme_nvm_id->groups[i];
+		dst = &nvm_id->groups[i];
+
+		dst->laddr_begin = le64_to_cpu(src->laddr_begin);
+		dst->queue_size = le32_to_cpu(src->queue_size);
+		dst->channels = le32_to_cpu(src->channels);
+		dst->luns_per_chnl = le32_to_cpu(src->luns_per_chnl);
+		dst->sec_per_pg = le32_to_cpu(src->sec_per_pg);
+		dst->pgs_per_blk = le32_to_cpu(src->pgs_per_blk);
+		dst->blks = le32_to_cpu(src->blks);
+		dst->planes = le32_to_cpu(src->planes);
+		dst->sec_size = le32_to_cpu(src->sec_size);
+		dst->oob_size = le32_to_cpu(src->oob_size);
+		dst->t_r = le32_to_cpu(src->t_r);
+		dst->t_sqr = le32_to_cpu(src->t_sqr);
+		dst->t_w = le32_to_cpu(src->t_w);
+		dst->t_sqw = le32_to_cpu(src->t_sqw);
+		dst->t_e = le32_to_cpu(src->t_e);
+		dst->plane_mode = src->plane_mode;
+		dst->addr_mode = src->addr_mode;
+	}
+
+	return 0;
+}
+
+static int nvme_nvm_identify(struct request_queue *q, struct nvm_id *nvm_id)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct nvme_nvm_id *nvme_nvm_id;
+	struct nvme_nvm_command c = {};
+	int ret;
+
+	c.identify.opcode = nvme_nvm_admin_identify;
+	c.identify.nsid = cpu_to_le32(ns->ns_id);
+	c.identify.chnl_off = 0;
+	nvme_nvm_id = kmalloc(sizeof(struct nvme_nvm_id), GFP_KERNEL);
+	if (!nvme_nvm_id)
+		return -ENOMEM;
+
+	ret = nvme_submit_sync_cmd(q, (struct nvme_command *)&c, nvme_nvm_id,
+						sizeof(struct nvme_nvm_id));
+	if (ret) {
+		ret = -EIO;
+		goto out;
+	}
+
+	nvm_id->ver_id = le16_to_cpu(nvme_nvm_id->ver_id);
+	nvm_id->nvm_vendor = le16_to_cpu(nvme_nvm_id->nvm_vendor);
+	nvm_id->ngroups = le16_to_cpu(nvme_nvm_id->ngroups);
+
+	ret = init_chnls(nvm_id, nvme_nvm_id);
+out:
+	kfree(nvme_nvm_id);
+	return ret;
+}
+
+static int nvme_nvm_get_features(struct request_queue *q,
+						struct nvm_get_features *gf)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct nvme_nvm_command c = {};
+	int sz = sizeof(struct nvm_get_features);
+	int ret;
+	u64 *resp;
+
+	c.common.opcode = nvme_nvm_admin_get_features;
+	c.common.nsid = ns->ns_id;
+	resp = kmalloc(sz, GFP_KERNEL);
+	if (!resp)
+		return -ENOMEM;
+
+	ret = nvme_submit_sync_cmd(q, (struct nvme_command *)&c, resp, sz);
+	if (ret)
+		goto done;
+
+	gf->rsp = le64_to_cpu(resp[0]);
+	gf->ext = le64_to_cpu(resp[1]);
+
+done:
+	kfree(resp);
+	return ret;
+}
+
+static int nvme_nvm_set_resp(struct request_queue *q, u64 resp)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct nvme_nvm_command c = {};
+
+	c.resp.opcode = nvme_nvm_admin_set_resp;
+	c.resp.nsid = cpu_to_le32(ns->ns_id);
+	c.resp.resp = cpu_to_le64(resp);
+	return nvme_submit_sync_cmd(q, (struct nvme_command *)&c, NULL, 0);
+}
+
+static int nvme_nvm_get_l2p_tbl(struct request_queue *q, u64 slba, u64 nlb,
+				nvm_l2p_update_fn *update_l2p, void *priv)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct nvme_dev *dev = ns->dev;
+	struct nvme_nvm_command c = {};
+	u32 len = queue_max_hw_sectors(q) << 9;
+	u64 nlb_pr_rq = len / sizeof(u64);
+	u64 cmd_slba = slba;
+	void *entries;
+	int ret = 0;
+
+	c.l2p.opcode = nvme_nvm_admin_get_l2p_tbl;
+	c.l2p.nsid = cpu_to_le32(ns->ns_id);
+	entries = kmalloc(len, GFP_KERNEL);
+	if (!entries)
+		return -ENOMEM;
+
+	while (nlb) {
+		u64 cmd_nlb = min_t(u64, nlb_pr_rq, nlb);
+
+		c.l2p.slba = cmd_slba;
+		c.l2p.nlb = cmd_nlb;
+
+		ret = nvme_submit_sync_cmd(q, (struct nvme_command *)&c,
+								entries, len);
+		if (ret) {
+			dev_err(dev->dev, "L2P table transfer failed (%d)\n",
+									ret);
+			ret = -EIO;
+			goto out;
+		}
+
+		if (update_l2p(cmd_slba, cmd_nlb, entries, priv)) {
+			ret = -EINTR;
+			goto out;
+		}
+
+		cmd_slba += cmd_nlb;
+		nlb -= cmd_nlb;
+	}
+
+out:
+	kfree(entries);
+	return ret;
+}
+
+static int nvme_nvm_get_bb_tbl(struct request_queue *q, int lunid,
+				unsigned int nr_blocks,
+				nvm_bb_update_fn *update_bbtbl, void *priv)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct nvme_dev *dev = ns->dev;
+	struct nvme_nvm_command c = {};
+	void *bb_bitmap;
+	u16 bb_bitmap_size;
+	int ret = 0;
+
+	c.get_bb.opcode = nvme_nvm_admin_get_bb_tbl;
+	c.get_bb.nsid = cpu_to_le32(ns->ns_id);
+	c.get_bb.lbb = cpu_to_le32(lunid);
+	bb_bitmap_size = ((nr_blocks >> 15) + 1) * PAGE_SIZE;
+	bb_bitmap = kmalloc(bb_bitmap_size, GFP_KERNEL);
+	if (!bb_bitmap)
+		return -ENOMEM;
+
+	bitmap_zero(bb_bitmap, nr_blocks);
+
+	ret = nvme_submit_sync_cmd(q, (struct nvme_command *)&c, bb_bitmap,
+								bb_bitmap_size);
+	if (ret) {
+		dev_err(dev->dev, "get bad block table failed (%d)\n", ret);
+		ret = -EIO;
+		goto out;
+	}
+
+	ret = update_bbtbl(lunid, bb_bitmap, nr_blocks, priv);
+	if (ret) {
+		ret = -EINTR;
+		goto out;
+	}
+
+out:
+	kfree(bb_bitmap);
+	return ret;
+}
+
+static inline void nvme_nvm_cmd_hybrid(struct nvm_rq *rqd, struct nvme_ns *ns,
+						struct nvme_nvm_command *c)
+{
+	c->hb_rw.opcode = (rqd->opcode & 1) ?
+				nvme_nvm_cmd_hb_write : nvme_nvm_cmd_hb_read;
+	c->hb_rw.nsid = cpu_to_le32(ns->ns_id);
+	if (rqd->nr_pages == 1)
+		c->hb_rw.spba = cpu_to_le64(rqd->ppa_addr.ppa);
+	else
+		c->hb_rw.spba = cpu_to_le64(rqd->dma_ppa_list);
+	c->hb_rw.length = cpu_to_le16(rqd->nr_pages - 1);
+	c->hb_rw.slba = cpu_to_le64(nvme_block_nr(ns,
+						rqd->bio->bi_iter.bi_sector));
+}
+
+static inline void nvme_nvm_cmd_phys(struct nvm_rq *rqd, struct nvme_ns *ns,
+						struct nvme_nvm_command *c)
+{
+	c->ph_rw.opcode = (rqd->opcode & 1) ?
+				nvme_nvm_cmd_ph_write : nvme_nvm_cmd_ph_read;
+	c->ph_rw.nsid = cpu_to_le32(ns->ns_id);
+	if (rqd->nr_pages == 1)
+		c->ph_rw.spba = cpu_to_le64(rqd->ppa_addr.ppa);
+	else
+		c->ph_rw.spba = cpu_to_le64(rqd->dma_ppa_list);
+	c->ph_rw.length = cpu_to_le16(rqd->nr_pages - 1);
+	c->ph_rw.control = cpu_to_le16(0x2); /*quad access*/
+}
+
+static inline void nvme_nvm_rqtocmd(struct request *rq, struct nvm_rq *rqd,
+				struct nvme_ns *ns, struct nvme_nvm_command *c)
+{
+	switch (rqd->opcode) {
+	case NVM_OP_HBWRITE:
+	case NVM_OP_HBREAD:
+		nvme_nvm_cmd_hybrid(rqd, ns, c);
+		break;
+	case NVM_OP_PWRITE:
+	case NVM_OP_PREAD:
+		nvme_nvm_cmd_phys(rqd, ns, c);
+		break;
+	default:
+		pr_err("nvme: invalid opcode\n");
+	}
+}
+
+static void nvme_nvm_end_io(struct request *rq, int error)
+{
+	struct nvm_rq *rqd = rq->end_io_data;
+	struct nvm_dev *dev = rqd->dev;
+
+	if (error)
+		pr_err("nvme: err status: %x result: %lx\n",
+				rq->errors, (unsigned long)rq->special);
+
+	dev->mt->end_io(rqd, error);
+
+	kfree(rq->cmd);
+	blk_mq_free_request(rq);
+}
+
+static int nvme_nvm_submit_io(struct request_queue *q, struct nvm_rq *rqd)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct request *rq;
+	struct bio *bio = rqd->bio;
+	struct nvme_nvm_command *cmd;
+
+	rq = blk_mq_alloc_request(q, bio_rw(bio), GFP_KERNEL, 0);
+	if (IS_ERR(rq))
+		return -ENOMEM;
+
+	cmd = kzalloc(sizeof(struct nvme_nvm_command), GFP_KERNEL);
+	if (!cmd) {
+		blk_mq_free_request(rq);
+		return -ENOMEM;
+	}
+
+	rq->cmd_type = REQ_TYPE_DRV_PRIV;
+	rq->ioprio = bio_prio(bio);
+
+	if (bio_has_data(bio))
+		rq->nr_phys_segments = bio_phys_segments(q, bio);
+
+	rq->__data_len = bio->bi_iter.bi_size;
+	rq->bio = rq->biotail = bio;
+
+	nvme_nvm_rqtocmd(rq, rqd, ns, cmd);
+
+	rq->cmd = (unsigned char *)cmd;
+	rq->cmd_len = sizeof(struct nvme_nvm_command);
+	rq->special = (void *)0;
+
+	rq->end_io_data = rqd;
+
+	blk_execute_rq_nowait(q, NULL, rq, 0, nvme_nvm_end_io);
+
+	return 0;
+}
+
+static int nvme_nvm_erase_block(struct request_queue *q, struct nvm_rq *rqd)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct nvme_nvm_command c = {};
+
+	c.erase.opcode = nvme_nvm_cmd_erase;
+	c.erase.nsid = cpu_to_le32(ns->ns_id);
+	if (rqd->nr_pages == 1)
+		c.erase.spba = cpu_to_le64(rqd->ppa_addr.ppa);
+	else
+		c.erase.spba = cpu_to_le64(rqd->dma_ppa_list);
+	c.erase.length = cpu_to_le16(rqd->nr_pages - 1);
+
+	return nvme_submit_sync_cmd(q, (struct nvme_command *)&c, NULL, 0);
+}
+
+static void *nvme_nvm_create_dma_pool(struct request_queue *q, char *name)
+{
+	struct nvme_ns *ns = q->queuedata;
+	struct nvme_dev *dev = ns->dev;
+
+	return dma_pool_create(name, dev->dev, PAGE_SIZE, PAGE_SIZE, 0);
+}
+
+static void nvme_nvm_destroy_dma_pool(void *pool)
+{
+	struct dma_pool *dma_pool = pool;
+
+	dma_pool_destroy(dma_pool);
+}
+
+static void *nvme_nvm_dev_dma_alloc(struct request_queue *q, void *pool,
+				    gfp_t mem_flags, dma_addr_t *dma_handler)
+{
+	return dma_pool_alloc(pool, mem_flags, dma_handler);
+}
+
+static void nvme_nvm_dev_dma_free(void *pool, void *ppa_list,
+							dma_addr_t dma_handler)
+{
+	dma_pool_free(pool, ppa_list, dma_handler);
+}
+
+static struct nvm_dev_ops nvme_nvm_dev_ops = {
+	.identify		= nvme_nvm_identify,
+
+	.get_features		= nvme_nvm_get_features,
+	.set_responsibility	= nvme_nvm_set_resp,
+
+	.get_l2p_tbl		= nvme_nvm_get_l2p_tbl,
+
+	.get_bb_tbl		= nvme_nvm_get_bb_tbl,
+
+	.submit_io		= nvme_nvm_submit_io,
+	.erase_block		= nvme_nvm_erase_block,
+
+	.create_dma_pool	= nvme_nvm_create_dma_pool,
+	.destroy_dma_pool	= nvme_nvm_destroy_dma_pool,
+	.dev_dma_alloc		= nvme_nvm_dev_dma_alloc,
+	.dev_dma_free		= nvme_nvm_dev_dma_free,
+
+	.max_phys_sect		= 64,
+};
+
+int nvme_nvm_register(struct request_queue *q, char *disk_name)
+{
+	return nvm_register(q, disk_name, &nvme_nvm_dev_ops);
+}
+
+void nvme_nvm_unregister(struct request_queue *q, char *disk_name)
+{
+	nvm_unregister(disk_name);
+}
+
+int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id)
+{
+	struct nvme_dev *dev = ns->dev;
+	struct pci_dev *pdev = to_pci_dev(dev->dev);
+
+	/* QEMU NVMe simulator - LightNVM detection*/
+	if (pdev->vendor == PCI_VENDOR_ID_INTEL && pdev->device == 0x5845 &&
+							id->vs[0] == 0x1)
+		return 1;
+
+	/* CNEX Labs */
+	if (pdev->vendor == 0x1d1d && pdev->device == 0x2807)
+		return 1;
+
+	return 0;
+}
+#else
+int nvme_nvm_register(struct request_queue *q, char *disk_name)
+{
+	return 0;
+}
+void nvme_nvm_unregister(char *disk_name) {};
+int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id)
+{
+	return 0;
+}
+#endif /* CONFIG_NVM */
diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index c1f41bf..fdb4e5b 100644
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -22,6 +22,11 @@ 
 extern unsigned char nvme_io_timeout;
 #define NVME_IO_TIMEOUT	(nvme_io_timeout * HZ)
 
+enum {
+	NVME_NS_LBA		= 0,
+	NVME_NS_LIGHTNVM	= 1,
+};
+
 /*
  * Represents an NVM Express device.  Each nvme_dev is a PCI function.
  */
@@ -84,6 +89,7 @@  struct nvme_ns {
 	u16 ms;
 	bool ext;
 	u8 pi_type;
+	int type;
 	u64 mode_select_num_blocks;
 	u32 mode_select_block_len;
 };
@@ -130,4 +136,8 @@  int nvme_sg_io(struct nvme_ns *ns, struct sg_io_hdr __user *u_hdr);
 int nvme_sg_io32(struct nvme_ns *ns, unsigned long arg);
 int nvme_sg_get_version_num(int __user *ip);
 
+int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id);
+int nvme_nvm_register(struct request_queue *q, char *disk_name);
+void nvme_nvm_unregister(struct request_queue *q, char *disk_name);
+
 #endif /* _NVME_H */
diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
index ad58ee3..cc22633 100644
--- a/drivers/nvme/host/pci.c
+++ b/drivers/nvme/host/pci.c
@@ -1946,6 +1946,9 @@  static void nvme_free_ns(struct kref *kref)
 {
 	struct nvme_ns *ns = container_of(kref, struct nvme_ns, kref);
 
+	if (ns->type == NVME_NS_LIGHTNVM)
+		nvme_nvm_unregister(ns->queue, ns->disk->disk_name);
+
 	spin_lock(&dev_list_lock);
 	ns->disk->private_data = NULL;
 	spin_unlock(&dev_list_lock);
@@ -2015,6 +2018,16 @@  static int nvme_revalidate_disk(struct gendisk *disk)
 		return -ENODEV;
 	}
 
+	if (nvme_nvm_ns_supported(ns, id) && ns->type != NVME_NS_LIGHTNVM) {
+		if (nvme_nvm_register(ns->queue, disk->disk_name)) {
+			dev_warn(dev->dev,
+				"%s: LightNVM init failure\n", __func__);
+			kfree(id);
+			return -ENODEV;
+		}
+		ns->type = NVME_NS_LIGHTNVM;
+	}
+
 	old_ms = ns->ms;
 	lbaf = id->flbas & NVME_NS_FLBAS_LBA_MASK;
 	ns->lba_shift = id->lbaf[lbaf].ds;
@@ -2046,7 +2059,9 @@  static int nvme_revalidate_disk(struct gendisk *disk)
 								!ns->ext)
 		nvme_init_integrity(ns);
 
-	if (ns->ms && !(ns->ms == 8 && ns->pi_type) && !blk_get_integrity(disk))
+	if ((ns->ms && !(ns->ms == 8 && ns->pi_type) &&
+						!blk_get_integrity(disk)) ||
+						ns->type == NVME_NS_LIGHTNVM)
 		set_capacity(disk, 0);
 	else
 		set_capacity(disk, le64_to_cpup(&id->nsze) << (ns->lba_shift - 9));
@@ -2169,17 +2184,19 @@  static void nvme_alloc_ns(struct nvme_dev *dev, unsigned nsid)
 		goto out_free_disk;
 
 	kref_get(&dev->kref);
-	add_disk(ns->disk);
-	if (ns->ms) {
-		struct block_device *bd = bdget_disk(ns->disk, 0);
-		if (!bd)
-			return;
-		if (blkdev_get(bd, FMODE_READ, NULL)) {
-			bdput(bd);
-			return;
+	if (ns->type != NVME_NS_LIGHTNVM) {
+		add_disk(ns->disk);
+		if (ns->ms) {
+			struct block_device *bd = bdget_disk(ns->disk, 0);
+			if (!bd)
+				return;
+			if (blkdev_get(bd, FMODE_READ, NULL)) {
+				bdput(bd);
+				return;
+			}
+			blkdev_reread_part(bd);
+			blkdev_put(bd, FMODE_READ);
 		}
-		blkdev_reread_part(bd);
-		blkdev_put(bd, FMODE_READ);
 	}
 	return;
  out_free_disk: