iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mtd: introduce mtd_write interface

Browse Source 
Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
This commit is contained in:
Artem Bityutskiy 2011-12-23 17:35:41 +02:00 committed by David Woodhouse
parent 329ad399a9
commit eda95cbf75
22 changed files with 84 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
drivers/mtd/chips/cfi_cmdset_0020.c
View File

@ -699,7 +699,8 @@ cfi_staa_writev(struct mtd_info *mtd, const struct kvec *vecs,
continue; continue;
} }
memcpy(buffer+buflen, elem_base, ECCBUF_SIZE-buflen); memcpy(buffer+buflen, elem_base, ECCBUF_SIZE-buflen);
ret = mtd->write(mtd, to, ECCBUF_SIZE, &thislen, buffer); ret = mtd_write(mtd, to, ECCBUF_SIZE, &thislen,
buffer);
totlen += thislen; totlen += thislen;
if (ret || thislen != ECCBUF_SIZE) if (ret || thislen != ECCBUF_SIZE)
goto write_error; goto write_error;
@ -708,7 +709,8 @@ cfi_staa_writev(struct mtd_info *mtd, const struct kvec *vecs,
to += ECCBUF_SIZE; to += ECCBUF_SIZE;
} }
if (ECCBUF_DIV(elem_len)) { /* write clean aligned data */ if (ECCBUF_DIV(elem_len)) { /* write clean aligned data */
ret = mtd->write(mtd, to, ECCBUF_DIV(elem_len), &thislen, elem_base); ret = mtd_write(mtd, to, ECCBUF_DIV(elem_len),
&thislen, elem_base);
totlen += thislen; totlen += thislen;
if (ret || thislen != ECCBUF_DIV(elem_len)) if (ret || thislen != ECCBUF_DIV(elem_len))
goto write_error; goto write_error;
@ -722,7 +724,7 @@ cfi_staa_writev(struct mtd_info *mtd, const struct kvec *vecs,
} }
if (buflen) { /* flush last page, even if not full */ if (buflen) { /* flush last page, even if not full */
/* This is sometimes intended behaviour, really */ /* This is sometimes intended behaviour, really */
ret = mtd->write(mtd, to, buflen, &thislen, buffer); ret = mtd_write(mtd, to, buflen, &thislen, buffer);
totlen += thislen; totlen += thislen;
if (ret || thislen != ECCBUF_SIZE) if (ret || thislen != ECCBUF_SIZE)
goto write_error; goto write_error;

31
drivers/mtd/ftl.c
View File

@ -422,8 +422,8 @@ static int prepare_xfer(partition_t *part, int i)
header.LogicalEUN = cpu_to_le16(0xffff); header.LogicalEUN = cpu_to_le16(0xffff);
header.EraseCount = cpu_to_le32(xfer->EraseCount); header.EraseCount = cpu_to_le32(xfer->EraseCount);
ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset, sizeof(header), ret = mtd_write(part->mbd.mtd, xfer->Offset, sizeof(header), &retlen,
&retlen, (u_char *)&header); (u_char *)&header);
if (ret) { if (ret) {
return ret; return ret;
@ -438,8 +438,8 @@ static int prepare_xfer(partition_t *part, int i)
for (i = 0; i < nbam; i++, offset += sizeof(uint32_t)) { for (i = 0; i < nbam; i++, offset += sizeof(uint32_t)) {
ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t), ret = mtd_write(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
&retlen, (u_char *)&ctl); (u_char *)&ctl);
if (ret) if (ret)
return ret; return ret;
@ -503,8 +503,8 @@ static int copy_erase_unit(partition_t *part, uint16_t srcunit,
offset = xfer->Offset + 20; /* Bad! */ offset = xfer->Offset + 20; /* Bad! */
unit = cpu_to_le16(0x7fff); unit = cpu_to_le16(0x7fff);
ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint16_t), ret = mtd_write(part->mbd.mtd, offset, sizeof(uint16_t), &retlen,
&retlen, (u_char *) &unit); (u_char *)&unit);
if (ret) { if (ret) {
printk( KERN_WARNING "ftl: Failed to write back to BAM cache in copy_erase_unit()!\n"); printk( KERN_WARNING "ftl: Failed to write back to BAM cache in copy_erase_unit()!\n");
@ -531,8 +531,8 @@ static int copy_erase_unit(partition_t *part, uint16_t srcunit,
} }
ret = part->mbd.mtd->write(part->mbd.mtd, dest, SECTOR_SIZE, ret = mtd_write(part->mbd.mtd, dest, SECTOR_SIZE, &retlen,
&retlen, (u_char *) buf); (u_char *)buf);
if (ret) { if (ret) {
printk(KERN_WARNING "ftl: Error writing new xfer unit in copy_erase_unit\n"); printk(KERN_WARNING "ftl: Error writing new xfer unit in copy_erase_unit\n");
return ret; return ret;
@ -550,8 +550,10 @@ static int copy_erase_unit(partition_t *part, uint16_t srcunit,
} }
/* Write the BAM to the transfer unit */ /* Write the BAM to the transfer unit */
ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + le32_to_cpu(part->header.BAMOffset), ret = mtd_write(part->mbd.mtd,
part->BlocksPerUnit * sizeof(int32_t), &retlen, xfer->Offset + le32_to_cpu(part->header.BAMOffset),
part->BlocksPerUnit * sizeof(int32_t),
&retlen,
(u_char *)part->bam_cache); (u_char *)part->bam_cache);
if (ret) { if (ret) {
printk( KERN_WARNING "ftl: Error writing BAM in copy_erase_unit\n"); printk( KERN_WARNING "ftl: Error writing BAM in copy_erase_unit\n");
@ -560,7 +562,7 @@ static int copy_erase_unit(partition_t *part, uint16_t srcunit,
/* All clear? Then update the LogicalEUN again */ /* All clear? Then update the LogicalEUN again */
ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_t), ret = mtd_write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_t),
&retlen, (u_char *)&srcunitswap); &retlen, (u_char *)&srcunitswap);
if (ret) { if (ret) {
@ -887,8 +889,8 @@ static int set_bam_entry(partition_t *part, uint32_t log_addr,
#endif #endif
part->bam_cache[blk] = le_virt_addr; part->bam_cache[blk] = le_virt_addr;
} }
ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t), ret = mtd_write(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
&retlen, (u_char *)&le_virt_addr); (u_char *)&le_virt_addr);
if (ret) { if (ret) {
printk(KERN_NOTICE "ftl_cs: set_bam_entry() failed!\n"); printk(KERN_NOTICE "ftl_cs: set_bam_entry() failed!\n");
@ -947,8 +949,7 @@ static int ftl_write(partition_t *part, caddr_t buffer,
part->EUNInfo[part->bam_index].Deleted++; part->EUNInfo[part->bam_index].Deleted++;
offset = (part->EUNInfo[part->bam_index].Offset + offset = (part->EUNInfo[part->bam_index].Offset +
blk * SECTOR_SIZE); blk * SECTOR_SIZE);
ret = part->mbd.mtd->write(part->mbd.mtd, offset, SECTOR_SIZE, &retlen, ret = mtd_write(part->mbd.mtd, offset, SECTOR_SIZE, &retlen, buffer);
buffer);
if (ret) { if (ret) {
printk(KERN_NOTICE "ftl_cs: block write failed!\n"); printk(KERN_NOTICE "ftl_cs: block write failed!\n");

4
drivers/mtd/mtdblock.c
View File

@ -102,7 +102,7 @@ static int erase_write (struct mtd_info *mtd, unsigned long pos,
* Next, write the data to flash. * Next, write the data to flash.
*/ */
ret = mtd->write(mtd, pos, len, &retlen, buf); ret = mtd_write(mtd, pos, len, &retlen, buf);
if (ret) if (ret)
return ret; return ret;
if (retlen != len) if (retlen != len)
@ -152,7 +152,7 @@ static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,
mtd->name, pos, len); mtd->name, pos, len);
if (!sect_size) if (!sect_size)
return mtd->write(mtd, pos, len, &retlen, buf); return mtd_write(mtd, pos, len, &retlen, buf);
while (len > 0) { while (len > 0) {
unsigned long sect_start = (pos/sect_size)*sect_size; unsigned long sect_start = (pos/sect_size)*sect_size;

2
drivers/mtd/mtdblock_ro.c
View File

@ -40,7 +40,7 @@ static int mtdblock_writesect(struct mtd_blktrans_dev *dev,
{ {
size_t retlen; size_t retlen;
if (dev->mtd->write(dev->mtd, (block * 512), 512, &retlen, buf)) if (mtd_write(dev->mtd, (block * 512), 512, &retlen, buf))
return 1; return 1;
return 0; return 0;
} }

2
drivers/mtd/mtdchar.c
View File

@ -331,7 +331,7 @@ static ssize_t mtdchar_write(struct file *file, const char __user *buf, size_t c
} }
default: default:
ret = (*(mtd->write))(mtd, *ppos, len, &retlen, kbuf); ret = mtd_write(mtd, *ppos, len, &retlen, kbuf);
} }
if (!ret) { if (!ret) {
*ppos += retlen; *ppos += retlen;

2
drivers/mtd/mtdconcat.c
View File

@ -148,7 +148,7 @@ concat_write(struct mtd_info *mtd, loff_t to, size_t len,
if (!(subdev->flags & MTD_WRITEABLE)) if (!(subdev->flags & MTD_WRITEABLE))
err = -EROFS; err = -EROFS;
else else
err = subdev->write(subdev, to, size, &retsize, buf); err = mtd_write(subdev, to, size, &retsize, buf);
if (err) if (err)
break; break;

3
drivers/mtd/mtdcore.c
View File

@ -699,7 +699,8 @@ int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
for (i=0; i<count; i++) { for (i=0; i<count; i++) {
if (!vecs[i].iov_len) if (!vecs[i].iov_len)
continue; continue;
ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base); ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
vecs[i].iov_base);
totlen += thislen; totlen += thislen;
if (ret || thislen != vecs[i].iov_len) if (ret || thislen != vecs[i].iov_len)
break; break;

2
drivers/mtd/mtdoops.c
View File

@ -225,7 +225,7 @@ static void mtdoops_write(struct mtdoops_context *cxt, int panic)
ret = mtd->panic_write(mtd, cxt->nextpage * record_size, ret = mtd->panic_write(mtd, cxt->nextpage * record_size,
record_size, &retlen, cxt->oops_buf); record_size, &retlen, cxt->oops_buf);
else else
ret = mtd->write(mtd, cxt->nextpage * record_size, ret = mtd_write(mtd, cxt->nextpage * record_size,
record_size, &retlen, cxt->oops_buf); record_size, &retlen, cxt->oops_buf);
if (retlen != record_size || ret < 0) if (retlen != record_size || ret < 0)

3
drivers/mtd/mtdpart.c
View File

@ -188,8 +188,7 @@ static int part_write(struct mtd_info *mtd, loff_t to, size_t len,
len = 0; len = 0;
else if (to + len > mtd->size) else if (to + len > mtd->size)
len = mtd->size - to; len = mtd->size - to;
return part->master->write(part->master, to + part->offset, return mtd_write(part->master, to + part->offset, len, retlen, buf);
len, retlen, buf);
} }
static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len, static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len,

2
drivers/mtd/mtdswap.c
View File

@ -689,7 +689,7 @@ retry:
return ret; return ret;
writepos = (loff_t)*bp << PAGE_SHIFT; writepos = (loff_t)*bp << PAGE_SHIFT;
ret = mtd->write(mtd, writepos, PAGE_SIZE, &retlen, buf); ret = mtd_write(mtd, writepos, PAGE_SIZE, &retlen, buf);
if (ret == -EIO || mtd_is_eccerr(ret)) { if (ret == -EIO || mtd_is_eccerr(ret)) {
d->curr_write_pos--; d->curr_write_pos--;
eb->active_count--; eb->active_count--;

17
drivers/mtd/rfd_ftl.c
View File

@ -304,9 +304,8 @@ static void erase_callback(struct erase_info *erase)
part->blocks[i].used_sectors = 0; part->blocks[i].used_sectors = 0;
part->blocks[i].erases++; part->blocks[i].erases++;
rc = part->mbd.mtd->write(part->mbd.mtd, rc = mtd_write(part->mbd.mtd, part->blocks[i].offset, sizeof(magic),
part->blocks[i].offset, sizeof(magic), &retlen, &retlen, (u_char *)&magic);
(u_char*)&magic);
if (!rc && retlen != sizeof(magic)) if (!rc && retlen != sizeof(magic))
rc = -EIO; rc = -EIO;
@ -595,8 +594,8 @@ static int mark_sector_deleted(struct partition *part, u_long old_addr)
addr = part->blocks[block].offset + addr = part->blocks[block].offset +
(HEADER_MAP_OFFSET + offset) * sizeof(u16); (HEADER_MAP_OFFSET + offset) * sizeof(u16);
rc = part->mbd.mtd->write(part->mbd.mtd, addr, rc = mtd_write(part->mbd.mtd, addr, sizeof(del), &retlen,
sizeof(del), &retlen, (u_char*)&del); (u_char *)&del);
if (!rc && retlen != sizeof(del)) if (!rc && retlen != sizeof(del))
rc = -EIO; rc = -EIO;
@ -668,8 +667,8 @@ static int do_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf,
addr = (i + part->header_sectors_per_block) * SECTOR_SIZE + addr = (i + part->header_sectors_per_block) * SECTOR_SIZE +
block->offset; block->offset;
rc = part->mbd.mtd->write(part->mbd.mtd, rc = mtd_write(part->mbd.mtd, addr, SECTOR_SIZE, &retlen,
addr, SECTOR_SIZE, &retlen, (u_char*)buf); (u_char *)buf);
if (!rc && retlen != SECTOR_SIZE) if (!rc && retlen != SECTOR_SIZE)
rc = -EIO; rc = -EIO;
@ -688,8 +687,8 @@ static int do_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf,
part->header_cache[i + HEADER_MAP_OFFSET] = entry; part->header_cache[i + HEADER_MAP_OFFSET] = entry;
addr = block->offset + (HEADER_MAP_OFFSET + i) * sizeof(u16); addr = block->offset + (HEADER_MAP_OFFSET + i) * sizeof(u16);
rc = part->mbd.mtd->write(part->mbd.mtd, addr, rc = mtd_write(part->mbd.mtd, addr, sizeof(entry), &retlen,
sizeof(entry), &retlen, (u_char*)&entry); (u_char *)&entry);
if (!rc && retlen != sizeof(entry)) if (!rc && retlen != sizeof(entry))
rc = -EIO; rc = -EIO;

8
drivers/mtd/tests/mtd_pagetest.c
View File

@ -100,7 +100,7 @@ static int write_eraseblock(int ebnum)
set_random_data(writebuf, mtd->erasesize); set_random_data(writebuf, mtd->erasesize);
cond_resched(); cond_resched();
err = mtd->write(mtd, addr, mtd->erasesize, &written, writebuf); err = mtd_write(mtd, addr, mtd->erasesize, &written, writebuf);
if (err || written != mtd->erasesize) if (err || written != mtd->erasesize)
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
(long long)addr); (long long)addr);
@ -335,7 +335,7 @@ static int erasecrosstest(void)
printk(PRINT_PREF "writing 1st page of block %d\n", ebnum); printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
set_random_data(writebuf, pgsize); set_random_data(writebuf, pgsize);
strcpy(writebuf, "There is no data like this!"); strcpy(writebuf, "There is no data like this!");
err = mtd->write(mtd, addr0, pgsize, &written, writebuf); err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
if (err || written != pgsize) { if (err || written != pgsize) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
(long long)addr0); (long long)addr0);
@ -368,7 +368,7 @@ static int erasecrosstest(void)
printk(PRINT_PREF "writing 1st page of block %d\n", ebnum); printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
set_random_data(writebuf, pgsize); set_random_data(writebuf, pgsize);
strcpy(writebuf, "There is no data like this!"); strcpy(writebuf, "There is no data like this!");
err = mtd->write(mtd, addr0, pgsize, &written, writebuf); err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
if (err || written != pgsize) { if (err || written != pgsize) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
(long long)addr0); (long long)addr0);
@ -425,7 +425,7 @@ static int erasetest(void)
printk(PRINT_PREF "writing 1st page of block %d\n", ebnum); printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
set_random_data(writebuf, pgsize); set_random_data(writebuf, pgsize);
err = mtd->write(mtd, addr0, pgsize, &written, writebuf); err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
if (err || written != pgsize) { if (err || written != pgsize) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
(long long)addr0); (long long)addr0);

8
drivers/mtd/tests/mtd_speedtest.c
View File

@ -143,7 +143,7 @@ static int write_eraseblock(int ebnum)
int err = 0; int err = 0;
loff_t addr = ebnum * mtd->erasesize; loff_t addr = ebnum * mtd->erasesize;
err = mtd->write(mtd, addr, mtd->erasesize, &written, iobuf); err = mtd_write(mtd, addr, mtd->erasesize, &written, iobuf);
if (err || written != mtd->erasesize) { if (err || written != mtd->erasesize) {
printk(PRINT_PREF "error: write failed at %#llx\n", addr); printk(PRINT_PREF "error: write failed at %#llx\n", addr);
if (!err) if (!err)
@ -161,7 +161,7 @@ static int write_eraseblock_by_page(int ebnum)
void *buf = iobuf; void *buf = iobuf;
for (i = 0; i < pgcnt; i++) { for (i = 0; i < pgcnt; i++) {
err = mtd->write(mtd, addr, pgsize, &written, buf); err = mtd_write(mtd, addr, pgsize, &written, buf);
if (err || written != pgsize) { if (err || written != pgsize) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
addr); addr);
@ -184,7 +184,7 @@ static int write_eraseblock_by_2pages(int ebnum)
void *buf = iobuf; void *buf = iobuf;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
err = mtd->write(mtd, addr, sz, &written, buf); err = mtd_write(mtd, addr, sz, &written, buf);
if (err || written != sz) { if (err || written != sz) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
addr); addr);
@ -196,7 +196,7 @@ static int write_eraseblock_by_2pages(int ebnum)
buf += sz; buf += sz;
} }
if (pgcnt % 2) { if (pgcnt % 2) {
err = mtd->write(mtd, addr, pgsize, &written, buf); err = mtd_write(mtd, addr, pgsize, &written, buf);
if (err || written != pgsize) { if (err || written != pgsize) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
addr); addr);

2
drivers/mtd/tests/mtd_stresstest.c
View File

@ -192,7 +192,7 @@ static int do_write(void)
} }
} }
addr = eb * mtd->erasesize + offs; addr = eb * mtd->erasesize + offs;
err = mtd->write(mtd, addr, len, &written, writebuf); err = mtd_write(mtd, addr, len, &written, writebuf);
if (unlikely(err || written != len)) { if (unlikely(err || written != len)) {
printk(PRINT_PREF "error: write failed at 0x%llx\n", printk(PRINT_PREF "error: write failed at 0x%llx\n",
(long long)addr); (long long)addr);

6
drivers/mtd/tests/mtd_subpagetest.c
View File

@ -120,7 +120,7 @@ static int write_eraseblock(int ebnum)
loff_t addr = ebnum * mtd->erasesize; loff_t addr = ebnum * mtd->erasesize;
set_random_data(writebuf, subpgsize); set_random_data(writebuf, subpgsize);
err = mtd->write(mtd, addr, subpgsize, &written, writebuf); err = mtd_write(mtd, addr, subpgsize, &written, writebuf);
if (unlikely(err || written != subpgsize)) { if (unlikely(err || written != subpgsize)) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
(long long)addr); (long long)addr);
@ -134,7 +134,7 @@ static int write_eraseblock(int ebnum)
addr += subpgsize; addr += subpgsize;
set_random_data(writebuf, subpgsize); set_random_data(writebuf, subpgsize);
err = mtd->write(mtd, addr, subpgsize, &written, writebuf); err = mtd_write(mtd, addr, subpgsize, &written, writebuf);
if (unlikely(err || written != subpgsize)) { if (unlikely(err || written != subpgsize)) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
(long long)addr); (long long)addr);
@ -158,7 +158,7 @@ static int write_eraseblock2(int ebnum)
if (addr + (subpgsize * k) > (ebnum + 1) * mtd->erasesize) if (addr + (subpgsize * k) > (ebnum + 1) * mtd->erasesize)
break; break;
set_random_data(writebuf, subpgsize * k); set_random_data(writebuf, subpgsize * k);
err = mtd->write(mtd, addr, subpgsize * k, &written, writebuf); err = mtd_write(mtd, addr, subpgsize * k, &written, writebuf);
if (unlikely(err || written != subpgsize * k)) { if (unlikely(err || written != subpgsize * k)) {
printk(PRINT_PREF "error: write failed at %#llx\n", printk(PRINT_PREF "error: write failed at %#llx\n",
(long long)addr); (long long)addr);

2
drivers/mtd/tests/mtd_torturetest.c
View File

@ -189,7 +189,7 @@ static inline int write_pattern(int ebnum, void *buf)
addr = (ebnum + 1) * mtd->erasesize - pgcnt * pgsize; addr = (ebnum + 1) * mtd->erasesize - pgcnt * pgsize;
len = pgcnt * pgsize; len = pgcnt * pgsize;
} }
err = mtd->write(mtd, addr, len, &written, buf); err = mtd_write(mtd, addr, len, &written, buf);
if (err) { if (err) {
printk(PRINT_PREF "error %d while writing EB %d, written %zd" printk(PRINT_PREF "error %d while writing EB %d, written %zd"
" bytes\n", err, ebnum, written); " bytes\n", err, ebnum, written);

7
drivers/mtd/ubi/io.c
View File

@ -289,7 +289,7 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
} }
addr = (loff_t)pnum * ubi->peb_size + offset; addr = (loff_t)pnum * ubi->peb_size + offset;
err = ubi->mtd->write(ubi->mtd, addr, len, &written, buf); err = mtd_write(ubi->mtd, addr, len, &written, buf);
if (err) { if (err) {
ubi_err("error %d while writing %d bytes to PEB %d:%d, written " ubi_err("error %d while writing %d bytes to PEB %d:%d, written "
"%zd bytes", err, len, pnum, offset, written); "%zd bytes", err, len, pnum, offset, written);
@ -525,11 +525,10 @@ static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
* the header comment in scan.c for more information). * the header comment in scan.c for more information).
*/ */
addr = (loff_t)pnum * ubi->peb_size; addr = (loff_t)pnum * ubi->peb_size;
err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data); err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
if (!err) { if (!err) {
addr += ubi->vid_hdr_aloffset; addr += ubi->vid_hdr_aloffset;
err = ubi->mtd->write(ubi->mtd, addr, 4, &written, err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
(void *)&data);
if (!err) if (!err)
return 0; return 0;
} }

6
drivers/staging/spectra/lld_mtd.c
View File

@ -233,9 +233,11 @@ u16 mtd_Write_Page_Main(u8 *write_data, u32 Block,
while (PageCount) { while (PageCount) {
ret = spectra_mtd->write(spectra_mtd, ret = mtd_write(spectra_mtd,
(Block * spectra_mtd->erasesize) + (Page * spectra_mtd->writesize), (Block * spectra_mtd->erasesize) + (Page * spectra_mtd->writesize),
DeviceInfo.wPageDataSize, &retlen, write_data); DeviceInfo.wPageDataSize,
&retlen,
write_data);
if (ret) { if (ret) {
printk(KERN_ERR "%s failed %d\n", __func__, ret); printk(KERN_ERR "%s failed %d\n", __func__, ret);
return FAIL; return FAIL;

12
fs/jffs2/wbuf.c
View File

@ -414,12 +414,11 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
if (breakme++ == 20) { if (breakme++ == 20) {
printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs); printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
breakme = 0; breakme = 0;
c->mtd->write(c->mtd, ofs, towrite, &retlen, mtd_write(c->mtd, ofs, towrite, &retlen, brokenbuf);
brokenbuf);
ret = -EIO; ret = -EIO;
} else } else
#endif #endif
ret = c->mtd->write(c->mtd, ofs, towrite, &retlen, ret = mtd_write(c->mtd, ofs, towrite, &retlen,
rewrite_buf); rewrite_buf);
if (ret || retlen != towrite || jffs2_verify_write(c, rewrite_buf, ofs)) { if (ret || retlen != towrite || jffs2_verify_write(c, rewrite_buf, ofs)) {
@ -620,13 +619,14 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
if (breakme++ == 20) { if (breakme++ == 20) {
printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs); printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
breakme = 0; breakme = 0;
c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
brokenbuf); brokenbuf);
ret = -EIO; ret = -EIO;
} else } else
#endif #endif
ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf); ret = mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
&retlen, c->wbuf);
if (ret) { if (ret) {
printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n", ret); printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n", ret);
@ -862,7 +862,7 @@ int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
v += wbuf_retlen; v += wbuf_retlen;
if (vlen >= c->wbuf_pagesize) { if (vlen >= c->wbuf_pagesize) {
ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen), ret = mtd_write(c->mtd, outvec_to, PAGE_DIV(vlen),
&wbuf_retlen, v); &wbuf_retlen, v);
if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen)) if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
goto outfile; goto outfile;

5
fs/jffs2/writev.c
View File

@ -26,7 +26,8 @@ static inline int mtd_fake_writev(struct mtd_info *mtd, const struct kvec *vecs,
for (i=0; i<count; i++) { for (i=0; i<count; i++) {
if (!vecs[i].iov_len) if (!vecs[i].iov_len)
continue; continue;
ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base); ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
vecs[i].iov_base);
totlen += thislen; totlen += thislen;
if (ret || thislen != vecs[i].iov_len) if (ret || thislen != vecs[i].iov_len)
break; break;
@ -61,7 +62,7 @@ int jffs2_flash_direct_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
size_t *retlen, const u_char *buf) size_t *retlen, const u_char *buf)
{ {
int ret; int ret;
ret = c->mtd->write(c->mtd, ofs, len, retlen, buf); ret = mtd_write(c->mtd, ofs, len, retlen, buf);
if (jffs2_sum_active()) { if (jffs2_sum_active()) {
struct kvec vecs[1]; struct kvec vecs[1];

2
fs/logfs/dev_mtd.c
View File

@ -49,7 +49,7 @@ static int loffs_mtd_write(struct super_block *sb, loff_t ofs, size_t len,
BUG_ON(len > PAGE_CACHE_SIZE); BUG_ON(len > PAGE_CACHE_SIZE);
page_start = ofs & PAGE_CACHE_MASK; page_start = ofs & PAGE_CACHE_MASK;
page_end = PAGE_CACHE_ALIGN(ofs + len) - 1; page_end = PAGE_CACHE_ALIGN(ofs + len) - 1;
ret = mtd->write(mtd, ofs, len, &retlen, buf); ret = mtd_write(mtd, ofs, len, &retlen, buf);
if (ret || (retlen != len)) if (ret || (retlen != len))
return -EIO; return -EIO;

9
include/linux/mtd/mtd.h
View File

@ -184,6 +184,8 @@ struct mtd_info {
unsigned long flags); unsigned long flags);
int (*read) (struct mtd_info *mtd, loff_t from, size_t len, int (*read) (struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, u_char *buf); size_t *retlen, u_char *buf);
int (*write) (struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf);
/* Backing device capabilities for this device /* Backing device capabilities for this device
* - provides mmap capabilities * - provides mmap capabilities
@ -191,7 +193,6 @@ struct mtd_info {
struct backing_dev_info *backing_dev_info; struct backing_dev_info *backing_dev_info;
int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
/* In blackbox flight recorder like scenarios we want to make successful /* In blackbox flight recorder like scenarios we want to make successful
writes in interrupt context. panic_write() is only intended to be writes in interrupt context. panic_write() is only intended to be
@ -308,6 +309,12 @@ static inline int mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
return mtd->read(mtd, from, len, retlen, buf); return mtd->read(mtd, from, len, retlen, buf);
} }
static inline int mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf)
{
return mtd->write(mtd, to, len, retlen, buf);
}
static inline struct mtd_info *dev_to_mtd(struct device *dev) static inline struct mtd_info *dev_to_mtd(struct device *dev)
{ {
return dev ? dev_get_drvdata(dev) : NULL; return dev ? dev_get_drvdata(dev) : NULL;