URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mtd/] [mtdblock.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * Direct MTD block device access
 *
 * $Id: mtdblock.c,v 1.68 2005/11/07 11:14:20 gleixner Exp $
 *
 * (C) 2000-2003 Nicolas Pitre <nico@cam.org>
 * (C) 1999-2003 David Woodhouse <dwmw2@infradead.org>
 */
 
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/vmalloc.h>
 
#include <linux/mtd/mtd.h>
#include <linux/mtd/blktrans.h>
#include <linux/mutex.h>
 
 
static struct mtdblk_dev {
        struct mtd_info *mtd;
        int count;
        struct mutex cache_mutex;
        unsigned char *cache_data;
        unsigned long cache_offset;
        unsigned int cache_size;
        enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state;
} *mtdblks[MAX_MTD_DEVICES];
 
/*
 * Cache stuff...
 *
 * Since typical flash erasable sectors are much larger than what Linux's
 * buffer cache can handle, we must implement read-modify-write on flash
 * sectors for each block write requests.  To avoid over-erasing flash sectors
 * and to speed things up, we locally cache a whole flash sector while it is
 * being written to until a different sector is required.
 */
 
static void erase_callback(struct erase_info *done)
{
        wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
        wake_up(wait_q);
}
 
static int erase_write (struct mtd_info *mtd, unsigned long pos,
                        int len, const char *buf)
{
        struct erase_info erase;
        DECLARE_WAITQUEUE(wait, current);
        wait_queue_head_t wait_q;
        size_t retlen;
        int ret;
 
        /*
         * First, let's erase the flash block.
         */
 
        init_waitqueue_head(&wait_q);
        erase.mtd = mtd;
        erase.callback = erase_callback;
        erase.addr = pos;
        erase.len = len;
        erase.priv = (u_long)&wait_q;
 
        set_current_state(TASK_INTERRUPTIBLE);
        add_wait_queue(&wait_q, &wait);
 
        ret = mtd->erase(mtd, &erase);
        if (ret) {
                set_current_state(TASK_RUNNING);
                remove_wait_queue(&wait_q, &wait);
                printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] "
                                     "on \"%s\" failed\n",
                        pos, len, mtd->name);
                return ret;
        }
 
        schedule();  /* Wait for erase to finish. */
        remove_wait_queue(&wait_q, &wait);
 
        /*
         * Next, writhe data to flash.
         */
 
        ret = mtd->write(mtd, pos, len, &retlen, buf);
        if (ret)
                return ret;
        if (retlen != len)
                return -EIO;
        return 0;
}
 
 
static int write_cached_data (struct mtdblk_dev *mtdblk)
{
        struct mtd_info *mtd = mtdblk->mtd;
        int ret;
 
        if (mtdblk->cache_state != STATE_DIRTY)
                return 0;
 
        DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: writing cached data for \"%s\" "
                        "at 0x%lx, size 0x%x\n", mtd->name,
                        mtdblk->cache_offset, mtdblk->cache_size);
 
        ret = erase_write (mtd, mtdblk->cache_offset,
                           mtdblk->cache_size, mtdblk->cache_data);
        if (ret)
                return ret;
 
        /*
         * Here we could argubly set the cache state to STATE_CLEAN.
         * However this could lead to inconsistency since we will not
         * be notified if this content is altered on the flash by other
         * means.  Let's declare it empty and leave buffering tasks to
         * the buffer cache instead.
         */
        mtdblk->cache_state = STATE_EMPTY;
        return 0;
}
 
 
static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,
                            int len, const char *buf)
{
        struct mtd_info *mtd = mtdblk->mtd;
        unsigned int sect_size = mtdblk->cache_size;
        size_t retlen;
        int ret;
 
        DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: write on \"%s\" at 0x%lx, size 0x%x\n",
                mtd->name, pos, len);
 
        if (!sect_size)
                return mtd->write(mtd, pos, len, &retlen, buf);
 
        while (len > 0) {
                unsigned long sect_start = (pos/sect_size)*sect_size;
                unsigned int offset = pos - sect_start;
                unsigned int size = sect_size - offset;
                if( size > len )
                        size = len;
 
                if (size == sect_size) {
                        /*
                         * We are covering a whole sector.  Thus there is no
                         * need to bother with the cache while it may still be
                         * useful for other partial writes.
                         */
                        ret = erase_write (mtd, pos, size, buf);
                        if (ret)
                                return ret;
                } else {
                        /* Partial sector: need to use the cache */
 
                        if (mtdblk->cache_state == STATE_DIRTY &&
                            mtdblk->cache_offset != sect_start) {
                                ret = write_cached_data(mtdblk);
                                if (ret)
                                        return ret;
                        }
 
                        if (mtdblk->cache_state == STATE_EMPTY ||
                            mtdblk->cache_offset != sect_start) {
                                /* fill the cache with the current sector */
                                mtdblk->cache_state = STATE_EMPTY;
                                ret = mtd->read(mtd, sect_start, sect_size,
                                                &retlen, mtdblk->cache_data);
                                if (ret)
                                        return ret;
                                if (retlen != sect_size)
                                        return -EIO;
 
                                mtdblk->cache_offset = sect_start;
                                mtdblk->cache_size = sect_size;
                                mtdblk->cache_state = STATE_CLEAN;
                        }
 
                        /* write data to our local cache */
                        memcpy (mtdblk->cache_data + offset, buf, size);
                        mtdblk->cache_state = STATE_DIRTY;
                }
 
                buf += size;
                pos += size;
                len -= size;
        }
 
        return 0;
}
 
 
static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
                           int len, char *buf)
{
        struct mtd_info *mtd = mtdblk->mtd;
        unsigned int sect_size = mtdblk->cache_size;
        size_t retlen;
        int ret;
 
        DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n",
                        mtd->name, pos, len);
 
        if (!sect_size)
                return mtd->read(mtd, pos, len, &retlen, buf);
 
        while (len > 0) {
                unsigned long sect_start = (pos/sect_size)*sect_size;
                unsigned int offset = pos - sect_start;
                unsigned int size = sect_size - offset;
                if (size > len)
                        size = len;
 
                /*
                 * Check if the requested data is already cached
                 * Read the requested amount of data from our internal cache if it
                 * contains what we want, otherwise we read the data directly
                 * from flash.
                 */
                if (mtdblk->cache_state != STATE_EMPTY &&
                    mtdblk->cache_offset == sect_start) {
                        memcpy (buf, mtdblk->cache_data + offset, size);
                } else {
                        ret = mtd->read(mtd, pos, size, &retlen, buf);
                        if (ret)
                                return ret;
                        if (retlen != size)
                                return -EIO;
                }
 
                buf += size;
                pos += size;
                len -= size;
        }
 
        return 0;
}
 
static int mtdblock_readsect(struct mtd_blktrans_dev *dev,
                              unsigned long block, char *buf)
{
        struct mtdblk_dev *mtdblk = mtdblks[dev->devnum];
        return do_cached_read(mtdblk, block<<9, 512, buf);
}
 
static int mtdblock_writesect(struct mtd_blktrans_dev *dev,
                              unsigned long block, char *buf)
{
        struct mtdblk_dev *mtdblk = mtdblks[dev->devnum];
        if (unlikely(!mtdblk->cache_data && mtdblk->cache_size)) {
                mtdblk->cache_data = vmalloc(mtdblk->mtd->erasesize);
                if (!mtdblk->cache_data)
                        return -EINTR;
                /* -EINTR is not really correct, but it is the best match
                 * documented in man 2 write for all cases.  We could also
                 * return -EAGAIN sometimes, but why bother?
                 */
        }
        return do_cached_write(mtdblk, block<<9, 512, buf);
}
 
static int mtdblock_open(struct mtd_blktrans_dev *mbd)
{
        struct mtdblk_dev *mtdblk;
        struct mtd_info *mtd = mbd->mtd;
        int dev = mbd->devnum;
 
        DEBUG(MTD_DEBUG_LEVEL1,"mtdblock_open\n");
 
        if (mtdblks[dev]) {
                mtdblks[dev]->count++;
                return 0;
        }
 
        /* OK, it's not open. Create cache info for it */
        mtdblk = kzalloc(sizeof(struct mtdblk_dev), GFP_KERNEL);
        if (!mtdblk)
                return -ENOMEM;
 
        mtdblk->count = 1;
        mtdblk->mtd = mtd;
 
        mutex_init(&mtdblk->cache_mutex);
        mtdblk->cache_state = STATE_EMPTY;
        if ( !(mtdblk->mtd->flags & MTD_NO_ERASE) && mtdblk->mtd->erasesize) {
                mtdblk->cache_size = mtdblk->mtd->erasesize;
                mtdblk->cache_data = NULL;
        }
 
        mtdblks[dev] = mtdblk;
 
        DEBUG(MTD_DEBUG_LEVEL1, "ok\n");
 
        return 0;
}
 
static int mtdblock_release(struct mtd_blktrans_dev *mbd)
{
        int dev = mbd->devnum;
        struct mtdblk_dev *mtdblk = mtdblks[dev];
 
        DEBUG(MTD_DEBUG_LEVEL1, "mtdblock_release\n");
 
        mutex_lock(&mtdblk->cache_mutex);
        write_cached_data(mtdblk);
        mutex_unlock(&mtdblk->cache_mutex);
 
        if (!--mtdblk->count) {
                /* It was the last usage. Free the device */
                mtdblks[dev] = NULL;
                if (mtdblk->mtd->sync)
                        mtdblk->mtd->sync(mtdblk->mtd);
                vfree(mtdblk->cache_data);
                kfree(mtdblk);
        }
        DEBUG(MTD_DEBUG_LEVEL1, "ok\n");
 
        return 0;
}
 
static int mtdblock_flush(struct mtd_blktrans_dev *dev)
{
        struct mtdblk_dev *mtdblk = mtdblks[dev->devnum];
 
        mutex_lock(&mtdblk->cache_mutex);
        write_cached_data(mtdblk);
        mutex_unlock(&mtdblk->cache_mutex);
 
        if (mtdblk->mtd->sync)
                mtdblk->mtd->sync(mtdblk->mtd);
        return 0;
}
 
static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
{
        struct mtd_blktrans_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 
        if (!dev)
                return;
 
        dev->mtd = mtd;
        dev->devnum = mtd->index;
 
        dev->size = mtd->size >> 9;
        dev->tr = tr;
 
        if (!(mtd->flags & MTD_WRITEABLE))
                dev->readonly = 1;
 
        add_mtd_blktrans_dev(dev);
}
 
static void mtdblock_remove_dev(struct mtd_blktrans_dev *dev)
{
        del_mtd_blktrans_dev(dev);
        kfree(dev);
}
 
static struct mtd_blktrans_ops mtdblock_tr = {
        .name           = "mtdblock",
        .major          = 31,
        .part_bits      = 0,
        .blksize        = 512,
        .open           = mtdblock_open,
        .flush          = mtdblock_flush,
        .release        = mtdblock_release,
        .readsect       = mtdblock_readsect,
        .writesect      = mtdblock_writesect,
        .add_mtd        = mtdblock_add_mtd,
        .remove_dev     = mtdblock_remove_dev,
        .owner          = THIS_MODULE,
};
 
static int __init init_mtdblock(void)
{
        return register_mtd_blktrans(&mtdblock_tr);
}
 
static void __exit cleanup_mtdblock(void)
{
        deregister_mtd_blktrans(&mtdblock_tr);
}
 
module_init(init_mtdblock);
module_exit(cleanup_mtdblock);
 
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Nicolas Pitre <nico@cam.org> et al.");
MODULE_DESCRIPTION("Caching read/erase/writeback block device emulation access to MTD devices");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mtd/] [mtdblock.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* Direct MTD block device access`
3			`*`
4			`* $Id: mtdblock.c,v 1.68 2005/11/07 11:14:20 gleixner Exp $`
5			`*`
6			`* (C) 2000-2003 Nicolas Pitre <nico@cam.org>`
7			`* (C) 1999-2003 David Woodhouse <dwmw2@infradead.org>`
8			`*/`
9
10			`#include <linux/fs.h>`
11			`#include <linux/init.h>`
12			`#include <linux/kernel.h>`
13			`#include <linux/module.h>`
14			`#include <linux/sched.h>`
15			`#include <linux/slab.h>`
16			`#include <linux/types.h>`
17			`#include <linux/vmalloc.h>`
18
19			`#include <linux/mtd/mtd.h>`
20			`#include <linux/mtd/blktrans.h>`
21			`#include <linux/mutex.h>`
22
23
24			`static struct mtdblk_dev {`
25			`struct mtd_info *mtd;`
26			`int count;`
27			`struct mutex cache_mutex;`
28			`unsigned char *cache_data;`
29			`unsigned long cache_offset;`
30			`unsigned int cache_size;`
31			`enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state;`
32			`} *mtdblks[MAX_MTD_DEVICES];`
33
34			`/*`
35			`* Cache stuff...`
36			`*`
37			`* Since typical flash erasable sectors are much larger than what Linux's`
38			`* buffer cache can handle, we must implement read-modify-write on flash`
39			`* sectors for each block write requests. To avoid over-erasing flash sectors`
40			`* and to speed things up, we locally cache a whole flash sector while it is`
41			`* being written to until a different sector is required.`
42			`*/`
43
44			`static void erase_callback(struct erase_info *done)`
45			`{`
46			`wait_queue_head_t wait_q = (wait_queue_head_t )done->priv;`
47			`wake_up(wait_q);`
48			`}`
49
50			`static int erase_write (struct mtd_info *mtd, unsigned long pos,`
51			`int len, const char *buf)`
52			`{`
53			`struct erase_info erase;`
54			`DECLARE_WAITQUEUE(wait, current);`
55			`wait_queue_head_t wait_q;`
56			`size_t retlen;`
57			`int ret;`
58
59			`/*`
60			`* First, let's erase the flash block.`
61			`*/`
62
63			`init_waitqueue_head(&wait_q);`
64			`erase.mtd = mtd;`
65			`erase.callback = erase_callback;`
66			`erase.addr = pos;`
67			`erase.len = len;`
68			`erase.priv = (u_long)&wait_q;`
69
70			`set_current_state(TASK_INTERRUPTIBLE);`
71			`add_wait_queue(&wait_q, &wait);`
72
73			`ret = mtd->erase(mtd, &erase);`
74			`if (ret) {`
75			`set_current_state(TASK_RUNNING);`
76			`remove_wait_queue(&wait_q, &wait);`
77			`printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] "`
78			`"on \"%s\" failed\n",`
79			`pos, len, mtd->name);`
80			`return ret;`
81			`}`
82
83			`schedule(); /* Wait for erase to finish. */`
84			`remove_wait_queue(&wait_q, &wait);`
85
86			`/*`
87			`* Next, writhe data to flash.`
88			`*/`
89
90			`ret = mtd->write(mtd, pos, len, &retlen, buf);`
91			`if (ret)`
92			`return ret;`
93			`if (retlen != len)`
94			`return -EIO;`
95			`return 0;`
96			`}`
97
98
99			`static int write_cached_data (struct mtdblk_dev *mtdblk)`
100			`{`
101			`struct mtd_info *mtd = mtdblk->mtd;`
102			`int ret;`
103
104			`if (mtdblk->cache_state != STATE_DIRTY)`
105			`return 0;`
106
107			`DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: writing cached data for \"%s\" "`
108			`"at 0x%lx, size 0x%x\n", mtd->name,`
109			`mtdblk->cache_offset, mtdblk->cache_size);`
110
111			`ret = erase_write (mtd, mtdblk->cache_offset,`
112			`mtdblk->cache_size, mtdblk->cache_data);`
113			`if (ret)`
114			`return ret;`
115
116			`/*`
117			`* Here we could argubly set the cache state to STATE_CLEAN.`
118			`* However this could lead to inconsistency since we will not`
119			`* be notified if this content is altered on the flash by other`
120			`* means. Let's declare it empty and leave buffering tasks to`
121			`* the buffer cache instead.`
122			`*/`
123			`mtdblk->cache_state = STATE_EMPTY;`
124			`return 0;`
125			`}`
126
127
128			`static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,`
129			`int len, const char *buf)`
130			`{`
131			`struct mtd_info *mtd = mtdblk->mtd;`
132			`unsigned int sect_size = mtdblk->cache_size;`
133			`size_t retlen;`
134			`int ret;`
135
136			`DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: write on \"%s\" at 0x%lx, size 0x%x\n",`
137			`mtd->name, pos, len);`
138
139			`if (!sect_size)`
140			`return mtd->write(mtd, pos, len, &retlen, buf);`
141
142			`while (len > 0) {`
143			`unsigned long sect_start = (pos/sect_size)*sect_size;`
144			`unsigned int offset = pos - sect_start;`
145			`unsigned int size = sect_size - offset;`
146			`if( size > len )`
147			`size = len;`
148
149			`if (size == sect_size) {`
150			`/*`
151			`* We are covering a whole sector. Thus there is no`
152			`* need to bother with the cache while it may still be`
153			`* useful for other partial writes.`
154			`*/`
155			`ret = erase_write (mtd, pos, size, buf);`
156			`if (ret)`
157			`return ret;`
158			`} else {`
159			`/* Partial sector: need to use the cache */`
160
161			`if (mtdblk->cache_state == STATE_DIRTY &&`
162			`mtdblk->cache_offset != sect_start) {`
163			`ret = write_cached_data(mtdblk);`
164			`if (ret)`
165			`return ret;`
166			`}`
167
168			`if (mtdblk->cache_state == STATE_EMPTY \|\|`
169			`mtdblk->cache_offset != sect_start) {`
170			`/* fill the cache with the current sector */`
171			`mtdblk->cache_state = STATE_EMPTY;`
172			`ret = mtd->read(mtd, sect_start, sect_size,`
173			`&retlen, mtdblk->cache_data);`
174			`if (ret)`
175			`return ret;`
176			`if (retlen != sect_size)`
177			`return -EIO;`
178
179			`mtdblk->cache_offset = sect_start;`
180			`mtdblk->cache_size = sect_size;`
181			`mtdblk->cache_state = STATE_CLEAN;`
182			`}`
183
184			`/* write data to our local cache */`
185			`memcpy (mtdblk->cache_data + offset, buf, size);`
186			`mtdblk->cache_state = STATE_DIRTY;`
187			`}`
188
189			`buf += size;`
190			`pos += size;`
191			`len -= size;`
192			`}`
193
194			`return 0;`
195			`}`
196
197
198			`static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,`
199			`int len, char *buf)`
200			`{`
201			`struct mtd_info *mtd = mtdblk->mtd;`
202			`unsigned int sect_size = mtdblk->cache_size;`
203			`size_t retlen;`
204			`int ret;`
205
206			`DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n",`
207			`mtd->name, pos, len);`
208
209			`if (!sect_size)`
210			`return mtd->read(mtd, pos, len, &retlen, buf);`
211
212			`while (len > 0) {`
213			`unsigned long sect_start = (pos/sect_size)*sect_size;`
214			`unsigned int offset = pos - sect_start;`
215			`unsigned int size = sect_size - offset;`
216			`if (size > len)`
217			`size = len;`
218
219			`/*`
220			`* Check if the requested data is already cached`
221			`* Read the requested amount of data from our internal cache if it`
222			`* contains what we want, otherwise we read the data directly`
223			`* from flash.`
224			`*/`
225			`if (mtdblk->cache_state != STATE_EMPTY &&`
226			`mtdblk->cache_offset == sect_start) {`
227			`memcpy (buf, mtdblk->cache_data + offset, size);`
228			`} else {`
229			`ret = mtd->read(mtd, pos, size, &retlen, buf);`
230			`if (ret)`
231			`return ret;`
232			`if (retlen != size)`
233			`return -EIO;`
234			`}`
235
236			`buf += size;`
237			`pos += size;`
238			`len -= size;`
239			`}`
240
241			`return 0;`
242			`}`
243
244			`static int mtdblock_readsect(struct mtd_blktrans_dev *dev,`
245			`unsigned long block, char *buf)`
246			`{`
247			`struct mtdblk_dev *mtdblk = mtdblks[dev->devnum];`
248			`return do_cached_read(mtdblk, block<<9, 512, buf);`
249			`}`
250
251			`static int mtdblock_writesect(struct mtd_blktrans_dev *dev,`
252			`unsigned long block, char *buf)`
253			`{`
254			`struct mtdblk_dev *mtdblk = mtdblks[dev->devnum];`
255			`if (unlikely(!mtdblk->cache_data && mtdblk->cache_size)) {`
256			`mtdblk->cache_data = vmalloc(mtdblk->mtd->erasesize);`
257			`if (!mtdblk->cache_data)`
258			`return -EINTR;`
259			`/* -EINTR is not really correct, but it is the best match`
260			`* documented in man 2 write for all cases. We could also`
261			`* return -EAGAIN sometimes, but why bother?`
262			`*/`
263			`}`
264			`return do_cached_write(mtdblk, block<<9, 512, buf);`
265			`}`
266
267			`static int mtdblock_open(struct mtd_blktrans_dev *mbd)`
268			`{`
269			`struct mtdblk_dev *mtdblk;`
270			`struct mtd_info *mtd = mbd->mtd;`
271			`int dev = mbd->devnum;`
272
273			`DEBUG(MTD_DEBUG_LEVEL1,"mtdblock_open\n");`
274
275			`if (mtdblks[dev]) {`
276			`mtdblks[dev]->count++;`
277			`return 0;`
278			`}`
279
280			`/* OK, it's not open. Create cache info for it */`
281			`mtdblk = kzalloc(sizeof(struct mtdblk_dev), GFP_KERNEL);`
282			`if (!mtdblk)`
283			`return -ENOMEM;`
284
285			`mtdblk->count = 1;`
286			`mtdblk->mtd = mtd;`
287
288			`mutex_init(&mtdblk->cache_mutex);`
289			`mtdblk->cache_state = STATE_EMPTY;`
290			`if ( !(mtdblk->mtd->flags & MTD_NO_ERASE) && mtdblk->mtd->erasesize) {`
291			`mtdblk->cache_size = mtdblk->mtd->erasesize;`
292			`mtdblk->cache_data = NULL;`
293			`}`
294
295			`mtdblks[dev] = mtdblk;`
296
297			`DEBUG(MTD_DEBUG_LEVEL1, "ok\n");`
298
299			`return 0;`
300			`}`
301
302			`static int mtdblock_release(struct mtd_blktrans_dev *mbd)`
303			`{`
304			`int dev = mbd->devnum;`
305			`struct mtdblk_dev *mtdblk = mtdblks[dev];`
306
307			`DEBUG(MTD_DEBUG_LEVEL1, "mtdblock_release\n");`
308
309			`mutex_lock(&mtdblk->cache_mutex);`
310			`write_cached_data(mtdblk);`
311			`mutex_unlock(&mtdblk->cache_mutex);`
312
313			`if (!--mtdblk->count) {`
314			`/* It was the last usage. Free the device */`
315			`mtdblks[dev] = NULL;`
316			`if (mtdblk->mtd->sync)`
317			`mtdblk->mtd->sync(mtdblk->mtd);`
318			`vfree(mtdblk->cache_data);`
319			`kfree(mtdblk);`
320			`}`
321			`DEBUG(MTD_DEBUG_LEVEL1, "ok\n");`
322
323			`return 0;`
324			`}`
325
326			`static int mtdblock_flush(struct mtd_blktrans_dev *dev)`
327			`{`
328			`struct mtdblk_dev *mtdblk = mtdblks[dev->devnum];`
329
330			`mutex_lock(&mtdblk->cache_mutex);`
331			`write_cached_data(mtdblk);`
332			`mutex_unlock(&mtdblk->cache_mutex);`
333
334			`if (mtdblk->mtd->sync)`
335			`mtdblk->mtd->sync(mtdblk->mtd);`
336			`return 0;`
337			`}`
338
339			`static void mtdblock_add_mtd(struct mtd_blktrans_ops tr, struct mtd_info mtd)`
340			`{`
341			`struct mtd_blktrans_dev dev = kzalloc(sizeof(dev), GFP_KERNEL);`
342
343			`if (!dev)`
344			`return;`
345
346			`dev->mtd = mtd;`
347			`dev->devnum = mtd->index;`
348
349			`dev->size = mtd->size >> 9;`
350			`dev->tr = tr;`
351
352			`if (!(mtd->flags & MTD_WRITEABLE))`
353			`dev->readonly = 1;`
354
355			`add_mtd_blktrans_dev(dev);`
356			`}`
357
358			`static void mtdblock_remove_dev(struct mtd_blktrans_dev *dev)`
359			`{`
360			`del_mtd_blktrans_dev(dev);`
361			`kfree(dev);`
362			`}`
363
364			`static struct mtd_blktrans_ops mtdblock_tr = {`
365			`.name = "mtdblock",`
366			`.major = 31,`
367			`.part_bits = 0,`
368			`.blksize = 512,`
369			`.open = mtdblock_open,`
370			`.flush = mtdblock_flush,`
371			`.release = mtdblock_release,`
372			`.readsect = mtdblock_readsect,`
373			`.writesect = mtdblock_writesect,`
374			`.add_mtd = mtdblock_add_mtd,`
375			`.remove_dev = mtdblock_remove_dev,`
376			`.owner = THIS_MODULE,`
377			`};`
378
379			`static int __init init_mtdblock(void)`
380			`{`
381			`return register_mtd_blktrans(&mtdblock_tr);`
382			`}`
383
384			`static void __exit cleanup_mtdblock(void)`
385			`{`
386			`deregister_mtd_blktrans(&mtdblock_tr);`
387			`}`
388
389			`module_init(init_mtdblock);`
390			`module_exit(cleanup_mtdblock);`
391
392
393			`MODULE_LICENSE("GPL");`
394			`MODULE_AUTHOR("Nicolas Pitre <nico@cam.org> et al.");`
395			`MODULE_DESCRIPTION("Caching read/erase/writeback block device emulation access to MTD devices");`