blob: cb20c67995d8ba52652d8765b80dbceb82eba2b8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
David Woodhousea1452a32010-08-08 20:58:20 +01002 * Interface to Linux block layer for MTD 'translation layers'.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
David Woodhousea1452a32010-08-08 20:58:20 +01004 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 *
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/init.h>
Ingo Molnar48b19262006-03-31 02:29:41 -080034#include <linux/mutex.h>
Eric W. Biederman99f9b242007-04-19 01:58:33 -060035#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Ben Dooks356d70f2007-05-28 20:28:34 +010038#include "mtdcore.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Ben Dooks356d70f2007-05-28 20:28:34 +010040static LIST_HEAD(blktrans_majors);
Maxim Levitsky048d8712010-02-22 20:39:30 +020041static DEFINE_MUTEX(blktrans_ref_mutex);
42
43void blktrans_dev_release(struct kref *kref)
44{
45 struct mtd_blktrans_dev *dev =
46 container_of(kref, struct mtd_blktrans_dev, ref);
47
48 dev->disk->private_data = NULL;
Maxim Levitskye4d64ca2010-02-27 02:31:51 +020049 blk_cleanup_queue(dev->rq);
Maxim Levitsky048d8712010-02-22 20:39:30 +020050 put_disk(dev->disk);
51 list_del(&dev->list);
52 kfree(dev);
53}
54
55static struct mtd_blktrans_dev *blktrans_dev_get(struct gendisk *disk)
56{
57 struct mtd_blktrans_dev *dev;
58
59 mutex_lock(&blktrans_ref_mutex);
60 dev = disk->private_data;
61
62 if (!dev)
63 goto unlock;
64 kref_get(&dev->ref);
65unlock:
66 mutex_unlock(&blktrans_ref_mutex);
67 return dev;
68}
69
70void blktrans_dev_put(struct mtd_blktrans_dev *dev)
71{
72 mutex_lock(&blktrans_ref_mutex);
73 kref_put(&dev->ref, blktrans_dev_release);
74 mutex_unlock(&blktrans_ref_mutex);
75}
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78static int do_blktrans_request(struct mtd_blktrans_ops *tr,
79 struct mtd_blktrans_dev *dev,
80 struct request *req)
81{
82 unsigned long block, nsect;
83 char *buf;
84
Tejun Heo83096eb2009-05-07 22:24:39 +090085 block = blk_rq_pos(req) << 9 >> tr->blkshift;
Tejun Heo1011c1b2009-05-07 22:24:45 +090086 nsect = blk_rq_cur_bytes(req) >> tr->blkshift;
Richard Purdie19187672006-10-27 09:09:33 +010087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 buf = req->buffer;
89
Christoph Hellwig33659eb2010-08-07 18:17:56 +020090 if (req->cmd_type != REQ_TYPE_FS)
Tejun Heof06d9a22009-04-23 11:05:19 +090091 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Tejun Heo83096eb2009-05-07 22:24:39 +090093 if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >
94 get_capacity(req->rq_disk))
Tejun Heof06d9a22009-04-23 11:05:19 +090095 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Christoph Hellwig33659eb2010-08-07 18:17:56 +020097 if (req->cmd_flags & REQ_DISCARD)
Christoph Hellwig1122a262009-09-30 13:52:12 +020098 return tr->discard(dev, block, nsect);
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 switch(rq_data_dir(req)) {
101 case READ:
Richard Purdie19187672006-10-27 09:09:33 +0100102 for (; nsect > 0; nsect--, block++, buf += tr->blksize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 if (tr->readsect(dev, block, buf))
Tejun Heof06d9a22009-04-23 11:05:19 +0900104 return -EIO;
Ilya Loginov2d4dc892009-11-26 09:16:19 +0100105 rq_flush_dcache_pages(req);
Tejun Heof06d9a22009-04-23 11:05:19 +0900106 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 case WRITE:
108 if (!tr->writesect)
Tejun Heof06d9a22009-04-23 11:05:19 +0900109 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Ilya Loginov2d4dc892009-11-26 09:16:19 +0100111 rq_flush_dcache_pages(req);
Richard Purdie19187672006-10-27 09:09:33 +0100112 for (; nsect > 0; nsect--, block++, buf += tr->blksize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 if (tr->writesect(dev, block, buf))
Tejun Heof06d9a22009-04-23 11:05:19 +0900114 return -EIO;
115 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 default:
Jeff Garzik9a292302006-10-01 12:16:00 -0400117 printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));
Tejun Heof06d9a22009-04-23 11:05:19 +0900118 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 }
120}
121
122static int mtd_blktrans_thread(void *arg)
123{
Maxim Levitskya8638622010-02-22 20:39:29 +0200124 struct mtd_blktrans_dev *dev = arg;
125 struct request_queue *rq = dev->rq;
Tejun Heo1498ada2009-05-08 11:54:11 +0900126 struct request *req = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 spin_lock_irq(rq->queue_lock);
Tejun Heo1498ada2009-05-08 11:54:11 +0900129
Christoph Hellwig3e67fe42007-04-22 20:40:57 +0100130 while (!kthread_should_stop()) {
Tejun Heof06d9a22009-04-23 11:05:19 +0900131 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Tejun Heo9934c8c2009-05-08 11:54:16 +0900133 if (!req && !(req = blk_fetch_request(rq))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 set_current_state(TASK_INTERRUPTIBLE);
Maxim Levitsky12aebf32010-10-15 17:20:45 +0200135
136 if (kthread_should_stop())
137 set_current_state(TASK_RUNNING);
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 spin_unlock_irq(rq->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 schedule();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 spin_lock_irq(rq->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 continue;
143 }
144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 spin_unlock_irq(rq->queue_lock);
146
Ingo Molnar48b19262006-03-31 02:29:41 -0800147 mutex_lock(&dev->lock);
Maxim Levitskya8638622010-02-22 20:39:29 +0200148 res = do_blktrans_request(dev->tr, dev, req);
Ingo Molnar48b19262006-03-31 02:29:41 -0800149 mutex_unlock(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151 spin_lock_irq(rq->queue_lock);
152
Tejun Heo1498ada2009-05-08 11:54:11 +0900153 if (!__blk_end_request_cur(req, res))
154 req = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 }
Tejun Heo1498ada2009-05-08 11:54:11 +0900156
157 if (req)
158 __blk_end_request_all(req, -EIO);
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 spin_unlock_irq(rq->queue_lock);
161
Christoph Hellwig3e67fe42007-04-22 20:40:57 +0100162 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
165static void mtd_blktrans_request(struct request_queue *rq)
166{
Maxim Levitsky048d8712010-02-22 20:39:30 +0200167 struct mtd_blktrans_dev *dev;
168 struct request *req = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
Maxim Levitsky048d8712010-02-22 20:39:30 +0200170 dev = rq->queuedata;
171
172 if (!dev)
173 while ((req = blk_fetch_request(rq)) != NULL)
174 __blk_end_request_all(req, -ENODEV);
175 else
176 wake_up_process(dev->thread);
177}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Al Viroaf0e2a02008-03-02 10:35:06 -0500179static int blktrans_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
Maxim Levitsky048d8712010-02-22 20:39:30 +0200181 struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
Maxim Levitsky008c7512010-10-15 17:20:43 +0200182 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Maxim Levitsky048d8712010-02-22 20:39:30 +0200184 if (!dev)
Arnd Bergmann6e9624b2010-08-07 18:25:34 +0200185 return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Maxim Levitsky048d8712010-02-22 20:39:30 +0200187 mutex_lock(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Maxim Levitsky008c7512010-10-15 17:20:43 +0200189 if (dev->open++)
Maxim Levitsky048d8712010-02-22 20:39:30 +0200190 goto unlock;
Maxim Levitsky008c7512010-10-15 17:20:43 +0200191
192 kref_get(&dev->ref);
193 __module_get(dev->tr->owner);
194
195 if (dev->mtd) {
196 ret = dev->tr->open ? dev->tr->open(dev) : 0;
197 __get_mtd_device(dev->mtd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 }
Maxim Levitsky048d8712010-02-22 20:39:30 +0200199
Maxim Levitsky048d8712010-02-22 20:39:30 +0200200unlock:
201 mutex_unlock(&dev->lock);
202 blktrans_dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 return ret;
204}
205
Al Viroaf0e2a02008-03-02 10:35:06 -0500206static int blktrans_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
Maxim Levitsky048d8712010-02-22 20:39:30 +0200208 struct mtd_blktrans_dev *dev = blktrans_dev_get(disk);
Maxim Levitsky008c7512010-10-15 17:20:43 +0200209 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Maxim Levitsky048d8712010-02-22 20:39:30 +0200211 if (!dev)
212 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Maxim Levitsky048d8712010-02-22 20:39:30 +0200214 mutex_lock(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Maxim Levitsky008c7512010-10-15 17:20:43 +0200216 if (--dev->open)
Maxim Levitsky048d8712010-02-22 20:39:30 +0200217 goto unlock;
218
Maxim Levitsky008c7512010-10-15 17:20:43 +0200219 kref_put(&dev->ref, blktrans_dev_release);
220 module_put(dev->tr->owner);
221
222 if (dev->mtd) {
223 ret = dev->tr->release ? dev->tr->release(dev) : 0;
224 __put_mtd_device(dev->mtd);
225 }
Maxim Levitsky048d8712010-02-22 20:39:30 +0200226unlock:
227 mutex_unlock(&dev->lock);
228 blktrans_dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return ret;
230}
231
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800232static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)
233{
Maxim Levitsky048d8712010-02-22 20:39:30 +0200234 struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
235 int ret = -ENXIO;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800236
Maxim Levitsky048d8712010-02-22 20:39:30 +0200237 if (!dev)
238 return ret;
239
240 mutex_lock(&dev->lock);
241
242 if (!dev->mtd)
243 goto unlock;
244
245 ret = dev->tr->getgeo ? dev->tr->getgeo(dev, geo) : 0;
246unlock:
247 mutex_unlock(&dev->lock);
248 blktrans_dev_put(dev);
249 return ret;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800250}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Al Viroaf0e2a02008-03-02 10:35:06 -0500252static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 unsigned int cmd, unsigned long arg)
254{
Maxim Levitsky048d8712010-02-22 20:39:30 +0200255 struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
256 int ret = -ENXIO;
257
258 if (!dev)
259 return ret;
260
261 mutex_lock(&dev->lock);
262
263 if (!dev->mtd)
264 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 switch (cmd) {
267 case BLKFLSBUF:
Maxim Levitsky048d8712010-02-22 20:39:30 +0200268 ret = dev->tr->flush ? dev->tr->flush(dev) : 0;
Dan Carpenter007c2d82010-05-31 16:03:38 +0200269 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 default:
Maxim Levitsky048d8712010-02-22 20:39:30 +0200271 ret = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 }
Maxim Levitsky048d8712010-02-22 20:39:30 +0200273unlock:
274 mutex_unlock(&dev->lock);
275 blktrans_dev_put(dev);
276 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277}
278
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -0700279static const struct block_device_operations mtd_blktrans_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 .owner = THIS_MODULE,
Al Viroaf0e2a02008-03-02 10:35:06 -0500281 .open = blktrans_open,
282 .release = blktrans_release,
Arnd Bergmann8a6cfeb2010-07-08 10:18:46 +0200283 .ioctl = blktrans_ioctl,
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800284 .getgeo = blktrans_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285};
286
287int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
288{
289 struct mtd_blktrans_ops *tr = new->tr;
Chris Malley71a928c2008-05-19 20:11:50 +0100290 struct mtd_blktrans_dev *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 int last_devnum = -1;
292 struct gendisk *gd;
Maxim Levitskya8638622010-02-22 20:39:29 +0200293 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Jean Delvareb3561ea2007-05-08 00:30:46 -0700295 if (mutex_trylock(&mtd_table_mutex)) {
Ingo Molnar48b19262006-03-31 02:29:41 -0800296 mutex_unlock(&mtd_table_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 BUG();
298 }
299
Maxim Levitsky048d8712010-02-22 20:39:30 +0200300 mutex_lock(&blktrans_ref_mutex);
Chris Malley71a928c2008-05-19 20:11:50 +0100301 list_for_each_entry(d, &tr->devs, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 if (new->devnum == -1) {
303 /* Use first free number */
304 if (d->devnum != last_devnum+1) {
305 /* Found a free devnum. Plug it in here */
306 new->devnum = last_devnum+1;
307 list_add_tail(&new->list, &d->list);
308 goto added;
309 }
310 } else if (d->devnum == new->devnum) {
311 /* Required number taken */
Maxim Levitsky048d8712010-02-22 20:39:30 +0200312 mutex_unlock(&blktrans_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 return -EBUSY;
314 } else if (d->devnum > new->devnum) {
315 /* Required number was free */
316 list_add_tail(&new->list, &d->list);
317 goto added;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000318 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 last_devnum = d->devnum;
320 }
Maxim Levitskya8638622010-02-22 20:39:29 +0200321
322 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 if (new->devnum == -1)
324 new->devnum = last_devnum+1;
325
Ben Hutchings4d3a8532010-01-29 20:59:53 +0000326 /* Check that the device and any partitions will get valid
327 * minor numbers and that the disk naming code below can cope
328 * with this number. */
329 if (new->devnum > (MINORMASK >> tr->part_bits) ||
Maxim Levitsky048d8712010-02-22 20:39:30 +0200330 (tr->part_bits && new->devnum >= 27 * 26)) {
331 mutex_unlock(&blktrans_ref_mutex);
Maxim Levitskya8638622010-02-22 20:39:29 +0200332 goto error1;
Maxim Levitsky048d8712010-02-22 20:39:30 +0200333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 list_add_tail(&new->list, &tr->devs);
336 added:
Maxim Levitsky048d8712010-02-22 20:39:30 +0200337 mutex_unlock(&blktrans_ref_mutex);
338
David Woodhousece37ab42007-12-03 12:46:12 +0000339 mutex_init(&new->lock);
Maxim Levitsky048d8712010-02-22 20:39:30 +0200340 kref_init(&new->ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 if (!tr->writesect)
342 new->readonly = 1;
343
Maxim Levitskya8638622010-02-22 20:39:29 +0200344 /* Create gendisk */
345 ret = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 gd = alloc_disk(1 << tr->part_bits);
Maxim Levitskya8638622010-02-22 20:39:29 +0200347
348 if (!gd)
349 goto error2;
350
351 new->disk = gd;
352 gd->private_data = new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 gd->major = tr->major;
354 gd->first_minor = (new->devnum) << tr->part_bits;
355 gd->fops = &mtd_blktrans_ops;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000356
Todd Poynor65a8de32005-07-29 20:42:07 +0100357 if (tr->part_bits)
358 if (new->devnum < 26)
359 snprintf(gd->disk_name, sizeof(gd->disk_name),
360 "%s%c", tr->name, 'a' + new->devnum);
361 else
362 snprintf(gd->disk_name, sizeof(gd->disk_name),
363 "%s%c%c", tr->name,
364 'a' - 1 + new->devnum / 26,
365 'a' + new->devnum % 26);
366 else
367 snprintf(gd->disk_name, sizeof(gd->disk_name),
368 "%s%d", tr->name, new->devnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Richard Purdie19187672006-10-27 09:09:33 +0100370 set_capacity(gd, (new->size * tr->blksize) >> 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
Maxim Levitskya8638622010-02-22 20:39:29 +0200372 /* Create the request queue */
373 spin_lock_init(&new->queue_lock);
374 new->rq = blk_init_queue(mtd_blktrans_request, &new->queue_lock);
375
376 if (!new->rq)
377 goto error3;
378
379 new->rq->queuedata = new;
380 blk_queue_logical_block_size(new->rq, tr->blksize);
381
382 if (tr->discard)
383 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
384 new->rq);
385
386 gd->queue = new->rq;
387
388 /* Create processing thread */
389 /* TODO: workqueue ? */
390 new->thread = kthread_run(mtd_blktrans_thread, new,
391 "%s%d", tr->name, new->mtd->index);
392 if (IS_ERR(new->thread)) {
393 ret = PTR_ERR(new->thread);
394 goto error4;
395 }
David Woodhoused6948462009-04-05 07:38:33 -0700396 gd->driverfs_dev = &new->mtd->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398 if (new->readonly)
399 set_disk_ro(gd, 1);
400
401 add_disk(gd);
Maxim Levitsky026ec572010-02-22 20:39:33 +0200402
Maxim Levitsky133fa8c2010-02-26 22:08:40 +0200403 if (new->disk_attributes) {
404 ret = sysfs_create_group(&disk_to_dev(gd)->kobj,
Maxim Levitsky026ec572010-02-22 20:39:33 +0200405 new->disk_attributes);
Maxim Levitsky133fa8c2010-02-26 22:08:40 +0200406 WARN_ON(ret);
407 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 return 0;
Maxim Levitskya8638622010-02-22 20:39:29 +0200409error4:
410 blk_cleanup_queue(new->rq);
411error3:
412 put_disk(new->disk);
413error2:
414 list_del(&new->list);
415error1:
416 kfree(new);
417 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418}
419
420int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
421{
Maxim Levitsky048d8712010-02-22 20:39:30 +0200422 unsigned long flags;
423
Jean Delvareb3561ea2007-05-08 00:30:46 -0700424 if (mutex_trylock(&mtd_table_mutex)) {
Ingo Molnar48b19262006-03-31 02:29:41 -0800425 mutex_unlock(&mtd_table_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 BUG();
427 }
428
Maxim Levitsky026ec572010-02-22 20:39:33 +0200429 if (old->disk_attributes)
430 sysfs_remove_group(&disk_to_dev(old->disk)->kobj,
431 old->disk_attributes);
432
Maxim Levitskydba76c02010-07-28 18:53:16 +0300433 /* Stop new requests to arrive */
434 del_gendisk(old->disk);
435
436
Maxim Levitskya8638622010-02-22 20:39:29 +0200437 /* Stop the thread */
438 kthread_stop(old->thread);
439
Maxim Levitsky048d8712010-02-22 20:39:30 +0200440 /* Kill current requests */
441 spin_lock_irqsave(&old->queue_lock, flags);
442 old->rq->queuedata = NULL;
443 blk_start_queue(old->rq);
444 spin_unlock_irqrestore(&old->queue_lock, flags);
Maxim Levitsky048d8712010-02-22 20:39:30 +0200445
Maxim Levitsky008c7512010-10-15 17:20:43 +0200446 /* If the device is currently open, tell trans driver to close it,
447 then put mtd device, and don't touch it again */
Maxim Levitsky048d8712010-02-22 20:39:30 +0200448 mutex_lock(&old->lock);
Maxim Levitsky008c7512010-10-15 17:20:43 +0200449 if (old->open) {
450 if (old->tr->release)
451 old->tr->release(old);
452 __put_mtd_device(old->mtd);
Maxim Levitsky048d8712010-02-22 20:39:30 +0200453 }
454
Maxim Levitsky048d8712010-02-22 20:39:30 +0200455 old->mtd = NULL;
456
457 mutex_unlock(&old->lock);
458 blktrans_dev_put(old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return 0;
460}
461
462static void blktrans_notify_remove(struct mtd_info *mtd)
463{
Chris Malley71a928c2008-05-19 20:11:50 +0100464 struct mtd_blktrans_ops *tr;
465 struct mtd_blktrans_dev *dev, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Chris Malley71a928c2008-05-19 20:11:50 +0100467 list_for_each_entry(tr, &blktrans_majors, list)
468 list_for_each_entry_safe(dev, next, &tr->devs, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 if (dev->mtd == mtd)
470 tr->remove_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471}
472
473static void blktrans_notify_add(struct mtd_info *mtd)
474{
Chris Malley71a928c2008-05-19 20:11:50 +0100475 struct mtd_blktrans_ops *tr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
477 if (mtd->type == MTD_ABSENT)
478 return;
479
Chris Malley71a928c2008-05-19 20:11:50 +0100480 list_for_each_entry(tr, &blktrans_majors, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 tr->add_mtd(tr, mtd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482}
483
484static struct mtd_notifier blktrans_notifier = {
485 .add = blktrans_notify_add,
486 .remove = blktrans_notify_remove,
487};
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
490{
Ben Hutchingsf1332ba2010-01-29 20:57:11 +0000491 struct mtd_info *mtd;
492 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000494 /* Register the notifier if/when the first device type is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 registered, to prevent the link/init ordering from fucking
496 us over. */
497 if (!blktrans_notifier.list.next)
498 register_mtd_user(&blktrans_notifier);
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Ingo Molnar48b19262006-03-31 02:29:41 -0800501 mutex_lock(&mtd_table_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503 ret = register_blkdev(tr->major, tr->name);
Frank Li6fe4c592010-10-26 11:02:19 +0800504 if (ret < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
506 tr->name, tr->major, ret);
Ingo Molnar48b19262006-03-31 02:29:41 -0800507 mutex_unlock(&mtd_table_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 return ret;
509 }
David Woodhouseeae9acd2008-08-05 18:08:25 +0100510
Frank Li6fe4c592010-10-26 11:02:19 +0800511 if (ret)
512 tr->major = ret;
513
Richard Purdie19187672006-10-27 09:09:33 +0100514 tr->blkshift = ffs(tr->blksize) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 INIT_LIST_HEAD(&tr->devs);
517 list_add(&tr->list, &blktrans_majors);
518
Ben Hutchingsf1332ba2010-01-29 20:57:11 +0000519 mtd_for_each_device(mtd)
520 if (mtd->type != MTD_ABSENT)
521 tr->add_mtd(tr, mtd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Ingo Molnar48b19262006-03-31 02:29:41 -0800523 mutex_unlock(&mtd_table_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return 0;
525}
526
527int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
528{
Chris Malley71a928c2008-05-19 20:11:50 +0100529 struct mtd_blktrans_dev *dev, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Ingo Molnar48b19262006-03-31 02:29:41 -0800531 mutex_lock(&mtd_table_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 /* Remove it from the list of active majors */
534 list_del(&tr->list);
535
Chris Malley71a928c2008-05-19 20:11:50 +0100536 list_for_each_entry_safe(dev, next, &tr->devs, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 tr->remove_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 unregister_blkdev(tr->major, tr->name);
Ingo Molnar48b19262006-03-31 02:29:41 -0800540 mutex_unlock(&mtd_table_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Eric Sesterhenn373ebfb2006-03-26 18:15:12 +0200542 BUG_ON(!list_empty(&tr->devs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 return 0;
544}
545
546static void __exit mtd_blktrans_exit(void)
547{
548 /* No race here -- if someone's currently in register_mtd_blktrans
549 we're screwed anyway. */
550 if (blktrans_notifier.list.next)
551 unregister_mtd_user(&blktrans_notifier);
552}
553
554module_exit(mtd_blktrans_exit);
555
556EXPORT_SYMBOL_GPL(register_mtd_blktrans);
557EXPORT_SYMBOL_GPL(deregister_mtd_blktrans);
558EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev);
559EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev);
560
561MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
562MODULE_LICENSE("GPL");
563MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");