11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Direct MTD block device access 31da177e4SLinus Torvalds * 4a1452a37SDavid Woodhouse * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org> 5a1452a37SDavid Woodhouse * Copyright © 2000-2003 Nicolas Pitre <nico@fluxnic.net> 6a1452a37SDavid Woodhouse * 7a1452a37SDavid Woodhouse * This program is free software; you can redistribute it and/or modify 8a1452a37SDavid Woodhouse * it under the terms of the GNU General Public License as published by 9a1452a37SDavid Woodhouse * the Free Software Foundation; either version 2 of the License, or 10a1452a37SDavid Woodhouse * (at your option) any later version. 11a1452a37SDavid Woodhouse * 12a1452a37SDavid Woodhouse * This program is distributed in the hope that it will be useful, 13a1452a37SDavid Woodhouse * but WITHOUT ANY WARRANTY; without even the implied warranty of 14a1452a37SDavid Woodhouse * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15a1452a37SDavid Woodhouse * GNU General Public License for more details. 16a1452a37SDavid Woodhouse * 17a1452a37SDavid Woodhouse * You should have received a copy of the GNU General Public License 18a1452a37SDavid Woodhouse * along with this program; if not, write to the Free Software 19a1452a37SDavid Woodhouse * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 20a1452a37SDavid Woodhouse * 211da177e4SLinus Torvalds */ 221da177e4SLinus Torvalds 231da177e4SLinus Torvalds #include <linux/fs.h> 241da177e4SLinus Torvalds #include <linux/init.h> 2515fdc52fSThomas Gleixner #include <linux/kernel.h> 2615fdc52fSThomas Gleixner #include <linux/module.h> 2715fdc52fSThomas Gleixner #include <linux/sched.h> 281da177e4SLinus Torvalds #include <linux/slab.h> 2915fdc52fSThomas Gleixner #include <linux/types.h> 301da177e4SLinus Torvalds #include <linux/vmalloc.h> 3115fdc52fSThomas Gleixner 321da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 331da177e4SLinus Torvalds #include <linux/mtd/blktrans.h> 3448b19268SIngo Molnar #include <linux/mutex.h> 3548b19268SIngo Molnar 361da177e4SLinus Torvalds 37cbfe93e9SBen Hutchings struct mtdblk_dev { 38cbfe93e9SBen Hutchings struct mtd_blktrans_dev mbd; 391da177e4SLinus Torvalds int count; 4048b19268SIngo Molnar struct mutex cache_mutex; 411da177e4SLinus Torvalds unsigned char *cache_data; 421da177e4SLinus Torvalds unsigned long cache_offset; 431da177e4SLinus Torvalds unsigned int cache_size; 441da177e4SLinus Torvalds enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state; 45cbfe93e9SBen Hutchings }; 461da177e4SLinus Torvalds 477578ca92SAxel Lin static DEFINE_MUTEX(mtdblks_lock); 48d676c117SMatthias Kaehlcke 491da177e4SLinus Torvalds /* 501da177e4SLinus Torvalds * Cache stuff... 511da177e4SLinus Torvalds * 521da177e4SLinus Torvalds * Since typical flash erasable sectors are much larger than what Linux's 531da177e4SLinus Torvalds * buffer cache can handle, we must implement read-modify-write on flash 541da177e4SLinus Torvalds * sectors for each block write requests. To avoid over-erasing flash sectors 551da177e4SLinus Torvalds * and to speed things up, we locally cache a whole flash sector while it is 561da177e4SLinus Torvalds * being written to until a different sector is required. 571da177e4SLinus Torvalds */ 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds static void erase_callback(struct erase_info *done) 601da177e4SLinus Torvalds { 611da177e4SLinus Torvalds wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv; 621da177e4SLinus Torvalds wake_up(wait_q); 631da177e4SLinus Torvalds } 641da177e4SLinus Torvalds 651da177e4SLinus Torvalds static int erase_write (struct mtd_info *mtd, unsigned long pos, 661da177e4SLinus Torvalds int len, const char *buf) 671da177e4SLinus Torvalds { 681da177e4SLinus Torvalds struct erase_info erase; 691da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 701da177e4SLinus Torvalds wait_queue_head_t wait_q; 711da177e4SLinus Torvalds size_t retlen; 721da177e4SLinus Torvalds int ret; 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* 751da177e4SLinus Torvalds * First, let's erase the flash block. 761da177e4SLinus Torvalds */ 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds init_waitqueue_head(&wait_q); 791da177e4SLinus Torvalds erase.mtd = mtd; 801da177e4SLinus Torvalds erase.callback = erase_callback; 811da177e4SLinus Torvalds erase.addr = pos; 821da177e4SLinus Torvalds erase.len = len; 831da177e4SLinus Torvalds erase.priv = (u_long)&wait_q; 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 861da177e4SLinus Torvalds add_wait_queue(&wait_q, &wait); 871da177e4SLinus Torvalds 887e1f0dc0SArtem Bityutskiy ret = mtd_erase(mtd, &erase); 891da177e4SLinus Torvalds if (ret) { 901da177e4SLinus Torvalds set_current_state(TASK_RUNNING); 911da177e4SLinus Torvalds remove_wait_queue(&wait_q, &wait); 921da177e4SLinus Torvalds printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] " 931da177e4SLinus Torvalds "on \"%s\" failed\n", 941da177e4SLinus Torvalds pos, len, mtd->name); 951da177e4SLinus Torvalds return ret; 961da177e4SLinus Torvalds } 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds schedule(); /* Wait for erase to finish. */ 991da177e4SLinus Torvalds remove_wait_queue(&wait_q, &wait); 1001da177e4SLinus Torvalds 1011da177e4SLinus Torvalds /* 102dff15509SMatthias Kaehlcke * Next, write the data to flash. 1031da177e4SLinus Torvalds */ 1041da177e4SLinus Torvalds 105eda95cbfSArtem Bityutskiy ret = mtd_write(mtd, pos, len, &retlen, buf); 1061da177e4SLinus Torvalds if (ret) 1071da177e4SLinus Torvalds return ret; 1081da177e4SLinus Torvalds if (retlen != len) 1091da177e4SLinus Torvalds return -EIO; 1101da177e4SLinus Torvalds return 0; 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds static int write_cached_data (struct mtdblk_dev *mtdblk) 1151da177e4SLinus Torvalds { 116cbfe93e9SBen Hutchings struct mtd_info *mtd = mtdblk->mbd.mtd; 1171da177e4SLinus Torvalds int ret; 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds if (mtdblk->cache_state != STATE_DIRTY) 1201da177e4SLinus Torvalds return 0; 1211da177e4SLinus Torvalds 122289c0522SBrian Norris pr_debug("mtdblock: writing cached data for \"%s\" " 1231da177e4SLinus Torvalds "at 0x%lx, size 0x%x\n", mtd->name, 1241da177e4SLinus Torvalds mtdblk->cache_offset, mtdblk->cache_size); 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds ret = erase_write (mtd, mtdblk->cache_offset, 1271da177e4SLinus Torvalds mtdblk->cache_size, mtdblk->cache_data); 1281da177e4SLinus Torvalds if (ret) 1291da177e4SLinus Torvalds return ret; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* 13225985edcSLucas De Marchi * Here we could arguably set the cache state to STATE_CLEAN. 1331da177e4SLinus Torvalds * However this could lead to inconsistency since we will not 1341da177e4SLinus Torvalds * be notified if this content is altered on the flash by other 1351da177e4SLinus Torvalds * means. Let's declare it empty and leave buffering tasks to 1361da177e4SLinus Torvalds * the buffer cache instead. 1371da177e4SLinus Torvalds */ 1381da177e4SLinus Torvalds mtdblk->cache_state = STATE_EMPTY; 1391da177e4SLinus Torvalds return 0; 1401da177e4SLinus Torvalds } 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos, 1441da177e4SLinus Torvalds int len, const char *buf) 1451da177e4SLinus Torvalds { 146cbfe93e9SBen Hutchings struct mtd_info *mtd = mtdblk->mbd.mtd; 1471da177e4SLinus Torvalds unsigned int sect_size = mtdblk->cache_size; 1481da177e4SLinus Torvalds size_t retlen; 1491da177e4SLinus Torvalds int ret; 1501da177e4SLinus Torvalds 151289c0522SBrian Norris pr_debug("mtdblock: write on \"%s\" at 0x%lx, size 0x%x\n", 1521da177e4SLinus Torvalds mtd->name, pos, len); 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds if (!sect_size) 155eda95cbfSArtem Bityutskiy return mtd_write(mtd, pos, len, &retlen, buf); 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds while (len > 0) { 1581da177e4SLinus Torvalds unsigned long sect_start = (pos/sect_size)*sect_size; 1591da177e4SLinus Torvalds unsigned int offset = pos - sect_start; 1601da177e4SLinus Torvalds unsigned int size = sect_size - offset; 1611da177e4SLinus Torvalds if( size > len ) 1621da177e4SLinus Torvalds size = len; 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds if (size == sect_size) { 1651da177e4SLinus Torvalds /* 1661da177e4SLinus Torvalds * We are covering a whole sector. Thus there is no 1671da177e4SLinus Torvalds * need to bother with the cache while it may still be 1681da177e4SLinus Torvalds * useful for other partial writes. 1691da177e4SLinus Torvalds */ 1701da177e4SLinus Torvalds ret = erase_write (mtd, pos, size, buf); 1711da177e4SLinus Torvalds if (ret) 1721da177e4SLinus Torvalds return ret; 1731da177e4SLinus Torvalds } else { 1741da177e4SLinus Torvalds /* Partial sector: need to use the cache */ 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds if (mtdblk->cache_state == STATE_DIRTY && 1771da177e4SLinus Torvalds mtdblk->cache_offset != sect_start) { 1781da177e4SLinus Torvalds ret = write_cached_data(mtdblk); 1791da177e4SLinus Torvalds if (ret) 1801da177e4SLinus Torvalds return ret; 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds if (mtdblk->cache_state == STATE_EMPTY || 1841da177e4SLinus Torvalds mtdblk->cache_offset != sect_start) { 1851da177e4SLinus Torvalds /* fill the cache with the current sector */ 1861da177e4SLinus Torvalds mtdblk->cache_state = STATE_EMPTY; 187329ad399SArtem Bityutskiy ret = mtd_read(mtd, sect_start, sect_size, 188f4a43cfcSThomas Gleixner &retlen, mtdblk->cache_data); 1891da177e4SLinus Torvalds if (ret) 1901da177e4SLinus Torvalds return ret; 1911da177e4SLinus Torvalds if (retlen != sect_size) 1921da177e4SLinus Torvalds return -EIO; 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds mtdblk->cache_offset = sect_start; 1951da177e4SLinus Torvalds mtdblk->cache_size = sect_size; 1961da177e4SLinus Torvalds mtdblk->cache_state = STATE_CLEAN; 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds /* write data to our local cache */ 2001da177e4SLinus Torvalds memcpy (mtdblk->cache_data + offset, buf, size); 2011da177e4SLinus Torvalds mtdblk->cache_state = STATE_DIRTY; 2021da177e4SLinus Torvalds } 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds buf += size; 2051da177e4SLinus Torvalds pos += size; 2061da177e4SLinus Torvalds len -= size; 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds return 0; 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds 2131da177e4SLinus Torvalds static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos, 2141da177e4SLinus Torvalds int len, char *buf) 2151da177e4SLinus Torvalds { 216cbfe93e9SBen Hutchings struct mtd_info *mtd = mtdblk->mbd.mtd; 2171da177e4SLinus Torvalds unsigned int sect_size = mtdblk->cache_size; 2181da177e4SLinus Torvalds size_t retlen; 2191da177e4SLinus Torvalds int ret; 2201da177e4SLinus Torvalds 221289c0522SBrian Norris pr_debug("mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n", 2221da177e4SLinus Torvalds mtd->name, pos, len); 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds if (!sect_size) 225329ad399SArtem Bityutskiy return mtd_read(mtd, pos, len, &retlen, buf); 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds while (len > 0) { 2281da177e4SLinus Torvalds unsigned long sect_start = (pos/sect_size)*sect_size; 2291da177e4SLinus Torvalds unsigned int offset = pos - sect_start; 2301da177e4SLinus Torvalds unsigned int size = sect_size - offset; 2311da177e4SLinus Torvalds if (size > len) 2321da177e4SLinus Torvalds size = len; 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds /* 2351da177e4SLinus Torvalds * Check if the requested data is already cached 2361da177e4SLinus Torvalds * Read the requested amount of data from our internal cache if it 2371da177e4SLinus Torvalds * contains what we want, otherwise we read the data directly 2381da177e4SLinus Torvalds * from flash. 2391da177e4SLinus Torvalds */ 2401da177e4SLinus Torvalds if (mtdblk->cache_state != STATE_EMPTY && 2411da177e4SLinus Torvalds mtdblk->cache_offset == sect_start) { 2421da177e4SLinus Torvalds memcpy (buf, mtdblk->cache_data + offset, size); 2431da177e4SLinus Torvalds } else { 244329ad399SArtem Bityutskiy ret = mtd_read(mtd, pos, size, &retlen, buf); 2451da177e4SLinus Torvalds if (ret) 2461da177e4SLinus Torvalds return ret; 2471da177e4SLinus Torvalds if (retlen != size) 2481da177e4SLinus Torvalds return -EIO; 2491da177e4SLinus Torvalds } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds buf += size; 2521da177e4SLinus Torvalds pos += size; 2531da177e4SLinus Torvalds len -= size; 2541da177e4SLinus Torvalds } 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds return 0; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds static int mtdblock_readsect(struct mtd_blktrans_dev *dev, 2601da177e4SLinus Torvalds unsigned long block, char *buf) 2611da177e4SLinus Torvalds { 262cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd); 2631da177e4SLinus Torvalds return do_cached_read(mtdblk, block<<9, 512, buf); 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds static int mtdblock_writesect(struct mtd_blktrans_dev *dev, 2671da177e4SLinus Torvalds unsigned long block, char *buf) 2681da177e4SLinus Torvalds { 269cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd); 2701da177e4SLinus Torvalds if (unlikely(!mtdblk->cache_data && mtdblk->cache_size)) { 271cbfe93e9SBen Hutchings mtdblk->cache_data = vmalloc(mtdblk->mbd.mtd->erasesize); 2721da177e4SLinus Torvalds if (!mtdblk->cache_data) 2731da177e4SLinus Torvalds return -EINTR; 2741da177e4SLinus Torvalds /* -EINTR is not really correct, but it is the best match 2751da177e4SLinus Torvalds * documented in man 2 write for all cases. We could also 2761da177e4SLinus Torvalds * return -EAGAIN sometimes, but why bother? 2771da177e4SLinus Torvalds */ 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds return do_cached_write(mtdblk, block<<9, 512, buf); 2801da177e4SLinus Torvalds } 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds static int mtdblock_open(struct mtd_blktrans_dev *mbd) 2831da177e4SLinus Torvalds { 284cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd); 2851da177e4SLinus Torvalds 286289c0522SBrian Norris pr_debug("mtdblock_open\n"); 2871da177e4SLinus Torvalds 288d676c117SMatthias Kaehlcke mutex_lock(&mtdblks_lock); 289cbfe93e9SBen Hutchings if (mtdblk->count) { 290cbfe93e9SBen Hutchings mtdblk->count++; 291d676c117SMatthias Kaehlcke mutex_unlock(&mtdblks_lock); 2921da177e4SLinus Torvalds return 0; 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds /* OK, it's not open. Create cache info for it */ 2961da177e4SLinus Torvalds mtdblk->count = 1; 29748b19268SIngo Molnar mutex_init(&mtdblk->cache_mutex); 2981da177e4SLinus Torvalds mtdblk->cache_state = STATE_EMPTY; 299cbfe93e9SBen Hutchings if (!(mbd->mtd->flags & MTD_NO_ERASE) && mbd->mtd->erasesize) { 300cbfe93e9SBen Hutchings mtdblk->cache_size = mbd->mtd->erasesize; 3011da177e4SLinus Torvalds mtdblk->cache_data = NULL; 3021da177e4SLinus Torvalds } 3031da177e4SLinus Torvalds 304d676c117SMatthias Kaehlcke mutex_unlock(&mtdblks_lock); 3051da177e4SLinus Torvalds 306289c0522SBrian Norris pr_debug("ok\n"); 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds return 0; 3091da177e4SLinus Torvalds } 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds static int mtdblock_release(struct mtd_blktrans_dev *mbd) 3121da177e4SLinus Torvalds { 313cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd); 3141da177e4SLinus Torvalds 315289c0522SBrian Norris pr_debug("mtdblock_release\n"); 3161da177e4SLinus Torvalds 317d676c117SMatthias Kaehlcke mutex_lock(&mtdblks_lock); 318d676c117SMatthias Kaehlcke 31948b19268SIngo Molnar mutex_lock(&mtdblk->cache_mutex); 3201da177e4SLinus Torvalds write_cached_data(mtdblk); 32148b19268SIngo Molnar mutex_unlock(&mtdblk->cache_mutex); 3221da177e4SLinus Torvalds 3231da177e4SLinus Torvalds if (!--mtdblk->count) { 32470d5098aSAlexander Stein /* 32570d5098aSAlexander Stein * It was the last usage. Free the cache, but only sync if 32670d5098aSAlexander Stein * opened for writing. 32770d5098aSAlexander Stein */ 32870d5098aSAlexander Stein if (mbd->file_mode & FMODE_WRITE) 32985f2f2a8SArtem Bityutskiy mtd_sync(mbd->mtd); 3301da177e4SLinus Torvalds vfree(mtdblk->cache_data); 3311da177e4SLinus Torvalds } 332d676c117SMatthias Kaehlcke 333d676c117SMatthias Kaehlcke mutex_unlock(&mtdblks_lock); 334d676c117SMatthias Kaehlcke 335289c0522SBrian Norris pr_debug("ok\n"); 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds return 0; 3381da177e4SLinus Torvalds } 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds static int mtdblock_flush(struct mtd_blktrans_dev *dev) 3411da177e4SLinus Torvalds { 342cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd); 3431da177e4SLinus Torvalds 34448b19268SIngo Molnar mutex_lock(&mtdblk->cache_mutex); 3451da177e4SLinus Torvalds write_cached_data(mtdblk); 34648b19268SIngo Molnar mutex_unlock(&mtdblk->cache_mutex); 34785f2f2a8SArtem Bityutskiy mtd_sync(dev->mtd); 3481da177e4SLinus Torvalds return 0; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd) 3521da177e4SLinus Torvalds { 353cbfe93e9SBen Hutchings struct mtdblk_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL); 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds if (!dev) 3561da177e4SLinus Torvalds return; 3571da177e4SLinus Torvalds 358cbfe93e9SBen Hutchings dev->mbd.mtd = mtd; 359cbfe93e9SBen Hutchings dev->mbd.devnum = mtd->index; 36019187672SRichard Purdie 361cbfe93e9SBen Hutchings dev->mbd.size = mtd->size >> 9; 362cbfe93e9SBen Hutchings dev->mbd.tr = tr; 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds if (!(mtd->flags & MTD_WRITEABLE)) 365cbfe93e9SBen Hutchings dev->mbd.readonly = 1; 3661da177e4SLinus Torvalds 367298304f1SMaxim Levitsky if (add_mtd_blktrans_dev(&dev->mbd)) 368298304f1SMaxim Levitsky kfree(dev); 3691da177e4SLinus Torvalds } 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds static void mtdblock_remove_dev(struct mtd_blktrans_dev *dev) 3721da177e4SLinus Torvalds { 3731da177e4SLinus Torvalds del_mtd_blktrans_dev(dev); 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds static struct mtd_blktrans_ops mtdblock_tr = { 3771da177e4SLinus Torvalds .name = "mtdblock", 3781da177e4SLinus Torvalds .major = 31, 3791da177e4SLinus Torvalds .part_bits = 0, 38019187672SRichard Purdie .blksize = 512, 3811da177e4SLinus Torvalds .open = mtdblock_open, 3821da177e4SLinus Torvalds .flush = mtdblock_flush, 3831da177e4SLinus Torvalds .release = mtdblock_release, 3841da177e4SLinus Torvalds .readsect = mtdblock_readsect, 3851da177e4SLinus Torvalds .writesect = mtdblock_writesect, 3861da177e4SLinus Torvalds .add_mtd = mtdblock_add_mtd, 3871da177e4SLinus Torvalds .remove_dev = mtdblock_remove_dev, 3881da177e4SLinus Torvalds .owner = THIS_MODULE, 3891da177e4SLinus Torvalds }; 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds static int __init init_mtdblock(void) 3921da177e4SLinus Torvalds { 3931da177e4SLinus Torvalds return register_mtd_blktrans(&mtdblock_tr); 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds static void __exit cleanup_mtdblock(void) 3971da177e4SLinus Torvalds { 3981da177e4SLinus Torvalds deregister_mtd_blktrans(&mtdblock_tr); 3991da177e4SLinus Torvalds } 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds module_init(init_mtdblock); 4021da177e4SLinus Torvalds module_exit(cleanup_mtdblock); 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 4062f82af08SNicolas Pitre MODULE_AUTHOR("Nicolas Pitre <nico@fluxnic.net> et al."); 4071da177e4SLinus Torvalds MODULE_DESCRIPTION("Caching read/erase/writeback block device emulation access to MTD devices"); 408