mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 10:41:38 -04:00
Merge branch 'for-4.11/block' into for-4.11/linus-merge
Signed-off-by: Jens Axboe <[email protected]>
This commit is contained in:
Jens Axboe
commit
6010720da8
68 changed files with 7340 additions and 2832 deletions
|
|
@ -784,6 +784,13 @@ static int nvme_ioctl(struct block_device *bdev, fmode_t mode,
|
|||
return nvme_sg_io(ns, (void __user *)arg);
|
||||
#endif
|
||||
default:
|
||||
#ifdef CONFIG_NVM
|
||||
if (ns->ndev)
|
||||
return nvme_nvm_ioctl(ns, cmd, arg);
|
||||
#endif
|
||||
if (is_sed_ioctl(cmd))
|
||||
return sed_ioctl(ns->ctrl->opal_dev, cmd,
|
||||
(void __user *) arg);
|
||||
return -ENOTTY;
|
||||
}
|
||||
}
|
||||
|
|
@ -1051,6 +1058,28 @@ static const struct pr_ops nvme_pr_ops = {
|
|||
.pr_clear = nvme_pr_clear,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_BLK_SED_OPAL
|
||||
int nvme_sec_submit(void *data, u16 spsp, u8 secp, void *buffer, size_t len,
|
||||
bool send)
|
||||
{
|
||||
struct nvme_ctrl *ctrl = data;
|
||||
struct nvme_command cmd;
|
||||
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
if (send)
|
||||
cmd.common.opcode = nvme_admin_security_send;
|
||||
else
|
||||
cmd.common.opcode = nvme_admin_security_recv;
|
||||
cmd.common.nsid = 0;
|
||||
cmd.common.cdw10[0] = cpu_to_le32(((u32)secp) << 24 | ((u32)spsp) << 8);
|
||||
cmd.common.cdw10[1] = cpu_to_le32(len);
|
||||
|
||||
return __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, NULL, buffer, len,
|
||||
ADMIN_TIMEOUT, NVME_QID_ANY, 1, 0);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nvme_sec_submit);
|
||||
#endif /* CONFIG_BLK_SED_OPAL */
|
||||
|
||||
static const struct block_device_operations nvme_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.ioctl = nvme_ioctl,
|
||||
|
|
@ -1230,6 +1259,7 @@ int nvme_init_identify(struct nvme_ctrl *ctrl)
|
|||
return -EIO;
|
||||
}
|
||||
|
||||
ctrl->oacs = le16_to_cpu(id->oacs);
|
||||
ctrl->vid = le16_to_cpu(id->vid);
|
||||
ctrl->oncs = le16_to_cpup(&id->oncs);
|
||||
atomic_set(&ctrl->abort_limit, id->acl + 1);
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@
|
|||
#include <linux/bitops.h>
|
||||
#include <linux/lightnvm.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/sched/sysctl.h>
|
||||
#include <uapi/linux/lightnvm.h>
|
||||
|
||||
enum nvme_nvm_admin_opcode {
|
||||
nvme_nvm_admin_identity = 0xe2,
|
||||
|
|
@ -248,50 +250,48 @@ static int init_grps(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, 4, nvm_id->cgrps);
|
||||
if (nvme_nvm_id->cgrps != 1)
|
||||
return -EINVAL;
|
||||
|
||||
for (i = 0; i < end; i++) {
|
||||
src = &nvme_nvm_id->groups[i];
|
||||
dst = &nvm_id->groups[i];
|
||||
src = &nvme_nvm_id->groups[0];
|
||||
dst = &nvm_id->grp;
|
||||
|
||||
dst->mtype = src->mtype;
|
||||
dst->fmtype = src->fmtype;
|
||||
dst->num_ch = src->num_ch;
|
||||
dst->num_lun = src->num_lun;
|
||||
dst->num_pln = src->num_pln;
|
||||
dst->mtype = src->mtype;
|
||||
dst->fmtype = src->fmtype;
|
||||
dst->num_ch = src->num_ch;
|
||||
dst->num_lun = src->num_lun;
|
||||
dst->num_pln = src->num_pln;
|
||||
|
||||
dst->num_pg = le16_to_cpu(src->num_pg);
|
||||
dst->num_blk = le16_to_cpu(src->num_blk);
|
||||
dst->fpg_sz = le16_to_cpu(src->fpg_sz);
|
||||
dst->csecs = le16_to_cpu(src->csecs);
|
||||
dst->sos = le16_to_cpu(src->sos);
|
||||
dst->num_pg = le16_to_cpu(src->num_pg);
|
||||
dst->num_blk = le16_to_cpu(src->num_blk);
|
||||
dst->fpg_sz = le16_to_cpu(src->fpg_sz);
|
||||
dst->csecs = le16_to_cpu(src->csecs);
|
||||
dst->sos = le16_to_cpu(src->sos);
|
||||
|
||||
dst->trdt = le32_to_cpu(src->trdt);
|
||||
dst->trdm = le32_to_cpu(src->trdm);
|
||||
dst->tprt = le32_to_cpu(src->tprt);
|
||||
dst->tprm = le32_to_cpu(src->tprm);
|
||||
dst->tbet = le32_to_cpu(src->tbet);
|
||||
dst->tbem = le32_to_cpu(src->tbem);
|
||||
dst->mpos = le32_to_cpu(src->mpos);
|
||||
dst->mccap = le32_to_cpu(src->mccap);
|
||||
dst->trdt = le32_to_cpu(src->trdt);
|
||||
dst->trdm = le32_to_cpu(src->trdm);
|
||||
dst->tprt = le32_to_cpu(src->tprt);
|
||||
dst->tprm = le32_to_cpu(src->tprm);
|
||||
dst->tbet = le32_to_cpu(src->tbet);
|
||||
dst->tbem = le32_to_cpu(src->tbem);
|
||||
dst->mpos = le32_to_cpu(src->mpos);
|
||||
dst->mccap = le32_to_cpu(src->mccap);
|
||||
|
||||
dst->cpar = le16_to_cpu(src->cpar);
|
||||
dst->cpar = le16_to_cpu(src->cpar);
|
||||
|
||||
if (dst->fmtype == NVM_ID_FMTYPE_MLC) {
|
||||
memcpy(dst->lptbl.id, src->lptbl.id, 8);
|
||||
dst->lptbl.mlc.num_pairs =
|
||||
le16_to_cpu(src->lptbl.mlc.num_pairs);
|
||||
if (dst->fmtype == NVM_ID_FMTYPE_MLC) {
|
||||
memcpy(dst->lptbl.id, src->lptbl.id, 8);
|
||||
dst->lptbl.mlc.num_pairs =
|
||||
le16_to_cpu(src->lptbl.mlc.num_pairs);
|
||||
|
||||
if (dst->lptbl.mlc.num_pairs > NVME_NVM_LP_MLC_PAIRS) {
|
||||
pr_err("nvm: number of MLC pairs not supported\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
memcpy(dst->lptbl.mlc.pairs, src->lptbl.mlc.pairs,
|
||||
dst->lptbl.mlc.num_pairs);
|
||||
if (dst->lptbl.mlc.num_pairs > NVME_NVM_LP_MLC_PAIRS) {
|
||||
pr_err("nvm: number of MLC pairs not supported\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
memcpy(dst->lptbl.mlc.pairs, src->lptbl.mlc.pairs,
|
||||
dst->lptbl.mlc.num_pairs);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
@ -321,7 +321,6 @@ static int nvme_nvm_identity(struct nvm_dev *nvmdev, struct nvm_id *nvm_id)
|
|||
|
||||
nvm_id->ver_id = nvme_nvm_id->ver_id;
|
||||
nvm_id->vmnt = nvme_nvm_id->vmnt;
|
||||
nvm_id->cgrps = nvme_nvm_id->cgrps;
|
||||
nvm_id->cap = le32_to_cpu(nvme_nvm_id->cap);
|
||||
nvm_id->dom = le32_to_cpu(nvme_nvm_id->dom);
|
||||
memcpy(&nvm_id->ppaf, &nvme_nvm_id->ppaf,
|
||||
|
|
@ -372,7 +371,7 @@ static int nvme_nvm_get_l2p_tbl(struct nvm_dev *nvmdev, u64 slba, u32 nlb,
|
|||
}
|
||||
|
||||
/* Transform physical address to target address space */
|
||||
nvmdev->mt->part_to_tgt(nvmdev, entries, cmd_nlb);
|
||||
nvm_part_to_tgt(nvmdev, entries, cmd_nlb);
|
||||
|
||||
if (update_l2p(cmd_slba, cmd_nlb, entries, priv)) {
|
||||
ret = -EINTR;
|
||||
|
|
@ -485,7 +484,8 @@ static void nvme_nvm_end_io(struct request *rq, int error)
|
|||
struct nvm_rq *rqd = rq->end_io_data;
|
||||
|
||||
rqd->ppa_status = nvme_req(rq)->result.u64;
|
||||
nvm_end_io(rqd, error);
|
||||
rqd->error = error;
|
||||
nvm_end_io(rqd);
|
||||
|
||||
kfree(nvme_req(rq)->cmd);
|
||||
blk_mq_free_request(rq);
|
||||
|
|
@ -586,6 +586,224 @@ static struct nvm_dev_ops nvme_nvm_dev_ops = {
|
|||
.max_phys_sect = 64,
|
||||
};
|
||||
|
||||
static void nvme_nvm_end_user_vio(struct request *rq, int error)
|
||||
{
|
||||
struct completion *waiting = rq->end_io_data;
|
||||
|
||||
complete(waiting);
|
||||
}
|
||||
|
||||
static int nvme_nvm_submit_user_cmd(struct request_queue *q,
|
||||
struct nvme_ns *ns,
|
||||
struct nvme_nvm_command *vcmd,
|
||||
void __user *ubuf, unsigned int bufflen,
|
||||
void __user *meta_buf, unsigned int meta_len,
|
||||
void __user *ppa_buf, unsigned int ppa_len,
|
||||
u32 *result, u64 *status, unsigned int timeout)
|
||||
{
|
||||
bool write = nvme_is_write((struct nvme_command *)vcmd);
|
||||
struct nvm_dev *dev = ns->ndev;
|
||||
struct gendisk *disk = ns->disk;
|
||||
struct request *rq;
|
||||
struct bio *bio = NULL;
|
||||
__le64 *ppa_list = NULL;
|
||||
dma_addr_t ppa_dma;
|
||||
__le64 *metadata = NULL;
|
||||
dma_addr_t metadata_dma;
|
||||
DECLARE_COMPLETION_ONSTACK(wait);
|
||||
int ret;
|
||||
|
||||
rq = nvme_alloc_request(q, (struct nvme_command *)vcmd, 0,
|
||||
NVME_QID_ANY);
|
||||
if (IS_ERR(rq)) {
|
||||
ret = -ENOMEM;
|
||||
goto err_cmd;
|
||||
}
|
||||
|
||||
rq->timeout = timeout ? timeout : ADMIN_TIMEOUT;
|
||||
|
||||
rq->cmd_flags &= ~REQ_FAILFAST_DRIVER;
|
||||
rq->end_io_data = &wait;
|
||||
|
||||
if (ppa_buf && ppa_len) {
|
||||
ppa_list = dma_pool_alloc(dev->dma_pool, GFP_KERNEL, &ppa_dma);
|
||||
if (!ppa_list) {
|
||||
ret = -ENOMEM;
|
||||
goto err_rq;
|
||||
}
|
||||
if (copy_from_user(ppa_list, (void __user *)ppa_buf,
|
||||
sizeof(u64) * (ppa_len + 1))) {
|
||||
ret = -EFAULT;
|
||||
goto err_ppa;
|
||||
}
|
||||
vcmd->ph_rw.spba = cpu_to_le64(ppa_dma);
|
||||
} else {
|
||||
vcmd->ph_rw.spba = cpu_to_le64((uintptr_t)ppa_buf);
|
||||
}
|
||||
|
||||
if (ubuf && bufflen) {
|
||||
ret = blk_rq_map_user(q, rq, NULL, ubuf, bufflen, GFP_KERNEL);
|
||||
if (ret)
|
||||
goto err_ppa;
|
||||
bio = rq->bio;
|
||||
|
||||
if (meta_buf && meta_len) {
|
||||
metadata = dma_pool_alloc(dev->dma_pool, GFP_KERNEL,
|
||||
&metadata_dma);
|
||||
if (!metadata) {
|
||||
ret = -ENOMEM;
|
||||
goto err_map;
|
||||
}
|
||||
|
||||
if (write) {
|
||||
if (copy_from_user(metadata,
|
||||
(void __user *)meta_buf,
|
||||
meta_len)) {
|
||||
ret = -EFAULT;
|
||||
goto err_meta;
|
||||
}
|
||||
}
|
||||
vcmd->ph_rw.metadata = cpu_to_le64(metadata_dma);
|
||||
}
|
||||
|
||||
if (!disk)
|
||||
goto submit;
|
||||
|
||||
bio->bi_bdev = bdget_disk(disk, 0);
|
||||
if (!bio->bi_bdev) {
|
||||
ret = -ENODEV;
|
||||
goto err_meta;
|
||||
}
|
||||
}
|
||||
|
||||
submit:
|
||||
blk_execute_rq_nowait(q, NULL, rq, 0, nvme_nvm_end_user_vio);
|
||||
|
||||
wait_for_completion_io(&wait);
|
||||
|
||||
ret = nvme_error_status(rq->errors);
|
||||
if (result)
|
||||
*result = rq->errors & 0x7ff;
|
||||
if (status)
|
||||
*status = le64_to_cpu(nvme_req(rq)->result.u64);
|
||||
|
||||
if (metadata && !ret && !write) {
|
||||
if (copy_to_user(meta_buf, (void *)metadata, meta_len))
|
||||
ret = -EFAULT;
|
||||
}
|
||||
err_meta:
|
||||
if (meta_buf && meta_len)
|
||||
dma_pool_free(dev->dma_pool, metadata, metadata_dma);
|
||||
err_map:
|
||||
if (bio) {
|
||||
if (disk && bio->bi_bdev)
|
||||
bdput(bio->bi_bdev);
|
||||
blk_rq_unmap_user(bio);
|
||||
}
|
||||
err_ppa:
|
||||
if (ppa_buf && ppa_len)
|
||||
dma_pool_free(dev->dma_pool, ppa_list, ppa_dma);
|
||||
err_rq:
|
||||
blk_mq_free_request(rq);
|
||||
err_cmd:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int nvme_nvm_submit_vio(struct nvme_ns *ns,
|
||||
struct nvm_user_vio __user *uvio)
|
||||
{
|
||||
struct nvm_user_vio vio;
|
||||
struct nvme_nvm_command c;
|
||||
unsigned int length;
|
||||
int ret;
|
||||
|
||||
if (copy_from_user(&vio, uvio, sizeof(vio)))
|
||||
return -EFAULT;
|
||||
if (vio.flags)
|
||||
return -EINVAL;
|
||||
|
||||
memset(&c, 0, sizeof(c));
|
||||
c.ph_rw.opcode = vio.opcode;
|
||||
c.ph_rw.nsid = cpu_to_le32(ns->ns_id);
|
||||
c.ph_rw.control = cpu_to_le16(vio.control);
|
||||
c.ph_rw.length = cpu_to_le16(vio.nppas);
|
||||
|
||||
length = (vio.nppas + 1) << ns->lba_shift;
|
||||
|
||||
ret = nvme_nvm_submit_user_cmd(ns->queue, ns, &c,
|
||||
(void __user *)(uintptr_t)vio.addr, length,
|
||||
(void __user *)(uintptr_t)vio.metadata,
|
||||
vio.metadata_len,
|
||||
(void __user *)(uintptr_t)vio.ppa_list, vio.nppas,
|
||||
&vio.result, &vio.status, 0);
|
||||
|
||||
if (ret && copy_to_user(uvio, &vio, sizeof(vio)))
|
||||
return -EFAULT;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int nvme_nvm_user_vcmd(struct nvme_ns *ns, int admin,
|
||||
struct nvm_passthru_vio __user *uvcmd)
|
||||
{
|
||||
struct nvm_passthru_vio vcmd;
|
||||
struct nvme_nvm_command c;
|
||||
struct request_queue *q;
|
||||
unsigned int timeout = 0;
|
||||
int ret;
|
||||
|
||||
if (copy_from_user(&vcmd, uvcmd, sizeof(vcmd)))
|
||||
return -EFAULT;
|
||||
if ((vcmd.opcode != 0xF2) && (!capable(CAP_SYS_ADMIN)))
|
||||
return -EACCES;
|
||||
if (vcmd.flags)
|
||||
return -EINVAL;
|
||||
|
||||
memset(&c, 0, sizeof(c));
|
||||
c.common.opcode = vcmd.opcode;
|
||||
c.common.nsid = cpu_to_le32(ns->ns_id);
|
||||
c.common.cdw2[0] = cpu_to_le32(vcmd.cdw2);
|
||||
c.common.cdw2[1] = cpu_to_le32(vcmd.cdw3);
|
||||
/* cdw11-12 */
|
||||
c.ph_rw.length = cpu_to_le16(vcmd.nppas);
|
||||
c.ph_rw.control = cpu_to_le32(vcmd.control);
|
||||
c.common.cdw10[3] = cpu_to_le32(vcmd.cdw13);
|
||||
c.common.cdw10[4] = cpu_to_le32(vcmd.cdw14);
|
||||
c.common.cdw10[5] = cpu_to_le32(vcmd.cdw15);
|
||||
|
||||
if (vcmd.timeout_ms)
|
||||
timeout = msecs_to_jiffies(vcmd.timeout_ms);
|
||||
|
||||
q = admin ? ns->ctrl->admin_q : ns->queue;
|
||||
|
||||
ret = nvme_nvm_submit_user_cmd(q, ns,
|
||||
(struct nvme_nvm_command *)&c,
|
||||
(void __user *)(uintptr_t)vcmd.addr, vcmd.data_len,
|
||||
(void __user *)(uintptr_t)vcmd.metadata,
|
||||
vcmd.metadata_len,
|
||||
(void __user *)(uintptr_t)vcmd.ppa_list, vcmd.nppas,
|
||||
&vcmd.result, &vcmd.status, timeout);
|
||||
|
||||
if (ret && copy_to_user(uvcmd, &vcmd, sizeof(vcmd)))
|
||||
return -EFAULT;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int nvme_nvm_ioctl(struct nvme_ns *ns, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
switch (cmd) {
|
||||
case NVME_NVM_IOCTL_ADMIN_VIO:
|
||||
return nvme_nvm_user_vcmd(ns, 1, (void __user *)arg);
|
||||
case NVME_NVM_IOCTL_IO_VIO:
|
||||
return nvme_nvm_user_vcmd(ns, 0, (void __user *)arg);
|
||||
case NVME_NVM_IOCTL_SUBMIT_VIO:
|
||||
return nvme_nvm_submit_vio(ns, (void __user *)arg);
|
||||
default:
|
||||
return -ENOTTY;
|
||||
}
|
||||
}
|
||||
|
||||
int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, int node)
|
||||
{
|
||||
struct request_queue *q = ns->queue;
|
||||
|
|
@ -622,7 +840,7 @@ static ssize_t nvm_dev_attr_show(struct device *dev,
|
|||
return 0;
|
||||
|
||||
id = &ndev->identity;
|
||||
grp = &id->groups[0];
|
||||
grp = &id->grp;
|
||||
attr = &dattr->attr;
|
||||
|
||||
if (strcmp(attr->name, "version") == 0) {
|
||||
|
|
@ -633,10 +851,9 @@ static ssize_t nvm_dev_attr_show(struct device *dev,
|
|||
return scnprintf(page, PAGE_SIZE, "%u\n", id->cap);
|
||||
} else if (strcmp(attr->name, "device_mode") == 0) {
|
||||
return scnprintf(page, PAGE_SIZE, "%u\n", id->dom);
|
||||
/* kept for compatibility */
|
||||
} else if (strcmp(attr->name, "media_manager") == 0) {
|
||||
if (!ndev->mt)
|
||||
return scnprintf(page, PAGE_SIZE, "%s\n", "none");
|
||||
return scnprintf(page, PAGE_SIZE, "%s\n", ndev->mt->name);
|
||||
return scnprintf(page, PAGE_SIZE, "%s\n", "gennvm");
|
||||
} else if (strcmp(attr->name, "ppa_format") == 0) {
|
||||
return scnprintf(page, PAGE_SIZE,
|
||||
"0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
#include <linux/kref.h>
|
||||
#include <linux/blk-mq.h>
|
||||
#include <linux/lightnvm.h>
|
||||
#include <linux/sed-opal.h>
|
||||
|
||||
enum {
|
||||
/*
|
||||
|
|
@ -125,6 +126,8 @@ struct nvme_ctrl {
|
|||
struct list_head node;
|
||||
struct ida ns_ida;
|
||||
|
||||
struct opal_dev *opal_dev;
|
||||
|
||||
char name[12];
|
||||
char serial[20];
|
||||
char model[40];
|
||||
|
|
@ -137,6 +140,7 @@ struct nvme_ctrl {
|
|||
u32 max_hw_sectors;
|
||||
u16 oncs;
|
||||
u16 vid;
|
||||
u16 oacs;
|
||||
atomic_t abort_limit;
|
||||
u8 event_limit;
|
||||
u8 vwc;
|
||||
|
|
@ -267,6 +271,9 @@ int nvme_init_identify(struct nvme_ctrl *ctrl);
|
|||
void nvme_queue_scan(struct nvme_ctrl *ctrl);
|
||||
void nvme_remove_namespaces(struct nvme_ctrl *ctrl);
|
||||
|
||||
int nvme_sec_submit(void *data, u16 spsp, u8 secp, void *buffer, size_t len,
|
||||
bool send);
|
||||
|
||||
#define NVME_NR_AERS 1
|
||||
void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,
|
||||
union nvme_result *res);
|
||||
|
|
@ -318,6 +325,7 @@ int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, int node);
|
|||
void nvme_nvm_unregister(struct nvme_ns *ns);
|
||||
int nvme_nvm_register_sysfs(struct nvme_ns *ns);
|
||||
void nvme_nvm_unregister_sysfs(struct nvme_ns *ns);
|
||||
int nvme_nvm_ioctl(struct nvme_ns *ns, unsigned int cmd, unsigned long arg);
|
||||
#else
|
||||
static inline int nvme_nvm_register(struct nvme_ns *ns, char *disk_name,
|
||||
int node)
|
||||
|
|
@ -335,6 +343,11 @@ static inline int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *i
|
|||
{
|
||||
return 0;
|
||||
}
|
||||
static inline int nvme_nvm_ioctl(struct nvme_ns *ns, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
return -ENOTTY;
|
||||
}
|
||||
#endif /* CONFIG_NVM */
|
||||
|
||||
static inline struct nvme_ns *nvme_get_ns_from_dev(struct device *dev)
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@
|
|||
#include <linux/types.h>
|
||||
#include <linux/io-64-nonatomic-lo-hi.h>
|
||||
#include <asm/unaligned.h>
|
||||
#include <linux/sed-opal.h>
|
||||
|
||||
#include "nvme.h"
|
||||
|
||||
|
|
@ -895,12 +896,11 @@ static enum blk_eh_timer_return nvme_timeout(struct request *req, bool reserved)
|
|||
return BLK_EH_HANDLED;
|
||||
}
|
||||
|
||||
iod->aborted = 1;
|
||||
|
||||
if (atomic_dec_return(&dev->ctrl.abort_limit) < 0) {
|
||||
atomic_inc(&dev->ctrl.abort_limit);
|
||||
return BLK_EH_RESET_TIMER;
|
||||
}
|
||||
iod->aborted = 1;
|
||||
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.abort.opcode = nvme_admin_abort_cmd;
|
||||
|
|
@ -1178,6 +1178,7 @@ static int nvme_alloc_admin_tags(struct nvme_dev *dev)
|
|||
dev->admin_tagset.timeout = ADMIN_TIMEOUT;
|
||||
dev->admin_tagset.numa_node = dev_to_node(dev->dev);
|
||||
dev->admin_tagset.cmd_size = nvme_cmd_size(dev);
|
||||
dev->admin_tagset.flags = BLK_MQ_F_NO_SCHED;
|
||||
dev->admin_tagset.driver_data = dev;
|
||||
|
||||
if (blk_mq_alloc_tag_set(&dev->admin_tagset))
|
||||
|
|
@ -1738,6 +1739,7 @@ static void nvme_pci_free_ctrl(struct nvme_ctrl *ctrl)
|
|||
if (dev->ctrl.admin_q)
|
||||
blk_put_queue(dev->ctrl.admin_q);
|
||||
kfree(dev->queues);
|
||||
kfree(dev->ctrl.opal_dev);
|
||||
kfree(dev);
|
||||
}
|
||||
|
||||
|
|
@ -1754,6 +1756,7 @@ static void nvme_remove_dead_ctrl(struct nvme_dev *dev, int status)
|
|||
static void nvme_reset_work(struct work_struct *work)
|
||||
{
|
||||
struct nvme_dev *dev = container_of(work, struct nvme_dev, reset_work);
|
||||
bool was_suspend = !!(dev->ctrl.ctrl_config & NVME_CC_SHN_NORMAL);
|
||||
int result = -ENODEV;
|
||||
|
||||
if (WARN_ON(dev->ctrl.state == NVME_CTRL_RESETTING))
|
||||
|
|
@ -1786,6 +1789,14 @@ static void nvme_reset_work(struct work_struct *work)
|
|||
if (result)
|
||||
goto out;
|
||||
|
||||
if ((dev->ctrl.oacs & NVME_CTRL_OACS_SEC_SUPP) && !dev->ctrl.opal_dev) {
|
||||
dev->ctrl.opal_dev =
|
||||
init_opal_dev(&dev->ctrl, &nvme_sec_submit);
|
||||
}
|
||||
|
||||
if (was_suspend)
|
||||
opal_unlock_from_suspend(dev->ctrl.opal_dev);
|
||||
|
||||
result = nvme_setup_io_queues(dev);
|
||||
if (result)
|
||||
goto out;
|
||||
|
|
|
|||
Loading…
Reference in a new issue