/*
 * Copyright (c) 2016 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "nvme.h"

static void nvme_disk_callback(nvme_request_t *req, struct lock *lk);
static int nvme_strategy_core(nvme_softns_t *nsc, struct bio *bio, int delay);
static const char *nvme_status_string(nvme_status_buf_t *buf,
                        int type, int code);

static d_open_t nvme_open;
static d_close_t nvme_close;
static d_ioctl_t nvme_ioctl;
static d_strategy_t nvme_strategy;
static d_dump_t nvme_dump;

static struct dev_ops nvme_ops = {
        { "nvme", 0, D_DISK | D_MPSAFE | D_CANFREE | D_TRACKCLOSE | D_KVABIO },
        .d_open =       nvme_open,
        .d_close =      nvme_close,
        .d_read =       physread,
        .d_dump =       nvme_dump,
        .d_write =      physwrite,
        .d_ioctl =      nvme_ioctl,
        .d_strategy =   nvme_strategy,
};

static struct krate krate_nvmeio = { .freq = 1 };

__read_mostly static int nvme_sync_delay = 0;
SYSCTL_INT(_debug, OID_AUTO, nvme_sync_delay, CTLFLAG_RW, &nvme_sync_delay, 0,
           "Enable synchronous delay/completion-check, uS");

/*
 * Attach a namespace as a disk, making the disk available to the system.
 */
void
nvme_disk_attach(nvme_softns_t *nsc)
{
        nvme_softc_t *sc;
        struct disk_info info;
        char serial[20+16];
        size_t len;
        uint64_t cap_gb;

        sc = nsc->sc;
        devstat_add_entry(&nsc->stats, "nvme", nsc->unit, nsc->blksize,
                          DEVSTAT_NO_ORDERED_TAGS,
                          DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER,
                          DEVSTAT_PRIORITY_OTHER);
        nsc->cdev = disk_create(nsc->unit, &nsc->disk, &nvme_ops);
        nsc->cdev->si_drv1 = nsc;
        nsc->cdev->si_iosize_max = MAXPHYS;     /* XXX */
        disk_setdisktype(&nsc->disk, "ssd");

        bzero(&info, sizeof(info));
        info.d_media_blksize = nsc->blksize;
        info.d_media_blocks = nsc->idns.size;
        info.d_secpertrack = 1024;
        info.d_nheads = 1;
        info.d_secpercyl = info.d_secpertrack * info.d_nheads;
        info.d_ncylinders =  (u_int)(info.d_media_blocks / info.d_secpercyl);

        KKASSERT(sizeof(sc->idctlr.serialno) == 20);
        bzero(serial, sizeof(serial));
        bcopy(sc->idctlr.serialno, serial, sizeof(sc->idctlr.serialno));
        len = string_cleanup(serial, 1);

        ksnprintf(serial + len, sizeof(serial) - len, "-%u", nsc->nsid);

        info.d_serialno = serial;

        cap_gb = nsc->idns.size / (1024 * 1024 * 1024 / nsc->blksize);
        device_printf(sc->dev,
                "Disk nvme%d ns=%u "
                "blksize=%u lbacnt=%ju cap=%juGB serno=%s\n",
                nsc->unit, nsc->nsid,
                nsc->blksize, nsc->idns.size, cap_gb, serial);

        disk_setdiskinfo(&nsc->disk, &info);
        /* serial is copied and does not have to be persistent */
}

void
nvme_disk_detach(nvme_softns_t *nsc)
{
        if (nsc->cdev) {
                disk_destroy(&nsc->disk);
                devstat_remove_entry(&nsc->stats);
        }
}

static
int
nvme_open(struct dev_open_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        nvme_softns_t *nsc = dev->si_drv1;
        nvme_softc_t *sc = nsc->sc;

        if (sc->flags & NVME_SC_UNLOADING)
                return ENXIO;

        atomic_add_long(&sc->opencnt, 1);

        return 0;
}

static
int
nvme_close(struct dev_close_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        nvme_softns_t *nsc = dev->si_drv1;
        nvme_softc_t *sc = nsc->sc;

        atomic_add_long(&sc->opencnt, -1);

        return 0;
}

static int
nvme_ioctl(struct dev_ioctl_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        nvme_softns_t *nsc = dev->si_drv1;
        nvme_softc_t *sc = nsc->sc;
        int error;

        switch(ap->a_cmd) {
        case NVMEIOCGETLOG:
                error = nvme_getlog_ioctl(sc, (void *)ap->a_data);
                break;
        default:
                error = ENOIOCTL;
                break;
        }
        return error;
}

static int
nvme_strategy(struct dev_strategy_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        nvme_softns_t *nsc = dev->si_drv1;

        nvme_strategy_core(nsc, ap->a_bio, nvme_sync_delay);

        return 0;
}

/*
 * Called from admin thread to requeue BIOs.  We must call
 * nvme_strategy_core() with delay = 0 to disable synchronous
 * optimizations to avoid deadlocking the admin thread.
 */
void
nvme_disk_requeues(nvme_softc_t *sc)
{
        nvme_softns_t *nsc;
        struct bio *bio;
        int i;

        for (i = 0; i < sc->nscmax; ++i) {
                nsc = sc->nscary[i];
                if (nsc == NULL || nsc->sc == NULL)
                        continue;
                if (bioq_first(&nsc->bioq)) {
                        lockmgr(&nsc->lk, LK_EXCLUSIVE);
                        while ((bio = bioq_first(&nsc->bioq)) != NULL) {
                                bioq_remove(&nsc->bioq, bio);
                                lockmgr(&nsc->lk, LK_RELEASE);
                                if (nvme_strategy_core(nsc, bio, 0))
                                        goto next;
                                lockmgr(&nsc->lk, LK_EXCLUSIVE);
                        }
                        lockmgr(&nsc->lk, LK_RELEASE);
                }
next:
                ;
        }
}


/*
 * Returns non-zero if no requests are available.
 *
 * WARNING! We are using the KVABIO API and must not access memory
 *          through bp->b_data without first calling bkvasync(bp).
 */
static int
nvme_strategy_core(nvme_softns_t *nsc, struct bio *bio, int delay)
{
        nvme_softc_t *sc = nsc->sc;
        struct buf *bp = bio->bio_buf;
        uint64_t nlba;
        uint64_t secno;
        nvme_subqueue_t *subq;
        nvme_request_t *req;
        int nobytes;

        /*
         * Calculate sector/extent
         */
        secno = bio->bio_offset / nsc->blksize;
        nlba = bp->b_bcount / nsc->blksize;

        devstat_start_transaction(&nsc->stats);

        subq = NULL;
        req = NULL;
        nobytes = 0;

        /*
         * Convert bio to low-level request
         */
        switch (bp->b_cmd) {
        case BUF_CMD_READ:
                if (nlba == 0) {
                        nobytes = 1;
                        break;
                }
                subq = &sc->subqueues[sc->qmap[mycpuid][NVME_QMAP_RD]];
                /* get_request does not need the subq lock */
                req = nvme_get_request(subq, NVME_IOCMD_READ,
                                       bp->b_data, nlba * nsc->blksize);
                if (req == NULL)
                        goto requeue;

                req->cmd.read.head.nsid = nsc->nsid;
                req->cmd.read.start_lba = secno;
                req->cmd.read.count_lba = nlba - 1;     /* 0's based */
                req->cmd.read.ioflags = 0; /* NVME_IOFLG_LR, NVME_IOFLG_FUA */
                req->cmd.read.dsm = 0;     /* NVME_DSM_INCOMPRESSIBLE */
                                           /* NVME_DSM_SEQREQ */
                break;
        case BUF_CMD_WRITE:
                if (nlba == 0) {
                        nobytes = 1;
                        break;
                }
                subq = &sc->subqueues[sc->qmap[mycpuid][NVME_QMAP_WR]];
                /* get_request does not need the subq lock */
                req = nvme_get_request(subq, NVME_IOCMD_WRITE,
                                       bp->b_data, nlba * nsc->blksize);
                if (req == NULL)
                        goto requeue;
                req->cmd.write.head.nsid = nsc->nsid;
                req->cmd.write.start_lba = secno;
                req->cmd.write.count_lba = nlba - 1;    /* 0's based */
                break;
        case BUF_CMD_FREEBLKS:
                if (nlba == 0) {
                        nobytes = 1;
                        break;
                }
                if (nlba > 65536) {
                        /* will cause INVAL error */
                        break;
                }
                subq = &sc->subqueues[sc->qmap[mycpuid][NVME_QMAP_WR]];
                /* get_request does not need the subq lock */
                req = nvme_get_request(subq, NVME_IOCMD_WRITEZ, NULL, 0);
                if (req == NULL)
                        goto requeue;
                req->cmd.writez.head.nsid = nsc->nsid;
                req->cmd.writez.start_lba = secno;
                req->cmd.writez.count_lba = nlba - 1;   /* 0's based */
                req->cmd.read.ioflags = 0; /* NVME_IOFLG_LR, NVME_IOFLG_FUA */
                req->cmd.read.dsm = 0;     /* NVME_DSM_INCOMPRESSIBLE */
                                           /* NVME_DSM_SEQREQ */
                break;
        case BUF_CMD_FLUSH:
                subq = &sc->subqueues[sc->qmap[mycpuid][NVME_QMAP_WR]];
                /* get_request does not need the subq lock */
                req = nvme_get_request(subq, NVME_IOCMD_FLUSH, NULL, 0);
                if (req == NULL)
                        goto requeue;
                req->cmd.flush.head.nsid = nsc->nsid;
                break;
        default:
                break;
        }

        /*
         * Submit the request
         */
        if (req) {
                nvme_comqueue_t *comq;

                /* HACK OPTIMIZATIONS - TODO NEEDS WORK */

                /*
                 * Prevent callback from occurring if the synchronous
                 * delay optimization is enabled.
                 *
                 * NOTE: subq lock does not protect the I/O (completion
                 *       only needs the comq lock).
                 */
                if (delay == 0)
                        req->callback = nvme_disk_callback;
                req->nsc = nsc;
                req->bio = bio;
                BUF_KERNPROC(bp);               /* do before submit */
                lockmgr(&subq->lk, LK_EXCLUSIVE);
                nvme_submit_request(req);       /* needs subq lock */
                lockmgr(&subq->lk, LK_RELEASE);
                if (delay) {
                        comq = req->comq;
                        DELAY(delay);           /* XXX */
                        lockmgr(&comq->lk, LK_EXCLUSIVE);
                        nvme_poll_completions(comq, &comq->lk);
                        if (req->state == NVME_REQ_SUBMITTED) {
                                /*
                                 * Didn't finish, do it the slow way
                                 * (restore async completion).
                                 */
                                req->callback = nvme_disk_callback;
                                lockmgr(&comq->lk, LK_RELEASE);
                        } else {
                                /*
                                 * Jeeze, that was fast.
                                 */
                                nvme_disk_callback(req, &comq->lk);
                                lockmgr(&comq->lk, LK_RELEASE);
                        }
                } /* else async completion */
        } else if (nobytes) {
                devstat_end_transaction_buf(&nsc->stats, bp);
                biodone(bio);
        } else {
                bp->b_error = EINVAL;
                bp->b_flags |= B_ERROR;
                devstat_end_transaction_buf(&nsc->stats, bp);
                biodone(bio);
        }
        return 0;

        /*
         * No requests were available, requeue the bio.
         *
         * The nvme_get_request() call armed the requeue signal but
         * it is possible that it was picked up too quickly.  If it
         * was, signal the admin thread ourselves.  This case will occur
         * relatively rarely and only under heavy I/O conditions so we
         * don't have to be entirely efficient about dealing with it.
         */
requeue:
        BUF_KERNPROC(bp);
        lockmgr(&nsc->lk, LK_EXCLUSIVE);
        bioqdisksort(&nsc->bioq, bio);
        lockmgr(&nsc->lk, LK_RELEASE);
        if (atomic_swap_int(&subq->signal_requeue, 1) == 0) {
                atomic_swap_int(&subq->signal_requeue, 0);
                atomic_set_int(&subq->sc->admin_signal, ADMIN_SIG_REQUEUE);
                wakeup(&subq->sc->admin_signal);
        }
        return 1;
}

static
void
nvme_disk_callback(nvme_request_t *req, struct lock *lk)
{
        nvme_softns_t *nsc = req->nsc;
        struct bio *bio;
        struct buf *bp;
        int code;
        int type;

        code = NVME_COMQ_STATUS_CODE_GET(req->res.tail.status);
        type = NVME_COMQ_STATUS_TYPE_GET(req->res.tail.status);
        bio = req->bio;
        bp = bio->bio_buf;

        if (lk)                                 /* comq lock */
                lockmgr(lk, LK_RELEASE);
        nvme_put_request(req);                  /* does not need subq lock */
        devstat_end_transaction_buf(&nsc->stats, bp);

        if (code) {
                nvme_status_buf_t sb;

                krateprintf(&krate_nvmeio,
                            "%s%d: %s error nvme-code %s\n",
                            device_get_name(nsc->sc->dev),
                            device_get_unit(nsc->sc->dev),
                            buf_cmd_name(bp),
                            nvme_status_string(&sb, type, code));
                bp->b_error = EIO;
                bp->b_flags |= B_ERROR;
                biodone(bio);
        } else {
                bp->b_resid = 0;
                biodone(bio);
        }
        if (lk)                                 /* comq lock */
                lockmgr(lk, LK_EXCLUSIVE);
}

int
nvme_alloc_disk_unit(void)
{
        static int unit_counter = 0;
        int unit;

        unit = atomic_fetchadd_int(&unit_counter, 1);

        return unit;
}

static int
nvme_dump(struct dev_dump_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        nvme_softns_t *nsc = dev->si_drv1;
        nvme_softc_t *sc = nsc->sc;
        uint64_t nlba;
        uint64_t secno;
        nvme_subqueue_t *subq;
        nvme_comqueue_t *comq;
        nvme_request_t *req;
        int didlock;

        /*
         * Calculate sector/extent
         */
        secno = ap->a_offset / nsc->blksize;
        nlba = ap->a_length / nsc->blksize;

        subq = &sc->subqueues[sc->qmap[mycpuid][NVME_QMAP_WR]];

        if (nlba) {
                /*
                 * Issue a WRITE
                 *
                 * get_request does not need the subq lock.
                 */
                req = nvme_get_dump_request(subq, NVME_IOCMD_WRITE,
                                       ap->a_virtual, nlba * nsc->blksize);
                req->cmd.write.head.nsid = nsc->nsid;
                req->cmd.write.start_lba = secno;
                req->cmd.write.count_lba = nlba - 1;    /* 0's based */
        } else {
                /*
                 * Issue a FLUSH
                 *
                 * get_request does not need the subq lock.
                 */
                req = nvme_get_dump_request(subq, NVME_IOCMD_FLUSH, NULL, 0);
                req->cmd.flush.head.nsid = nsc->nsid;
        }

        /*
         * Prevent callback from occurring if the synchronous
         * delay optimization is enabled.
         */
        req->callback = NULL;
        req->nsc = nsc;

        /*
         * 500 x 1uS poll wait on lock.  We might be the idle thread, so
         * we can't safely block during a dump.
         */
        didlock = 500;
        while (lockmgr(&subq->lk, LK_EXCLUSIVE | LK_NOWAIT) != 0) {
                if (--didlock == 0)
                        break;
                tsc_delay(1000);        /* 1uS */
                lwkt_switch();
        }
        nvme_submit_request(req);       /* needs subq lock */
        if (didlock)
                lockmgr(&subq->lk, LK_RELEASE);

        comq = req->comq;
        nvme_poll_request(req);
        nvme_put_dump_request(req);             /* does not need subq lock */

        /*
         * Shut the nvme controller down nicely when we finish the dump.
         * We should to do this whether we are in a panic or not because
         * frankly the dump is overwriting swap space, thus the system is
         * probably not stable.
         */
        if (nlba == 0)
                nvme_issue_shutdown(sc, 1);
        return 0;
}

static
const char *
nvme_status_string(nvme_status_buf_t *sb, int type, int code)
{
        const char *cstr = NULL;

        switch(type) {
        case NVME_STATUS_TYPE_GENERIC:
                switch(code) {
                case NVME_CODE_SUCCESS:
                        cstr = "success";
                        break;
                case NVME_CODE_BADOP:
                        cstr = "badop";
                        break;
                case NVME_CODE_BADFIELD:
                        cstr = "badfield";
                        break;
                case NVME_CODE_IDCONFLICT:
                        cstr = "idconflict";
                        break;
                case NVME_CODE_BADXFER:
                        cstr = "badxfer";
                        break;
                case NVME_CODE_ABORTED_PWRLOSS:
                        cstr = "aborted-powerloss";
                        break;
                case NVME_CODE_INTERNAL:
                        cstr = "internal";
                        break;
                case NVME_CODE_ABORTED_ONREQ:
                        cstr = "aborted-onreq";
                        break;
                case NVME_CODE_ABORTED_SQDEL:
                        cstr = "aborted-sqdel";
                        break;
                case NVME_CODE_ABORTED_FUSEFAIL:
                        cstr = "aborted-fusefail";
                        break;
                case NVME_CODE_ABORTED_FUSEMISSING:
                        cstr = "aborted-fusemissing";
                        break;
                case NVME_CODE_BADNAMESPACE:
                        cstr = "badnamespace";
                        break;
                case NVME_CODE_SEQERROR:
                        cstr = "seqerror";
                        break;
                case NVME_CODE_BADSGLSEG:
                        cstr = "badsgl-seg";
                        break;
                case NVME_CODE_BADSGLCNT:
                        cstr = "badsgl-cnt";
                        break;
                case NVME_CODE_BADSGLLEN:
                        cstr = "badsgl-len";
                        break;
                case NVME_CODE_BADSGLMLEN:
                        cstr = "badsgl-mlen";
                        break;
                case NVME_CODE_BADSGLTYPE:
                        cstr = "badsgl-type";
                        break;
                case NVME_CODE_BADMEMBUFUSE:
                        cstr = "badmem-bufuse";
                        break;
                case NVME_CODE_BADPRPOFF:
                        cstr = "bad-prpoff";
                        break;

                case NVME_CODE_ATOMICWUOVFL:
                        cstr = "atomic-wuovfl";
                        break;
                case NVME_CODE_LBA_RANGE:
                        cstr = "lba-range";
                        break;
                case NVME_CODE_CAP_EXCEEDED:
                        cstr = "cap-exceeded";
                        break;
                case NVME_CODE_NAM_NOT_READY:
                        cstr = "nam-not-ready";
                        break;
                case NVME_CODE_RSV_CONFLICT:
                        cstr = "rsv-conflict";
                        break;
                case NVME_CODE_FMT_IN_PROG:
                        cstr = "fmt-in-prog";
                        break;
                default:
                        cstr = "unknown";
                        break;
                }
                ksnprintf(sb->buf, sizeof(sb->buf),
                          "type=generic code=%s(%04x)", cstr, code);
                break;
        case NVME_STATUS_TYPE_SPECIFIC:
                switch(code) {
                case NVME_CSSCODE_BADCOMQ:
                        cstr = "bad-comq";
                        break;
                case NVME_CSSCODE_BADQID:
                        cstr = "bad-qid";
                        break;
                case NVME_CSSCODE_BADQSIZE:
                        cstr = "bad-qsize";
                        break;
                case NVME_CSSCODE_ABORTLIM:
                        cstr = "abort-lim";
                        break;
                case NVME_CSSCODE_RESERVED04 :
                        cstr = "unknown";
                        break;
                case NVME_CSSCODE_ASYNCEVENTLIM:
                        cstr = "async-event-lim";
                        break;
                case NVME_CSSCODE_BADFWSLOT:
                        cstr = "bad-fwslot";
                        break;
                case NVME_CSSCODE_BADFWIMAGE:
                        cstr = "bad-fwimage";
                        break;
                case NVME_CSSCODE_BADINTRVECT:
                        cstr = "bad-intrvect";
                        break;
                case NVME_CSSCODE_BADLOGPAGE:
                        cstr = "bad-logpage";
                        break;
                case NVME_CSSCODE_BADFORMAT:
                        cstr = "bad-format";
                        break;
                case NVME_CSSCODE_FW_NEEDSCONVRESET:
                        cstr = "needs-convreset";
                        break;
                case NVME_CSSCODE_BADQDELETE:
                        cstr = "bad-qdelete";
                        break;
                case NVME_CSSCODE_FEAT_NOT_SAVEABLE:
                        cstr = "feat-not-saveable";
                        break;
                case NVME_CSSCODE_FEAT_NOT_CHGABLE:
                        cstr = "feat-not-changeable";
                        break;
                case NVME_CSSCODE_FEAT_NOT_NSSPEC:
                        cstr = "feat-not-nsspec";
                        break;
                case NVME_CSSCODE_FW_NEEDSSUBRESET:
                        cstr = "fw-needs-subreset";
                        break;
                case NVME_CSSCODE_FW_NEEDSRESET:
                        cstr = "fw-needs-reset";
                        break;
                case NVME_CSSCODE_FW_NEEDSMAXTVIOLATE:
                        cstr = "fw-needsmaxviolate";
                        break;
                case NVME_CSSCODE_FW_PROHIBITED:
                        cstr = "fw-prohibited";
                        break;
                case NVME_CSSCODE_RANGE_OVERLAP:
                        cstr = "range-overlap";
                        break;
                case NVME_CSSCODE_NAM_INSUFF_CAP:
                        cstr = "name-insufficient-cap";
                        break;
                case NVME_CSSCODE_NAM_ID_UNAVAIL:
                        cstr = "name-id-unavail";
                        break;
                case NVME_CSSCODE_RESERVED17:
                        cstr = "unknown";
                        break;
                case NVME_CSSCODE_NAM_ALREADY_ATT:
                        cstr = "name-already-att";
                        break;
                case NVME_CSSCODE_NAM_IS_PRIVATE:
                        cstr = "name-is-private";
                        break;
                case NVME_CSSCODE_NAM_NOT_ATT:
                        cstr = "name-not-att";
                        break;
                case NVME_CSSCODE_NO_THIN_PROVISION:
                        cstr = "no-thin-provision";
                        break;
                case NVME_CSSCODE_CTLR_LIST_INVALID:
                        cstr = "controller-list-invalid";
                        break;

                case NVME_CSSCODE_ATTR_CONFLICT:
                        cstr = "attr-conflict";
                        break;
                case NVME_CSSCODE_BADPROTINFO:
                        cstr = "bad-prot-info";
                        break;
                case NVME_CSSCODE_WRITE_TO_RDONLY:
                        cstr = "write-to-readonly";
                        break;
                default:
                        cstr = "unknown";
                        break;
                }
                ksnprintf(sb->buf, sizeof(sb->buf),
                          "type=specific code=%s(%04x)", cstr, code);
                break;
        case NVME_STATUS_TYPE_MEDIA:
                switch(code) {
                case NVME_MEDCODE_WRITE_FAULT:
                        cstr = "write-fault";
                        break;
                case NVME_MEDCODE_UNRECOV_READ_ERROR:
                        cstr = "unrecoverable-read-error";
                        break;
                case NVME_MEDCODE_ETOE_GUARD_CHK:
                        cstr = "etoe-guard-check";
                        break;
                case NVME_MEDCODE_ETOE_APPTAG_CHK:
                        cstr = "etoe-apptag-check";
                        break;
                case NVME_MEDCODE_ETOE_REFTAG_CHK:
                        cstr = "etoe-reftag-check";
                        break;
                case NVME_MEDCODE_COMPARE_FAILURE:
                        cstr = "compare-failure";
                        break;
                case NVME_MEDCODE_ACCESS_DENIED:
                        cstr = "access-denied";
                        break;
                case NVME_MEDCODE_UNALLOCATED:
                        cstr = "unallocated";
                        break;
                default:
                        cstr = "unknown";
                        break;
                }
                ksnprintf(sb->buf, sizeof(sb->buf),
                          "type=media code=%s(%04x)", cstr, code);
                break;
        case NVME_STATUS_TYPE_VENDOR:
                ksnprintf(sb->buf, sizeof(sb->buf),
                          "type=vendor code=%04x", code);
                break;
        default:
                ksnprintf(sb->buf, sizeof(sb->buf),
                          "type=%02x code=%04x", type, code);
                break;
        }
        return sb->buf;
}