xref: /openbmc/linux/drivers/mtd/mtd_blkdevs.c (revision e2f1cf25)
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/blkpg.h>
31 #include <linux/spinlock.h>
32 #include <linux/hdreg.h>
33 #include <linux/mutex.h>
34 #include <asm/uaccess.h>
35 
36 #include "mtdcore.h"
37 
38 static LIST_HEAD(blktrans_majors);
39 static DEFINE_MUTEX(blktrans_ref_mutex);
40 
41 static void blktrans_dev_release(struct kref *kref)
42 {
43 	struct mtd_blktrans_dev *dev =
44 		container_of(kref, struct mtd_blktrans_dev, ref);
45 
46 	dev->disk->private_data = NULL;
47 	blk_cleanup_queue(dev->rq);
48 	put_disk(dev->disk);
49 	list_del(&dev->list);
50 	kfree(dev);
51 }
52 
53 static struct mtd_blktrans_dev *blktrans_dev_get(struct gendisk *disk)
54 {
55 	struct mtd_blktrans_dev *dev;
56 
57 	mutex_lock(&blktrans_ref_mutex);
58 	dev = disk->private_data;
59 
60 	if (!dev)
61 		goto unlock;
62 	kref_get(&dev->ref);
63 unlock:
64 	mutex_unlock(&blktrans_ref_mutex);
65 	return dev;
66 }
67 
68 static void blktrans_dev_put(struct mtd_blktrans_dev *dev)
69 {
70 	mutex_lock(&blktrans_ref_mutex);
71 	kref_put(&dev->ref, blktrans_dev_release);
72 	mutex_unlock(&blktrans_ref_mutex);
73 }
74 
75 
76 static int do_blktrans_request(struct mtd_blktrans_ops *tr,
77 			       struct mtd_blktrans_dev *dev,
78 			       struct request *req)
79 {
80 	unsigned long block, nsect;
81 	char *buf;
82 
83 	block = blk_rq_pos(req) << 9 >> tr->blkshift;
84 	nsect = blk_rq_cur_bytes(req) >> tr->blkshift;
85 	buf = bio_data(req->bio);
86 
87 	if (req->cmd_type != REQ_TYPE_FS)
88 		return -EIO;
89 
90 	if (req->cmd_flags & REQ_FLUSH)
91 		return tr->flush(dev);
92 
93 	if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >
94 	    get_capacity(req->rq_disk))
95 		return -EIO;
96 
97 	if (req->cmd_flags & REQ_DISCARD)
98 		return tr->discard(dev, block, nsect);
99 
100 	switch(rq_data_dir(req)) {
101 	case READ:
102 		for (; nsect > 0; nsect--, block++, buf += tr->blksize)
103 			if (tr->readsect(dev, block, buf))
104 				return -EIO;
105 		rq_flush_dcache_pages(req);
106 		return 0;
107 	case WRITE:
108 		if (!tr->writesect)
109 			return -EIO;
110 
111 		rq_flush_dcache_pages(req);
112 		for (; nsect > 0; nsect--, block++, buf += tr->blksize)
113 			if (tr->writesect(dev, block, buf))
114 				return -EIO;
115 		return 0;
116 	default:
117 		printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));
118 		return -EIO;
119 	}
120 }
121 
122 int mtd_blktrans_cease_background(struct mtd_blktrans_dev *dev)
123 {
124 	return dev->bg_stop;
125 }
126 EXPORT_SYMBOL_GPL(mtd_blktrans_cease_background);
127 
128 static void mtd_blktrans_work(struct work_struct *work)
129 {
130 	struct mtd_blktrans_dev *dev =
131 		container_of(work, struct mtd_blktrans_dev, work);
132 	struct mtd_blktrans_ops *tr = dev->tr;
133 	struct request_queue *rq = dev->rq;
134 	struct request *req = NULL;
135 	int background_done = 0;
136 
137 	spin_lock_irq(rq->queue_lock);
138 
139 	while (1) {
140 		int res;
141 
142 		dev->bg_stop = false;
143 		if (!req && !(req = blk_fetch_request(rq))) {
144 			if (tr->background && !background_done) {
145 				spin_unlock_irq(rq->queue_lock);
146 				mutex_lock(&dev->lock);
147 				tr->background(dev);
148 				mutex_unlock(&dev->lock);
149 				spin_lock_irq(rq->queue_lock);
150 				/*
151 				 * Do background processing just once per idle
152 				 * period.
153 				 */
154 				background_done = !dev->bg_stop;
155 				continue;
156 			}
157 			break;
158 		}
159 
160 		spin_unlock_irq(rq->queue_lock);
161 
162 		mutex_lock(&dev->lock);
163 		res = do_blktrans_request(dev->tr, dev, req);
164 		mutex_unlock(&dev->lock);
165 
166 		spin_lock_irq(rq->queue_lock);
167 
168 		if (!__blk_end_request_cur(req, res))
169 			req = NULL;
170 
171 		background_done = 0;
172 	}
173 
174 	spin_unlock_irq(rq->queue_lock);
175 }
176 
177 static void mtd_blktrans_request(struct request_queue *rq)
178 {
179 	struct mtd_blktrans_dev *dev;
180 	struct request *req = NULL;
181 
182 	dev = rq->queuedata;
183 
184 	if (!dev)
185 		while ((req = blk_fetch_request(rq)) != NULL)
186 			__blk_end_request_all(req, -ENODEV);
187 	else
188 		queue_work(dev->wq, &dev->work);
189 }
190 
191 static int blktrans_open(struct block_device *bdev, fmode_t mode)
192 {
193 	struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
194 	int ret = 0;
195 
196 	if (!dev)
197 		return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/
198 
199 	mutex_lock(&dev->lock);
200 	mutex_lock(&mtd_table_mutex);
201 
202 	if (dev->open)
203 		goto unlock;
204 
205 	kref_get(&dev->ref);
206 	__module_get(dev->tr->owner);
207 
208 	if (!dev->mtd)
209 		goto unlock;
210 
211 	if (dev->tr->open) {
212 		ret = dev->tr->open(dev);
213 		if (ret)
214 			goto error_put;
215 	}
216 
217 	ret = __get_mtd_device(dev->mtd);
218 	if (ret)
219 		goto error_release;
220 	dev->file_mode = mode;
221 
222 unlock:
223 	dev->open++;
224 	mutex_unlock(&mtd_table_mutex);
225 	mutex_unlock(&dev->lock);
226 	blktrans_dev_put(dev);
227 	return ret;
228 
229 error_release:
230 	if (dev->tr->release)
231 		dev->tr->release(dev);
232 error_put:
233 	module_put(dev->tr->owner);
234 	kref_put(&dev->ref, blktrans_dev_release);
235 	mutex_unlock(&mtd_table_mutex);
236 	mutex_unlock(&dev->lock);
237 	blktrans_dev_put(dev);
238 	return ret;
239 }
240 
241 static void blktrans_release(struct gendisk *disk, fmode_t mode)
242 {
243 	struct mtd_blktrans_dev *dev = blktrans_dev_get(disk);
244 
245 	if (!dev)
246 		return;
247 
248 	mutex_lock(&dev->lock);
249 	mutex_lock(&mtd_table_mutex);
250 
251 	if (--dev->open)
252 		goto unlock;
253 
254 	kref_put(&dev->ref, blktrans_dev_release);
255 	module_put(dev->tr->owner);
256 
257 	if (dev->mtd) {
258 		if (dev->tr->release)
259 			dev->tr->release(dev);
260 		__put_mtd_device(dev->mtd);
261 	}
262 unlock:
263 	mutex_unlock(&mtd_table_mutex);
264 	mutex_unlock(&dev->lock);
265 	blktrans_dev_put(dev);
266 }
267 
268 static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)
269 {
270 	struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
271 	int ret = -ENXIO;
272 
273 	if (!dev)
274 		return ret;
275 
276 	mutex_lock(&dev->lock);
277 
278 	if (!dev->mtd)
279 		goto unlock;
280 
281 	ret = dev->tr->getgeo ? dev->tr->getgeo(dev, geo) : -ENOTTY;
282 unlock:
283 	mutex_unlock(&dev->lock);
284 	blktrans_dev_put(dev);
285 	return ret;
286 }
287 
288 static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,
289 			      unsigned int cmd, unsigned long arg)
290 {
291 	struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
292 	int ret = -ENXIO;
293 
294 	if (!dev)
295 		return ret;
296 
297 	mutex_lock(&dev->lock);
298 
299 	if (!dev->mtd)
300 		goto unlock;
301 
302 	switch (cmd) {
303 	case BLKFLSBUF:
304 		ret = dev->tr->flush ? dev->tr->flush(dev) : 0;
305 		break;
306 	default:
307 		ret = -ENOTTY;
308 	}
309 unlock:
310 	mutex_unlock(&dev->lock);
311 	blktrans_dev_put(dev);
312 	return ret;
313 }
314 
315 static const struct block_device_operations mtd_block_ops = {
316 	.owner		= THIS_MODULE,
317 	.open		= blktrans_open,
318 	.release	= blktrans_release,
319 	.ioctl		= blktrans_ioctl,
320 	.getgeo		= blktrans_getgeo,
321 };
322 
323 int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
324 {
325 	struct mtd_blktrans_ops *tr = new->tr;
326 	struct mtd_blktrans_dev *d;
327 	int last_devnum = -1;
328 	struct gendisk *gd;
329 	int ret;
330 
331 	if (mutex_trylock(&mtd_table_mutex)) {
332 		mutex_unlock(&mtd_table_mutex);
333 		BUG();
334 	}
335 
336 	mutex_lock(&blktrans_ref_mutex);
337 	list_for_each_entry(d, &tr->devs, list) {
338 		if (new->devnum == -1) {
339 			/* Use first free number */
340 			if (d->devnum != last_devnum+1) {
341 				/* Found a free devnum. Plug it in here */
342 				new->devnum = last_devnum+1;
343 				list_add_tail(&new->list, &d->list);
344 				goto added;
345 			}
346 		} else if (d->devnum == new->devnum) {
347 			/* Required number taken */
348 			mutex_unlock(&blktrans_ref_mutex);
349 			return -EBUSY;
350 		} else if (d->devnum > new->devnum) {
351 			/* Required number was free */
352 			list_add_tail(&new->list, &d->list);
353 			goto added;
354 		}
355 		last_devnum = d->devnum;
356 	}
357 
358 	ret = -EBUSY;
359 	if (new->devnum == -1)
360 		new->devnum = last_devnum+1;
361 
362 	/* Check that the device and any partitions will get valid
363 	 * minor numbers and that the disk naming code below can cope
364 	 * with this number. */
365 	if (new->devnum > (MINORMASK >> tr->part_bits) ||
366 	    (tr->part_bits && new->devnum >= 27 * 26)) {
367 		mutex_unlock(&blktrans_ref_mutex);
368 		goto error1;
369 	}
370 
371 	list_add_tail(&new->list, &tr->devs);
372  added:
373 	mutex_unlock(&blktrans_ref_mutex);
374 
375 	mutex_init(&new->lock);
376 	kref_init(&new->ref);
377 	if (!tr->writesect)
378 		new->readonly = 1;
379 
380 	/* Create gendisk */
381 	ret = -ENOMEM;
382 	gd = alloc_disk(1 << tr->part_bits);
383 
384 	if (!gd)
385 		goto error2;
386 
387 	new->disk = gd;
388 	gd->private_data = new;
389 	gd->major = tr->major;
390 	gd->first_minor = (new->devnum) << tr->part_bits;
391 	gd->fops = &mtd_block_ops;
392 
393 	if (tr->part_bits)
394 		if (new->devnum < 26)
395 			snprintf(gd->disk_name, sizeof(gd->disk_name),
396 				 "%s%c", tr->name, 'a' + new->devnum);
397 		else
398 			snprintf(gd->disk_name, sizeof(gd->disk_name),
399 				 "%s%c%c", tr->name,
400 				 'a' - 1 + new->devnum / 26,
401 				 'a' + new->devnum % 26);
402 	else
403 		snprintf(gd->disk_name, sizeof(gd->disk_name),
404 			 "%s%d", tr->name, new->devnum);
405 
406 	set_capacity(gd, (new->size * tr->blksize) >> 9);
407 
408 	/* Create the request queue */
409 	spin_lock_init(&new->queue_lock);
410 	new->rq = blk_init_queue(mtd_blktrans_request, &new->queue_lock);
411 
412 	if (!new->rq)
413 		goto error3;
414 
415 	if (tr->flush)
416 		blk_queue_flush(new->rq, REQ_FLUSH);
417 
418 	new->rq->queuedata = new;
419 	blk_queue_logical_block_size(new->rq, tr->blksize);
420 
421 	queue_flag_set_unlocked(QUEUE_FLAG_NONROT, new->rq);
422 	queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, new->rq);
423 
424 	if (tr->discard) {
425 		queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, new->rq);
426 		new->rq->limits.max_discard_sectors = UINT_MAX;
427 	}
428 
429 	gd->queue = new->rq;
430 
431 	/* Create processing workqueue */
432 	new->wq = alloc_workqueue("%s%d", 0, 0,
433 				  tr->name, new->mtd->index);
434 	if (!new->wq)
435 		goto error4;
436 	INIT_WORK(&new->work, mtd_blktrans_work);
437 
438 	gd->driverfs_dev = &new->mtd->dev;
439 
440 	if (new->readonly)
441 		set_disk_ro(gd, 1);
442 
443 	add_disk(gd);
444 
445 	if (new->disk_attributes) {
446 		ret = sysfs_create_group(&disk_to_dev(gd)->kobj,
447 					new->disk_attributes);
448 		WARN_ON(ret);
449 	}
450 	return 0;
451 error4:
452 	blk_cleanup_queue(new->rq);
453 error3:
454 	put_disk(new->disk);
455 error2:
456 	list_del(&new->list);
457 error1:
458 	return ret;
459 }
460 
461 int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
462 {
463 	unsigned long flags;
464 
465 	if (mutex_trylock(&mtd_table_mutex)) {
466 		mutex_unlock(&mtd_table_mutex);
467 		BUG();
468 	}
469 
470 	if (old->disk_attributes)
471 		sysfs_remove_group(&disk_to_dev(old->disk)->kobj,
472 						old->disk_attributes);
473 
474 	/* Stop new requests to arrive */
475 	del_gendisk(old->disk);
476 
477 	/* Stop workqueue. This will perform any pending request. */
478 	destroy_workqueue(old->wq);
479 
480 	/* Kill current requests */
481 	spin_lock_irqsave(&old->queue_lock, flags);
482 	old->rq->queuedata = NULL;
483 	blk_start_queue(old->rq);
484 	spin_unlock_irqrestore(&old->queue_lock, flags);
485 
486 	/* If the device is currently open, tell trans driver to close it,
487 		then put mtd device, and don't touch it again */
488 	mutex_lock(&old->lock);
489 	if (old->open) {
490 		if (old->tr->release)
491 			old->tr->release(old);
492 		__put_mtd_device(old->mtd);
493 	}
494 
495 	old->mtd = NULL;
496 
497 	mutex_unlock(&old->lock);
498 	blktrans_dev_put(old);
499 	return 0;
500 }
501 
502 static void blktrans_notify_remove(struct mtd_info *mtd)
503 {
504 	struct mtd_blktrans_ops *tr;
505 	struct mtd_blktrans_dev *dev, *next;
506 
507 	list_for_each_entry(tr, &blktrans_majors, list)
508 		list_for_each_entry_safe(dev, next, &tr->devs, list)
509 			if (dev->mtd == mtd)
510 				tr->remove_dev(dev);
511 }
512 
513 static void blktrans_notify_add(struct mtd_info *mtd)
514 {
515 	struct mtd_blktrans_ops *tr;
516 
517 	if (mtd->type == MTD_ABSENT)
518 		return;
519 
520 	list_for_each_entry(tr, &blktrans_majors, list)
521 		tr->add_mtd(tr, mtd);
522 }
523 
524 static struct mtd_notifier blktrans_notifier = {
525 	.add = blktrans_notify_add,
526 	.remove = blktrans_notify_remove,
527 };
528 
529 int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
530 {
531 	struct mtd_info *mtd;
532 	int ret;
533 
534 	/* Register the notifier if/when the first device type is
535 	   registered, to prevent the link/init ordering from fucking
536 	   us over. */
537 	if (!blktrans_notifier.list.next)
538 		register_mtd_user(&blktrans_notifier);
539 
540 
541 	mutex_lock(&mtd_table_mutex);
542 
543 	ret = register_blkdev(tr->major, tr->name);
544 	if (ret < 0) {
545 		printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
546 		       tr->name, tr->major, ret);
547 		mutex_unlock(&mtd_table_mutex);
548 		return ret;
549 	}
550 
551 	if (ret)
552 		tr->major = ret;
553 
554 	tr->blkshift = ffs(tr->blksize) - 1;
555 
556 	INIT_LIST_HEAD(&tr->devs);
557 	list_add(&tr->list, &blktrans_majors);
558 
559 	mtd_for_each_device(mtd)
560 		if (mtd->type != MTD_ABSENT)
561 			tr->add_mtd(tr, mtd);
562 
563 	mutex_unlock(&mtd_table_mutex);
564 	return 0;
565 }
566 
567 int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
568 {
569 	struct mtd_blktrans_dev *dev, *next;
570 
571 	mutex_lock(&mtd_table_mutex);
572 
573 	/* Remove it from the list of active majors */
574 	list_del(&tr->list);
575 
576 	list_for_each_entry_safe(dev, next, &tr->devs, list)
577 		tr->remove_dev(dev);
578 
579 	unregister_blkdev(tr->major, tr->name);
580 	mutex_unlock(&mtd_table_mutex);
581 
582 	BUG_ON(!list_empty(&tr->devs));
583 	return 0;
584 }
585 
586 static void __exit mtd_blktrans_exit(void)
587 {
588 	/* No race here -- if someone's currently in register_mtd_blktrans
589 	   we're screwed anyway. */
590 	if (blktrans_notifier.list.next)
591 		unregister_mtd_user(&blktrans_notifier);
592 }
593 
594 module_exit(mtd_blktrans_exit);
595 
596 EXPORT_SYMBOL_GPL(register_mtd_blktrans);
597 EXPORT_SYMBOL_GPL(deregister_mtd_blktrans);
598 EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev);
599 EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev);
600 
601 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
602 MODULE_LICENSE("GPL");
603 MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");
604