362 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Direct MTD block device access4 *5 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>6 * Copyright © 2000-2003 Nicolas Pitre <nico@fluxnic.net>7 */8 9#include <linux/fs.h>10#include <linux/init.h>11#include <linux/kernel.h>12#include <linux/module.h>13#include <linux/sched.h>14#include <linux/slab.h>15#include <linux/types.h>16#include <linux/vmalloc.h>17 18#include <linux/mtd/mtd.h>19#include <linux/mtd/blktrans.h>20#include <linux/mutex.h>21#include <linux/major.h>22 23 24struct mtdblk_dev {25 struct mtd_blktrans_dev mbd;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};33 34/*35 * Cache stuff...36 *37 * Since typical flash erasable sectors are much larger than what Linux's38 * buffer cache can handle, we must implement read-modify-write on flash39 * sectors for each block write requests. To avoid over-erasing flash sectors40 * and to speed things up, we locally cache a whole flash sector while it is41 * being written to until a different sector is required.42 */43 44static int erase_write (struct mtd_info *mtd, unsigned long pos,45 unsigned int len, const char *buf)46{47 struct erase_info erase;48 size_t retlen;49 int ret;50 51 /*52 * First, let's erase the flash block.53 */54 erase.addr = pos;55 erase.len = len;56 57 ret = mtd_erase(mtd, &erase);58 if (ret) {59 printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] "60 "on \"%s\" failed\n",61 pos, len, mtd->name);62 return ret;63 }64 65 /*66 * Next, write the data to flash.67 */68 69 ret = mtd_write(mtd, pos, len, &retlen, buf);70 if (ret)71 return ret;72 if (retlen != len)73 return -EIO;74 return 0;75}76 77 78static int write_cached_data (struct mtdblk_dev *mtdblk)79{80 struct mtd_info *mtd = mtdblk->mbd.mtd;81 int ret;82 83 if (mtdblk->cache_state != STATE_DIRTY)84 return 0;85 86 pr_debug("mtdblock: writing cached data for \"%s\" "87 "at 0x%lx, size 0x%x\n", mtd->name,88 mtdblk->cache_offset, mtdblk->cache_size);89 90 ret = erase_write (mtd, mtdblk->cache_offset,91 mtdblk->cache_size, mtdblk->cache_data);92 93 /*94 * Here we could arguably set the cache state to STATE_CLEAN.95 * However this could lead to inconsistency since we will not96 * be notified if this content is altered on the flash by other97 * means. Let's declare it empty and leave buffering tasks to98 * the buffer cache instead.99 *100 * If this cache_offset points to a bad block, data cannot be101 * written to the device. Clear cache_state to avoid writing to102 * bad blocks repeatedly.103 */104 if (ret == 0 || ret == -EIO)105 mtdblk->cache_state = STATE_EMPTY;106 return ret;107}108 109 110static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,111 int len, const char *buf)112{113 struct mtd_info *mtd = mtdblk->mbd.mtd;114 unsigned int sect_size = mtdblk->cache_size;115 size_t retlen;116 int ret;117 118 pr_debug("mtdblock: write on \"%s\" at 0x%lx, size 0x%x\n",119 mtd->name, pos, len);120 121 if (!sect_size)122 return mtd_write(mtd, pos, len, &retlen, buf);123 124 while (len > 0) {125 unsigned long sect_start = (pos/sect_size)*sect_size;126 unsigned int offset = pos - sect_start;127 unsigned int size = sect_size - offset;128 if( size > len )129 size = len;130 131 if (size == sect_size) {132 /*133 * We are covering a whole sector. Thus there is no134 * need to bother with the cache while it may still be135 * useful for other partial writes.136 */137 ret = erase_write (mtd, pos, size, buf);138 if (ret)139 return ret;140 } else {141 /* Partial sector: need to use the cache */142 143 if (mtdblk->cache_state == STATE_DIRTY &&144 mtdblk->cache_offset != sect_start) {145 ret = write_cached_data(mtdblk);146 if (ret)147 return ret;148 }149 150 if (mtdblk->cache_state == STATE_EMPTY ||151 mtdblk->cache_offset != sect_start) {152 /* fill the cache with the current sector */153 mtdblk->cache_state = STATE_EMPTY;154 ret = mtd_read(mtd, sect_start, sect_size,155 &retlen, mtdblk->cache_data);156 if (ret && !mtd_is_bitflip(ret))157 return ret;158 if (retlen != sect_size)159 return -EIO;160 161 mtdblk->cache_offset = sect_start;162 mtdblk->cache_size = sect_size;163 mtdblk->cache_state = STATE_CLEAN;164 }165 166 /* write data to our local cache */167 memcpy (mtdblk->cache_data + offset, buf, size);168 mtdblk->cache_state = STATE_DIRTY;169 }170 171 buf += size;172 pos += size;173 len -= size;174 }175 176 return 0;177}178 179 180static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,181 int len, char *buf)182{183 struct mtd_info *mtd = mtdblk->mbd.mtd;184 unsigned int sect_size = mtdblk->cache_size;185 size_t retlen;186 int ret;187 188 pr_debug("mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n",189 mtd->name, pos, len);190 191 if (!sect_size) {192 ret = mtd_read(mtd, pos, len, &retlen, buf);193 if (ret && !mtd_is_bitflip(ret))194 return ret;195 return 0;196 }197 198 while (len > 0) {199 unsigned long sect_start = (pos/sect_size)*sect_size;200 unsigned int offset = pos - sect_start;201 unsigned int size = sect_size - offset;202 if (size > len)203 size = len;204 205 /*206 * Check if the requested data is already cached207 * Read the requested amount of data from our internal cache if it208 * contains what we want, otherwise we read the data directly209 * from flash.210 */211 if (mtdblk->cache_state != STATE_EMPTY &&212 mtdblk->cache_offset == sect_start) {213 memcpy (buf, mtdblk->cache_data + offset, size);214 } else {215 ret = mtd_read(mtd, pos, size, &retlen, buf);216 if (ret && !mtd_is_bitflip(ret))217 return ret;218 if (retlen != size)219 return -EIO;220 }221 222 buf += size;223 pos += size;224 len -= size;225 }226 227 return 0;228}229 230static int mtdblock_readsect(struct mtd_blktrans_dev *dev,231 unsigned long block, char *buf)232{233 struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd);234 return do_cached_read(mtdblk, block<<9, 512, buf);235}236 237static int mtdblock_writesect(struct mtd_blktrans_dev *dev,238 unsigned long block, char *buf)239{240 struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd);241 if (unlikely(!mtdblk->cache_data && mtdblk->cache_size)) {242 mtdblk->cache_data = vmalloc(mtdblk->mbd.mtd->erasesize);243 if (!mtdblk->cache_data)244 return -EINTR;245 /* -EINTR is not really correct, but it is the best match246 * documented in man 2 write for all cases. We could also247 * return -EAGAIN sometimes, but why bother?248 */249 }250 return do_cached_write(mtdblk, block<<9, 512, buf);251}252 253static int mtdblock_open(struct mtd_blktrans_dev *mbd)254{255 struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd);256 257 pr_debug("mtdblock_open\n");258 259 if (mtdblk->count) {260 mtdblk->count++;261 return 0;262 }263 264 if (mtd_type_is_nand(mbd->mtd))265 pr_warn_ratelimited("%s: MTD device '%s' is NAND, please consider using UBI block devices instead.\n",266 mbd->tr->name, mbd->mtd->name);267 268 /* OK, it's not open. Create cache info for it */269 mtdblk->count = 1;270 mutex_init(&mtdblk->cache_mutex);271 mtdblk->cache_state = STATE_EMPTY;272 if (!(mbd->mtd->flags & MTD_NO_ERASE) && mbd->mtd->erasesize) {273 mtdblk->cache_size = mbd->mtd->erasesize;274 mtdblk->cache_data = NULL;275 }276 277 pr_debug("ok\n");278 279 return 0;280}281 282static void mtdblock_release(struct mtd_blktrans_dev *mbd)283{284 struct mtdblk_dev *mtdblk = container_of(mbd, struct mtdblk_dev, mbd);285 286 pr_debug("mtdblock_release\n");287 288 mutex_lock(&mtdblk->cache_mutex);289 write_cached_data(mtdblk);290 mutex_unlock(&mtdblk->cache_mutex);291 292 if (!--mtdblk->count) {293 /*294 * It was the last usage. Free the cache, but only sync if295 * opened for writing.296 */297 if (mbd->writable)298 mtd_sync(mbd->mtd);299 vfree(mtdblk->cache_data);300 }301 302 pr_debug("ok\n");303}304 305static int mtdblock_flush(struct mtd_blktrans_dev *dev)306{307 struct mtdblk_dev *mtdblk = container_of(dev, struct mtdblk_dev, mbd);308 int ret;309 310 mutex_lock(&mtdblk->cache_mutex);311 ret = write_cached_data(mtdblk);312 mutex_unlock(&mtdblk->cache_mutex);313 mtd_sync(dev->mtd);314 return ret;315}316 317static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)318{319 struct mtdblk_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL);320 321 if (!dev)322 return;323 324 dev->mbd.mtd = mtd;325 dev->mbd.devnum = mtd->index;326 327 dev->mbd.size = mtd->size >> 9;328 dev->mbd.tr = tr;329 330 if (!(mtd->flags & MTD_WRITEABLE))331 dev->mbd.readonly = 1;332 333 if (add_mtd_blktrans_dev(&dev->mbd))334 kfree(dev);335}336 337static void mtdblock_remove_dev(struct mtd_blktrans_dev *dev)338{339 del_mtd_blktrans_dev(dev);340}341 342static struct mtd_blktrans_ops mtdblock_tr = {343 .name = "mtdblock",344 .major = MTD_BLOCK_MAJOR,345 .part_bits = 0,346 .blksize = 512,347 .open = mtdblock_open,348 .flush = mtdblock_flush,349 .release = mtdblock_release,350 .readsect = mtdblock_readsect,351 .writesect = mtdblock_writesect,352 .add_mtd = mtdblock_add_mtd,353 .remove_dev = mtdblock_remove_dev,354 .owner = THIS_MODULE,355};356 357module_mtd_blktrans(mtdblock_tr);358 359MODULE_LICENSE("GPL");360MODULE_AUTHOR("Nicolas Pitre <nico@fluxnic.net> et al.");361MODULE_DESCRIPTION("Caching read/erase/writeback block device emulation access to MTD devices");362