| 1 | /* |
| 2 | * Copyright (c) 2011-2014, Intel Corporation. |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify it |
| 5 | * under the terms and conditions of the GNU General Public License, |
| 6 | * version 2, as published by the Free Software Foundation. |
| 7 | * |
| 8 | * This program is distributed in the hope it will be useful, but WITHOUT |
| 9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 11 | * more details. |
| 12 | */ |
| 13 | |
| 14 | #ifndef _NVME_H |
| 15 | #define _NVME_H |
| 16 | |
| 17 | #include <linux/nvme.h> |
| 18 | #include <linux/pci.h> |
| 19 | #include <linux/kref.h> |
| 20 | #include <linux/blk-mq.h> |
| 21 | |
| 22 | enum { |
| 23 | /* |
| 24 | * Driver internal status code for commands that were cancelled due |
| 25 | * to timeouts or controller shutdown. The value is negative so |
| 26 | * that it a) doesn't overlap with the unsigned hardware error codes, |
| 27 | * and b) can easily be tested for. |
| 28 | */ |
| 29 | NVME_SC_CANCELLED = -EINTR, |
| 30 | }; |
| 31 | |
| 32 | extern unsigned char nvme_io_timeout; |
| 33 | #define NVME_IO_TIMEOUT (nvme_io_timeout * HZ) |
| 34 | |
| 35 | extern unsigned char admin_timeout; |
| 36 | #define ADMIN_TIMEOUT (admin_timeout * HZ) |
| 37 | |
| 38 | extern unsigned char shutdown_timeout; |
| 39 | #define SHUTDOWN_TIMEOUT (shutdown_timeout * HZ) |
| 40 | |
| 41 | enum { |
| 42 | NVME_NS_LBA = 0, |
| 43 | NVME_NS_LIGHTNVM = 1, |
| 44 | }; |
| 45 | |
| 46 | /* |
| 47 | * List of workarounds for devices that required behavior not specified in |
| 48 | * the standard. |
| 49 | */ |
| 50 | enum nvme_quirks { |
| 51 | /* |
| 52 | * Prefers I/O aligned to a stripe size specified in a vendor |
| 53 | * specific Identify field. |
| 54 | */ |
| 55 | NVME_QUIRK_STRIPE_SIZE = (1 << 0), |
| 56 | |
| 57 | /* |
| 58 | * The controller doesn't handle Identify value others than 0 or 1 |
| 59 | * correctly. |
| 60 | */ |
| 61 | NVME_QUIRK_IDENTIFY_CNS = (1 << 1), |
| 62 | |
| 63 | /* |
| 64 | * The controller deterministically returns O's on reads to discarded |
| 65 | * logical blocks. |
| 66 | */ |
| 67 | NVME_QUIRK_DISCARD_ZEROES = (1 << 2), |
| 68 | }; |
| 69 | |
| 70 | enum nvme_ctrl_state { |
| 71 | NVME_CTRL_NEW, |
| 72 | NVME_CTRL_LIVE, |
| 73 | NVME_CTRL_RESETTING, |
| 74 | NVME_CTRL_DELETING, |
| 75 | }; |
| 76 | |
| 77 | struct nvme_ctrl { |
| 78 | enum nvme_ctrl_state state; |
| 79 | spinlock_t lock; |
| 80 | const struct nvme_ctrl_ops *ops; |
| 81 | struct request_queue *admin_q; |
| 82 | struct device *dev; |
| 83 | struct kref kref; |
| 84 | int instance; |
| 85 | struct blk_mq_tag_set *tagset; |
| 86 | struct list_head namespaces; |
| 87 | struct mutex namespaces_mutex; |
| 88 | struct device *device; /* char device */ |
| 89 | struct list_head node; |
| 90 | struct ida ns_ida; |
| 91 | |
| 92 | char name[12]; |
| 93 | char serial[20]; |
| 94 | char model[40]; |
| 95 | char firmware_rev[8]; |
| 96 | u16 cntlid; |
| 97 | |
| 98 | u32 ctrl_config; |
| 99 | |
| 100 | u32 page_size; |
| 101 | u32 max_hw_sectors; |
| 102 | u32 stripe_size; |
| 103 | u16 oncs; |
| 104 | u16 vid; |
| 105 | atomic_t abort_limit; |
| 106 | u8 event_limit; |
| 107 | u8 vwc; |
| 108 | u32 vs; |
| 109 | bool subsystem; |
| 110 | unsigned long quirks; |
| 111 | struct work_struct scan_work; |
| 112 | }; |
| 113 | |
| 114 | /* |
| 115 | * An NVM Express namespace is equivalent to a SCSI LUN |
| 116 | */ |
| 117 | struct nvme_ns { |
| 118 | struct list_head list; |
| 119 | |
| 120 | struct nvme_ctrl *ctrl; |
| 121 | struct request_queue *queue; |
| 122 | struct gendisk *disk; |
| 123 | struct kref kref; |
| 124 | int instance; |
| 125 | |
| 126 | u8 eui[8]; |
| 127 | u8 uuid[16]; |
| 128 | |
| 129 | unsigned ns_id; |
| 130 | int lba_shift; |
| 131 | u16 ms; |
| 132 | bool ext; |
| 133 | u8 pi_type; |
| 134 | int type; |
| 135 | unsigned long flags; |
| 136 | |
| 137 | #define NVME_NS_REMOVING 0 |
| 138 | #define NVME_NS_DEAD 1 |
| 139 | |
| 140 | u64 mode_select_num_blocks; |
| 141 | u32 mode_select_block_len; |
| 142 | }; |
| 143 | |
| 144 | struct nvme_ctrl_ops { |
| 145 | struct module *module; |
| 146 | int (*reg_read32)(struct nvme_ctrl *ctrl, u32 off, u32 *val); |
| 147 | int (*reg_write32)(struct nvme_ctrl *ctrl, u32 off, u32 val); |
| 148 | int (*reg_read64)(struct nvme_ctrl *ctrl, u32 off, u64 *val); |
| 149 | int (*reset_ctrl)(struct nvme_ctrl *ctrl); |
| 150 | void (*free_ctrl)(struct nvme_ctrl *ctrl); |
| 151 | void (*post_scan)(struct nvme_ctrl *ctrl); |
| 152 | }; |
| 153 | |
| 154 | static inline bool nvme_ctrl_ready(struct nvme_ctrl *ctrl) |
| 155 | { |
| 156 | u32 val = 0; |
| 157 | |
| 158 | if (ctrl->ops->reg_read32(ctrl, NVME_REG_CSTS, &val)) |
| 159 | return false; |
| 160 | return val & NVME_CSTS_RDY; |
| 161 | } |
| 162 | |
| 163 | static inline int nvme_reset_subsystem(struct nvme_ctrl *ctrl) |
| 164 | { |
| 165 | if (!ctrl->subsystem) |
| 166 | return -ENOTTY; |
| 167 | return ctrl->ops->reg_write32(ctrl, NVME_REG_NSSR, 0x4E564D65); |
| 168 | } |
| 169 | |
| 170 | static inline u64 nvme_block_nr(struct nvme_ns *ns, sector_t sector) |
| 171 | { |
| 172 | return (sector >> (ns->lba_shift - 9)); |
| 173 | } |
| 174 | |
| 175 | static inline unsigned nvme_map_len(struct request *rq) |
| 176 | { |
| 177 | if (rq->cmd_flags & REQ_DISCARD) |
| 178 | return sizeof(struct nvme_dsm_range); |
| 179 | else |
| 180 | return blk_rq_bytes(rq); |
| 181 | } |
| 182 | |
| 183 | static inline int nvme_error_status(u16 status) |
| 184 | { |
| 185 | switch (status & 0x7ff) { |
| 186 | case NVME_SC_SUCCESS: |
| 187 | return 0; |
| 188 | case NVME_SC_CAP_EXCEEDED: |
| 189 | return -ENOSPC; |
| 190 | default: |
| 191 | return -EIO; |
| 192 | } |
| 193 | } |
| 194 | |
| 195 | static inline bool nvme_req_needs_retry(struct request *req, u16 status) |
| 196 | { |
| 197 | return !(status & NVME_SC_DNR || blk_noretry_request(req)) && |
| 198 | (jiffies - req->start_time) < req->timeout; |
| 199 | } |
| 200 | |
| 201 | bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, |
| 202 | enum nvme_ctrl_state new_state); |
| 203 | int nvme_disable_ctrl(struct nvme_ctrl *ctrl, u64 cap); |
| 204 | int nvme_enable_ctrl(struct nvme_ctrl *ctrl, u64 cap); |
| 205 | int nvme_shutdown_ctrl(struct nvme_ctrl *ctrl); |
| 206 | int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev, |
| 207 | const struct nvme_ctrl_ops *ops, unsigned long quirks); |
| 208 | void nvme_uninit_ctrl(struct nvme_ctrl *ctrl); |
| 209 | void nvme_put_ctrl(struct nvme_ctrl *ctrl); |
| 210 | int nvme_init_identify(struct nvme_ctrl *ctrl); |
| 211 | |
| 212 | void nvme_queue_scan(struct nvme_ctrl *ctrl); |
| 213 | void nvme_remove_namespaces(struct nvme_ctrl *ctrl); |
| 214 | |
| 215 | void nvme_stop_queues(struct nvme_ctrl *ctrl); |
| 216 | void nvme_start_queues(struct nvme_ctrl *ctrl); |
| 217 | void nvme_kill_queues(struct nvme_ctrl *ctrl); |
| 218 | |
| 219 | struct request *nvme_alloc_request(struct request_queue *q, |
| 220 | struct nvme_command *cmd, unsigned int flags); |
| 221 | void nvme_requeue_req(struct request *req); |
| 222 | int nvme_setup_cmd(struct nvme_ns *ns, struct request *req, |
| 223 | struct nvme_command *cmd); |
| 224 | int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd, |
| 225 | void *buf, unsigned bufflen); |
| 226 | int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd, |
| 227 | struct nvme_completion *cqe, void *buffer, unsigned bufflen, |
| 228 | unsigned timeout); |
| 229 | int nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd, |
| 230 | void __user *ubuffer, unsigned bufflen, u32 *result, |
| 231 | unsigned timeout); |
| 232 | int __nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd, |
| 233 | void __user *ubuffer, unsigned bufflen, |
| 234 | void __user *meta_buffer, unsigned meta_len, u32 meta_seed, |
| 235 | u32 *result, unsigned timeout); |
| 236 | int nvme_identify_ctrl(struct nvme_ctrl *dev, struct nvme_id_ctrl **id); |
| 237 | int nvme_identify_ns(struct nvme_ctrl *dev, unsigned nsid, |
| 238 | struct nvme_id_ns **id); |
| 239 | int nvme_get_log_page(struct nvme_ctrl *dev, struct nvme_smart_log **log); |
| 240 | int nvme_get_features(struct nvme_ctrl *dev, unsigned fid, unsigned nsid, |
| 241 | dma_addr_t dma_addr, u32 *result); |
| 242 | int nvme_set_features(struct nvme_ctrl *dev, unsigned fid, unsigned dword11, |
| 243 | dma_addr_t dma_addr, u32 *result); |
| 244 | int nvme_set_queue_count(struct nvme_ctrl *ctrl, int *count); |
| 245 | |
| 246 | struct sg_io_hdr; |
| 247 | |
| 248 | int nvme_sg_io(struct nvme_ns *ns, struct sg_io_hdr __user *u_hdr); |
| 249 | int nvme_sg_io32(struct nvme_ns *ns, unsigned long arg); |
| 250 | int nvme_sg_get_version_num(int __user *ip); |
| 251 | |
| 252 | #ifdef CONFIG_NVM |
| 253 | int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id); |
| 254 | int nvme_nvm_register(struct request_queue *q, char *disk_name); |
| 255 | void nvme_nvm_unregister(struct request_queue *q, char *disk_name); |
| 256 | #else |
| 257 | static inline int nvme_nvm_register(struct request_queue *q, char *disk_name) |
| 258 | { |
| 259 | return 0; |
| 260 | } |
| 261 | |
| 262 | static inline void nvme_nvm_unregister(struct request_queue *q, char *disk_name) {}; |
| 263 | |
| 264 | static inline int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id) |
| 265 | { |
| 266 | return 0; |
| 267 | } |
| 268 | #endif /* CONFIG_NVM */ |
| 269 | |
| 270 | int __init nvme_core_init(void); |
| 271 | void nvme_core_exit(void); |
| 272 | |
| 273 | #endif /* _NVME_H */ |