11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Direct MTD block device access 31da177e4SLinus Torvalds * 42f82af08SNicolas Pitre * (C) 2000-2003 Nicolas Pitre <nico@fluxnic.net> 51da177e4SLinus Torvalds * (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> 61da177e4SLinus Torvalds */ 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds #include <linux/fs.h> 91da177e4SLinus Torvalds #include <linux/init.h> 1015fdc52fSThomas Gleixner #include <linux/kernel.h> 1115fdc52fSThomas Gleixner #include <linux/module.h> 1215fdc52fSThomas Gleixner #include <linux/sched.h> 131da177e4SLinus Torvalds #include <linux/slab.h> 1415fdc52fSThomas Gleixner #include <linux/types.h> 151da177e4SLinus Torvalds #include <linux/vmalloc.h> 1615fdc52fSThomas Gleixner 171da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 181da177e4SLinus Torvalds #include <linux/mtd/blktrans.h> 1948b19268SIngo Molnar #include <linux/mutex.h> 2048b19268SIngo Molnar 211da177e4SLinus Torvalds 22cbfe93e9SBen Hutchings struct mtdblk_dev { 23cbfe93e9SBen Hutchings struct mtd_blktrans_dev mbd; 241da177e4SLinus Torvalds int count; 2548b19268SIngo Molnar struct mutex cache_mutex; 261da177e4SLinus Torvalds unsigned char *cache_data; 271da177e4SLinus Torvalds unsigned long cache_offset; 281da177e4SLinus Torvalds unsigned int cache_size; 291da177e4SLinus Torvalds enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state; 30cbfe93e9SBen Hutchings }; 311da177e4SLinus Torvalds 32d676c117SMatthias Kaehlcke static struct mutex mtdblks_lock; 33d676c117SMatthias Kaehlcke 341da177e4SLinus Torvalds /* 351da177e4SLinus Torvalds * Cache stuff... 361da177e4SLinus Torvalds * 371da177e4SLinus Torvalds * Since typical flash erasable sectors are much larger than what Linux's 381da177e4SLinus Torvalds * buffer cache can handle, we must implement read-modify-write on flash 391da177e4SLinus Torvalds * sectors for each block write requests. To avoid over-erasing flash sectors 401da177e4SLinus Torvalds * and to speed things up, we locally cache a whole flash sector while it is 411da177e4SLinus Torvalds * being written to until a different sector is required. 421da177e4SLinus Torvalds */ 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds static void erase_callback(struct erase_info *done) 451da177e4SLinus Torvalds { 461da177e4SLinus Torvalds wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv; 471da177e4SLinus Torvalds wake_up(wait_q); 481da177e4SLinus Torvalds } 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds static int erase_write (struct mtd_info *mtd, unsigned long pos, 511da177e4SLinus Torvalds int len, const char *buf) 521da177e4SLinus Torvalds { 531da177e4SLinus Torvalds struct erase_info erase; 541da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 551da177e4SLinus Torvalds wait_queue_head_t wait_q; 561da177e4SLinus Torvalds size_t retlen; 571da177e4SLinus Torvalds int ret; 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds /* 601da177e4SLinus Torvalds * First, let's erase the flash block. 611da177e4SLinus Torvalds */ 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds init_waitqueue_head(&wait_q); 641da177e4SLinus Torvalds erase.mtd = mtd; 651da177e4SLinus Torvalds erase.callback = erase_callback; 661da177e4SLinus Torvalds erase.addr = pos; 671da177e4SLinus Torvalds erase.len = len; 681da177e4SLinus Torvalds erase.priv = (u_long)&wait_q; 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 711da177e4SLinus Torvalds add_wait_queue(&wait_q, &wait); 721da177e4SLinus Torvalds 73f4a43cfcSThomas Gleixner ret = mtd->erase(mtd, &erase); 741da177e4SLinus Torvalds if (ret) { 751da177e4SLinus Torvalds set_current_state(TASK_RUNNING); 761da177e4SLinus Torvalds remove_wait_queue(&wait_q, &wait); 771da177e4SLinus Torvalds printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] " 781da177e4SLinus Torvalds "on \"%s\" failed\n", 791da177e4SLinus Torvalds pos, len, mtd->name); 801da177e4SLinus Torvalds return ret; 811da177e4SLinus Torvalds } 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds schedule(); /* Wait for erase to finish. */ 841da177e4SLinus Torvalds remove_wait_queue(&wait_q, &wait); 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds /* 87dff15509SMatthias Kaehlcke * Next, write the data to flash. 881da177e4SLinus Torvalds */ 891da177e4SLinus Torvalds 90f4a43cfcSThomas Gleixner ret = mtd->write(mtd, pos, len, &retlen, buf); 911da177e4SLinus Torvalds if (ret) 921da177e4SLinus Torvalds return ret; 931da177e4SLinus Torvalds if (retlen != len) 941da177e4SLinus Torvalds return -EIO; 951da177e4SLinus Torvalds return 0; 961da177e4SLinus Torvalds } 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds static int write_cached_data (struct mtdblk_dev *mtdblk) 1001da177e4SLinus Torvalds { 101cbfe93e9SBen Hutchings struct mtd_info *mtd = mtdblk->mbd.mtd; 1021da177e4SLinus Torvalds int ret; 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds if (mtdblk->cache_state != STATE_DIRTY) 1051da177e4SLinus Torvalds return 0; 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: writing cached data for \"%s\" " 1081da177e4SLinus Torvalds "at 0x%lx, size 0x%x\n", mtd->name, 1091da177e4SLinus Torvalds mtdblk->cache_offset, mtdblk->cache_size); 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds ret = erase_write (mtd, mtdblk->cache_offset, 1121da177e4SLinus Torvalds mtdblk->cache_size, mtdblk->cache_data); 1131da177e4SLinus Torvalds if (ret) 1141da177e4SLinus Torvalds return ret; 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds /* 1171da177e4SLinus Torvalds * Here we could argubly set the cache state to STATE_CLEAN. 1181da177e4SLinus Torvalds * However this could lead to inconsistency since we will not 1191da177e4SLinus Torvalds * be notified if this content is altered on the flash by other 1201da177e4SLinus Torvalds * means. Let's declare it empty and leave buffering tasks to 1211da177e4SLinus Torvalds * the buffer cache instead. 1221da177e4SLinus Torvalds */ 1231da177e4SLinus Torvalds mtdblk->cache_state = STATE_EMPTY; 1241da177e4SLinus Torvalds return 0; 1251da177e4SLinus Torvalds } 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds 1281da177e4SLinus Torvalds static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos, 1291da177e4SLinus Torvalds int len, const char *buf) 1301da177e4SLinus Torvalds { 131cbfe93e9SBen Hutchings struct mtd_info *mtd = mtdblk->mbd.mtd; 1321da177e4SLinus Torvalds unsigned int sect_size = mtdblk->cache_size; 1331da177e4SLinus Torvalds size_t retlen; 1341da177e4SLinus Torvalds int ret; 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: write on \"%s\" at 0x%lx, size 0x%x\n", 1371da177e4SLinus Torvalds mtd->name, pos, len); 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds if (!sect_size) 140f4a43cfcSThomas Gleixner return mtd->write(mtd, pos, len, &retlen, buf); 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds while (len > 0) { 1431da177e4SLinus Torvalds unsigned long sect_start = (pos/sect_size)*sect_size; 1441da177e4SLinus Torvalds unsigned int offset = pos - sect_start; 1451da177e4SLinus Torvalds unsigned int size = sect_size - offset; 1461da177e4SLinus Torvalds if( size > len ) 1471da177e4SLinus Torvalds size = len; 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds if (size == sect_size) { 1501da177e4SLinus Torvalds /* 1511da177e4SLinus Torvalds * We are covering a whole sector. Thus there is no 1521da177e4SLinus Torvalds * need to bother with the cache while it may still be 1531da177e4SLinus Torvalds * useful for other partial writes. 1541da177e4SLinus Torvalds */ 1551da177e4SLinus Torvalds ret = erase_write (mtd, pos, size, buf); 1561da177e4SLinus Torvalds if (ret) 1571da177e4SLinus Torvalds return ret; 1581da177e4SLinus Torvalds } else { 1591da177e4SLinus Torvalds /* Partial sector: need to use the cache */ 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds if (mtdblk->cache_state == STATE_DIRTY && 1621da177e4SLinus Torvalds mtdblk->cache_offset != sect_start) { 1631da177e4SLinus Torvalds ret = write_cached_data(mtdblk); 1641da177e4SLinus Torvalds if (ret) 1651da177e4SLinus Torvalds return ret; 1661da177e4SLinus Torvalds } 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds if (mtdblk->cache_state == STATE_EMPTY || 1691da177e4SLinus Torvalds mtdblk->cache_offset != sect_start) { 1701da177e4SLinus Torvalds /* fill the cache with the current sector */ 1711da177e4SLinus Torvalds mtdblk->cache_state = STATE_EMPTY; 172f4a43cfcSThomas Gleixner ret = mtd->read(mtd, sect_start, sect_size, 173f4a43cfcSThomas Gleixner &retlen, mtdblk->cache_data); 1741da177e4SLinus Torvalds if (ret) 1751da177e4SLinus Torvalds return ret; 1761da177e4SLinus Torvalds if (retlen != sect_size) 1771da177e4SLinus Torvalds return -EIO; 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds mtdblk->cache_offset = sect_start; 1801da177e4SLinus Torvalds mtdblk->cache_size = sect_size; 1811da177e4SLinus Torvalds mtdblk->cache_state = STATE_CLEAN; 1821da177e4SLinus Torvalds } 1831da177e4SLinus Torvalds 1841da177e4SLinus Torvalds /* write data to our local cache */ 1851da177e4SLinus Torvalds memcpy (mtdblk->cache_data + offset, buf, size); 1861da177e4SLinus Torvalds mtdblk->cache_state = STATE_DIRTY; 1871da177e4SLinus Torvalds } 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds buf += size; 1901da177e4SLinus Torvalds pos += size; 1911da177e4SLinus Torvalds len -= size; 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds return 0; 1951da177e4SLinus Torvalds } 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos, 1991da177e4SLinus Torvalds int len, char *buf) 2001da177e4SLinus Torvalds { 201cbfe93e9SBen Hutchings struct mtd_info *mtd = mtdblk->mbd.mtd; 2021da177e4SLinus Torvalds unsigned int sect_size = mtdblk->cache_size; 2031da177e4SLinus Torvalds size_t retlen; 2041da177e4SLinus Torvalds int ret; 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n", 2071da177e4SLinus Torvalds mtd->name, pos, len); 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds if (!sect_size) 210f4a43cfcSThomas Gleixner return mtd->read(mtd, pos, len, &retlen, buf); 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds while (len > 0) { 2131da177e4SLinus Torvalds unsigned long sect_start = (pos/sect_size)*sect_size; 2141da177e4SLinus Torvalds unsigned int offset = pos - sect_start; 2151da177e4SLinus Torvalds unsigned int size = sect_size - offset; 2161da177e4SLinus Torvalds if (size > len) 2171da177e4SLinus Torvalds size = len; 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds /* 2201da177e4SLinus Torvalds * Check if the requested data is already cached 2211da177e4SLinus Torvalds * Read the requested amount of data from our internal cache if it 2221da177e4SLinus Torvalds * contains what we want, otherwise we read the data directly 2231da177e4SLinus Torvalds * from flash. 2241da177e4SLinus Torvalds */ 2251da177e4SLinus Torvalds if (mtdblk->cache_state != STATE_EMPTY && 2261da177e4SLinus Torvalds mtdblk->cache_offset == sect_start) { 2271da177e4SLinus Torvalds memcpy (buf, mtdblk->cache_data + offset, size); 2281da177e4SLinus Torvalds } else { 229f4a43cfcSThomas Gleixner ret = mtd->read(mtd, pos, size, &retlen, buf); 2301da177e4SLinus Torvalds if (ret) 2311da177e4SLinus Torvalds return ret; 2321da177e4SLinus Torvalds if (retlen != size) 2331da177e4SLinus Torvalds return -EIO; 2341da177e4SLinus Torvalds } 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds buf += size; 2371da177e4SLinus Torvalds pos += size; 2381da177e4SLinus Torvalds len -= size; 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds return 0; 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds static int mtdblock_readsect(struct mtd_blktrans_dev *dev, 2451da177e4SLinus Torvalds unsigned long block, char *buf) 2461da177e4SLinus Torvalds { 247cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd); 2481da177e4SLinus Torvalds return do_cached_read(mtdblk, block<<9, 512, buf); 2491da177e4SLinus Torvalds } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds static int mtdblock_writesect(struct mtd_blktrans_dev *dev, 2521da177e4SLinus Torvalds unsigned long block, char *buf) 2531da177e4SLinus Torvalds { 254cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd); 2551da177e4SLinus Torvalds if (unlikely(!mtdblk->cache_data && mtdblk->cache_size)) { 256cbfe93e9SBen Hutchings mtdblk->cache_data = vmalloc(mtdblk->mbd.mtd->erasesize); 2571da177e4SLinus Torvalds if (!mtdblk->cache_data) 2581da177e4SLinus Torvalds return -EINTR; 2591da177e4SLinus Torvalds /* -EINTR is not really correct, but it is the best match 2601da177e4SLinus Torvalds * documented in man 2 write for all cases. We could also 2611da177e4SLinus Torvalds * return -EAGAIN sometimes, but why bother? 2621da177e4SLinus Torvalds */ 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds return do_cached_write(mtdblk, block<<9, 512, buf); 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds static int mtdblock_open(struct mtd_blktrans_dev *mbd) 2681da177e4SLinus Torvalds { 269cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd); 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds DEBUG(MTD_DEBUG_LEVEL1,"mtdblock_open\n"); 2721da177e4SLinus Torvalds 273d676c117SMatthias Kaehlcke mutex_lock(&mtdblks_lock); 274cbfe93e9SBen Hutchings if (mtdblk->count) { 275cbfe93e9SBen Hutchings mtdblk->count++; 276d676c117SMatthias Kaehlcke mutex_unlock(&mtdblks_lock); 2771da177e4SLinus Torvalds return 0; 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds /* OK, it's not open. Create cache info for it */ 2811da177e4SLinus Torvalds mtdblk->count = 1; 28248b19268SIngo Molnar mutex_init(&mtdblk->cache_mutex); 2831da177e4SLinus Torvalds mtdblk->cache_state = STATE_EMPTY; 284cbfe93e9SBen Hutchings if (!(mbd->mtd->flags & MTD_NO_ERASE) && mbd->mtd->erasesize) { 285cbfe93e9SBen Hutchings mtdblk->cache_size = mbd->mtd->erasesize; 2861da177e4SLinus Torvalds mtdblk->cache_data = NULL; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 289d676c117SMatthias Kaehlcke mutex_unlock(&mtdblks_lock); 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds DEBUG(MTD_DEBUG_LEVEL1, "ok\n"); 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds return 0; 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds static int mtdblock_release(struct mtd_blktrans_dev *mbd) 2971da177e4SLinus Torvalds { 298cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd); 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds DEBUG(MTD_DEBUG_LEVEL1, "mtdblock_release\n"); 3011da177e4SLinus Torvalds 302d676c117SMatthias Kaehlcke mutex_lock(&mtdblks_lock); 303d676c117SMatthias Kaehlcke 30448b19268SIngo Molnar mutex_lock(&mtdblk->cache_mutex); 3051da177e4SLinus Torvalds write_cached_data(mtdblk); 30648b19268SIngo Molnar mutex_unlock(&mtdblk->cache_mutex); 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds if (!--mtdblk->count) { 309cbfe93e9SBen Hutchings /* It was the last usage. Free the cache */ 310cbfe93e9SBen Hutchings if (mbd->mtd->sync) 311cbfe93e9SBen Hutchings mbd->mtd->sync(mbd->mtd); 3121da177e4SLinus Torvalds vfree(mtdblk->cache_data); 3131da177e4SLinus Torvalds } 314d676c117SMatthias Kaehlcke 315d676c117SMatthias Kaehlcke mutex_unlock(&mtdblks_lock); 316d676c117SMatthias Kaehlcke 3171da177e4SLinus Torvalds DEBUG(MTD_DEBUG_LEVEL1, "ok\n"); 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds return 0; 3201da177e4SLinus Torvalds } 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds static int mtdblock_flush(struct mtd_blktrans_dev *dev) 3231da177e4SLinus Torvalds { 324cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd); 3251da177e4SLinus Torvalds 32648b19268SIngo Molnar mutex_lock(&mtdblk->cache_mutex); 3271da177e4SLinus Torvalds write_cached_data(mtdblk); 32848b19268SIngo Molnar mutex_unlock(&mtdblk->cache_mutex); 3291da177e4SLinus Torvalds 330cbfe93e9SBen Hutchings if (dev->mtd->sync) 331cbfe93e9SBen Hutchings dev->mtd->sync(dev->mtd); 3321da177e4SLinus Torvalds return 0; 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd) 3361da177e4SLinus Torvalds { 337cbfe93e9SBen Hutchings struct mtdblk_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL); 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds if (!dev) 3401da177e4SLinus Torvalds return; 3411da177e4SLinus Torvalds 342cbfe93e9SBen Hutchings dev->mbd.mtd = mtd; 343cbfe93e9SBen Hutchings dev->mbd.devnum = mtd->index; 34419187672SRichard Purdie 345cbfe93e9SBen Hutchings dev->mbd.size = mtd->size >> 9; 346cbfe93e9SBen Hutchings dev->mbd.tr = tr; 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds if (!(mtd->flags & MTD_WRITEABLE)) 349cbfe93e9SBen Hutchings dev->mbd.readonly = 1; 3501da177e4SLinus Torvalds 351298304f1SMaxim Levitsky if (add_mtd_blktrans_dev(&dev->mbd)) 352298304f1SMaxim Levitsky kfree(dev); 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds static void mtdblock_remove_dev(struct mtd_blktrans_dev *dev) 3561da177e4SLinus Torvalds { 357cbfe93e9SBen Hutchings struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd); 3581da177e4SLinus Torvalds del_mtd_blktrans_dev(dev); 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds static struct mtd_blktrans_ops mtdblock_tr = { 3621da177e4SLinus Torvalds .name = "mtdblock", 3631da177e4SLinus Torvalds .major = 31, 3641da177e4SLinus Torvalds .part_bits = 0, 36519187672SRichard Purdie .blksize = 512, 3661da177e4SLinus Torvalds .open = mtdblock_open, 3671da177e4SLinus Torvalds .flush = mtdblock_flush, 3681da177e4SLinus Torvalds .release = mtdblock_release, 3691da177e4SLinus Torvalds .readsect = mtdblock_readsect, 3701da177e4SLinus Torvalds .writesect = mtdblock_writesect, 3711da177e4SLinus Torvalds .add_mtd = mtdblock_add_mtd, 3721da177e4SLinus Torvalds .remove_dev = mtdblock_remove_dev, 3731da177e4SLinus Torvalds .owner = THIS_MODULE, 3741da177e4SLinus Torvalds }; 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds static int __init init_mtdblock(void) 3771da177e4SLinus Torvalds { 378d676c117SMatthias Kaehlcke mutex_init(&mtdblks_lock); 379d676c117SMatthias Kaehlcke 3801da177e4SLinus Torvalds return register_mtd_blktrans(&mtdblock_tr); 3811da177e4SLinus Torvalds } 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds static void __exit cleanup_mtdblock(void) 3841da177e4SLinus Torvalds { 3851da177e4SLinus Torvalds deregister_mtd_blktrans(&mtdblock_tr); 3861da177e4SLinus Torvalds } 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds module_init(init_mtdblock); 3891da177e4SLinus Torvalds module_exit(cleanup_mtdblock); 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 3932f82af08SNicolas Pitre MODULE_AUTHOR("Nicolas Pitre <nico@fluxnic.net> et al."); 3941da177e4SLinus Torvalds MODULE_DESCRIPTION("Caching read/erase/writeback block device emulation access to MTD devices"); 395