Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 1 | #ifndef NVM_H |
| 2 | #define NVM_H |
| 3 | |
Jens Axboe | a7fd9a4 | 2016-01-13 13:04:11 -0700 | [diff] [blame] | 4 | #include <linux/types.h> |
| 5 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 6 | enum { |
| 7 | NVM_IO_OK = 0, |
| 8 | NVM_IO_REQUEUE = 1, |
| 9 | NVM_IO_DONE = 2, |
| 10 | NVM_IO_ERR = 3, |
| 11 | |
| 12 | NVM_IOTYPE_NONE = 0, |
| 13 | NVM_IOTYPE_GC = 1, |
| 14 | }; |
| 15 | |
Jens Axboe | a7fd9a4 | 2016-01-13 13:04:11 -0700 | [diff] [blame] | 16 | #define NVM_BLK_BITS (16) |
| 17 | #define NVM_PG_BITS (16) |
| 18 | #define NVM_SEC_BITS (8) |
| 19 | #define NVM_PL_BITS (8) |
| 20 | #define NVM_LUN_BITS (8) |
| 21 | #define NVM_CH_BITS (8) |
| 22 | |
| 23 | struct ppa_addr { |
| 24 | /* Generic structure for all addresses */ |
| 25 | union { |
| 26 | struct { |
| 27 | u64 blk : NVM_BLK_BITS; |
| 28 | u64 pg : NVM_PG_BITS; |
| 29 | u64 sec : NVM_SEC_BITS; |
| 30 | u64 pl : NVM_PL_BITS; |
| 31 | u64 lun : NVM_LUN_BITS; |
| 32 | u64 ch : NVM_CH_BITS; |
| 33 | } g; |
| 34 | |
| 35 | u64 ppa; |
| 36 | }; |
| 37 | }; |
| 38 | |
| 39 | struct nvm_rq; |
| 40 | struct nvm_id; |
| 41 | struct nvm_dev; |
| 42 | |
| 43 | typedef int (nvm_l2p_update_fn)(u64, u32, __le64 *, void *); |
| 44 | typedef int (nvm_bb_update_fn)(struct ppa_addr, int, u8 *, void *); |
| 45 | typedef int (nvm_id_fn)(struct nvm_dev *, struct nvm_id *); |
| 46 | typedef int (nvm_get_l2p_tbl_fn)(struct nvm_dev *, u64, u32, |
| 47 | nvm_l2p_update_fn *, void *); |
| 48 | typedef int (nvm_op_bb_tbl_fn)(struct nvm_dev *, struct ppa_addr, int, |
| 49 | nvm_bb_update_fn *, void *); |
| 50 | typedef int (nvm_op_set_bb_fn)(struct nvm_dev *, struct nvm_rq *, int); |
| 51 | typedef int (nvm_submit_io_fn)(struct nvm_dev *, struct nvm_rq *); |
| 52 | typedef int (nvm_erase_blk_fn)(struct nvm_dev *, struct nvm_rq *); |
| 53 | typedef void *(nvm_create_dma_pool_fn)(struct nvm_dev *, char *); |
| 54 | typedef void (nvm_destroy_dma_pool_fn)(void *); |
| 55 | typedef void *(nvm_dev_dma_alloc_fn)(struct nvm_dev *, void *, gfp_t, |
| 56 | dma_addr_t *); |
| 57 | typedef void (nvm_dev_dma_free_fn)(void *, void*, dma_addr_t); |
| 58 | |
| 59 | struct nvm_dev_ops { |
| 60 | nvm_id_fn *identity; |
| 61 | nvm_get_l2p_tbl_fn *get_l2p_tbl; |
| 62 | nvm_op_bb_tbl_fn *get_bb_tbl; |
| 63 | nvm_op_set_bb_fn *set_bb_tbl; |
| 64 | |
| 65 | nvm_submit_io_fn *submit_io; |
| 66 | nvm_erase_blk_fn *erase_block; |
| 67 | |
| 68 | nvm_create_dma_pool_fn *create_dma_pool; |
| 69 | nvm_destroy_dma_pool_fn *destroy_dma_pool; |
| 70 | nvm_dev_dma_alloc_fn *dev_dma_alloc; |
| 71 | nvm_dev_dma_free_fn *dev_dma_free; |
| 72 | |
| 73 | unsigned int max_phys_sect; |
| 74 | }; |
| 75 | |
| 76 | |
| 77 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 78 | #ifdef CONFIG_NVM |
| 79 | |
| 80 | #include <linux/blkdev.h> |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 81 | #include <linux/file.h> |
| 82 | #include <linux/dmapool.h> |
Matias Bjørling | e3eb379 | 2016-01-12 07:49:36 +0100 | [diff] [blame] | 83 | #include <uapi/linux/lightnvm.h> |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 84 | |
| 85 | enum { |
| 86 | /* HW Responsibilities */ |
| 87 | NVM_RSP_L2P = 1 << 0, |
| 88 | NVM_RSP_ECC = 1 << 1, |
| 89 | |
| 90 | /* Physical Adressing Mode */ |
| 91 | NVM_ADDRMODE_LINEAR = 0, |
| 92 | NVM_ADDRMODE_CHANNEL = 1, |
| 93 | |
| 94 | /* Plane programming mode for LUN */ |
Matias Bjørling | d5bdec8 | 2016-02-19 13:56:58 +0100 | [diff] [blame] | 95 | NVM_PLANE_SINGLE = 1, |
| 96 | NVM_PLANE_DOUBLE = 2, |
| 97 | NVM_PLANE_QUAD = 4, |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 98 | |
| 99 | /* Status codes */ |
| 100 | NVM_RSP_SUCCESS = 0x0, |
| 101 | NVM_RSP_NOT_CHANGEABLE = 0x1, |
| 102 | NVM_RSP_ERR_FAILWRITE = 0x40ff, |
| 103 | NVM_RSP_ERR_EMPTYPAGE = 0x42ff, |
| 104 | |
| 105 | /* Device opcodes */ |
| 106 | NVM_OP_HBREAD = 0x02, |
| 107 | NVM_OP_HBWRITE = 0x81, |
| 108 | NVM_OP_PWRITE = 0x91, |
| 109 | NVM_OP_PREAD = 0x92, |
| 110 | NVM_OP_ERASE = 0x90, |
| 111 | |
| 112 | /* PPA Command Flags */ |
| 113 | NVM_IO_SNGL_ACCESS = 0x0, |
| 114 | NVM_IO_DUAL_ACCESS = 0x1, |
| 115 | NVM_IO_QUAD_ACCESS = 0x2, |
| 116 | |
Matias Bjørling | 57b4bd0 | 2015-12-06 11:25:47 +0100 | [diff] [blame] | 117 | /* NAND Access Modes */ |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 118 | NVM_IO_SUSPEND = 0x80, |
| 119 | NVM_IO_SLC_MODE = 0x100, |
| 120 | NVM_IO_SCRAMBLE_DISABLE = 0x200, |
Matias Bjørling | 57b4bd0 | 2015-12-06 11:25:47 +0100 | [diff] [blame] | 121 | |
| 122 | /* Block Types */ |
| 123 | NVM_BLK_T_FREE = 0x0, |
| 124 | NVM_BLK_T_BAD = 0x1, |
Matias Bjørling | b5d4acd | 2016-01-12 07:49:32 +0100 | [diff] [blame] | 125 | NVM_BLK_T_GRWN_BAD = 0x2, |
| 126 | NVM_BLK_T_DEV = 0x4, |
| 127 | NVM_BLK_T_HOST = 0x8, |
Matias Bjørling | f9a9995 | 2016-01-12 07:49:34 +0100 | [diff] [blame] | 128 | |
| 129 | /* Memory capabilities */ |
| 130 | NVM_ID_CAP_SLC = 0x1, |
| 131 | NVM_ID_CAP_CMD_SUSPEND = 0x2, |
| 132 | NVM_ID_CAP_SCRAMBLE = 0x4, |
| 133 | NVM_ID_CAP_ENCRYPT = 0x8, |
Matias Bjørling | ca5927e | 2016-01-12 07:49:35 +0100 | [diff] [blame] | 134 | |
| 135 | /* Memory types */ |
| 136 | NVM_ID_FMTYPE_SLC = 0, |
| 137 | NVM_ID_FMTYPE_MLC = 1, |
Matias Bjørling | bf64318 | 2016-02-04 15:13:27 +0100 | [diff] [blame] | 138 | |
| 139 | /* Device capabilities */ |
| 140 | NVM_ID_DCAP_BBLKMGMT = 0x1, |
| 141 | NVM_UD_DCAP_ECC = 0x2, |
Matias Bjørling | ca5927e | 2016-01-12 07:49:35 +0100 | [diff] [blame] | 142 | }; |
| 143 | |
| 144 | struct nvm_id_lp_mlc { |
| 145 | u16 num_pairs; |
| 146 | u8 pairs[886]; |
| 147 | }; |
| 148 | |
| 149 | struct nvm_id_lp_tbl { |
| 150 | __u8 id[8]; |
| 151 | struct nvm_id_lp_mlc mlc; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 152 | }; |
| 153 | |
| 154 | struct nvm_id_group { |
| 155 | u8 mtype; |
| 156 | u8 fmtype; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 157 | u8 num_ch; |
| 158 | u8 num_lun; |
| 159 | u8 num_pln; |
| 160 | u16 num_blk; |
| 161 | u16 num_pg; |
| 162 | u16 fpg_sz; |
| 163 | u16 csecs; |
| 164 | u16 sos; |
| 165 | u32 trdt; |
| 166 | u32 trdm; |
| 167 | u32 tprt; |
| 168 | u32 tprm; |
| 169 | u32 tbet; |
| 170 | u32 tbem; |
| 171 | u32 mpos; |
Matias Bjørling | 12be5ed | 2015-11-16 15:34:39 +0100 | [diff] [blame] | 172 | u32 mccap; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 173 | u16 cpar; |
Matias Bjørling | ca5927e | 2016-01-12 07:49:35 +0100 | [diff] [blame] | 174 | |
| 175 | struct nvm_id_lp_tbl lptbl; |
Matias Bjørling | 73387e7 | 2015-11-16 15:34:40 +0100 | [diff] [blame] | 176 | }; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 177 | |
| 178 | struct nvm_addr_format { |
| 179 | u8 ch_offset; |
| 180 | u8 ch_len; |
| 181 | u8 lun_offset; |
| 182 | u8 lun_len; |
| 183 | u8 pln_offset; |
| 184 | u8 pln_len; |
| 185 | u8 blk_offset; |
| 186 | u8 blk_len; |
| 187 | u8 pg_offset; |
| 188 | u8 pg_len; |
| 189 | u8 sect_offset; |
| 190 | u8 sect_len; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 191 | }; |
| 192 | |
| 193 | struct nvm_id { |
| 194 | u8 ver_id; |
| 195 | u8 vmnt; |
| 196 | u8 cgrps; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 197 | u32 cap; |
| 198 | u32 dom; |
| 199 | struct nvm_addr_format ppaf; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 200 | struct nvm_id_group groups[4]; |
| 201 | } __packed; |
| 202 | |
| 203 | struct nvm_target { |
| 204 | struct list_head list; |
| 205 | struct nvm_tgt_type *type; |
| 206 | struct gendisk *disk; |
| 207 | }; |
| 208 | |
| 209 | struct nvm_tgt_instance { |
| 210 | struct nvm_tgt_type *tt; |
| 211 | }; |
| 212 | |
| 213 | #define ADDR_EMPTY (~0ULL) |
| 214 | |
| 215 | #define NVM_VERSION_MAJOR 1 |
| 216 | #define NVM_VERSION_MINOR 0 |
| 217 | #define NVM_VERSION_PATCH 0 |
| 218 | |
Matias Bjørling | 91276162 | 2016-01-12 07:49:21 +0100 | [diff] [blame] | 219 | struct nvm_rq; |
Matias Bjørling | 72d256e | 2016-01-12 07:49:29 +0100 | [diff] [blame] | 220 | typedef void (nvm_end_io_fn)(struct nvm_rq *); |
Matias Bjørling | 91276162 | 2016-01-12 07:49:21 +0100 | [diff] [blame] | 221 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 222 | struct nvm_rq { |
| 223 | struct nvm_tgt_instance *ins; |
| 224 | struct nvm_dev *dev; |
| 225 | |
| 226 | struct bio *bio; |
| 227 | |
| 228 | union { |
| 229 | struct ppa_addr ppa_addr; |
| 230 | dma_addr_t dma_ppa_list; |
| 231 | }; |
| 232 | |
| 233 | struct ppa_addr *ppa_list; |
| 234 | |
| 235 | void *metadata; |
| 236 | dma_addr_t dma_metadata; |
| 237 | |
Matias Bjørling | 91276162 | 2016-01-12 07:49:21 +0100 | [diff] [blame] | 238 | struct completion *wait; |
| 239 | nvm_end_io_fn *end_io; |
| 240 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 241 | uint8_t opcode; |
| 242 | uint16_t nr_pages; |
| 243 | uint16_t flags; |
Matias Bjørling | 72d256e | 2016-01-12 07:49:29 +0100 | [diff] [blame] | 244 | |
Matias Bjorling | 9f86726 | 2016-03-03 15:06:39 +0100 | [diff] [blame] | 245 | u64 ppa_status; /* ppa media status */ |
Matias Bjørling | 72d256e | 2016-01-12 07:49:29 +0100 | [diff] [blame] | 246 | int error; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 247 | }; |
| 248 | |
| 249 | static inline struct nvm_rq *nvm_rq_from_pdu(void *pdu) |
| 250 | { |
| 251 | return pdu - sizeof(struct nvm_rq); |
| 252 | } |
| 253 | |
| 254 | static inline void *nvm_rq_to_pdu(struct nvm_rq *rqdata) |
| 255 | { |
| 256 | return rqdata + 1; |
| 257 | } |
| 258 | |
| 259 | struct nvm_block; |
| 260 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 261 | struct nvm_lun { |
| 262 | int id; |
| 263 | |
| 264 | int lun_id; |
| 265 | int chnl_id; |
| 266 | |
Javier González | ff0e498 | 2016-01-12 07:49:33 +0100 | [diff] [blame] | 267 | /* It is up to the target to mark blocks as closed. If the target does |
| 268 | * not do it, all blocks are marked as open, and nr_open_blocks |
| 269 | * represents the number of blocks in use |
| 270 | */ |
| 271 | unsigned int nr_open_blocks; /* Number of used, writable blocks */ |
| 272 | unsigned int nr_closed_blocks; /* Number of used, read-only blocks */ |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 273 | unsigned int nr_free_blocks; /* Number of unused blocks */ |
Javier Gonzalez | 0b59733 | 2015-11-20 13:47:56 +0100 | [diff] [blame] | 274 | unsigned int nr_bad_blocks; /* Number of bad blocks */ |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 275 | |
| 276 | spinlock_t lock; |
Javier González | ff0e498 | 2016-01-12 07:49:33 +0100 | [diff] [blame] | 277 | |
| 278 | struct nvm_block *blocks; |
| 279 | }; |
| 280 | |
| 281 | enum { |
| 282 | NVM_BLK_ST_FREE = 0x1, /* Free block */ |
| 283 | NVM_BLK_ST_OPEN = 0x2, /* Open block - read-write */ |
| 284 | NVM_BLK_ST_CLOSED = 0x4, /* Closed block - read-only */ |
| 285 | NVM_BLK_ST_BAD = 0x8, /* Bad block */ |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 286 | }; |
| 287 | |
| 288 | struct nvm_block { |
| 289 | struct list_head list; |
| 290 | struct nvm_lun *lun; |
| 291 | unsigned long id; |
| 292 | |
| 293 | void *priv; |
Javier González | ff0e498 | 2016-01-12 07:49:33 +0100 | [diff] [blame] | 294 | int state; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 295 | }; |
| 296 | |
Matias Bjørling | e3eb379 | 2016-01-12 07:49:36 +0100 | [diff] [blame] | 297 | /* system block cpu representation */ |
| 298 | struct nvm_sb_info { |
| 299 | unsigned long seqnr; |
| 300 | unsigned long erase_cnt; |
| 301 | unsigned int version; |
| 302 | char mmtype[NVM_MMTYPE_LEN]; |
| 303 | struct ppa_addr fs_ppa; |
| 304 | }; |
| 305 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 306 | struct nvm_dev { |
| 307 | struct nvm_dev_ops *ops; |
| 308 | |
| 309 | struct list_head devices; |
| 310 | struct list_head online_targets; |
| 311 | |
| 312 | /* Media manager */ |
| 313 | struct nvmm_type *mt; |
| 314 | void *mp; |
| 315 | |
Matias Bjørling | b769207 | 2016-01-12 07:49:38 +0100 | [diff] [blame] | 316 | /* System blocks */ |
| 317 | struct nvm_sb_info sb; |
| 318 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 319 | /* Device information */ |
| 320 | int nr_chnls; |
| 321 | int nr_planes; |
| 322 | int luns_per_chnl; |
| 323 | int sec_per_pg; /* only sectors for a single page */ |
| 324 | int pgs_per_blk; |
| 325 | int blks_per_lun; |
| 326 | int sec_size; |
| 327 | int oob_size; |
Matias Bjørling | f9a9995 | 2016-01-12 07:49:34 +0100 | [diff] [blame] | 328 | int mccap; |
Matias Bjørling | 7386af2 | 2015-11-16 15:34:44 +0100 | [diff] [blame] | 329 | struct nvm_addr_format ppaf; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 330 | |
| 331 | /* Calculated/Cached values. These do not reflect the actual usable |
| 332 | * blocks at run-time. |
| 333 | */ |
| 334 | int max_rq_size; |
| 335 | int plane_mode; /* drive device in single, double or quad mode */ |
| 336 | |
| 337 | int sec_per_pl; /* all sectors across planes */ |
| 338 | int sec_per_blk; |
| 339 | int sec_per_lun; |
| 340 | |
Matias Bjørling | ca5927e | 2016-01-12 07:49:35 +0100 | [diff] [blame] | 341 | /* lower page table */ |
| 342 | int lps_per_blk; |
| 343 | int *lptbl; |
| 344 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 345 | unsigned long total_blocks; |
Matias Bjørling | 4ece44a | 2016-02-20 08:52:41 +0100 | [diff] [blame] | 346 | unsigned long total_secs; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 347 | int nr_luns; |
| 348 | unsigned max_pages_per_blk; |
| 349 | |
Wenwei Tao | da1e284 | 2016-03-03 15:06:38 +0100 | [diff] [blame] | 350 | unsigned long *lun_map; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 351 | void *ppalist_pool; |
| 352 | |
| 353 | struct nvm_id identity; |
| 354 | |
| 355 | /* Backend device */ |
| 356 | struct request_queue *q; |
| 357 | char name[DISK_NAME_LEN]; |
Matias Bjørling | e3eb379 | 2016-01-12 07:49:36 +0100 | [diff] [blame] | 358 | |
| 359 | struct mutex mlock; |
Wenwei Tao | 4c9dacb | 2016-03-03 15:06:37 +0100 | [diff] [blame] | 360 | spinlock_t lock; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 361 | }; |
| 362 | |
Matias Bjørling | 7386af2 | 2015-11-16 15:34:44 +0100 | [diff] [blame] | 363 | static inline struct ppa_addr generic_to_dev_addr(struct nvm_dev *dev, |
| 364 | struct ppa_addr r) |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 365 | { |
| 366 | struct ppa_addr l; |
| 367 | |
Matias Bjørling | 7386af2 | 2015-11-16 15:34:44 +0100 | [diff] [blame] | 368 | l.ppa = ((u64)r.g.blk) << dev->ppaf.blk_offset; |
| 369 | l.ppa |= ((u64)r.g.pg) << dev->ppaf.pg_offset; |
| 370 | l.ppa |= ((u64)r.g.sec) << dev->ppaf.sect_offset; |
| 371 | l.ppa |= ((u64)r.g.pl) << dev->ppaf.pln_offset; |
| 372 | l.ppa |= ((u64)r.g.lun) << dev->ppaf.lun_offset; |
| 373 | l.ppa |= ((u64)r.g.ch) << dev->ppaf.ch_offset; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 374 | |
| 375 | return l; |
| 376 | } |
| 377 | |
Matias Bjørling | 7386af2 | 2015-11-16 15:34:44 +0100 | [diff] [blame] | 378 | static inline struct ppa_addr dev_to_generic_addr(struct nvm_dev *dev, |
| 379 | struct ppa_addr r) |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 380 | { |
| 381 | struct ppa_addr l; |
| 382 | |
Matias Bjørling | 7386af2 | 2015-11-16 15:34:44 +0100 | [diff] [blame] | 383 | /* |
| 384 | * (r.ppa << X offset) & X len bitmask. X eq. blk, pg, etc. |
| 385 | */ |
| 386 | l.g.blk = (r.ppa >> dev->ppaf.blk_offset) & |
| 387 | (((1 << dev->ppaf.blk_len) - 1)); |
| 388 | l.g.pg |= (r.ppa >> dev->ppaf.pg_offset) & |
| 389 | (((1 << dev->ppaf.pg_len) - 1)); |
| 390 | l.g.sec |= (r.ppa >> dev->ppaf.sect_offset) & |
| 391 | (((1 << dev->ppaf.sect_len) - 1)); |
| 392 | l.g.pl |= (r.ppa >> dev->ppaf.pln_offset) & |
| 393 | (((1 << dev->ppaf.pln_len) - 1)); |
| 394 | l.g.lun |= (r.ppa >> dev->ppaf.lun_offset) & |
| 395 | (((1 << dev->ppaf.lun_len) - 1)); |
| 396 | l.g.ch |= (r.ppa >> dev->ppaf.ch_offset) & |
| 397 | (((1 << dev->ppaf.ch_len) - 1)); |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 398 | |
| 399 | return l; |
| 400 | } |
| 401 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 402 | static inline int ppa_empty(struct ppa_addr ppa_addr) |
| 403 | { |
| 404 | return (ppa_addr.ppa == ADDR_EMPTY); |
| 405 | } |
| 406 | |
| 407 | static inline void ppa_set_empty(struct ppa_addr *ppa_addr) |
| 408 | { |
| 409 | ppa_addr->ppa = ADDR_EMPTY; |
| 410 | } |
| 411 | |
| 412 | static inline struct ppa_addr block_to_ppa(struct nvm_dev *dev, |
| 413 | struct nvm_block *blk) |
| 414 | { |
| 415 | struct ppa_addr ppa; |
| 416 | struct nvm_lun *lun = blk->lun; |
| 417 | |
| 418 | ppa.ppa = 0; |
| 419 | ppa.g.blk = blk->id % dev->blks_per_lun; |
| 420 | ppa.g.lun = lun->lun_id; |
| 421 | ppa.g.ch = lun->chnl_id; |
| 422 | |
| 423 | return ppa; |
| 424 | } |
| 425 | |
Matias Bjørling | e3eb379 | 2016-01-12 07:49:36 +0100 | [diff] [blame] | 426 | static inline int ppa_to_slc(struct nvm_dev *dev, int slc_pg) |
| 427 | { |
| 428 | return dev->lptbl[slc_pg]; |
| 429 | } |
| 430 | |
Jens Axboe | dece163 | 2015-11-05 10:41:16 -0700 | [diff] [blame] | 431 | typedef blk_qc_t (nvm_tgt_make_rq_fn)(struct request_queue *, struct bio *); |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 432 | typedef sector_t (nvm_tgt_capacity_fn)(void *); |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 433 | typedef void *(nvm_tgt_init_fn)(struct nvm_dev *, struct gendisk *, int, int); |
| 434 | typedef void (nvm_tgt_exit_fn)(void *); |
| 435 | |
| 436 | struct nvm_tgt_type { |
| 437 | const char *name; |
| 438 | unsigned int version[3]; |
| 439 | |
| 440 | /* target entry points */ |
| 441 | nvm_tgt_make_rq_fn *make_rq; |
| 442 | nvm_tgt_capacity_fn *capacity; |
Matias Bjørling | 91276162 | 2016-01-12 07:49:21 +0100 | [diff] [blame] | 443 | nvm_end_io_fn *end_io; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 444 | |
| 445 | /* module-specific init/teardown */ |
| 446 | nvm_tgt_init_fn *init; |
| 447 | nvm_tgt_exit_fn *exit; |
| 448 | |
| 449 | /* For internal use */ |
| 450 | struct list_head list; |
| 451 | }; |
| 452 | |
| 453 | extern int nvm_register_target(struct nvm_tgt_type *); |
| 454 | extern void nvm_unregister_target(struct nvm_tgt_type *); |
| 455 | |
| 456 | extern void *nvm_dev_dma_alloc(struct nvm_dev *, gfp_t, dma_addr_t *); |
| 457 | extern void nvm_dev_dma_free(struct nvm_dev *, void *, dma_addr_t); |
| 458 | |
| 459 | typedef int (nvmm_register_fn)(struct nvm_dev *); |
| 460 | typedef void (nvmm_unregister_fn)(struct nvm_dev *); |
| 461 | typedef struct nvm_block *(nvmm_get_blk_fn)(struct nvm_dev *, |
| 462 | struct nvm_lun *, unsigned long); |
| 463 | typedef void (nvmm_put_blk_fn)(struct nvm_dev *, struct nvm_block *); |
| 464 | typedef int (nvmm_open_blk_fn)(struct nvm_dev *, struct nvm_block *); |
| 465 | typedef int (nvmm_close_blk_fn)(struct nvm_dev *, struct nvm_block *); |
| 466 | typedef void (nvmm_flush_blk_fn)(struct nvm_dev *, struct nvm_block *); |
| 467 | typedef int (nvmm_submit_io_fn)(struct nvm_dev *, struct nvm_rq *); |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 468 | typedef int (nvmm_erase_blk_fn)(struct nvm_dev *, struct nvm_block *, |
| 469 | unsigned long); |
| 470 | typedef struct nvm_lun *(nvmm_get_lun_fn)(struct nvm_dev *, int); |
Wenwei Tao | da1e284 | 2016-03-03 15:06:38 +0100 | [diff] [blame] | 471 | typedef int (nvmm_reserve_lun)(struct nvm_dev *, int); |
| 472 | typedef void (nvmm_release_lun)(struct nvm_dev *, int); |
Javier Gonzalez | 2fde0e4 | 2015-11-20 13:47:57 +0100 | [diff] [blame] | 473 | typedef void (nvmm_lun_info_print_fn)(struct nvm_dev *); |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 474 | |
Wenwei Tao | 4c9dacb | 2016-03-03 15:06:37 +0100 | [diff] [blame] | 475 | typedef int (nvmm_get_area_fn)(struct nvm_dev *, sector_t *, sector_t); |
| 476 | typedef void (nvmm_put_area_fn)(struct nvm_dev *, sector_t); |
| 477 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 478 | struct nvmm_type { |
| 479 | const char *name; |
| 480 | unsigned int version[3]; |
| 481 | |
| 482 | nvmm_register_fn *register_mgr; |
| 483 | nvmm_unregister_fn *unregister_mgr; |
| 484 | |
| 485 | /* Block administration callbacks */ |
Javier González | ff0e498 | 2016-01-12 07:49:33 +0100 | [diff] [blame] | 486 | nvmm_get_blk_fn *get_blk_unlocked; |
| 487 | nvmm_put_blk_fn *put_blk_unlocked; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 488 | nvmm_get_blk_fn *get_blk; |
| 489 | nvmm_put_blk_fn *put_blk; |
| 490 | nvmm_open_blk_fn *open_blk; |
| 491 | nvmm_close_blk_fn *close_blk; |
| 492 | nvmm_flush_blk_fn *flush_blk; |
| 493 | |
| 494 | nvmm_submit_io_fn *submit_io; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 495 | nvmm_erase_blk_fn *erase_blk; |
| 496 | |
| 497 | /* Configuration management */ |
| 498 | nvmm_get_lun_fn *get_lun; |
Wenwei Tao | da1e284 | 2016-03-03 15:06:38 +0100 | [diff] [blame] | 499 | nvmm_reserve_lun *reserve_lun; |
| 500 | nvmm_release_lun *release_lun; |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 501 | |
| 502 | /* Statistics */ |
Javier Gonzalez | 2fde0e4 | 2015-11-20 13:47:57 +0100 | [diff] [blame] | 503 | nvmm_lun_info_print_fn *lun_info_print; |
Wenwei Tao | 4c9dacb | 2016-03-03 15:06:37 +0100 | [diff] [blame] | 504 | |
| 505 | nvmm_get_area_fn *get_area; |
| 506 | nvmm_put_area_fn *put_area; |
| 507 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 508 | struct list_head list; |
| 509 | }; |
| 510 | |
| 511 | extern int nvm_register_mgr(struct nvmm_type *); |
| 512 | extern void nvm_unregister_mgr(struct nvmm_type *); |
| 513 | |
Javier González | ff0e498 | 2016-01-12 07:49:33 +0100 | [diff] [blame] | 514 | extern struct nvm_block *nvm_get_blk_unlocked(struct nvm_dev *, |
| 515 | struct nvm_lun *, unsigned long); |
| 516 | extern void nvm_put_blk_unlocked(struct nvm_dev *, struct nvm_block *); |
| 517 | |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 518 | extern struct nvm_block *nvm_get_blk(struct nvm_dev *, struct nvm_lun *, |
| 519 | unsigned long); |
| 520 | extern void nvm_put_blk(struct nvm_dev *, struct nvm_block *); |
| 521 | |
| 522 | extern int nvm_register(struct request_queue *, char *, |
| 523 | struct nvm_dev_ops *); |
| 524 | extern void nvm_unregister(char *); |
| 525 | |
| 526 | extern int nvm_submit_io(struct nvm_dev *, struct nvm_rq *); |
Matias Bjørling | 069368e | 2016-01-12 07:49:19 +0100 | [diff] [blame] | 527 | extern void nvm_generic_to_addr_mode(struct nvm_dev *, struct nvm_rq *); |
| 528 | extern void nvm_addr_to_generic_mode(struct nvm_dev *, struct nvm_rq *); |
Matias Bjørling | abd805e | 2016-01-12 07:49:20 +0100 | [diff] [blame] | 529 | extern int nvm_set_rqd_ppalist(struct nvm_dev *, struct nvm_rq *, |
| 530 | struct ppa_addr *, int); |
| 531 | extern void nvm_free_rqd_ppalist(struct nvm_dev *, struct nvm_rq *); |
Matias Bjørling | 81e681d | 2016-01-12 07:49:28 +0100 | [diff] [blame] | 532 | extern int nvm_erase_ppa(struct nvm_dev *, struct ppa_addr *, int); |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 533 | extern int nvm_erase_blk(struct nvm_dev *, struct nvm_block *); |
Matias Bjørling | 91276162 | 2016-01-12 07:49:21 +0100 | [diff] [blame] | 534 | extern void nvm_end_io(struct nvm_rq *, int); |
Matias Bjørling | 09719b6 | 2016-01-12 07:49:30 +0100 | [diff] [blame] | 535 | extern int nvm_submit_ppa(struct nvm_dev *, struct ppa_addr *, int, int, int, |
| 536 | void *, int); |
Matias Bjørling | e3eb379 | 2016-01-12 07:49:36 +0100 | [diff] [blame] | 537 | |
| 538 | /* sysblk.c */ |
| 539 | #define NVM_SYSBLK_MAGIC 0x4E564D53 /* "NVMS" */ |
| 540 | |
| 541 | /* system block on disk representation */ |
| 542 | struct nvm_system_block { |
| 543 | __be32 magic; /* magic signature */ |
| 544 | __be32 seqnr; /* sequence number */ |
| 545 | __be32 erase_cnt; /* erase count */ |
| 546 | __be16 version; /* version number */ |
| 547 | u8 mmtype[NVM_MMTYPE_LEN]; /* media manager name */ |
| 548 | __be64 fs_ppa; /* PPA for media manager |
| 549 | * superblock */ |
| 550 | }; |
| 551 | |
| 552 | extern int nvm_get_sysblock(struct nvm_dev *, struct nvm_sb_info *); |
| 553 | extern int nvm_update_sysblock(struct nvm_dev *, struct nvm_sb_info *); |
| 554 | extern int nvm_init_sysblock(struct nvm_dev *, struct nvm_sb_info *); |
Matias Bjørling | 8b4970c | 2016-01-12 07:49:39 +0100 | [diff] [blame] | 555 | |
| 556 | extern int nvm_dev_factory(struct nvm_dev *, int flags); |
Matias Bjørling | cd9e980 | 2015-10-28 19:54:55 +0100 | [diff] [blame] | 557 | #else /* CONFIG_NVM */ |
| 558 | struct nvm_dev_ops; |
| 559 | |
| 560 | static inline int nvm_register(struct request_queue *q, char *disk_name, |
| 561 | struct nvm_dev_ops *ops) |
| 562 | { |
| 563 | return -EINVAL; |
| 564 | } |
| 565 | static inline void nvm_unregister(char *disk_name) {} |
| 566 | #endif /* CONFIG_NVM */ |
| 567 | #endif /* LIGHTNVM.H */ |