?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dt-bindings: mtd: ingenic: Use standard ecc-engine property
[linux/fpc-iii.git] / drivers / mtd / mtd_blkdevs.c
blobb0d44f9214b034b6a1620858247164cadb4e7a7d
1 /*
2 * Interface to Linux block layer for MTD 'translation layers'.
3 *
4 * Copyright © 2003-2010 David Woodhouse <dwmw2@infradead.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 #include <linux/kernel.h>
23 #include <linux/slab.h>
24 #include <linux/module.h>
25 #include <linux/list.h>
26 #include <linux/fs.h>
27 #include <linux/mtd/blktrans.h>
28 #include <linux/mtd/mtd.h>
29 #include <linux/blkdev.h>
30 #include <linux/blk-mq.h>
31 #include <linux/blkpg.h>
32 #include <linux/spinlock.h>
33 #include <linux/hdreg.h>
34 #include <linux/mutex.h>
35 #include <linux/uaccess.h>
36
37 #include "mtdcore.h"
38
39 static LIST_HEAD(blktrans_majors);
40 static DEFINE_MUTEX(blktrans_ref_mutex);
41
42 static void blktrans_dev_release(struct kref *kref)
43 {
44 struct mtd_blktrans_dev *dev =
45 container_of(kref, struct mtd_blktrans_dev, ref);
46
47 dev->disk->private_data = NULL;
48 blk_cleanup_queue(dev->rq);
49 blk_mq_free_tag_set(dev->tag_set);
50 kfree(dev->tag_set);
51 put_disk(dev->disk);
52 list_del(&dev->list);
53 kfree(dev);
54 }
55
56 static struct mtd_blktrans_dev *blktrans_dev_get(struct gendisk *disk)
57 {
58 struct mtd_blktrans_dev *dev;
59
60 mutex_lock(&blktrans_ref_mutex);
61 dev = disk->private_data;
62
63 if (!dev)
64 goto unlock;
65 kref_get(&dev->ref);
66 unlock:
67 mutex_unlock(&blktrans_ref_mutex);
68 return dev;
69 }
70
71 static void blktrans_dev_put(struct mtd_blktrans_dev *dev)
72 {
73 mutex_lock(&blktrans_ref_mutex);
74 kref_put(&dev->ref, blktrans_dev_release);
75 mutex_unlock(&blktrans_ref_mutex);
76 }
77
78
79 static blk_status_t do_blktrans_request(struct mtd_blktrans_ops *tr,
80 struct mtd_blktrans_dev *dev,
81 struct request *req)
82 {
83 unsigned long block, nsect;
84 char *buf;
85
86 block = blk_rq_pos(req) << 9 >> tr->blkshift;
87 nsect = blk_rq_cur_bytes(req) >> tr->blkshift;
88
89 if (req_op(req) == REQ_OP_FLUSH) {
90 if (tr->flush(dev))
91 return BLK_STS_IOERR;
92 return BLK_STS_OK;
93 }
94
95 if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >
96 get_capacity(req->rq_disk))
97 return BLK_STS_IOERR;
98
99 switch (req_op(req)) {
100 case REQ_OP_DISCARD:
101 if (tr->discard(dev, block, nsect))
102 return BLK_STS_IOERR;
103 return BLK_STS_OK;
104 case REQ_OP_READ:
105 buf = kmap(bio_page(req->bio)) + bio_offset(req->bio);
106 for (; nsect > 0; nsect--, block++, buf += tr->blksize) {
107 if (tr->readsect(dev, block, buf)) {
108 kunmap(bio_page(req->bio));
109 return BLK_STS_IOERR;
110 }
111 }
112 kunmap(bio_page(req->bio));
113 rq_flush_dcache_pages(req);
114 return BLK_STS_OK;
115 case REQ_OP_WRITE:
116 if (!tr->writesect)
117 return BLK_STS_IOERR;
118
119 rq_flush_dcache_pages(req);
120 buf = kmap(bio_page(req->bio)) + bio_offset(req->bio);
121 for (; nsect > 0; nsect--, block++, buf += tr->blksize) {
122 if (tr->writesect(dev, block, buf)) {
123 kunmap(bio_page(req->bio));
124 return BLK_STS_IOERR;
125 }
126 }
127 kunmap(bio_page(req->bio));
128 return BLK_STS_OK;
129 default:
130 return BLK_STS_IOERR;
131 }
132 }
133
134 int mtd_blktrans_cease_background(struct mtd_blktrans_dev *dev)
135 {
136 return dev->bg_stop;
137 }
138 EXPORT_SYMBOL_GPL(mtd_blktrans_cease_background);
139
140 static struct request *mtd_next_request(struct mtd_blktrans_dev *dev)
141 {
142 struct request *rq;
143
144 rq = list_first_entry_or_null(&dev->rq_list, struct request, queuelist);
145 if (rq) {
146 list_del_init(&rq->queuelist);
147 blk_mq_start_request(rq);
148 return rq;
149 }
150
151 return NULL;
152 }
153
154 static void mtd_blktrans_work(struct mtd_blktrans_dev *dev)
155 __releases(&dev->queue_lock)
156 __acquires(&dev->queue_lock)
157 {
158 struct mtd_blktrans_ops *tr = dev->tr;
159 struct request *req = NULL;
160 int background_done = 0;
161
162 while (1) {
163 blk_status_t res;
164
165 dev->bg_stop = false;
166 if (!req && !(req = mtd_next_request(dev))) {
167 if (tr->background && !background_done) {
168 spin_unlock_irq(&dev->queue_lock);
169 mutex_lock(&dev->lock);
170 tr->background(dev);
171 mutex_unlock(&dev->lock);
172 spin_lock_irq(&dev->queue_lock);
173 /*
174 * Do background processing just once per idle
175 * period.
176 */
177 background_done = !dev->bg_stop;
178 continue;
179 }
180 break;
181 }
182
183 spin_unlock_irq(&dev->queue_lock);
184
185 mutex_lock(&dev->lock);
186 res = do_blktrans_request(dev->tr, dev, req);
187 mutex_unlock(&dev->lock);
188
189 if (!blk_update_request(req, res, blk_rq_cur_bytes(req))) {
190 __blk_mq_end_request(req, res);
191 req = NULL;
192 }
193
194 background_done = 0;
195 spin_lock_irq(&dev->queue_lock);
196 }
197 }
198
199 static blk_status_t mtd_queue_rq(struct blk_mq_hw_ctx *hctx,
200 const struct blk_mq_queue_data *bd)
201 {
202 struct mtd_blktrans_dev *dev;
203
204 dev = hctx->queue->queuedata;
205 if (!dev) {
206 blk_mq_start_request(bd->rq);
207 return BLK_STS_IOERR;
208 }
209
210 spin_lock_irq(&dev->queue_lock);
211 list_add_tail(&bd->rq->queuelist, &dev->rq_list);
212 mtd_blktrans_work(dev);
213 spin_unlock_irq(&dev->queue_lock);
214
215 return BLK_STS_OK;
216 }
217
218 static int blktrans_open(struct block_device *bdev, fmode_t mode)
219 {
220 struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
221 int ret = 0;
222
223 if (!dev)
224 return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/
225
226 mutex_lock(&mtd_table_mutex);
227 mutex_lock(&dev->lock);
228
229 if (dev->open)
230 goto unlock;
231
232 kref_get(&dev->ref);
233 __module_get(dev->tr->owner);
234
235 if (!dev->mtd)
236 goto unlock;
237
238 if (dev->tr->open) {
239 ret = dev->tr->open(dev);
240 if (ret)
241 goto error_put;
242 }
243
244 ret = __get_mtd_device(dev->mtd);
245 if (ret)
246 goto error_release;
247 dev->file_mode = mode;
248
249 unlock:
250 dev->open++;
251 mutex_unlock(&dev->lock);
252 mutex_unlock(&mtd_table_mutex);
253 blktrans_dev_put(dev);
254 return ret;
255
256 error_release:
257 if (dev->tr->release)
258 dev->tr->release(dev);
259 error_put:
260 module_put(dev->tr->owner);
261 kref_put(&dev->ref, blktrans_dev_release);
262 mutex_unlock(&dev->lock);
263 mutex_unlock(&mtd_table_mutex);
264 blktrans_dev_put(dev);
265 return ret;
266 }
267
268 static void blktrans_release(struct gendisk *disk, fmode_t mode)
269 {
270 struct mtd_blktrans_dev *dev = blktrans_dev_get(disk);
271
272 if (!dev)
273 return;
274
275 mutex_lock(&mtd_table_mutex);
276 mutex_lock(&dev->lock);
277
278 if (--dev->open)
279 goto unlock;
280
281 kref_put(&dev->ref, blktrans_dev_release);
282 module_put(dev->tr->owner);
283
284 if (dev->mtd) {
285 if (dev->tr->release)
286 dev->tr->release(dev);
287 __put_mtd_device(dev->mtd);
288 }
289 unlock:
290 mutex_unlock(&dev->lock);
291 mutex_unlock(&mtd_table_mutex);
292 blktrans_dev_put(dev);
293 }
294
295 static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)
296 {
297 struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
298 int ret = -ENXIO;
299
300 if (!dev)
301 return ret;
302
303 mutex_lock(&dev->lock);
304
305 if (!dev->mtd)
306 goto unlock;
307
308 ret = dev->tr->getgeo ? dev->tr->getgeo(dev, geo) : -ENOTTY;
309 unlock:
310 mutex_unlock(&dev->lock);
311 blktrans_dev_put(dev);
312 return ret;
313 }
314
315 static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,
316 unsigned int cmd, unsigned long arg)
317 {
318 struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
319 int ret = -ENXIO;
320
321 if (!dev)
322 return ret;
323
324 mutex_lock(&dev->lock);
325
326 if (!dev->mtd)
327 goto unlock;
328
329 switch (cmd) {
330 case BLKFLSBUF:
331 ret = dev->tr->flush ? dev->tr->flush(dev) : 0;
332 break;
333 default:
334 ret = -ENOTTY;
335 }
336 unlock:
337 mutex_unlock(&dev->lock);
338 blktrans_dev_put(dev);
339 return ret;
340 }
341
342 static const struct block_device_operations mtd_block_ops = {
343 .owner = THIS_MODULE,
344 .open = blktrans_open,
345 .release = blktrans_release,
346 .ioctl = blktrans_ioctl,
347 .getgeo = blktrans_getgeo,
348 };
349
350 static const struct blk_mq_ops mtd_mq_ops = {
351 .queue_rq = mtd_queue_rq,
352 };
353
354 int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
355 {
356 struct mtd_blktrans_ops *tr = new->tr;
357 struct mtd_blktrans_dev *d;
358 int last_devnum = -1;
359 struct gendisk *gd;
360 int ret;
361
362 if (mutex_trylock(&mtd_table_mutex)) {
363 mutex_unlock(&mtd_table_mutex);
364 BUG();
365 }
366
367 mutex_lock(&blktrans_ref_mutex);
368 list_for_each_entry(d, &tr->devs, list) {
369 if (new->devnum == -1) {
370 /* Use first free number */
371 if (d->devnum != last_devnum+1) {
372 /* Found a free devnum. Plug it in here */
373 new->devnum = last_devnum+1;
374 list_add_tail(&new->list, &d->list);
375 goto added;
376 }
377 } else if (d->devnum == new->devnum) {
378 /* Required number taken */
379 mutex_unlock(&blktrans_ref_mutex);
380 return -EBUSY;
381 } else if (d->devnum > new->devnum) {
382 /* Required number was free */
383 list_add_tail(&new->list, &d->list);
384 goto added;
385 }
386 last_devnum = d->devnum;
387 }
388
389 ret = -EBUSY;
390 if (new->devnum == -1)
391 new->devnum = last_devnum+1;
392
393 /* Check that the device and any partitions will get valid
394 * minor numbers and that the disk naming code below can cope
395 * with this number. */
396 if (new->devnum > (MINORMASK >> tr->part_bits) ||
397 (tr->part_bits && new->devnum >= 27 * 26)) {
398 mutex_unlock(&blktrans_ref_mutex);
399 goto error1;
400 }
401
402 list_add_tail(&new->list, &tr->devs);
403 added:
404 mutex_unlock(&blktrans_ref_mutex);
405
406 mutex_init(&new->lock);
407 kref_init(&new->ref);
408 if (!tr->writesect)
409 new->readonly = 1;
410
411 /* Create gendisk */
412 ret = -ENOMEM;
413 gd = alloc_disk(1 << tr->part_bits);
414
415 if (!gd)
416 goto error2;
417
418 new->disk = gd;
419 gd->private_data = new;
420 gd->major = tr->major;
421 gd->first_minor = (new->devnum) << tr->part_bits;
422 gd->fops = &mtd_block_ops;
423
424 if (tr->part_bits)
425 if (new->devnum < 26)
426 snprintf(gd->disk_name, sizeof(gd->disk_name),
427 "%s%c", tr->name, 'a' + new->devnum);
428 else
429 snprintf(gd->disk_name, sizeof(gd->disk_name),
430 "%s%c%c", tr->name,
431 'a' - 1 + new->devnum / 26,
432 'a' + new->devnum % 26);
433 else
434 snprintf(gd->disk_name, sizeof(gd->disk_name),
435 "%s%d", tr->name, new->devnum);
436
437 set_capacity(gd, ((u64)new->size * tr->blksize) >> 9);
438
439 /* Create the request queue */
440 spin_lock_init(&new->queue_lock);
441 INIT_LIST_HEAD(&new->rq_list);
442
443 new->tag_set = kzalloc(sizeof(*new->tag_set), GFP_KERNEL);
444 if (!new->tag_set)
445 goto error3;
446
447 new->rq = blk_mq_init_sq_queue(new->tag_set, &mtd_mq_ops, 2,
448 BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING);
449 if (IS_ERR(new->rq)) {
450 ret = PTR_ERR(new->rq);
451 new->rq = NULL;
452 goto error4;
453 }
454
455 if (tr->flush)
456 blk_queue_write_cache(new->rq, true, false);
457
458 new->rq->queuedata = new;
459 blk_queue_logical_block_size(new->rq, tr->blksize);
460
461 blk_queue_flag_set(QUEUE_FLAG_NONROT, new->rq);
462 blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, new->rq);
463
464 if (tr->discard) {
465 blk_queue_flag_set(QUEUE_FLAG_DISCARD, new->rq);
466 blk_queue_max_discard_sectors(new->rq, UINT_MAX);
467 }
468
469 gd->queue = new->rq;
470
471 if (new->readonly)
472 set_disk_ro(gd, 1);
473
474 device_add_disk(&new->mtd->dev, gd, NULL);
475
476 if (new->disk_attributes) {
477 ret = sysfs_create_group(&disk_to_dev(gd)->kobj,
478 new->disk_attributes);
479 WARN_ON(ret);
480 }
481 return 0;
482 error4:
483 kfree(new->tag_set);
484 error3:
485 put_disk(new->disk);
486 error2:
487 list_del(&new->list);
488 error1:
489 return ret;
490 }
491
492 int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
493 {
494 unsigned long flags;
495
496 if (mutex_trylock(&mtd_table_mutex)) {
497 mutex_unlock(&mtd_table_mutex);
498 BUG();
499 }
500
501 if (old->disk_attributes)
502 sysfs_remove_group(&disk_to_dev(old->disk)->kobj,
503 old->disk_attributes);
504
505 /* Stop new requests to arrive */
506 del_gendisk(old->disk);
507
508 /* Kill current requests */
509 spin_lock_irqsave(&old->queue_lock, flags);
510 old->rq->queuedata = NULL;
511 spin_unlock_irqrestore(&old->queue_lock, flags);
512
513 /* freeze+quiesce queue to ensure all requests are flushed */
514 blk_mq_freeze_queue(old->rq);
515 blk_mq_quiesce_queue(old->rq);
516 blk_mq_unquiesce_queue(old->rq);
517 blk_mq_unfreeze_queue(old->rq);
518
519 /* If the device is currently open, tell trans driver to close it,
520 then put mtd device, and don't touch it again */
521 mutex_lock(&old->lock);
522 if (old->open) {
523 if (old->tr->release)
524 old->tr->release(old);
525 __put_mtd_device(old->mtd);
526 }
527
528 old->mtd = NULL;
529
530 mutex_unlock(&old->lock);
531 blktrans_dev_put(old);
532 return 0;
533 }
534
535 static void blktrans_notify_remove(struct mtd_info *mtd)
536 {
537 struct mtd_blktrans_ops *tr;
538 struct mtd_blktrans_dev *dev, *next;
539
540 list_for_each_entry(tr, &blktrans_majors, list)
541 list_for_each_entry_safe(dev, next, &tr->devs, list)
542 if (dev->mtd == mtd)
543 tr->remove_dev(dev);
544 }
545
546 static void blktrans_notify_add(struct mtd_info *mtd)
547 {
548 struct mtd_blktrans_ops *tr;
549
550 if (mtd->type == MTD_ABSENT)
551 return;
552
553 list_for_each_entry(tr, &blktrans_majors, list)
554 tr->add_mtd(tr, mtd);
555 }
556
557 static struct mtd_notifier blktrans_notifier = {
558 .add = blktrans_notify_add,
559 .remove = blktrans_notify_remove,
560 };
561
562 int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
563 {
564 struct mtd_info *mtd;
565 int ret;
566
567 /* Register the notifier if/when the first device type is
568 registered, to prevent the link/init ordering from fucking
569 us over. */
570 if (!blktrans_notifier.list.next)
571 register_mtd_user(&blktrans_notifier);
572
573
574 mutex_lock(&mtd_table_mutex);
575
576 ret = register_blkdev(tr->major, tr->name);
577 if (ret < 0) {
578 printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
579 tr->name, tr->major, ret);
580 mutex_unlock(&mtd_table_mutex);
581 return ret;
582 }
583
584 if (ret)
585 tr->major = ret;
586
587 tr->blkshift = ffs(tr->blksize) - 1;
588
589 INIT_LIST_HEAD(&tr->devs);
590 list_add(&tr->list, &blktrans_majors);
591
592 mtd_for_each_device(mtd)
593 if (mtd->type != MTD_ABSENT)
594 tr->add_mtd(tr, mtd);
595
596 mutex_unlock(&mtd_table_mutex);
597 return 0;
598 }
599
600 int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
601 {
602 struct mtd_blktrans_dev *dev, *next;
603
604 mutex_lock(&mtd_table_mutex);
605
606 /* Remove it from the list of active majors */
607 list_del(&tr->list);
608
609 list_for_each_entry_safe(dev, next, &tr->devs, list)
610 tr->remove_dev(dev);
611
612 unregister_blkdev(tr->major, tr->name);
613 mutex_unlock(&mtd_table_mutex);
614
615 BUG_ON(!list_empty(&tr->devs));
616 return 0;
617 }
618
619 static void __exit mtd_blktrans_exit(void)
620 {
621 /* No race here -- if someone's currently in register_mtd_blktrans
622 we're screwed anyway. */
623 if (blktrans_notifier.list.next)
624 unregister_mtd_user(&blktrans_notifier);
625 }
626
627 module_exit(mtd_blktrans_exit);
628
629 EXPORT_SYMBOL_GPL(register_mtd_blktrans);
630 EXPORT_SYMBOL_GPL(deregister_mtd_blktrans);
631 EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev);
632 EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev);
633
634 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
635 MODULE_LICENSE("GPL");
636 MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");
Linux with added FPC-III support