]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/lightnvm/core.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lightnvm: merge gennvm with core
[mirror_ubuntu-artful-kernel.git] / drivers / lightnvm / core.c
CommitLineData
cd9e9808
MB		 1/*
2 * Copyright (C) 2015 IT University of Copenhagen. All rights reserved.
3 * Initial release: Matias Bjorling <m@bjorling.me>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version
7 * 2 as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; see the file COPYING. If not, write to
16 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
17 * USA.
18 *
19 */
20
cd9e9808
MB		 21#include <linux/list.h>
22#include <linux/types.h>
23#include <linux/sem.h>
24#include <linux/bitmap.h>
389b2a1c 25#include <linux/moduleparam.h>
cd9e9808
MB		 26#include <linux/miscdevice.h>
27#include <linux/lightnvm.h>
91276162 28#include <linux/sched/sysctl.h>
cd9e9808 29
6063fe39 30static LIST_HEAD(nvm_tgt_types);
5cd90785 31static DECLARE_RWSEM(nvm_tgtt_lock);
cd9e9808
MB		 32static LIST_HEAD(nvm_devices);
33static DECLARE_RWSEM(nvm_lock);
34
ade69e24
MB		 35/* Map between virtual and physical channel and lun */
36struct nvm_ch_map {
37 int ch_off;
38 int nr_luns;
39 int *lun_offs;
40};
41
42struct nvm_dev_map {
43 struct nvm_ch_map *chnls;
44 int nr_chnls;
45};
46
47struct nvm_area {
48 struct list_head list;
49 sector_t begin;
50 sector_t end; /* end is excluded */
51};
52
53enum {
54 TRANS_TGT_TO_DEV = 0x0,
55 TRANS_DEV_TO_TGT = 0x1,
56};
57
58static struct nvm_target *nvm_find_target(struct nvm_dev *dev, const char *name)
59{
60 struct nvm_target *tgt;
61
62 list_for_each_entry(tgt, &dev->targets, list)
63 if (!strcmp(name, tgt->disk->disk_name))
64 return tgt;
65
66 return NULL;
67}
68
69static int nvm_reserve_luns(struct nvm_dev *dev, int lun_begin, int lun_end)
70{
71 int i;
72
73 for (i = lun_begin; i <= lun_end; i++) {
74 if (test_and_set_bit(i, dev->lun_map)) {
75 pr_err("nvm: lun %d already allocated\n", i);
76 goto err;
77 }
78 }
79
80 return 0;
81err:
82 while (--i > lun_begin)
83 clear_bit(i, dev->lun_map);
84
85 return -EBUSY;
86}
87
88static void nvm_release_luns_err(struct nvm_dev *dev, int lun_begin,
89 int lun_end)
90{
91 int i;
92
93 for (i = lun_begin; i <= lun_end; i++)
94 WARN_ON(!test_and_clear_bit(i, dev->lun_map));
95}
96
97static void nvm_remove_tgt_dev(struct nvm_tgt_dev *tgt_dev)
98{
99 struct nvm_dev *dev = tgt_dev->parent;
100 struct nvm_dev_map *dev_map = tgt_dev->map;
101 int i, j;
102
103 for (i = 0; i < dev_map->nr_chnls; i++) {
104 struct nvm_ch_map *ch_map = &dev_map->chnls[i];
105 int *lun_offs = ch_map->lun_offs;
106 int ch = i + ch_map->ch_off;
107
108 for (j = 0; j < ch_map->nr_luns; j++) {
109 int lun = j + lun_offs[j];
110 int lunid = (ch * dev->geo.luns_per_chnl) + lun;
111
112 WARN_ON(!test_and_clear_bit(lunid, dev->lun_map));
113 }
114
115 kfree(ch_map->lun_offs);
116 }
117
118 kfree(dev_map->chnls);
119 kfree(dev_map);
120
121 kfree(tgt_dev->luns);
122 kfree(tgt_dev);
123}
124
125static struct nvm_tgt_dev *nvm_create_tgt_dev(struct nvm_dev *dev,
126 int lun_begin, int lun_end)
127{
128 struct nvm_tgt_dev *tgt_dev = NULL;
129 struct nvm_dev_map *dev_rmap = dev->rmap;
130 struct nvm_dev_map *dev_map;
131 struct ppa_addr *luns;
132 int nr_luns = lun_end - lun_begin + 1;
133 int luns_left = nr_luns;
134 int nr_chnls = nr_luns / dev->geo.luns_per_chnl;
135 int nr_chnls_mod = nr_luns % dev->geo.luns_per_chnl;
136 int bch = lun_begin / dev->geo.luns_per_chnl;
137 int blun = lun_begin % dev->geo.luns_per_chnl;
138 int lunid = 0;
139 int lun_balanced = 1;
140 int prev_nr_luns;
141 int i, j;
142
143 nr_chnls = nr_luns / dev->geo.luns_per_chnl;
144 nr_chnls = (nr_chnls_mod == 0) ? nr_chnls : nr_chnls + 1;
145
146 dev_map = kmalloc(sizeof(struct nvm_dev_map), GFP_KERNEL);
147 if (!dev_map)
148 goto err_dev;
149
150 dev_map->chnls = kcalloc(nr_chnls, sizeof(struct nvm_ch_map),
151 GFP_KERNEL);
152 if (!dev_map->chnls)
153 goto err_chnls;
154
155 luns = kcalloc(nr_luns, sizeof(struct ppa_addr), GFP_KERNEL);
156 if (!luns)
157 goto err_luns;
158
159 prev_nr_luns = (luns_left > dev->geo.luns_per_chnl) ?
160 dev->geo.luns_per_chnl : luns_left;
161 for (i = 0; i < nr_chnls; i++) {
162 struct nvm_ch_map *ch_rmap = &dev_rmap->chnls[i + bch];
163 int *lun_roffs = ch_rmap->lun_offs;
164 struct nvm_ch_map *ch_map = &dev_map->chnls[i];
165 int *lun_offs;
166 int luns_in_chnl = (luns_left > dev->geo.luns_per_chnl) ?
167 dev->geo.luns_per_chnl : luns_left;
168
169 if (lun_balanced && prev_nr_luns != luns_in_chnl)
170 lun_balanced = 0;
171
172 ch_map->ch_off = ch_rmap->ch_off = bch;
173 ch_map->nr_luns = luns_in_chnl;
174
175 lun_offs = kcalloc(luns_in_chnl, sizeof(int), GFP_KERNEL);
176 if (!lun_offs)
177 goto err_ch;
178
179 for (j = 0; j < luns_in_chnl; j++) {
180 luns[lunid].ppa = 0;
181 luns[lunid].g.ch = i;
182 luns[lunid++].g.lun = j;
183
184 lun_offs[j] = blun;
185 lun_roffs[j + blun] = blun;
186 }
187
188 ch_map->lun_offs = lun_offs;
189
190 /* when starting a new channel, lun offset is reset */
191 blun = 0;
192 luns_left -= luns_in_chnl;
193 }
194
195 dev_map->nr_chnls = nr_chnls;
196
197 tgt_dev = kmalloc(sizeof(struct nvm_tgt_dev), GFP_KERNEL);
198 if (!tgt_dev)
199 goto err_ch;
200
201 memcpy(&tgt_dev->geo, &dev->geo, sizeof(struct nvm_geo));
202 /* Target device only owns a portion of the physical device */
203 tgt_dev->geo.nr_chnls = nr_chnls;
204 tgt_dev->geo.nr_luns = nr_luns;
205 tgt_dev->geo.luns_per_chnl = (lun_balanced) ? prev_nr_luns : -1;
206 tgt_dev->total_secs = nr_luns * tgt_dev->geo.sec_per_lun;
207 tgt_dev->q = dev->q;
208 tgt_dev->map = dev_map;
209 tgt_dev->luns = luns;
210 memcpy(&tgt_dev->identity, &dev->identity, sizeof(struct nvm_id));
211
212 tgt_dev->parent = dev;
213
214 return tgt_dev;
215err_ch:
216 while (--i > 0)
217 kfree(dev_map->chnls[i].lun_offs);
218 kfree(luns);
219err_luns:
220 kfree(dev_map->chnls);
221err_chnls:
222 kfree(dev_map);
223err_dev:
224 return tgt_dev;
225}
226
227static const struct block_device_operations nvm_fops = {
228 .owner = THIS_MODULE,
229};
230
231static int nvm_create_tgt(struct nvm_dev *dev, struct nvm_ioctl_create *create)
232{
233 struct nvm_ioctl_create_simple *s = &create->conf.s;
234 struct request_queue *tqueue;
235 struct gendisk *tdisk;
236 struct nvm_tgt_type *tt;
237 struct nvm_target *t;
238 struct nvm_tgt_dev *tgt_dev;
239 void *targetdata;
240
241 tt = nvm_find_target_type(create->tgttype, 1);
242 if (!tt) {
243 pr_err("nvm: target type %s not found\n", create->tgttype);
244 return -EINVAL;
245 }
246
247 mutex_lock(&dev->mlock);
248 t = nvm_find_target(dev, create->tgtname);
249 if (t) {
250 pr_err("nvm: target name already exists.\n");
251 mutex_unlock(&dev->mlock);
252 return -EINVAL;
253 }
254 mutex_unlock(&dev->mlock);
255
256 if (nvm_reserve_luns(dev, s->lun_begin, s->lun_end))
257 return -ENOMEM;
258
259 t = kmalloc(sizeof(struct nvm_target), GFP_KERNEL);
260 if (!t)
261 goto err_reserve;
262
263 tgt_dev = nvm_create_tgt_dev(dev, s->lun_begin, s->lun_end);
264 if (!tgt_dev) {
265 pr_err("nvm: could not create target device\n");
266 goto err_t;
267 }
268
269 tqueue = blk_alloc_queue_node(GFP_KERNEL, dev->q->node);
270 if (!tqueue)
271 goto err_dev;
272 blk_queue_make_request(tqueue, tt->make_rq);
273
274 tdisk = alloc_disk(0);
275 if (!tdisk)
276 goto err_queue;
277
278 sprintf(tdisk->disk_name, "%s", create->tgtname);
279 tdisk->flags = GENHD_FL_EXT_DEVT;
280 tdisk->major = 0;
281 tdisk->first_minor = 0;
282 tdisk->fops = &nvm_fops;
283 tdisk->queue = tqueue;
284
285 targetdata = tt->init(tgt_dev, tdisk);
286 if (IS_ERR(targetdata))
287 goto err_init;
288
289 tdisk->private_data = targetdata;
290 tqueue->queuedata = targetdata;
291
292 blk_queue_max_hw_sectors(tqueue, 8 * dev->ops->max_phys_sect);
293
294 set_capacity(tdisk, tt->capacity(targetdata));
295 add_disk(tdisk);
296
297 t->type = tt;
298 t->disk = tdisk;
299 t->dev = tgt_dev;
300
301 mutex_lock(&dev->mlock);
302 list_add_tail(&t->list, &dev->targets);
303 mutex_unlock(&dev->mlock);
304
305 return 0;
306err_init:
307 put_disk(tdisk);
308err_queue:
309 blk_cleanup_queue(tqueue);
310err_dev:
311 kfree(tgt_dev);
312err_t:
313 kfree(t);
314err_reserve:
315 nvm_release_luns_err(dev, s->lun_begin, s->lun_end);
316 return -ENOMEM;
317}
318
319static void __nvm_remove_target(struct nvm_target *t)
320{
321 struct nvm_tgt_type *tt = t->type;
322 struct gendisk *tdisk = t->disk;
323 struct request_queue *q = tdisk->queue;
324
325 del_gendisk(tdisk);
326 blk_cleanup_queue(q);
327
328 if (tt->exit)
329 tt->exit(tdisk->private_data);
330
331 nvm_remove_tgt_dev(t->dev);
332 put_disk(tdisk);
333
334 list_del(&t->list);
335 kfree(t);
336}
337
338/**
339 * nvm_remove_tgt - Removes a target from the media manager
340 * @dev: device
341 * @remove: ioctl structure with target name to remove.
342 *
343 * Returns:
344 * 0: on success
345 * 1: on not found
346 * <0: on error
347 */
348static int nvm_remove_tgt(struct nvm_dev *dev, struct nvm_ioctl_remove *remove)
349{
350 struct nvm_target *t;
351
352 mutex_lock(&dev->mlock);
353 t = nvm_find_target(dev, remove->tgtname);
354 if (!t) {
355 mutex_unlock(&dev->mlock);
356 return 1;
357 }
358 __nvm_remove_target(t);
359 mutex_unlock(&dev->mlock);
360
361 return 0;
362}
363
364static int nvm_register_map(struct nvm_dev *dev)
365{
366 struct nvm_dev_map *rmap;
367 int i, j;
368
369 rmap = kmalloc(sizeof(struct nvm_dev_map), GFP_KERNEL);
370 if (!rmap)
371 goto err_rmap;
372
373 rmap->chnls = kcalloc(dev->geo.nr_chnls, sizeof(struct nvm_ch_map),
374 GFP_KERNEL);
375 if (!rmap->chnls)
376 goto err_chnls;
377
378 for (i = 0; i < dev->geo.nr_chnls; i++) {
379 struct nvm_ch_map *ch_rmap;
380 int *lun_roffs;
381 int luns_in_chnl = dev->geo.luns_per_chnl;
382
383 ch_rmap = &rmap->chnls[i];
384
385 ch_rmap->ch_off = -1;
386 ch_rmap->nr_luns = luns_in_chnl;
387
388 lun_roffs = kcalloc(luns_in_chnl, sizeof(int), GFP_KERNEL);
389 if (!lun_roffs)
390 goto err_ch;
391
392 for (j = 0; j < luns_in_chnl; j++)
393 lun_roffs[j] = -1;
394
395 ch_rmap->lun_offs = lun_roffs;
396 }
397
398 dev->rmap = rmap;
399
400 return 0;
401err_ch:
402 while (--i >= 0)
403 kfree(rmap->chnls[i].lun_offs);
404err_chnls:
405 kfree(rmap);
406err_rmap:
407 return -ENOMEM;
408}
409
410static int nvm_map_to_dev(struct nvm_tgt_dev *tgt_dev, struct ppa_addr *p)
411{
412 struct nvm_dev_map *dev_map = tgt_dev->map;
413 struct nvm_ch_map *ch_map = &dev_map->chnls[p->g.ch];
414 int lun_off = ch_map->lun_offs[p->g.lun];
415 struct nvm_dev *dev = tgt_dev->parent;
416 struct nvm_dev_map *dev_rmap = dev->rmap;
417 struct nvm_ch_map *ch_rmap;
418 int lun_roff;
419
420 p->g.ch += ch_map->ch_off;
421 p->g.lun += lun_off;
422
423 ch_rmap = &dev_rmap->chnls[p->g.ch];
424 lun_roff = ch_rmap->lun_offs[p->g.lun];
425
426 if (unlikely(ch_rmap->ch_off < 0 || lun_roff < 0)) {
427 pr_err("nvm: corrupted device partition table\n");
428 return -EINVAL;
429 }
430
431 return 0;
432}
433
434static int nvm_map_to_tgt(struct nvm_tgt_dev *tgt_dev, struct ppa_addr *p)
435{
436 struct nvm_dev *dev = tgt_dev->parent;
437 struct nvm_dev_map *dev_rmap = dev->rmap;
438 struct nvm_ch_map *ch_rmap = &dev_rmap->chnls[p->g.ch];
439 int lun_roff = ch_rmap->lun_offs[p->g.lun];
440
441 p->g.ch -= ch_rmap->ch_off;
442 p->g.lun -= lun_roff;
443
444 return 0;
445}
446
447static int nvm_trans_rq(struct nvm_tgt_dev *tgt_dev, struct nvm_rq *rqd,
448 int flag)
449{
450 int i;
451 int ret;
452
453 if (rqd->nr_ppas == 1) {
454 if (flag == TRANS_TGT_TO_DEV)
455 return nvm_map_to_dev(tgt_dev, &rqd->ppa_addr);
456 else
457 return nvm_map_to_tgt(tgt_dev, &rqd->ppa_addr);
458 }
459
460 for (i = 0; i < rqd->nr_ppas; i++) {
461 if (flag == TRANS_TGT_TO_DEV)
462 ret = nvm_map_to_dev(tgt_dev, &rqd->ppa_list[i]);
463 else
464 ret = nvm_map_to_tgt(tgt_dev, &rqd->ppa_list[i]);
465
466 if (ret)
467 break;
468 }
469
470 return ret;
471}
472
473static struct ppa_addr nvm_trans_ppa(struct nvm_tgt_dev *tgt_dev,
474 struct ppa_addr p, int dir)
475{
476 struct ppa_addr ppa = p;
477
478 if (dir == TRANS_TGT_TO_DEV)
479 nvm_map_to_dev(tgt_dev, &ppa);
480 else
481 nvm_map_to_tgt(tgt_dev, &ppa);
482
483 return ppa;
484}
485
486void nvm_part_to_tgt(struct nvm_dev *dev, sector_t *entries,
487 int len)
488{
489 struct nvm_geo *geo = &dev->geo;
490 struct nvm_dev_map *dev_rmap = dev->rmap;
491 u64 i;
492
493 for (i = 0; i < len; i++) {
494 struct nvm_ch_map *ch_rmap;
495 int *lun_roffs;
496 struct ppa_addr gaddr;
497 u64 pba = le64_to_cpu(entries[i]);
498 int off;
499 u64 diff;
500
501 if (!pba)
502 continue;
503
504 gaddr = linear_to_generic_addr(geo, pba);
505 ch_rmap = &dev_rmap->chnls[gaddr.g.ch];
506 lun_roffs = ch_rmap->lun_offs;
507
508 off = gaddr.g.ch * geo->luns_per_chnl + gaddr.g.lun;
509
510 diff = ((ch_rmap->ch_off * geo->luns_per_chnl) +
511 (lun_roffs[gaddr.g.lun])) * geo->sec_per_lun;
512
513 entries[i] -= cpu_to_le64(diff);
514 }
515}
516EXPORT_SYMBOL(nvm_part_to_tgt);
517
b76eb20b 518struct nvm_tgt_type *nvm_find_target_type(const char *name, int lock)
6f8645cb 519{
b76eb20b 520 struct nvm_tgt_type *tmp, *tt = NULL;
6f8645cb 521
b76eb20b 522 if (lock)
5cd90785 523 down_write(&nvm_tgtt_lock);
6f8645cb 524
b76eb20b
MB		 525 list_for_each_entry(tmp, &nvm_tgt_types, list)
526 if (!strcmp(name, tmp->name)) {
527 tt = tmp;
528 break;
529 }
cd9e9808 530
b76eb20b 531 if (lock)
5cd90785 532 up_write(&nvm_tgtt_lock);
b76eb20b 533 return tt;
cd9e9808 534}
b76eb20b 535EXPORT_SYMBOL(nvm_find_target_type);
cd9e9808 536
6063fe39 537int nvm_register_tgt_type(struct nvm_tgt_type *tt)
cd9e9808
MB		 538{
539 int ret = 0;
540
5cd90785 541 down_write(&nvm_tgtt_lock);
b76eb20b 542 if (nvm_find_target_type(tt->name, 0))
cd9e9808
MB		 543 ret = -EEXIST;
544 else
6063fe39 545 list_add(&tt->list, &nvm_tgt_types);
5cd90785 546 up_write(&nvm_tgtt_lock);
cd9e9808
MB		 547
548 return ret;
549}
6063fe39 550EXPORT_SYMBOL(nvm_register_tgt_type);
cd9e9808 551
6063fe39 552void nvm_unregister_tgt_type(struct nvm_tgt_type *tt)
cd9e9808
MB		 553{
554 if (!tt)
555 return;
556
557 down_write(&nvm_lock);
558 list_del(&tt->list);
559 up_write(&nvm_lock);
560}
6063fe39 561EXPORT_SYMBOL(nvm_unregister_tgt_type);
cd9e9808
MB		 562
563void *nvm_dev_dma_alloc(struct nvm_dev *dev, gfp_t mem_flags,
564 dma_addr_t *dma_handler)
565{
75b85649 566 return dev->ops->dev_dma_alloc(dev, dev->dma_pool, mem_flags,
cd9e9808
MB		 567 dma_handler);
568}
569EXPORT_SYMBOL(nvm_dev_dma_alloc);
570
da2d7cb8 571void nvm_dev_dma_free(struct nvm_dev *dev, void *addr, dma_addr_t dma_handler)
cd9e9808 572{
75b85649 573 dev->ops->dev_dma_free(dev->dma_pool, addr, dma_handler);
cd9e9808
MB		 574}
575EXPORT_SYMBOL(nvm_dev_dma_free);
576
cd9e9808
MB		 577static struct nvm_dev *nvm_find_nvm_dev(const char *name)
578{
579 struct nvm_dev *dev;
580
581 list_for_each_entry(dev, &nvm_devices, devices)
582 if (!strcmp(name, dev->name))
583 return dev;
584
585 return NULL;
586}
587
333ba053
JG		 588static void nvm_tgt_generic_to_addr_mode(struct nvm_tgt_dev *tgt_dev,
589 struct nvm_rq *rqd)
590{
591 struct nvm_dev *dev = tgt_dev->parent;
592 int i;
593
594 if (rqd->nr_ppas > 1) {
595 for (i = 0; i < rqd->nr_ppas; i++) {
ade69e24 596 rqd->ppa_list[i] = nvm_trans_ppa(tgt_dev,
333ba053
JG		 597 rqd->ppa_list[i], TRANS_TGT_TO_DEV);
598 rqd->ppa_list[i] = generic_to_dev_addr(dev,
599 rqd->ppa_list[i]);
600 }
601 } else {
ade69e24 602 rqd->ppa_addr = nvm_trans_ppa(tgt_dev, rqd->ppa_addr,
333ba053
JG		 603 TRANS_TGT_TO_DEV);
604 rqd->ppa_addr = generic_to_dev_addr(dev, rqd->ppa_addr);
605 }
606}
607
a24ba464
JG		 608int nvm_set_bb_tbl(struct nvm_dev *dev, struct ppa_addr *ppas, int nr_ppas,
609 int type)
610{
611 struct nvm_rq rqd;
612 int ret;
613
614 if (nr_ppas > dev->ops->max_phys_sect) {
615 pr_err("nvm: unable to update all sysblocks atomically\n");
616 return -EINVAL;
617 }
618
619 memset(&rqd, 0, sizeof(struct nvm_rq));
620
621 nvm_set_rqd_ppalist(dev, &rqd, ppas, nr_ppas, 1);
622 nvm_generic_to_addr_mode(dev, &rqd);
623
624 ret = dev->ops->set_bb_tbl(dev, &rqd.ppa_addr, rqd.nr_ppas, type);
625 nvm_free_rqd_ppalist(dev, &rqd);
626 if (ret) {
627 pr_err("nvm: sysblk failed bb mark\n");
628 return -EINVAL;
629 }
630
631 return 0;
632}
633EXPORT_SYMBOL(nvm_set_bb_tbl);
634
333ba053
JG		 635int nvm_set_tgt_bb_tbl(struct nvm_tgt_dev *tgt_dev, struct ppa_addr *ppas,
636 int nr_ppas, int type)
637{
638 struct nvm_dev *dev = tgt_dev->parent;
639 struct nvm_rq rqd;
640 int ret;
641
642 if (nr_ppas > dev->ops->max_phys_sect) {
643 pr_err("nvm: unable to update all blocks atomically\n");
644 return -EINVAL;
645 }
646
647 memset(&rqd, 0, sizeof(struct nvm_rq));
648
649 nvm_set_rqd_ppalist(dev, &rqd, ppas, nr_ppas, 1);
650 nvm_tgt_generic_to_addr_mode(tgt_dev, &rqd);
651
652 ret = dev->ops->set_bb_tbl(dev, &rqd.ppa_addr, rqd.nr_ppas, type);
653 nvm_free_rqd_ppalist(dev, &rqd);
654 if (ret) {
ade69e24 655 pr_err("nvm: failed bb mark\n");
333ba053
JG		 656 return -EINVAL;
657 }
658
659 return 0;
660}
661EXPORT_SYMBOL(nvm_set_tgt_bb_tbl);
662
a279006a
JG		 663int nvm_max_phys_sects(struct nvm_tgt_dev *tgt_dev)
664{
665 struct nvm_dev *dev = tgt_dev->parent;
666
667 return dev->ops->max_phys_sect;
668}
669EXPORT_SYMBOL(nvm_max_phys_sects);
670
8e53624d 671int nvm_submit_io(struct nvm_tgt_dev *tgt_dev, struct nvm_rq *rqd)
cd9e9808 672{
8e53624d
JG		 673 struct nvm_dev *dev = tgt_dev->parent;
674
ade69e24
MB		 675 if (!dev->ops->submit_io)
676 return -ENODEV;
677
678 /* Convert address space */
679 nvm_generic_to_addr_mode(dev, rqd);
680
681 rqd->dev = tgt_dev;
682 return dev->ops->submit_io(dev, rqd);
cd9e9808
MB		 683}
684EXPORT_SYMBOL(nvm_submit_io);
685
8e53624d 686int nvm_erase_blk(struct nvm_tgt_dev *tgt_dev, struct ppa_addr *p, int flags)
cd9e9808 687{
ade69e24
MB		 688 /* Convert address space */
689 nvm_map_to_dev(tgt_dev, p);
8e53624d 690
ade69e24 691 return nvm_erase_ppa(tgt_dev->parent, p, 1, flags);
cd9e9808
MB		 692}
693EXPORT_SYMBOL(nvm_erase_blk);
694
da2d7cb8 695int nvm_get_l2p_tbl(struct nvm_tgt_dev *tgt_dev, u64 slba, u32 nlb,
959e911b
JG		 696 nvm_l2p_update_fn *update_l2p, void *priv)
697{
da2d7cb8
JG		 698 struct nvm_dev *dev = tgt_dev->parent;
699
959e911b
JG		 700 if (!dev->ops->get_l2p_tbl)
701 return 0;
702
703 return dev->ops->get_l2p_tbl(dev, slba, nlb, update_l2p, priv);
704}
705EXPORT_SYMBOL(nvm_get_l2p_tbl);
706
da2d7cb8 707int nvm_get_area(struct nvm_tgt_dev *tgt_dev, sector_t *lba, sector_t len)
959e911b 708{
da2d7cb8 709 struct nvm_dev *dev = tgt_dev->parent;
ade69e24
MB		 710 struct nvm_geo *geo = &dev->geo;
711 struct nvm_area *area, *prev, *next;
712 sector_t begin = 0;
713 sector_t max_sectors = (geo->sec_size * dev->total_secs) >> 9;
714
715 if (len > max_sectors)
716 return -EINVAL;
717
718 area = kmalloc(sizeof(struct nvm_area), GFP_KERNEL);
719 if (!area)
720 return -ENOMEM;
721
722 prev = NULL;
723
724 spin_lock(&dev->lock);
725 list_for_each_entry(next, &dev->area_list, list) {
726 if (begin + len > next->begin) {
727 begin = next->end;
728 prev = next;
729 continue;
730 }
731 break;
732 }
733
734 if ((begin + len) > max_sectors) {
735 spin_unlock(&dev->lock);
736 kfree(area);
737 return -EINVAL;
738 }
da2d7cb8 739
ade69e24
MB		 740 area->begin = *lba = begin;
741 area->end = begin + len;
742
743 if (prev) /* insert into sorted order */
744 list_add(&area->list, &prev->list);
745 else
746 list_add(&area->list, &dev->area_list);
747 spin_unlock(&dev->lock);
748
749 return 0;
959e911b
JG		 750}
751EXPORT_SYMBOL(nvm_get_area);
752
ade69e24 753void nvm_put_area(struct nvm_tgt_dev *tgt_dev, sector_t begin)
959e911b 754{
da2d7cb8 755 struct nvm_dev *dev = tgt_dev->parent;
ade69e24 756 struct nvm_area *area;
da2d7cb8 757
ade69e24
MB		 758 spin_lock(&dev->lock);
759 list_for_each_entry(area, &dev->area_list, list) {
760 if (area->begin != begin)
761 continue;
762
763 list_del(&area->list);
764 spin_unlock(&dev->lock);
765 kfree(area);
766 return;
767 }
768 spin_unlock(&dev->lock);
959e911b
JG		 769}
770EXPORT_SYMBOL(nvm_put_area);
771
069368e9
MB		 772void nvm_addr_to_generic_mode(struct nvm_dev *dev, struct nvm_rq *rqd)
773{
774 int i;
775
6d5be959
JG		 776 if (rqd->nr_ppas > 1) {
777 for (i = 0; i < rqd->nr_ppas; i++)
069368e9
MB		 778 rqd->ppa_list[i] = dev_to_generic_addr(dev,
779 rqd->ppa_list[i]);
780 } else {
781 rqd->ppa_addr = dev_to_generic_addr(dev, rqd->ppa_addr);
782 }
783}
784EXPORT_SYMBOL(nvm_addr_to_generic_mode);
785
786void nvm_generic_to_addr_mode(struct nvm_dev *dev, struct nvm_rq *rqd)
787{
788 int i;
789
6d5be959
JG		 790 if (rqd->nr_ppas > 1) {
791 for (i = 0; i < rqd->nr_ppas; i++)
069368e9
MB		 792 rqd->ppa_list[i] = generic_to_dev_addr(dev,
793 rqd->ppa_list[i]);
794 } else {
795 rqd->ppa_addr = generic_to_dev_addr(dev, rqd->ppa_addr);
796 }
797}
798EXPORT_SYMBOL(nvm_generic_to_addr_mode);
799
abd805ec 800int nvm_set_rqd_ppalist(struct nvm_dev *dev, struct nvm_rq *rqd,
8680f165 801 const struct ppa_addr *ppas, int nr_ppas, int vblk)
069368e9 802{
8e79b5cb 803 struct nvm_geo *geo = &dev->geo;
abd805ec 804 int i, plane_cnt, pl_idx;
8680f165 805 struct ppa_addr ppa;
abd805ec 806
8e79b5cb 807 if ((!vblk || geo->plane_mode == NVM_PLANE_SINGLE) && nr_ppas == 1) {
6d5be959 808 rqd->nr_ppas = nr_ppas;
abd805ec 809 rqd->ppa_addr = ppas[0];
069368e9 810
069368e9 811 return 0;
abd805ec 812 }
069368e9 813
6d5be959 814 rqd->nr_ppas = nr_ppas;
abd805ec
MB		 815 rqd->ppa_list = nvm_dev_dma_alloc(dev, GFP_KERNEL, &rqd->dma_ppa_list);
816 if (!rqd->ppa_list) {
817 pr_err("nvm: failed to allocate dma memory\n");
818 return -ENOMEM;
819 }
820
5ebc7d9f
MB		 821 if (!vblk) {
822 for (i = 0; i < nr_ppas; i++)
823 rqd->ppa_list[i] = ppas[i];
824 } else {
8e79b5cb 825 plane_cnt = geo->plane_mode;
6d5be959 826 rqd->nr_ppas *= plane_cnt;
5ebc7d9f 827
556755e9 828 for (i = 0; i < nr_ppas; i++) {
5ebc7d9f 829 for (pl_idx = 0; pl_idx < plane_cnt; pl_idx++) {
8680f165
MB		 830 ppa = ppas[i];
831 ppa.g.pl = pl_idx;
832 rqd->ppa_list[(pl_idx * nr_ppas) + i] = ppa;
5ebc7d9f 833 }
069368e9
MB		 834 }
835 }
836
abd805ec
MB		 837 return 0;
838}
839EXPORT_SYMBOL(nvm_set_rqd_ppalist);
840
841void nvm_free_rqd_ppalist(struct nvm_dev *dev, struct nvm_rq *rqd)
842{
843 if (!rqd->ppa_list)
844 return;
845
846 nvm_dev_dma_free(dev, rqd->ppa_list, rqd->dma_ppa_list);
847}
848EXPORT_SYMBOL(nvm_free_rqd_ppalist);
849
bb314979
JG		 850int nvm_erase_ppa(struct nvm_dev *dev, struct ppa_addr *ppas, int nr_ppas,
851 int flags)
abd805ec
MB		 852{
853 struct nvm_rq rqd;
854 int ret;
855
856 if (!dev->ops->erase_block)
857 return 0;
858
859 memset(&rqd, 0, sizeof(struct nvm_rq));
860
5ebc7d9f 861 ret = nvm_set_rqd_ppalist(dev, &rqd, ppas, nr_ppas, 1);
abd805ec
MB		 862 if (ret)
863 return ret;
864
069368e9
MB		 865 nvm_generic_to_addr_mode(dev, &rqd);
866
bb314979
JG		 867 rqd.flags = flags;
868
069368e9
MB		 869 ret = dev->ops->erase_block(dev, &rqd);
870
abd805ec 871 nvm_free_rqd_ppalist(dev, &rqd);
069368e9
MB		 872
873 return ret;
874}
875EXPORT_SYMBOL(nvm_erase_ppa);
876
91276162
MB		 877void nvm_end_io(struct nvm_rq *rqd, int error)
878{
ade69e24
MB		 879 struct nvm_tgt_dev *tgt_dev = rqd->dev;
880 struct nvm_tgt_instance *ins = rqd->ins;
881
882 /* Convert address space */
883 if (tgt_dev)
884 nvm_trans_rq(tgt_dev, rqd, TRANS_DEV_TO_TGT);
885
72d256ec 886 rqd->error = error;
ade69e24 887 ins->tt->end_io(rqd);
91276162
MB		 888}
889EXPORT_SYMBOL(nvm_end_io);
890
09719b62 891static void nvm_end_io_sync(struct nvm_rq *rqd)
91276162
MB		 892{
893 struct completion *waiting = rqd->wait;
894
895 rqd->wait = NULL;
896
897 complete(waiting);
898}
899
d9e46d5d 900static int __nvm_submit_ppa(struct nvm_dev *dev, struct nvm_rq *rqd, int opcode,
1145e635 901 int flags, void *buf, int len)
09719b62
MB		 902{
903 DECLARE_COMPLETION_ONSTACK(wait);
09719b62
MB		 904 struct bio *bio;
905 int ret;
906 unsigned long hang_check;
907
908 bio = bio_map_kern(dev->q, buf, len, GFP_KERNEL);
909 if (IS_ERR_OR_NULL(bio))
910 return -ENOMEM;
911
1145e635 912 nvm_generic_to_addr_mode(dev, rqd);
09719b62 913
8e53624d 914 rqd->dev = NULL;
1145e635
MB		 915 rqd->opcode = opcode;
916 rqd->flags = flags;
917 rqd->bio = bio;
918 rqd->wait = &wait;
919 rqd->end_io = nvm_end_io_sync;
09719b62 920
1145e635 921 ret = dev->ops->submit_io(dev, rqd);
ecfb40c6 922 if (ret) {
ecfb40c6
MB		 923 bio_put(bio);
924 return ret;
925 }
09719b62
MB		 926
927 /* Prevent hang_check timer from firing at us during very long I/O */
928 hang_check = sysctl_hung_task_timeout_secs;
929 if (hang_check)
12624af2
MB		 930 while (!wait_for_completion_io_timeout(&wait,
931 hang_check * (HZ/2)))
932 ;
09719b62
MB		 933 else
934 wait_for_completion_io(&wait);
935
1145e635
MB		 936 return rqd->error;
937}
938
939/**
940 * nvm_submit_ppa_list - submit user-defined ppa list to device. The user must
941 * take to free ppa list if necessary.
942 * @dev: device
943 * @ppa_list: user created ppa_list
944 * @nr_ppas: length of ppa_list
945 * @opcode: device opcode
946 * @flags: device flags
947 * @buf: data buffer
948 * @len: data buffer length
949 */
950int nvm_submit_ppa_list(struct nvm_dev *dev, struct ppa_addr *ppa_list,
951 int nr_ppas, int opcode, int flags, void *buf, int len)
952{
953 struct nvm_rq rqd;
954
955 if (dev->ops->max_phys_sect < nr_ppas)
956 return -EINVAL;
957
958 memset(&rqd, 0, sizeof(struct nvm_rq));
959
6d5be959 960 rqd.nr_ppas = nr_ppas;
1145e635
MB		 961 if (nr_ppas > 1)
962 rqd.ppa_list = ppa_list;
963 else
964 rqd.ppa_addr = ppa_list[0];
965
966 return __nvm_submit_ppa(dev, &rqd, opcode, flags, buf, len);
967}
968EXPORT_SYMBOL(nvm_submit_ppa_list);
969
970/**
971 * nvm_submit_ppa - submit PPAs to device. PPAs will automatically be unfolded
972 * as single, dual, quad plane PPAs depending on device type.
973 * @dev: device
974 * @ppa: user created ppa_list
975 * @nr_ppas: length of ppa_list
976 * @opcode: device opcode
977 * @flags: device flags
978 * @buf: data buffer
979 * @len: data buffer length
980 */
981int nvm_submit_ppa(struct nvm_dev *dev, struct ppa_addr *ppa, int nr_ppas,
982 int opcode, int flags, void *buf, int len)
983{
984 struct nvm_rq rqd;
985 int ret;
986
987 memset(&rqd, 0, sizeof(struct nvm_rq));
5ebc7d9f 988 ret = nvm_set_rqd_ppalist(dev, &rqd, ppa, nr_ppas, 1);
1145e635
MB		 989 if (ret)
990 return ret;
991
992 ret = __nvm_submit_ppa(dev, &rqd, opcode, flags, buf, len);
993
09719b62
MB		 994 nvm_free_rqd_ppalist(dev, &rqd);
995
1145e635 996 return ret;
09719b62
MB		 997}
998EXPORT_SYMBOL(nvm_submit_ppa);
999
22e8c976
MB		 1000/*
1001 * folds a bad block list from its plane representation to its virtual
1002 * block representation. The fold is done in place and reduced size is
1003 * returned.
1004 *
1005 * If any of the planes status are bad or grown bad block, the virtual block
1006 * is marked bad. If not bad, the first plane state acts as the block state.
1007 */
1008int nvm_bb_tbl_fold(struct nvm_dev *dev, u8 *blks, int nr_blks)
1009{
8e79b5cb 1010 struct nvm_geo *geo = &dev->geo;
22e8c976
MB		 1011 int blk, offset, pl, blktype;
1012
8e79b5cb 1013 if (nr_blks != geo->blks_per_lun * geo->plane_mode)
22e8c976
MB		 1014 return -EINVAL;
1015
8e79b5cb
JG		 1016 for (blk = 0; blk < geo->blks_per_lun; blk++) {
1017 offset = blk * geo->plane_mode;
22e8c976
MB		 1018 blktype = blks[offset];
1019
1020 /* Bad blocks on any planes take precedence over other types */
8e79b5cb 1021 for (pl = 0; pl < geo->plane_mode; pl++) {
22e8c976
MB		 1022 if (blks[offset + pl] &
1023 (NVM_BLK_T_BAD|NVM_BLK_T_GRWN_BAD)) {
1024 blktype = blks[offset + pl];
1025 break;
1026 }
1027 }
1028
1029 blks[blk] = blktype;
1030 }
1031
8e79b5cb 1032 return geo->blks_per_lun;
22e8c976
MB		 1033}
1034EXPORT_SYMBOL(nvm_bb_tbl_fold);
1035
e11903f5
MB		 1036int nvm_get_bb_tbl(struct nvm_dev *dev, struct ppa_addr ppa, u8 *blks)
1037{
1038 ppa = generic_to_dev_addr(dev, ppa);
1039
1040 return dev->ops->get_bb_tbl(dev, ppa, blks);
1041}
1042EXPORT_SYMBOL(nvm_get_bb_tbl);
1043
333ba053
JG		 1044int nvm_get_tgt_bb_tbl(struct nvm_tgt_dev *tgt_dev, struct ppa_addr ppa,
1045 u8 *blks)
1046{
ade69e24 1047 ppa = nvm_trans_ppa(tgt_dev, ppa, TRANS_TGT_TO_DEV);
333ba053 1048
ade69e24 1049 return nvm_get_bb_tbl(tgt_dev->parent, ppa, blks);
333ba053
JG		 1050}
1051EXPORT_SYMBOL(nvm_get_tgt_bb_tbl);
1052
ca5927e7
MB		 1053static int nvm_init_slc_tbl(struct nvm_dev *dev, struct nvm_id_group *grp)
1054{
8e79b5cb 1055 struct nvm_geo *geo = &dev->geo;
ca5927e7
MB		 1056 int i;
1057
8e79b5cb 1058 dev->lps_per_blk = geo->pgs_per_blk;
ca5927e7
MB		 1059 dev->lptbl = kcalloc(dev->lps_per_blk, sizeof(int), GFP_KERNEL);
1060 if (!dev->lptbl)
1061 return -ENOMEM;
1062
1063 /* Just a linear array */
1064 for (i = 0; i < dev->lps_per_blk; i++)
1065 dev->lptbl[i] = i;
1066
1067 return 0;
1068}
1069
1070static int nvm_init_mlc_tbl(struct nvm_dev *dev, struct nvm_id_group *grp)
1071{
1072 int i, p;
1073 struct nvm_id_lp_mlc *mlc = &grp->lptbl.mlc;
1074
1075 if (!mlc->num_pairs)
1076 return 0;
1077
1078 dev->lps_per_blk = mlc->num_pairs;
1079 dev->lptbl = kcalloc(dev->lps_per_blk, sizeof(int), GFP_KERNEL);
1080 if (!dev->lptbl)
1081 return -ENOMEM;
1082
1083 /* The lower page table encoding consists of a list of bytes, where each
1084 * has a lower and an upper half. The first half byte maintains the
1085 * increment value and every value after is an offset added to the
12624af2
MB		 1086 * previous incrementation value
1087 */
ca5927e7
MB		 1088 dev->lptbl[0] = mlc->pairs[0] & 0xF;
1089 for (i = 1; i < dev->lps_per_blk; i++) {
1090 p = mlc->pairs[i >> 1];
1091 if (i & 0x1) /* upper */
1092 dev->lptbl[i] = dev->lptbl[i - 1] + ((p & 0xF0) >> 4);
1093 else /* lower */
1094 dev->lptbl[i] = dev->lptbl[i - 1] + (p & 0xF);
1095 }
1096
1097 return 0;
1098}
1099
cd9e9808
MB		 1100static int nvm_core_init(struct nvm_dev *dev)
1101{
1102 struct nvm_id *id = &dev->identity;
1103 struct nvm_id_group *grp = &id->groups[0];
8e79b5cb 1104 struct nvm_geo *geo = &dev->geo;
7f7c5d03 1105 int ret;
cd9e9808 1106
8e79b5cb
JG		 1107 /* Whole device values */
1108 geo->nr_chnls = grp->num_ch;
1109 geo->luns_per_chnl = grp->num_lun;
1110
1111 /* Generic device values */
1112 geo->pgs_per_blk = grp->num_pg;
1113 geo->blks_per_lun = grp->num_blk;
1114 geo->nr_planes = grp->num_pln;
1115 geo->fpg_size = grp->fpg_sz;
1116 geo->pfpg_size = grp->fpg_sz * grp->num_pln;
1117 geo->sec_size = grp->csecs;
1118 geo->oob_size = grp->sos;
1119 geo->sec_per_pg = grp->fpg_sz / grp->csecs;
1120 geo->mccap = grp->mccap;
1121 memcpy(&geo->ppaf, &id->ppaf, sizeof(struct nvm_addr_format));
1122
1123 geo->plane_mode = NVM_PLANE_SINGLE;
1124 geo->max_rq_size = dev->ops->max_phys_sect * geo->sec_size;
cd9e9808
MB		 1125
1126 if (grp->mpos & 0x020202)
8e79b5cb 1127 geo->plane_mode = NVM_PLANE_DOUBLE;
cd9e9808 1128 if (grp->mpos & 0x040404)
8e79b5cb 1129 geo->plane_mode = NVM_PLANE_QUAD;
cd9e9808 1130
7f7c5d03
MB		 1131 if (grp->mtype != 0) {
1132 pr_err("nvm: memory type not supported\n");
1133 return -EINVAL;
1134 }
1135
cd9e9808 1136 /* calculated values */
8e79b5cb
JG		 1137 geo->sec_per_pl = geo->sec_per_pg * geo->nr_planes;
1138 geo->sec_per_blk = geo->sec_per_pl * geo->pgs_per_blk;
1139 geo->sec_per_lun = geo->sec_per_blk * geo->blks_per_lun;
1140 geo->nr_luns = geo->luns_per_chnl * geo->nr_chnls;
cd9e9808 1141
8e79b5cb
JG		 1142 dev->total_secs = geo->nr_luns * geo->sec_per_lun;
1143 dev->lun_map = kcalloc(BITS_TO_LONGS(geo->nr_luns),
da1e2849
WT		 1144 sizeof(unsigned long), GFP_KERNEL);
1145 if (!dev->lun_map)
1146 return -ENOMEM;
7f7c5d03
MB		 1147
1148 switch (grp->fmtype) {
1149 case NVM_ID_FMTYPE_SLC:
1150 if (nvm_init_slc_tbl(dev, grp)) {
1151 ret = -ENOMEM;
1152 goto err_fmtype;
1153 }
1154 break;
1155 case NVM_ID_FMTYPE_MLC:
1156 if (nvm_init_mlc_tbl(dev, grp)) {
1157 ret = -ENOMEM;
1158 goto err_fmtype;
1159 }
1160 break;
1161 default:
1162 pr_err("nvm: flash type not supported\n");
1163 ret = -EINVAL;
1164 goto err_fmtype;
1165 }
1166
ade69e24
MB		 1167 INIT_LIST_HEAD(&dev->area_list);
1168 INIT_LIST_HEAD(&dev->targets);
e3eb3799 1169 mutex_init(&dev->mlock);
4c9dacb8 1170 spin_lock_init(&dev->lock);
cd9e9808 1171
ade69e24
MB		 1172 ret = nvm_register_map(dev);
1173 if (ret)
1174 goto err_fmtype;
ac81bfa9 1175
ade69e24 1176 blk_queue_logical_block_size(dev->q, geo->sec_size);
cd9e9808 1177 return 0;
7f7c5d03
MB		 1178err_fmtype:
1179 kfree(dev->lun_map);
1180 return ret;
cd9e9808
MB		 1181}
1182
40267efd 1183void nvm_free(struct nvm_dev *dev)
cd9e9808
MB		 1184{
1185 if (!dev)
1186 return;
1187
40267efd
SL		 1188 if (dev->dma_pool)
1189 dev->ops->destroy_dma_pool(dev->dma_pool);
1190
ade69e24 1191 kfree(dev->rmap);
ca5927e7 1192 kfree(dev->lptbl);
7f7c5d03 1193 kfree(dev->lun_map);
40267efd 1194 kfree(dev);
cd9e9808
MB		 1195}
1196
1197static int nvm_init(struct nvm_dev *dev)
1198{
8e79b5cb 1199 struct nvm_geo *geo = &dev->geo;
480fc0db 1200 int ret = -EINVAL;
cd9e9808 1201
16f26c3a 1202 if (dev->ops->identity(dev, &dev->identity)) {
cd9e9808 1203 pr_err("nvm: device could not be identified\n");
cd9e9808
MB		 1204 goto err;
1205 }
1206
1207 pr_debug("nvm: ver:%x nvm_vendor:%x groups:%u\n",
1208 dev->identity.ver_id, dev->identity.vmnt,
1209 dev->identity.cgrps);
1210
1211 if (dev->identity.ver_id != 1) {
1212 pr_err("nvm: device not supported by kernel.");
1213 goto err;
1214 }
1215
1216 if (dev->identity.cgrps != 1) {
1217 pr_err("nvm: only one group configuration supported.");
1218 goto err;
1219 }
1220
1221 ret = nvm_core_init(dev);
1222 if (ret) {
1223 pr_err("nvm: could not initialize core structures.\n");
1224 goto err;
1225 }
1226
cd9e9808 1227 pr_info("nvm: registered %s [%u/%u/%u/%u/%u/%u]\n",
8e79b5cb
JG		 1228 dev->name, geo->sec_per_pg, geo->nr_planes,
1229 geo->pgs_per_blk, geo->blks_per_lun,
1230 geo->nr_luns, geo->nr_chnls);
cd9e9808
MB		 1231 return 0;
1232err:
cd9e9808
MB		 1233 pr_err("nvm: failed to initialize nvm\n");
1234 return ret;
1235}
1236
b0b4e09c 1237struct nvm_dev *nvm_alloc_dev(int node)
cd9e9808 1238{
b0b4e09c 1239 return kzalloc_node(sizeof(struct nvm_dev), GFP_KERNEL, node);
cd9e9808 1240}
b0b4e09c 1241EXPORT_SYMBOL(nvm_alloc_dev);
cd9e9808 1242
b0b4e09c 1243int nvm_register(struct nvm_dev *dev)
cd9e9808 1244{
cd9e9808
MB		 1245 int ret;
1246
ade69e24
MB		 1247 if (!dev->q || !dev->ops)
1248 return -EINVAL;
cd9e9808 1249
d160147b
WT		 1250 if (dev->ops->max_phys_sect > 256) {
1251 pr_info("nvm: max sectors supported is 256.\n");
ade69e24 1252 return -EINVAL;
d160147b
WT		 1253 }
1254
cd9e9808 1255 if (dev->ops->max_phys_sect > 1) {
75b85649
JG		 1256 dev->dma_pool = dev->ops->create_dma_pool(dev, "ppalist");
1257 if (!dev->dma_pool) {
1258 pr_err("nvm: could not create dma pool\n");
ade69e24 1259 return -ENOMEM;
cd9e9808 1260 }
cd9e9808
MB		 1261 }
1262
ade69e24
MB		 1263 ret = nvm_init(dev);
1264 if (ret)
1265 goto err_init;
b7692076 1266
762796bc 1267 /* register device with a supported media manager */
edad2e66
MB		 1268 down_write(&nvm_lock);
1269 list_add(&dev->devices, &nvm_devices);
1270 up_write(&nvm_lock);
1271
cd9e9808
MB		 1272 return 0;
1273err_init:
ade69e24 1274 dev->ops->destroy_dma_pool(dev->dma_pool);
cd9e9808
MB		 1275 return ret;
1276}
1277EXPORT_SYMBOL(nvm_register);
1278
b0b4e09c 1279void nvm_unregister(struct nvm_dev *dev)
cd9e9808 1280{
ade69e24
MB		 1281 struct nvm_target *t, *tmp;
1282
1283 mutex_lock(&dev->mlock);
1284 list_for_each_entry_safe(t, tmp, &dev->targets, list) {
1285 if (t->dev->parent != dev)
1286 continue;
1287 __nvm_remove_target(t);
1288 }
1289 mutex_unlock(&dev->mlock);
1290
d0a712ce 1291 down_write(&nvm_lock);
cd9e9808
MB		 1292 list_del(&dev->devices);
1293 up_write(&nvm_lock);
c1480ad5 1294
3dc87dd0 1295 nvm_free(dev);
cd9e9808
MB		 1296}
1297EXPORT_SYMBOL(nvm_unregister);
1298
cd9e9808
MB		 1299static int __nvm_configure_create(struct nvm_ioctl_create *create)
1300{
1301 struct nvm_dev *dev;
1302 struct nvm_ioctl_create_simple *s;
1303
d0a712ce 1304 down_write(&nvm_lock);
cd9e9808 1305 dev = nvm_find_nvm_dev(create->dev);
d0a712ce 1306 up_write(&nvm_lock);
b76eb20b 1307
cd9e9808
MB		 1308 if (!dev) {
1309 pr_err("nvm: device not found\n");
1310 return -EINVAL;
1311 }
1312
1313 if (create->conf.type != NVM_CONFIG_TYPE_SIMPLE) {
1314 pr_err("nvm: config type not valid\n");
1315 return -EINVAL;
1316 }
1317 s = &create->conf.s;
1318
8e79b5cb 1319 if (s->lun_begin > s->lun_end || s->lun_end > dev->geo.nr_luns) {
cd9e9808 1320 pr_err("nvm: lun out of bound (%u:%u > %u)\n",
8e79b5cb 1321 s->lun_begin, s->lun_end, dev->geo.nr_luns);
cd9e9808
MB		 1322 return -EINVAL;
1323 }
1324
ade69e24 1325 return nvm_create_tgt(dev, create);
cd9e9808
MB		 1326}
1327
cd9e9808
MB		 1328static long nvm_ioctl_info(struct file *file, void __user *arg)
1329{
1330 struct nvm_ioctl_info *info;
1331 struct nvm_tgt_type *tt;
1332 int tgt_iter = 0;
1333
1334 if (!capable(CAP_SYS_ADMIN))
1335 return -EPERM;
1336
1337 info = memdup_user(arg, sizeof(struct nvm_ioctl_info));
1338 if (IS_ERR(info))
1339 return -EFAULT;
1340
1341 info->version[0] = NVM_VERSION_MAJOR;
1342 info->version[1] = NVM_VERSION_MINOR;
1343 info->version[2] = NVM_VERSION_PATCH;
1344
1345 down_write(&nvm_lock);
6063fe39 1346 list_for_each_entry(tt, &nvm_tgt_types, list) {
cd9e9808
MB		 1347 struct nvm_ioctl_info_tgt *tgt = &info->tgts[tgt_iter];
1348
1349 tgt->version[0] = tt->version[0];
1350 tgt->version[1] = tt->version[1];
1351 tgt->version[2] = tt->version[2];
1352 strncpy(tgt->tgtname, tt->name, NVM_TTYPE_NAME_MAX);
1353
1354 tgt_iter++;
1355 }
1356
1357 info->tgtsize = tgt_iter;
1358 up_write(&nvm_lock);
1359
76e25081
SM		 1360 if (copy_to_user(arg, info, sizeof(struct nvm_ioctl_info))) {
1361 kfree(info);
cd9e9808 1362 return -EFAULT;
76e25081 1363 }
cd9e9808
MB		 1364
1365 kfree(info);
1366 return 0;
1367}
1368
1369static long nvm_ioctl_get_devices(struct file *file, void __user *arg)
1370{
1371 struct nvm_ioctl_get_devices *devices;
1372 struct nvm_dev *dev;
1373 int i = 0;
1374
1375 if (!capable(CAP_SYS_ADMIN))
1376 return -EPERM;
1377
1378 devices = kzalloc(sizeof(struct nvm_ioctl_get_devices), GFP_KERNEL);
1379 if (!devices)
1380 return -ENOMEM;
1381
1382 down_write(&nvm_lock);
1383 list_for_each_entry(dev, &nvm_devices, devices) {
1384 struct nvm_ioctl_device_info *info = &devices->info[i];
1385
1386 sprintf(info->devname, "%s", dev->name);
cd9e9808 1387
ade69e24
MB		 1388 /* kept for compatibility */
1389 info->bmversion[0] = 1;
1390 info->bmversion[1] = 0;
1391 info->bmversion[2] = 0;
1392 sprintf(info->bmname, "%s", "gennvm");
cd9e9808 1393 i++;
ade69e24 1394
cd9e9808
MB		 1395 if (i > 31) {
1396 pr_err("nvm: max 31 devices can be reported.\n");
1397 break;
1398 }
1399 }
1400 up_write(&nvm_lock);
1401
1402 devices->nr_devices = i;
1403
76e25081
SM		 1404 if (copy_to_user(arg, devices,
1405 sizeof(struct nvm_ioctl_get_devices))) {
1406 kfree(devices);
cd9e9808 1407 return -EFAULT;
76e25081 1408 }
cd9e9808
MB		 1409
1410 kfree(devices);
1411 return 0;
1412}
1413
1414static long nvm_ioctl_dev_create(struct file *file, void __user *arg)
1415{
1416 struct nvm_ioctl_create create;
1417
1418 if (!capable(CAP_SYS_ADMIN))
1419 return -EPERM;
1420
1421 if (copy_from_user(&create, arg, sizeof(struct nvm_ioctl_create)))
1422 return -EFAULT;
1423
1424 create.dev[DISK_NAME_LEN - 1] = '\0';
1425 create.tgttype[NVM_TTYPE_NAME_MAX - 1] = '\0';
1426 create.tgtname[DISK_NAME_LEN - 1] = '\0';
1427
1428 if (create.flags != 0) {
1429 pr_err("nvm: no flags supported\n");
1430 return -EINVAL;
1431 }
1432
1433 return __nvm_configure_create(&create);
1434}
1435
1436static long nvm_ioctl_dev_remove(struct file *file, void __user *arg)
1437{
1438 struct nvm_ioctl_remove remove;
b76eb20b
MB		 1439 struct nvm_dev *dev;
1440 int ret = 0;
cd9e9808
MB		 1441
1442 if (!capable(CAP_SYS_ADMIN))
1443 return -EPERM;
1444
1445 if (copy_from_user(&remove, arg, sizeof(struct nvm_ioctl_remove)))
1446 return -EFAULT;
1447
1448 remove.tgtname[DISK_NAME_LEN - 1] = '\0';
1449
1450 if (remove.flags != 0) {
1451 pr_err("nvm: no flags supported\n");
1452 return -EINVAL;
1453 }
1454
b76eb20b 1455 list_for_each_entry(dev, &nvm_devices, devices) {
ade69e24 1456 ret = nvm_remove_tgt(dev, &remove);
b76eb20b
MB		 1457 if (!ret)
1458 break;
1459 }
1460
1461 return ret;
cd9e9808
MB		 1462}
1463
ade69e24 1464/* kept for compatibility reasons */
55696154
MB		 1465static long nvm_ioctl_dev_init(struct file *file, void __user *arg)
1466{
1467 struct nvm_ioctl_dev_init init;
1468
1469 if (!capable(CAP_SYS_ADMIN))
1470 return -EPERM;
1471
1472 if (copy_from_user(&init, arg, sizeof(struct nvm_ioctl_dev_init)))
1473 return -EFAULT;
1474
1475 if (init.flags != 0) {
1476 pr_err("nvm: no flags supported\n");
1477 return -EINVAL;
1478 }
1479
ade69e24 1480 return 0;
55696154
MB		 1481}
1482
ade69e24 1483/* Kept for compatibility reasons */
8b4970c4
MB		 1484static long nvm_ioctl_dev_factory(struct file *file, void __user *arg)
1485{
1486 struct nvm_ioctl_dev_factory fact;
8b4970c4
MB		 1487
1488 if (!capable(CAP_SYS_ADMIN))
1489 return -EPERM;
1490
1491 if (copy_from_user(&fact, arg, sizeof(struct nvm_ioctl_dev_factory)))
1492 return -EFAULT;
1493
1494 fact.dev[DISK_NAME_LEN - 1] = '\0';
1495
1496 if (fact.flags & ~(NVM_FACTORY_NR_BITS - 1))
1497 return -EINVAL;
1498
bf643185 1499 return 0;
8b4970c4
MB		 1500}
1501
cd9e9808
MB		 1502static long nvm_ctl_ioctl(struct file *file, uint cmd, unsigned long arg)
1503{
1504 void __user *argp = (void __user *)arg;
1505
1506 switch (cmd) {
1507 case NVM_INFO:
1508 return nvm_ioctl_info(file, argp);
1509 case NVM_GET_DEVICES:
1510 return nvm_ioctl_get_devices(file, argp);
1511 case NVM_DEV_CREATE:
1512 return nvm_ioctl_dev_create(file, argp);
1513 case NVM_DEV_REMOVE:
1514 return nvm_ioctl_dev_remove(file, argp);
55696154
MB		 1515 case NVM_DEV_INIT:
1516 return nvm_ioctl_dev_init(file, argp);
8b4970c4
MB		 1517 case NVM_DEV_FACTORY:
1518 return nvm_ioctl_dev_factory(file, argp);
cd9e9808
MB		 1519 }
1520 return 0;
1521}
1522
1523static const struct file_operations _ctl_fops = {
1524 .open = nonseekable_open,
1525 .unlocked_ioctl = nvm_ctl_ioctl,
1526 .owner = THIS_MODULE,
1527 .llseek = noop_llseek,
1528};
1529
1530static struct miscdevice _nvm_misc = {
1531 .minor = MISC_DYNAMIC_MINOR,
1532 .name = "lightnvm",
1533 .nodename = "lightnvm/control",
1534 .fops = &_ctl_fops,
1535};
389b2a1c 1536builtin_misc_device(_nvm_misc);
Ubuntu Artful kernel mirror