2 * nvme-lightnvm.c - LightNVM NVMe device
4 * Copyright (C) 2014-2015 IT University of Copenhagen
5 * Initial release: Matias Bjorling <mb@lightnvm.io>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; see the file COPYING. If not, write to
18 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
25 #include <linux/nvme.h>
26 #include <linux/bitops.h>
27 #include <linux/lightnvm.h>
28 #include <linux/vmalloc.h>
29 #include <linux/sched/sysctl.h>
30 #include <uapi/linux/lightnvm.h>
32 enum nvme_nvm_admin_opcode {
33 nvme_nvm_admin_identity = 0xe2,
34 nvme_nvm_admin_get_bb_tbl = 0xf2,
35 nvme_nvm_admin_set_bb_tbl = 0xf1,
38 struct nvme_nvm_ph_rw {
54 struct nvme_nvm_erase_blk {
69 struct nvme_nvm_identity {
80 struct nvme_nvm_getbbtbl {
92 struct nvme_nvm_setbbtbl {
107 struct nvme_nvm_command {
109 struct nvme_common_command common;
110 struct nvme_nvm_ph_rw ph_rw;
111 struct nvme_nvm_erase_blk erase;
112 struct nvme_nvm_identity identity;
113 struct nvme_nvm_getbbtbl get_bb;
114 struct nvme_nvm_setbbtbl set_bb;
118 struct nvme_nvm_id12_grp {
144 struct nvme_nvm_id12_addrf {
160 struct nvme_nvm_id12 {
167 struct nvme_nvm_id12_addrf ppaf;
169 struct nvme_nvm_id12_grp grp;
173 struct nvme_nvm_bb_tbl {
187 struct nvme_nvm_id20_addrf {
195 struct nvme_nvm_id20 {
200 struct nvme_nvm_id20_addrf lbaf;
215 /* Write data requirements */
223 /* Performance related metrics */
235 /* Vendor specific */
240 * Check we didn't inadvertently grow the command struct
242 static inline void _nvme_nvm_check_size(void)
244 BUILD_BUG_ON(sizeof(struct nvme_nvm_identity) != 64);
245 BUILD_BUG_ON(sizeof(struct nvme_nvm_ph_rw) != 64);
246 BUILD_BUG_ON(sizeof(struct nvme_nvm_erase_blk) != 64);
247 BUILD_BUG_ON(sizeof(struct nvme_nvm_getbbtbl) != 64);
248 BUILD_BUG_ON(sizeof(struct nvme_nvm_setbbtbl) != 64);
249 BUILD_BUG_ON(sizeof(struct nvme_nvm_id12_grp) != 960);
250 BUILD_BUG_ON(sizeof(struct nvme_nvm_id12_addrf) != 16);
251 BUILD_BUG_ON(sizeof(struct nvme_nvm_id12) != NVME_IDENTIFY_DATA_SIZE);
252 BUILD_BUG_ON(sizeof(struct nvme_nvm_bb_tbl) != 64);
253 BUILD_BUG_ON(sizeof(struct nvme_nvm_id20_addrf) != 8);
254 BUILD_BUG_ON(sizeof(struct nvme_nvm_id20) != NVME_IDENTIFY_DATA_SIZE);
257 static int init_grp(struct nvm_id *nvm_id, struct nvme_nvm_id12 *id12)
259 struct nvme_nvm_id12_grp *src;
260 int sec_per_pg, sec_per_pl, pg_per_blk;
262 if (id12->cgrps != 1)
267 nvm_id->mtype = src->mtype;
268 nvm_id->fmtype = src->fmtype;
270 nvm_id->num_ch = src->num_ch;
271 nvm_id->num_lun = src->num_lun;
273 nvm_id->num_chk = le16_to_cpu(src->num_chk);
274 nvm_id->csecs = le16_to_cpu(src->csecs);
275 nvm_id->sos = le16_to_cpu(src->sos);
277 pg_per_blk = le16_to_cpu(src->num_pg);
278 sec_per_pg = le16_to_cpu(src->fpg_sz) / nvm_id->csecs;
279 sec_per_pl = sec_per_pg * src->num_pln;
280 nvm_id->clba = sec_per_pl * pg_per_blk;
281 nvm_id->ws_per_chk = pg_per_blk;
283 nvm_id->mpos = le32_to_cpu(src->mpos);
284 nvm_id->cpar = le16_to_cpu(src->cpar);
285 nvm_id->mccap = le32_to_cpu(src->mccap);
287 nvm_id->ws_opt = nvm_id->ws_min = sec_per_pg;
288 nvm_id->ws_seq = NVM_IO_SNGL_ACCESS;
290 if (nvm_id->mpos & 0x020202) {
291 nvm_id->ws_seq = NVM_IO_DUAL_ACCESS;
292 nvm_id->ws_opt <<= 1;
293 } else if (nvm_id->mpos & 0x040404) {
294 nvm_id->ws_seq = NVM_IO_QUAD_ACCESS;
295 nvm_id->ws_opt <<= 2;
298 nvm_id->trdt = le32_to_cpu(src->trdt);
299 nvm_id->trdm = le32_to_cpu(src->trdm);
300 nvm_id->tprt = le32_to_cpu(src->tprt);
301 nvm_id->tprm = le32_to_cpu(src->tprm);
302 nvm_id->tbet = le32_to_cpu(src->tbet);
303 nvm_id->tbem = le32_to_cpu(src->tbem);
305 /* 1.2 compatibility */
306 nvm_id->num_pln = src->num_pln;
307 nvm_id->num_pg = le16_to_cpu(src->num_pg);
308 nvm_id->fpg_sz = le16_to_cpu(src->fpg_sz);
313 static int nvme_nvm_setup_12(struct nvm_dev *nvmdev, struct nvm_id *nvm_id,
314 struct nvme_nvm_id12 *id)
316 nvm_id->ver_id = id->ver_id;
317 nvm_id->vmnt = id->vmnt;
318 nvm_id->cap = le32_to_cpu(id->cap);
319 nvm_id->dom = le32_to_cpu(id->dom);
320 memcpy(&nvm_id->ppaf, &id->ppaf,
321 sizeof(struct nvm_addr_format));
323 return init_grp(nvm_id, id);
326 static int nvme_nvm_setup_20(struct nvm_dev *nvmdev, struct nvm_id *nvm_id,
327 struct nvme_nvm_id20 *id)
329 nvm_id->ver_id = id->mjr;
331 nvm_id->num_ch = le16_to_cpu(id->num_grp);
332 nvm_id->num_lun = le16_to_cpu(id->num_pu);
333 nvm_id->num_chk = le32_to_cpu(id->num_chk);
334 nvm_id->clba = le32_to_cpu(id->clba);
336 nvm_id->ws_min = le32_to_cpu(id->ws_min);
337 nvm_id->ws_opt = le32_to_cpu(id->ws_opt);
338 nvm_id->mw_cunits = le32_to_cpu(id->mw_cunits);
340 nvm_id->trdt = le32_to_cpu(id->trdt);
341 nvm_id->trdm = le32_to_cpu(id->trdm);
342 nvm_id->tprt = le32_to_cpu(id->twrt);
343 nvm_id->tprm = le32_to_cpu(id->twrm);
344 nvm_id->tbet = le32_to_cpu(id->tcrst);
345 nvm_id->tbem = le32_to_cpu(id->tcrsm);
347 /* calculated values */
348 nvm_id->ws_per_chk = nvm_id->clba / nvm_id->ws_min;
350 /* 1.2 compatibility */
351 nvm_id->ws_seq = NVM_IO_SNGL_ACCESS;
356 static int nvme_nvm_identity(struct nvm_dev *nvmdev, struct nvm_id *nvm_id)
358 struct nvme_ns *ns = nvmdev->q->queuedata;
359 struct nvme_nvm_id12 *id;
360 struct nvme_nvm_command c = {};
363 c.identity.opcode = nvme_nvm_admin_identity;
364 c.identity.nsid = cpu_to_le32(ns->head->ns_id);
366 id = kmalloc(sizeof(struct nvme_nvm_id12), GFP_KERNEL);
370 ret = nvme_submit_sync_cmd(ns->ctrl->admin_q, (struct nvme_command *)&c,
371 id, sizeof(struct nvme_nvm_id12));
378 * The 1.2 and 2.0 specifications share the first byte in their geometry
379 * command to make it possible to know what version a device implements.
381 switch (id->ver_id) {
383 ret = nvme_nvm_setup_12(nvmdev, nvm_id, id);
386 ret = nvme_nvm_setup_20(nvmdev, nvm_id,
387 (struct nvme_nvm_id20 *)id);
390 dev_err(ns->ctrl->device,
391 "OCSSD revision not supported (%d)\n",
400 static int nvme_nvm_get_bb_tbl(struct nvm_dev *nvmdev, struct ppa_addr ppa,
403 struct request_queue *q = nvmdev->q;
404 struct nvm_geo *geo = &nvmdev->geo;
405 struct nvme_ns *ns = q->queuedata;
406 struct nvme_ctrl *ctrl = ns->ctrl;
407 struct nvme_nvm_command c = {};
408 struct nvme_nvm_bb_tbl *bb_tbl;
409 int nr_blks = geo->nr_chks * geo->plane_mode;
410 int tblsz = sizeof(struct nvme_nvm_bb_tbl) + nr_blks;
413 c.get_bb.opcode = nvme_nvm_admin_get_bb_tbl;
414 c.get_bb.nsid = cpu_to_le32(ns->head->ns_id);
415 c.get_bb.spba = cpu_to_le64(ppa.ppa);
417 bb_tbl = kzalloc(tblsz, GFP_KERNEL);
421 ret = nvme_submit_sync_cmd(ctrl->admin_q, (struct nvme_command *)&c,
424 dev_err(ctrl->device, "get bad block table failed (%d)\n", ret);
429 if (bb_tbl->tblid[0] != 'B' || bb_tbl->tblid[1] != 'B' ||
430 bb_tbl->tblid[2] != 'L' || bb_tbl->tblid[3] != 'T') {
431 dev_err(ctrl->device, "bbt format mismatch\n");
436 if (le16_to_cpu(bb_tbl->verid) != 1) {
438 dev_err(ctrl->device, "bbt version not supported\n");
442 if (le32_to_cpu(bb_tbl->tblks) != nr_blks) {
444 dev_err(ctrl->device,
445 "bbt unsuspected blocks returned (%u!=%u)",
446 le32_to_cpu(bb_tbl->tblks), nr_blks);
450 memcpy(blks, bb_tbl->blk, geo->nr_chks * geo->plane_mode);
456 static int nvme_nvm_set_bb_tbl(struct nvm_dev *nvmdev, struct ppa_addr *ppas,
457 int nr_ppas, int type)
459 struct nvme_ns *ns = nvmdev->q->queuedata;
460 struct nvme_nvm_command c = {};
463 c.set_bb.opcode = nvme_nvm_admin_set_bb_tbl;
464 c.set_bb.nsid = cpu_to_le32(ns->head->ns_id);
465 c.set_bb.spba = cpu_to_le64(ppas->ppa);
466 c.set_bb.nlb = cpu_to_le16(nr_ppas - 1);
467 c.set_bb.value = type;
469 ret = nvme_submit_sync_cmd(ns->ctrl->admin_q, (struct nvme_command *)&c,
472 dev_err(ns->ctrl->device, "set bad block table failed (%d)\n",
477 static inline void nvme_nvm_rqtocmd(struct nvm_rq *rqd, struct nvme_ns *ns,
478 struct nvme_nvm_command *c)
480 c->ph_rw.opcode = rqd->opcode;
481 c->ph_rw.nsid = cpu_to_le32(ns->head->ns_id);
482 c->ph_rw.spba = cpu_to_le64(rqd->ppa_addr.ppa);
483 c->ph_rw.metadata = cpu_to_le64(rqd->dma_meta_list);
484 c->ph_rw.control = cpu_to_le16(rqd->flags);
485 c->ph_rw.length = cpu_to_le16(rqd->nr_ppas - 1);
488 static void nvme_nvm_end_io(struct request *rq, blk_status_t status)
490 struct nvm_rq *rqd = rq->end_io_data;
492 rqd->ppa_status = le64_to_cpu(nvme_req(rq)->result.u64);
493 rqd->error = nvme_req(rq)->status;
496 kfree(nvme_req(rq)->cmd);
497 blk_mq_free_request(rq);
500 static struct request *nvme_nvm_alloc_request(struct request_queue *q,
502 struct nvme_nvm_command *cmd)
504 struct nvme_ns *ns = q->queuedata;
507 nvme_nvm_rqtocmd(rqd, ns, cmd);
509 rq = nvme_alloc_request(q, (struct nvme_command *)cmd, 0, NVME_QID_ANY);
513 rq->cmd_flags &= ~REQ_FAILFAST_DRIVER;
516 blk_init_request_from_bio(rq, rqd->bio);
518 rq->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, IOPRIO_NORM);
525 static int nvme_nvm_submit_io(struct nvm_dev *dev, struct nvm_rq *rqd)
527 struct request_queue *q = dev->q;
528 struct nvme_nvm_command *cmd;
531 cmd = kzalloc(sizeof(struct nvme_nvm_command), GFP_KERNEL);
535 rq = nvme_nvm_alloc_request(q, rqd, cmd);
541 rq->end_io_data = rqd;
543 blk_execute_rq_nowait(q, NULL, rq, 0, nvme_nvm_end_io);
548 static int nvme_nvm_submit_io_sync(struct nvm_dev *dev, struct nvm_rq *rqd)
550 struct request_queue *q = dev->q;
552 struct nvme_nvm_command cmd;
555 memset(&cmd, 0, sizeof(struct nvme_nvm_command));
557 rq = nvme_nvm_alloc_request(q, rqd, &cmd);
561 /* I/Os can fail and the error is signaled through rqd. Callers must
562 * handle the error accordingly.
564 blk_execute_rq(q, NULL, rq, 0);
565 if (nvme_req(rq)->flags & NVME_REQ_CANCELLED)
568 rqd->ppa_status = le64_to_cpu(nvme_req(rq)->result.u64);
569 rqd->error = nvme_req(rq)->status;
571 blk_mq_free_request(rq);
576 static void *nvme_nvm_create_dma_pool(struct nvm_dev *nvmdev, char *name)
578 struct nvme_ns *ns = nvmdev->q->queuedata;
580 return dma_pool_create(name, ns->ctrl->dev, PAGE_SIZE, PAGE_SIZE, 0);
583 static void nvme_nvm_destroy_dma_pool(void *pool)
585 struct dma_pool *dma_pool = pool;
587 dma_pool_destroy(dma_pool);
590 static void *nvme_nvm_dev_dma_alloc(struct nvm_dev *dev, void *pool,
591 gfp_t mem_flags, dma_addr_t *dma_handler)
593 return dma_pool_alloc(pool, mem_flags, dma_handler);
596 static void nvme_nvm_dev_dma_free(void *pool, void *addr,
597 dma_addr_t dma_handler)
599 dma_pool_free(pool, addr, dma_handler);
602 static struct nvm_dev_ops nvme_nvm_dev_ops = {
603 .identity = nvme_nvm_identity,
605 .get_bb_tbl = nvme_nvm_get_bb_tbl,
606 .set_bb_tbl = nvme_nvm_set_bb_tbl,
608 .submit_io = nvme_nvm_submit_io,
609 .submit_io_sync = nvme_nvm_submit_io_sync,
611 .create_dma_pool = nvme_nvm_create_dma_pool,
612 .destroy_dma_pool = nvme_nvm_destroy_dma_pool,
613 .dev_dma_alloc = nvme_nvm_dev_dma_alloc,
614 .dev_dma_free = nvme_nvm_dev_dma_free,
617 static int nvme_nvm_submit_user_cmd(struct request_queue *q,
619 struct nvme_nvm_command *vcmd,
620 void __user *ubuf, unsigned int bufflen,
621 void __user *meta_buf, unsigned int meta_len,
622 void __user *ppa_buf, unsigned int ppa_len,
623 u32 *result, u64 *status, unsigned int timeout)
625 bool write = nvme_is_write((struct nvme_command *)vcmd);
626 struct nvm_dev *dev = ns->ndev;
627 struct gendisk *disk = ns->disk;
629 struct bio *bio = NULL;
630 __le64 *ppa_list = NULL;
632 __le64 *metadata = NULL;
633 dma_addr_t metadata_dma;
634 DECLARE_COMPLETION_ONSTACK(wait);
637 rq = nvme_alloc_request(q, (struct nvme_command *)vcmd, 0,
644 rq->timeout = timeout ? timeout : ADMIN_TIMEOUT;
646 if (ppa_buf && ppa_len) {
647 ppa_list = dma_pool_alloc(dev->dma_pool, GFP_KERNEL, &ppa_dma);
652 if (copy_from_user(ppa_list, (void __user *)ppa_buf,
653 sizeof(u64) * (ppa_len + 1))) {
657 vcmd->ph_rw.spba = cpu_to_le64(ppa_dma);
659 vcmd->ph_rw.spba = cpu_to_le64((uintptr_t)ppa_buf);
662 if (ubuf && bufflen) {
663 ret = blk_rq_map_user(q, rq, NULL, ubuf, bufflen, GFP_KERNEL);
668 if (meta_buf && meta_len) {
669 metadata = dma_pool_alloc(dev->dma_pool, GFP_KERNEL,
677 if (copy_from_user(metadata,
678 (void __user *)meta_buf,
684 vcmd->ph_rw.metadata = cpu_to_le64(metadata_dma);
690 blk_execute_rq(q, NULL, rq, 0);
692 if (nvme_req(rq)->flags & NVME_REQ_CANCELLED)
694 else if (nvme_req(rq)->status & 0x7ff)
697 *result = nvme_req(rq)->status & 0x7ff;
699 *status = le64_to_cpu(nvme_req(rq)->result.u64);
701 if (metadata && !ret && !write) {
702 if (copy_to_user(meta_buf, (void *)metadata, meta_len))
706 if (meta_buf && meta_len)
707 dma_pool_free(dev->dma_pool, metadata, metadata_dma);
710 blk_rq_unmap_user(bio);
712 if (ppa_buf && ppa_len)
713 dma_pool_free(dev->dma_pool, ppa_list, ppa_dma);
715 blk_mq_free_request(rq);
720 static int nvme_nvm_submit_vio(struct nvme_ns *ns,
721 struct nvm_user_vio __user *uvio)
723 struct nvm_user_vio vio;
724 struct nvme_nvm_command c;
728 if (copy_from_user(&vio, uvio, sizeof(vio)))
733 memset(&c, 0, sizeof(c));
734 c.ph_rw.opcode = vio.opcode;
735 c.ph_rw.nsid = cpu_to_le32(ns->head->ns_id);
736 c.ph_rw.control = cpu_to_le16(vio.control);
737 c.ph_rw.length = cpu_to_le16(vio.nppas);
739 length = (vio.nppas + 1) << ns->lba_shift;
741 ret = nvme_nvm_submit_user_cmd(ns->queue, ns, &c,
742 (void __user *)(uintptr_t)vio.addr, length,
743 (void __user *)(uintptr_t)vio.metadata,
745 (void __user *)(uintptr_t)vio.ppa_list, vio.nppas,
746 &vio.result, &vio.status, 0);
748 if (ret && copy_to_user(uvio, &vio, sizeof(vio)))
754 static int nvme_nvm_user_vcmd(struct nvme_ns *ns, int admin,
755 struct nvm_passthru_vio __user *uvcmd)
757 struct nvm_passthru_vio vcmd;
758 struct nvme_nvm_command c;
759 struct request_queue *q;
760 unsigned int timeout = 0;
763 if (copy_from_user(&vcmd, uvcmd, sizeof(vcmd)))
765 if ((vcmd.opcode != 0xF2) && (!capable(CAP_SYS_ADMIN)))
770 memset(&c, 0, sizeof(c));
771 c.common.opcode = vcmd.opcode;
772 c.common.nsid = cpu_to_le32(ns->head->ns_id);
773 c.common.cdw2[0] = cpu_to_le32(vcmd.cdw2);
774 c.common.cdw2[1] = cpu_to_le32(vcmd.cdw3);
776 c.ph_rw.length = cpu_to_le16(vcmd.nppas);
777 c.ph_rw.control = cpu_to_le16(vcmd.control);
778 c.common.cdw10[3] = cpu_to_le32(vcmd.cdw13);
779 c.common.cdw10[4] = cpu_to_le32(vcmd.cdw14);
780 c.common.cdw10[5] = cpu_to_le32(vcmd.cdw15);
783 timeout = msecs_to_jiffies(vcmd.timeout_ms);
785 q = admin ? ns->ctrl->admin_q : ns->queue;
787 ret = nvme_nvm_submit_user_cmd(q, ns,
788 (struct nvme_nvm_command *)&c,
789 (void __user *)(uintptr_t)vcmd.addr, vcmd.data_len,
790 (void __user *)(uintptr_t)vcmd.metadata,
792 (void __user *)(uintptr_t)vcmd.ppa_list, vcmd.nppas,
793 &vcmd.result, &vcmd.status, timeout);
795 if (ret && copy_to_user(uvcmd, &vcmd, sizeof(vcmd)))
801 int nvme_nvm_ioctl(struct nvme_ns *ns, unsigned int cmd, unsigned long arg)
804 case NVME_NVM_IOCTL_ADMIN_VIO:
805 return nvme_nvm_user_vcmd(ns, 1, (void __user *)arg);
806 case NVME_NVM_IOCTL_IO_VIO:
807 return nvme_nvm_user_vcmd(ns, 0, (void __user *)arg);
808 case NVME_NVM_IOCTL_SUBMIT_VIO:
809 return nvme_nvm_submit_vio(ns, (void __user *)arg);
815 void nvme_nvm_update_nvm_info(struct nvme_ns *ns)
817 struct nvm_dev *ndev = ns->ndev;
819 ndev->identity.csecs = ndev->geo.sec_size = 1 << ns->lba_shift;
820 ndev->identity.sos = ndev->geo.oob_size = ns->ms;
823 int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, int node)
825 struct request_queue *q = ns->queue;
828 _nvme_nvm_check_size();
830 dev = nvm_alloc_dev(node);
835 memcpy(dev->name, disk_name, DISK_NAME_LEN);
836 dev->ops = &nvme_nvm_dev_ops;
837 dev->private_data = ns;
840 return nvm_register(dev);
843 void nvme_nvm_unregister(struct nvme_ns *ns)
845 nvm_unregister(ns->ndev);
848 static ssize_t nvm_dev_attr_show(struct device *dev,
849 struct device_attribute *dattr, char *page)
851 struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
852 struct nvm_dev *ndev = ns->ndev;
854 struct attribute *attr;
859 id = &ndev->identity;
862 if (strcmp(attr->name, "version") == 0) {
863 return scnprintf(page, PAGE_SIZE, "%u\n", id->ver_id);
864 } else if (strcmp(attr->name, "capabilities") == 0) {
865 return scnprintf(page, PAGE_SIZE, "%u\n", id->cap);
866 } else if (strcmp(attr->name, "read_typ") == 0) {
867 return scnprintf(page, PAGE_SIZE, "%u\n", id->trdt);
868 } else if (strcmp(attr->name, "read_max") == 0) {
869 return scnprintf(page, PAGE_SIZE, "%u\n", id->trdm);
871 return scnprintf(page,
873 "Unhandled attr(%s) in `nvm_dev_attr_show`\n",
878 static ssize_t nvm_dev_attr_show_12(struct device *dev,
879 struct device_attribute *dattr, char *page)
881 struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
882 struct nvm_dev *ndev = ns->ndev;
884 struct attribute *attr;
889 id = &ndev->identity;
892 if (strcmp(attr->name, "vendor_opcode") == 0) {
893 return scnprintf(page, PAGE_SIZE, "%u\n", id->vmnt);
894 } else if (strcmp(attr->name, "device_mode") == 0) {
895 return scnprintf(page, PAGE_SIZE, "%u\n", id->dom);
896 /* kept for compatibility */
897 } else if (strcmp(attr->name, "media_manager") == 0) {
898 return scnprintf(page, PAGE_SIZE, "%s\n", "gennvm");
899 } else if (strcmp(attr->name, "ppa_format") == 0) {
900 return scnprintf(page, PAGE_SIZE,
901 "0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
902 id->ppaf.ch_offset, id->ppaf.ch_len,
903 id->ppaf.lun_offset, id->ppaf.lun_len,
904 id->ppaf.pln_offset, id->ppaf.pln_len,
905 id->ppaf.blk_offset, id->ppaf.blk_len,
906 id->ppaf.pg_offset, id->ppaf.pg_len,
907 id->ppaf.sect_offset, id->ppaf.sect_len);
908 } else if (strcmp(attr->name, "media_type") == 0) { /* u8 */
909 return scnprintf(page, PAGE_SIZE, "%u\n", id->mtype);
910 } else if (strcmp(attr->name, "flash_media_type") == 0) {
911 return scnprintf(page, PAGE_SIZE, "%u\n", id->fmtype);
912 } else if (strcmp(attr->name, "num_channels") == 0) {
913 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_ch);
914 } else if (strcmp(attr->name, "num_luns") == 0) {
915 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_lun);
916 } else if (strcmp(attr->name, "num_planes") == 0) {
917 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_pln);
918 } else if (strcmp(attr->name, "num_blocks") == 0) { /* u16 */
919 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_chk);
920 } else if (strcmp(attr->name, "num_pages") == 0) {
921 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_pg);
922 } else if (strcmp(attr->name, "page_size") == 0) {
923 return scnprintf(page, PAGE_SIZE, "%u\n", id->fpg_sz);
924 } else if (strcmp(attr->name, "hw_sector_size") == 0) {
925 return scnprintf(page, PAGE_SIZE, "%u\n", id->csecs);
926 } else if (strcmp(attr->name, "oob_sector_size") == 0) {/* u32 */
927 return scnprintf(page, PAGE_SIZE, "%u\n", id->sos);
928 } else if (strcmp(attr->name, "prog_typ") == 0) {
929 return scnprintf(page, PAGE_SIZE, "%u\n", id->tprt);
930 } else if (strcmp(attr->name, "prog_max") == 0) {
931 return scnprintf(page, PAGE_SIZE, "%u\n", id->tprm);
932 } else if (strcmp(attr->name, "erase_typ") == 0) {
933 return scnprintf(page, PAGE_SIZE, "%u\n", id->tbet);
934 } else if (strcmp(attr->name, "erase_max") == 0) {
935 return scnprintf(page, PAGE_SIZE, "%u\n", id->tbem);
936 } else if (strcmp(attr->name, "multiplane_modes") == 0) {
937 return scnprintf(page, PAGE_SIZE, "0x%08x\n", id->mpos);
938 } else if (strcmp(attr->name, "media_capabilities") == 0) {
939 return scnprintf(page, PAGE_SIZE, "0x%08x\n", id->mccap);
940 } else if (strcmp(attr->name, "max_phys_secs") == 0) {
941 return scnprintf(page, PAGE_SIZE, "%u\n", NVM_MAX_VLBA);
943 return scnprintf(page,
945 "Unhandled attr(%s) in `nvm_dev_attr_show_12`\n",
950 static ssize_t nvm_dev_attr_show_20(struct device *dev,
951 struct device_attribute *dattr, char *page)
953 struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
954 struct nvm_dev *ndev = ns->ndev;
956 struct attribute *attr;
961 id = &ndev->identity;
964 if (strcmp(attr->name, "groups") == 0) {
965 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_ch);
966 } else if (strcmp(attr->name, "punits") == 0) {
967 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_lun);
968 } else if (strcmp(attr->name, "chunks") == 0) {
969 return scnprintf(page, PAGE_SIZE, "%u\n", id->num_chk);
970 } else if (strcmp(attr->name, "clba") == 0) {
971 return scnprintf(page, PAGE_SIZE, "%u\n", id->clba);
972 } else if (strcmp(attr->name, "ws_min") == 0) {
973 return scnprintf(page, PAGE_SIZE, "%u\n", id->ws_min);
974 } else if (strcmp(attr->name, "ws_opt") == 0) {
975 return scnprintf(page, PAGE_SIZE, "%u\n", id->ws_opt);
976 } else if (strcmp(attr->name, "mw_cunits") == 0) {
977 return scnprintf(page, PAGE_SIZE, "%u\n", id->mw_cunits);
978 } else if (strcmp(attr->name, "write_typ") == 0) {
979 return scnprintf(page, PAGE_SIZE, "%u\n", id->tprt);
980 } else if (strcmp(attr->name, "write_max") == 0) {
981 return scnprintf(page, PAGE_SIZE, "%u\n", id->tprm);
982 } else if (strcmp(attr->name, "reset_typ") == 0) {
983 return scnprintf(page, PAGE_SIZE, "%u\n", id->tbet);
984 } else if (strcmp(attr->name, "reset_max") == 0) {
985 return scnprintf(page, PAGE_SIZE, "%u\n", id->tbem);
987 return scnprintf(page,
989 "Unhandled attr(%s) in `nvm_dev_attr_show_20`\n",
994 #define NVM_DEV_ATTR_RO(_name) \
995 DEVICE_ATTR(_name, S_IRUGO, nvm_dev_attr_show, NULL)
996 #define NVM_DEV_ATTR_12_RO(_name) \
997 DEVICE_ATTR(_name, S_IRUGO, nvm_dev_attr_show_12, NULL)
998 #define NVM_DEV_ATTR_20_RO(_name) \
999 DEVICE_ATTR(_name, S_IRUGO, nvm_dev_attr_show_20, NULL)
1001 /* general attributes */
1002 static NVM_DEV_ATTR_RO(version);
1003 static NVM_DEV_ATTR_RO(capabilities);
1005 static NVM_DEV_ATTR_RO(read_typ);
1006 static NVM_DEV_ATTR_RO(read_max);
1009 static NVM_DEV_ATTR_12_RO(vendor_opcode);
1010 static NVM_DEV_ATTR_12_RO(device_mode);
1011 static NVM_DEV_ATTR_12_RO(ppa_format);
1012 static NVM_DEV_ATTR_12_RO(media_manager);
1013 static NVM_DEV_ATTR_12_RO(media_type);
1014 static NVM_DEV_ATTR_12_RO(flash_media_type);
1015 static NVM_DEV_ATTR_12_RO(num_channels);
1016 static NVM_DEV_ATTR_12_RO(num_luns);
1017 static NVM_DEV_ATTR_12_RO(num_planes);
1018 static NVM_DEV_ATTR_12_RO(num_blocks);
1019 static NVM_DEV_ATTR_12_RO(num_pages);
1020 static NVM_DEV_ATTR_12_RO(page_size);
1021 static NVM_DEV_ATTR_12_RO(hw_sector_size);
1022 static NVM_DEV_ATTR_12_RO(oob_sector_size);
1023 static NVM_DEV_ATTR_12_RO(prog_typ);
1024 static NVM_DEV_ATTR_12_RO(prog_max);
1025 static NVM_DEV_ATTR_12_RO(erase_typ);
1026 static NVM_DEV_ATTR_12_RO(erase_max);
1027 static NVM_DEV_ATTR_12_RO(multiplane_modes);
1028 static NVM_DEV_ATTR_12_RO(media_capabilities);
1029 static NVM_DEV_ATTR_12_RO(max_phys_secs);
1031 static struct attribute *nvm_dev_attrs_12[] = {
1032 &dev_attr_version.attr,
1033 &dev_attr_capabilities.attr,
1035 &dev_attr_vendor_opcode.attr,
1036 &dev_attr_device_mode.attr,
1037 &dev_attr_media_manager.attr,
1038 &dev_attr_ppa_format.attr,
1039 &dev_attr_media_type.attr,
1040 &dev_attr_flash_media_type.attr,
1041 &dev_attr_num_channels.attr,
1042 &dev_attr_num_luns.attr,
1043 &dev_attr_num_planes.attr,
1044 &dev_attr_num_blocks.attr,
1045 &dev_attr_num_pages.attr,
1046 &dev_attr_page_size.attr,
1047 &dev_attr_hw_sector_size.attr,
1048 &dev_attr_oob_sector_size.attr,
1049 &dev_attr_read_typ.attr,
1050 &dev_attr_read_max.attr,
1051 &dev_attr_prog_typ.attr,
1052 &dev_attr_prog_max.attr,
1053 &dev_attr_erase_typ.attr,
1054 &dev_attr_erase_max.attr,
1055 &dev_attr_multiplane_modes.attr,
1056 &dev_attr_media_capabilities.attr,
1057 &dev_attr_max_phys_secs.attr,
1062 static const struct attribute_group nvm_dev_attr_group_12 = {
1064 .attrs = nvm_dev_attrs_12,
1068 static NVM_DEV_ATTR_20_RO(groups);
1069 static NVM_DEV_ATTR_20_RO(punits);
1070 static NVM_DEV_ATTR_20_RO(chunks);
1071 static NVM_DEV_ATTR_20_RO(clba);
1072 static NVM_DEV_ATTR_20_RO(ws_min);
1073 static NVM_DEV_ATTR_20_RO(ws_opt);
1074 static NVM_DEV_ATTR_20_RO(mw_cunits);
1075 static NVM_DEV_ATTR_20_RO(write_typ);
1076 static NVM_DEV_ATTR_20_RO(write_max);
1077 static NVM_DEV_ATTR_20_RO(reset_typ);
1078 static NVM_DEV_ATTR_20_RO(reset_max);
1080 static struct attribute *nvm_dev_attrs_20[] = {
1081 &dev_attr_version.attr,
1082 &dev_attr_capabilities.attr,
1084 &dev_attr_groups.attr,
1085 &dev_attr_punits.attr,
1086 &dev_attr_chunks.attr,
1087 &dev_attr_clba.attr,
1088 &dev_attr_ws_min.attr,
1089 &dev_attr_ws_opt.attr,
1090 &dev_attr_mw_cunits.attr,
1092 &dev_attr_read_typ.attr,
1093 &dev_attr_read_max.attr,
1094 &dev_attr_write_typ.attr,
1095 &dev_attr_write_max.attr,
1096 &dev_attr_reset_typ.attr,
1097 &dev_attr_reset_max.attr,
1102 static const struct attribute_group nvm_dev_attr_group_20 = {
1104 .attrs = nvm_dev_attrs_20,
1107 int nvme_nvm_register_sysfs(struct nvme_ns *ns)
1112 switch (ns->ndev->identity.ver_id) {
1114 return sysfs_create_group(&disk_to_dev(ns->disk)->kobj,
1115 &nvm_dev_attr_group_12);
1117 return sysfs_create_group(&disk_to_dev(ns->disk)->kobj,
1118 &nvm_dev_attr_group_20);
1124 void nvme_nvm_unregister_sysfs(struct nvme_ns *ns)
1126 switch (ns->ndev->identity.ver_id) {
1128 sysfs_remove_group(&disk_to_dev(ns->disk)->kobj,
1129 &nvm_dev_attr_group_12);
1132 sysfs_remove_group(&disk_to_dev(ns->disk)->kobj,
1133 &nvm_dev_attr_group_20);