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>
30 enum nvme_nvm_admin_opcode
{
31 nvme_nvm_admin_identity
= 0xe2,
32 nvme_nvm_admin_get_l2p_tbl
= 0xea,
33 nvme_nvm_admin_get_bb_tbl
= 0xf2,
34 nvme_nvm_admin_set_bb_tbl
= 0xf1,
37 struct nvme_nvm_hb_rw
{
53 struct nvme_nvm_ph_rw
{
69 struct nvme_nvm_identity
{
81 struct nvme_nvm_l2ptbl
{
94 struct nvme_nvm_getbbtbl
{
106 struct nvme_nvm_setbbtbl
{
121 struct nvme_nvm_erase_blk
{
136 struct nvme_nvm_command
{
138 struct nvme_common_command common
;
139 struct nvme_nvm_identity identity
;
140 struct nvme_nvm_hb_rw hb_rw
;
141 struct nvme_nvm_ph_rw ph_rw
;
142 struct nvme_nvm_l2ptbl l2p
;
143 struct nvme_nvm_getbbtbl get_bb
;
144 struct nvme_nvm_setbbtbl set_bb
;
145 struct nvme_nvm_erase_blk erase
;
149 struct nvme_nvm_completion
{
150 __le64 result
; /* Used by LightNVM to return ppa completions */
151 __le16 sq_head
; /* how much of this queue may be reclaimed */
152 __le16 sq_id
; /* submission queue that generated this entry */
153 __u16 command_id
; /* of the command which completed */
154 __le16 status
; /* did the command fail, and if so, why? */
157 #define NVME_NVM_LP_MLC_PAIRS 886
158 struct nvme_nvm_lp_mlc
{
160 __u8 pairs
[NVME_NVM_LP_MLC_PAIRS
];
163 struct nvme_nvm_lp_tbl
{
165 struct nvme_nvm_lp_mlc mlc
;
168 struct nvme_nvm_id_group
{
192 struct nvme_nvm_lp_tbl lptbl
;
195 struct nvme_nvm_addr_format
{
218 struct nvme_nvm_addr_format ppaf
;
220 struct nvme_nvm_id_group groups
[4];
223 struct nvme_nvm_bb_tbl
{
238 * Check we didn't inadvertently grow the command struct
240 static inline void _nvme_nvm_check_size(void)
242 BUILD_BUG_ON(sizeof(struct nvme_nvm_identity
) != 64);
243 BUILD_BUG_ON(sizeof(struct nvme_nvm_hb_rw
) != 64);
244 BUILD_BUG_ON(sizeof(struct nvme_nvm_ph_rw
) != 64);
245 BUILD_BUG_ON(sizeof(struct nvme_nvm_getbbtbl
) != 64);
246 BUILD_BUG_ON(sizeof(struct nvme_nvm_setbbtbl
) != 64);
247 BUILD_BUG_ON(sizeof(struct nvme_nvm_l2ptbl
) != 64);
248 BUILD_BUG_ON(sizeof(struct nvme_nvm_erase_blk
) != 64);
249 BUILD_BUG_ON(sizeof(struct nvme_nvm_id_group
) != 960);
250 BUILD_BUG_ON(sizeof(struct nvme_nvm_addr_format
) != 128);
251 BUILD_BUG_ON(sizeof(struct nvme_nvm_id
) != 4096);
252 BUILD_BUG_ON(sizeof(struct nvme_nvm_bb_tbl
) != 512);
255 static int init_grps(struct nvm_id
*nvm_id
, struct nvme_nvm_id
*nvme_nvm_id
)
257 struct nvme_nvm_id_group
*src
;
258 struct nvm_id_group
*dst
;
261 end
= min_t(u32
, 4, nvm_id
->cgrps
);
263 for (i
= 0; i
< end
; i
++) {
264 src
= &nvme_nvm_id
->groups
[i
];
265 dst
= &nvm_id
->groups
[i
];
267 dst
->mtype
= src
->mtype
;
268 dst
->fmtype
= src
->fmtype
;
269 dst
->num_ch
= src
->num_ch
;
270 dst
->num_lun
= src
->num_lun
;
271 dst
->num_pln
= src
->num_pln
;
273 dst
->num_pg
= le16_to_cpu(src
->num_pg
);
274 dst
->num_blk
= le16_to_cpu(src
->num_blk
);
275 dst
->fpg_sz
= le16_to_cpu(src
->fpg_sz
);
276 dst
->csecs
= le16_to_cpu(src
->csecs
);
277 dst
->sos
= le16_to_cpu(src
->sos
);
279 dst
->trdt
= le32_to_cpu(src
->trdt
);
280 dst
->trdm
= le32_to_cpu(src
->trdm
);
281 dst
->tprt
= le32_to_cpu(src
->tprt
);
282 dst
->tprm
= le32_to_cpu(src
->tprm
);
283 dst
->tbet
= le32_to_cpu(src
->tbet
);
284 dst
->tbem
= le32_to_cpu(src
->tbem
);
285 dst
->mpos
= le32_to_cpu(src
->mpos
);
286 dst
->mccap
= le32_to_cpu(src
->mccap
);
288 dst
->cpar
= le16_to_cpu(src
->cpar
);
290 if (dst
->fmtype
== NVM_ID_FMTYPE_MLC
) {
291 memcpy(dst
->lptbl
.id
, src
->lptbl
.id
, 8);
292 dst
->lptbl
.mlc
.num_pairs
=
293 le16_to_cpu(src
->lptbl
.mlc
.num_pairs
);
295 if (dst
->lptbl
.mlc
.num_pairs
> NVME_NVM_LP_MLC_PAIRS
) {
296 pr_err("nvm: number of MLC pairs not supported\n");
300 memcpy(dst
->lptbl
.mlc
.pairs
, src
->lptbl
.mlc
.pairs
,
301 dst
->lptbl
.mlc
.num_pairs
);
308 static int nvme_nvm_identity(struct nvm_dev
*nvmdev
, struct nvm_id
*nvm_id
)
310 struct nvme_ns
*ns
= nvmdev
->q
->queuedata
;
311 struct nvme_nvm_id
*nvme_nvm_id
;
312 struct nvme_nvm_command c
= {};
315 c
.identity
.opcode
= nvme_nvm_admin_identity
;
316 c
.identity
.nsid
= cpu_to_le32(ns
->ns_id
);
317 c
.identity
.chnl_off
= 0;
319 nvme_nvm_id
= kmalloc(sizeof(struct nvme_nvm_id
), GFP_KERNEL
);
323 ret
= nvme_submit_sync_cmd(ns
->ctrl
->admin_q
, (struct nvme_command
*)&c
,
324 nvme_nvm_id
, sizeof(struct nvme_nvm_id
));
330 nvm_id
->ver_id
= nvme_nvm_id
->ver_id
;
331 nvm_id
->vmnt
= nvme_nvm_id
->vmnt
;
332 nvm_id
->cgrps
= nvme_nvm_id
->cgrps
;
333 nvm_id
->cap
= le32_to_cpu(nvme_nvm_id
->cap
);
334 nvm_id
->dom
= le32_to_cpu(nvme_nvm_id
->dom
);
335 memcpy(&nvm_id
->ppaf
, &nvme_nvm_id
->ppaf
,
336 sizeof(struct nvme_nvm_addr_format
));
338 ret
= init_grps(nvm_id
, nvme_nvm_id
);
344 static int nvme_nvm_get_l2p_tbl(struct nvm_dev
*nvmdev
, u64 slba
, u32 nlb
,
345 nvm_l2p_update_fn
*update_l2p
, void *priv
)
347 struct nvme_ns
*ns
= nvmdev
->q
->queuedata
;
348 struct nvme_nvm_command c
= {};
349 u32 len
= queue_max_hw_sectors(ns
->ctrl
->admin_q
) << 9;
350 u32 nlb_pr_rq
= len
/ sizeof(u64
);
355 c
.l2p
.opcode
= nvme_nvm_admin_get_l2p_tbl
;
356 c
.l2p
.nsid
= cpu_to_le32(ns
->ns_id
);
357 entries
= kmalloc(len
, GFP_KERNEL
);
362 u32 cmd_nlb
= min(nlb_pr_rq
, nlb
);
364 c
.l2p
.slba
= cpu_to_le64(cmd_slba
);
365 c
.l2p
.nlb
= cpu_to_le32(cmd_nlb
);
367 ret
= nvme_submit_sync_cmd(ns
->ctrl
->admin_q
,
368 (struct nvme_command
*)&c
, entries
, len
);
370 dev_err(ns
->ctrl
->device
,
371 "L2P table transfer failed (%d)\n", ret
);
376 if (update_l2p(cmd_slba
, cmd_nlb
, entries
, priv
)) {
390 static int nvme_nvm_get_bb_tbl(struct nvm_dev
*nvmdev
, struct ppa_addr ppa
,
393 struct request_queue
*q
= nvmdev
->q
;
394 struct nvme_ns
*ns
= q
->queuedata
;
395 struct nvme_ctrl
*ctrl
= ns
->ctrl
;
396 struct nvme_nvm_command c
= {};
397 struct nvme_nvm_bb_tbl
*bb_tbl
;
398 int nr_blks
= nvmdev
->blks_per_lun
* nvmdev
->plane_mode
;
399 int tblsz
= sizeof(struct nvme_nvm_bb_tbl
) + nr_blks
;
402 c
.get_bb
.opcode
= nvme_nvm_admin_get_bb_tbl
;
403 c
.get_bb
.nsid
= cpu_to_le32(ns
->ns_id
);
404 c
.get_bb
.spba
= cpu_to_le64(ppa
.ppa
);
406 bb_tbl
= kzalloc(tblsz
, GFP_KERNEL
);
410 ret
= nvme_submit_sync_cmd(ctrl
->admin_q
, (struct nvme_command
*)&c
,
413 dev_err(ctrl
->device
, "get bad block table failed (%d)\n", ret
);
418 if (bb_tbl
->tblid
[0] != 'B' || bb_tbl
->tblid
[1] != 'B' ||
419 bb_tbl
->tblid
[2] != 'L' || bb_tbl
->tblid
[3] != 'T') {
420 dev_err(ctrl
->device
, "bbt format mismatch\n");
425 if (le16_to_cpu(bb_tbl
->verid
) != 1) {
427 dev_err(ctrl
->device
, "bbt version not supported\n");
431 if (le32_to_cpu(bb_tbl
->tblks
) != nr_blks
) {
433 dev_err(ctrl
->device
,
434 "bbt unsuspected blocks returned (%u!=%u)",
435 le32_to_cpu(bb_tbl
->tblks
), nr_blks
);
439 memcpy(blks
, bb_tbl
->blk
, nvmdev
->blks_per_lun
* nvmdev
->plane_mode
);
445 static int nvme_nvm_set_bb_tbl(struct nvm_dev
*nvmdev
, struct ppa_addr
*ppas
,
446 int nr_ppas
, int type
)
448 struct nvme_ns
*ns
= nvmdev
->q
->queuedata
;
449 struct nvme_nvm_command c
= {};
452 c
.set_bb
.opcode
= nvme_nvm_admin_set_bb_tbl
;
453 c
.set_bb
.nsid
= cpu_to_le32(ns
->ns_id
);
454 c
.set_bb
.spba
= cpu_to_le64(ppas
->ppa
);
455 c
.set_bb
.nlb
= cpu_to_le16(nr_ppas
- 1);
456 c
.set_bb
.value
= type
;
458 ret
= nvme_submit_sync_cmd(ns
->ctrl
->admin_q
, (struct nvme_command
*)&c
,
461 dev_err(ns
->ctrl
->device
, "set bad block table failed (%d)\n",
466 static inline void nvme_nvm_rqtocmd(struct request
*rq
, struct nvm_rq
*rqd
,
467 struct nvme_ns
*ns
, struct nvme_nvm_command
*c
)
469 c
->ph_rw
.opcode
= rqd
->opcode
;
470 c
->ph_rw
.nsid
= cpu_to_le32(ns
->ns_id
);
471 c
->ph_rw
.spba
= cpu_to_le64(rqd
->ppa_addr
.ppa
);
472 c
->ph_rw
.metadata
= cpu_to_le64(rqd
->dma_meta_list
);
473 c
->ph_rw
.control
= cpu_to_le16(rqd
->flags
);
474 c
->ph_rw
.length
= cpu_to_le16(rqd
->nr_ppas
- 1);
476 if (rqd
->opcode
== NVM_OP_HBWRITE
|| rqd
->opcode
== NVM_OP_HBREAD
)
477 c
->hb_rw
.slba
= cpu_to_le64(nvme_block_nr(ns
,
478 rqd
->bio
->bi_iter
.bi_sector
));
481 static void nvme_nvm_end_io(struct request
*rq
, int error
)
483 struct nvm_rq
*rqd
= rq
->end_io_data
;
484 struct nvme_nvm_completion
*cqe
= rq
->special
;
487 rqd
->ppa_status
= le64_to_cpu(cqe
->result
);
489 nvm_end_io(rqd
, error
);
492 blk_mq_free_request(rq
);
495 static int nvme_nvm_submit_io(struct nvm_dev
*dev
, struct nvm_rq
*rqd
)
497 struct request_queue
*q
= dev
->q
;
498 struct nvme_ns
*ns
= q
->queuedata
;
500 struct bio
*bio
= rqd
->bio
;
501 struct nvme_nvm_command
*cmd
;
503 rq
= blk_mq_alloc_request(q
, bio_data_dir(bio
), 0);
507 cmd
= kzalloc(sizeof(struct nvme_nvm_command
) +
508 sizeof(struct nvme_nvm_completion
), GFP_KERNEL
);
510 blk_mq_free_request(rq
);
514 rq
->cmd_type
= REQ_TYPE_DRV_PRIV
;
515 rq
->ioprio
= bio_prio(bio
);
517 if (bio_has_data(bio
))
518 rq
->nr_phys_segments
= bio_phys_segments(q
, bio
);
520 rq
->__data_len
= bio
->bi_iter
.bi_size
;
521 rq
->bio
= rq
->biotail
= bio
;
523 nvme_nvm_rqtocmd(rq
, rqd
, ns
, cmd
);
525 rq
->cmd
= (unsigned char *)cmd
;
526 rq
->cmd_len
= sizeof(struct nvme_nvm_command
);
527 rq
->special
= cmd
+ 1;
529 rq
->end_io_data
= rqd
;
531 blk_execute_rq_nowait(q
, NULL
, rq
, 0, nvme_nvm_end_io
);
536 static int nvme_nvm_erase_block(struct nvm_dev
*dev
, struct nvm_rq
*rqd
)
538 struct request_queue
*q
= dev
->q
;
539 struct nvme_ns
*ns
= q
->queuedata
;
540 struct nvme_nvm_command c
= {};
542 c
.erase
.opcode
= NVM_OP_ERASE
;
543 c
.erase
.nsid
= cpu_to_le32(ns
->ns_id
);
544 c
.erase
.spba
= cpu_to_le64(rqd
->ppa_addr
.ppa
);
545 c
.erase
.length
= cpu_to_le16(rqd
->nr_ppas
- 1);
547 return nvme_submit_sync_cmd(q
, (struct nvme_command
*)&c
, NULL
, 0);
550 static void *nvme_nvm_create_dma_pool(struct nvm_dev
*nvmdev
, char *name
)
552 struct nvme_ns
*ns
= nvmdev
->q
->queuedata
;
554 return dma_pool_create(name
, ns
->ctrl
->dev
, PAGE_SIZE
, PAGE_SIZE
, 0);
557 static void nvme_nvm_destroy_dma_pool(void *pool
)
559 struct dma_pool
*dma_pool
= pool
;
561 dma_pool_destroy(dma_pool
);
564 static void *nvme_nvm_dev_dma_alloc(struct nvm_dev
*dev
, void *pool
,
565 gfp_t mem_flags
, dma_addr_t
*dma_handler
)
567 return dma_pool_alloc(pool
, mem_flags
, dma_handler
);
570 static void nvme_nvm_dev_dma_free(void *pool
, void *addr
,
571 dma_addr_t dma_handler
)
573 dma_pool_free(pool
, addr
, dma_handler
);
576 static struct nvm_dev_ops nvme_nvm_dev_ops
= {
577 .identity
= nvme_nvm_identity
,
579 .get_l2p_tbl
= nvme_nvm_get_l2p_tbl
,
581 .get_bb_tbl
= nvme_nvm_get_bb_tbl
,
582 .set_bb_tbl
= nvme_nvm_set_bb_tbl
,
584 .submit_io
= nvme_nvm_submit_io
,
585 .erase_block
= nvme_nvm_erase_block
,
587 .create_dma_pool
= nvme_nvm_create_dma_pool
,
588 .destroy_dma_pool
= nvme_nvm_destroy_dma_pool
,
589 .dev_dma_alloc
= nvme_nvm_dev_dma_alloc
,
590 .dev_dma_free
= nvme_nvm_dev_dma_free
,
595 int nvme_nvm_register(struct nvme_ns
*ns
, char *disk_name
, int node
,
596 const struct attribute_group
*attrs
)
598 struct request_queue
*q
= ns
->queue
;
602 dev
= nvm_alloc_dev(node
);
607 memcpy(dev
->name
, disk_name
, DISK_NAME_LEN
);
608 dev
->ops
= &nvme_nvm_dev_ops
;
609 dev
->parent_dev
= ns
->ctrl
->device
;
610 dev
->private_data
= ns
;
613 ret
= nvm_register(dev
);
615 ns
->lba_shift
= ilog2(dev
->sec_size
) - 9;
617 if (sysfs_create_group(&dev
->dev
.kobj
, attrs
))
618 pr_warn("%s: failed to create sysfs group for identification\n",
623 void nvme_nvm_unregister(struct nvme_ns
*ns
)
625 nvm_unregister(ns
->ndev
);
628 /* move to shared place when used in multiple places. */
629 #define PCI_VENDOR_ID_CNEX 0x1d1d
630 #define PCI_DEVICE_ID_CNEX_WL 0x2807
631 #define PCI_DEVICE_ID_CNEX_QEMU 0x1f1f
633 int nvme_nvm_ns_supported(struct nvme_ns
*ns
, struct nvme_id_ns
*id
)
635 struct nvme_ctrl
*ctrl
= ns
->ctrl
;
636 /* XXX: this is poking into PCI structures from generic code! */
637 struct pci_dev
*pdev
= to_pci_dev(ctrl
->dev
);
639 /* QEMU NVMe simulator - PCI ID + Vendor specific bit */
640 if (pdev
->vendor
== PCI_VENDOR_ID_CNEX
&&
641 pdev
->device
== PCI_DEVICE_ID_CNEX_QEMU
&&
645 /* CNEX Labs - PCI ID + Vendor specific bit */
646 if (pdev
->vendor
== PCI_VENDOR_ID_CNEX
&&
647 pdev
->device
== PCI_DEVICE_ID_CNEX_WL
&&