leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

mtd: Stop updating erase_info->state and calling mtd_erase_callback()

Browse Source 
MTD users are no longer checking erase_info->state to determine if the
erase operation failed or succeeded. Moreover, mtd_erase_callback() is
now a NOP.

We can safely get rid of all mtd_erase_callback() calls and all
erase_info->state assignments. While at it, get rid of the
erase_info->state field, all MTD_ERASE_XXX definitions and the
mtd_erase_callback() function.

Signed-off-by: Boris Brezillon <boris.brezillon@bootlin.com>
Reviewed-by: Richard Weinberger <richard@nod.at>
Reviewed-by: Miquel Raynal <miquel.raynal@bootlin.com>
Acked-by: Bert Kenward <bkenward@solarflare.com>
---
Changes in v2:
- Address a few coding style issues (reported by Miquel)
- Remove comments that are no longer valid (reported by Miquel)
This commit is contained in:
Boris Brezillon 2018-02-12 22:03:11 +01:00
parent 8f347c4232
commit e7bfb3fdbd
30 changed files with 23 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
drivers/mtd/chips/cfi_cmdset_0001.c
View File

@ -1993,20 +1993,8 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr) static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
{ {
unsigned long ofs, len; return cfi_varsize_frob(mtd, do_erase_oneblock, instr->addr,
int ret; instr->len, NULL);
ofs = instr->addr;
len = instr->len;
ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
if (ret)
return ret;
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0;
} }
static void cfi_intelext_sync (struct mtd_info *mtd) static void cfi_intelext_sync (struct mtd_info *mtd)

26
drivers/mtd/chips/cfi_cmdset_0002.c
View File

@ -2415,20 +2415,8 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
static int cfi_amdstd_erase_varsize(struct mtd_info *mtd, struct erase_info *instr) static int cfi_amdstd_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
{ {
unsigned long ofs, len; return cfi_varsize_frob(mtd, do_erase_oneblock, instr->addr,
int ret; instr->len, NULL);
ofs = instr->addr;
len = instr->len;
ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
if (ret)
return ret;
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0;
} }
@ -2436,7 +2424,6 @@ static int cfi_amdstd_erase_chip(struct mtd_info *mtd, struct erase_info *instr)
{ {
struct map_info *map = mtd->priv; struct map_info *map = mtd->priv;
struct cfi_private *cfi = map->fldrv_priv; struct cfi_private *cfi = map->fldrv_priv;
int ret = 0;
if (instr->addr != 0) if (instr->addr != 0)
return -EINVAL; return -EINVAL;
@ -2444,14 +2431,7 @@ static int cfi_amdstd_erase_chip(struct mtd_info *mtd, struct erase_info *instr)
if (instr->len != mtd->size) if (instr->len != mtd->size)
return -EINVAL; return -EINVAL;
ret = do_erase_chip(map, &cfi->chips[0]); return do_erase_chip(map, &cfi->chips[0]);
if (ret)
return ret;
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0;
} }
static int do_atmel_lock(struct map_info *map, struct flchip *chip, static int do_atmel_lock(struct map_info *map, struct flchip *chip,

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

@ -965,9 +965,6 @@ static int cfi_staa_erase_varsize(struct mtd_info *mtd,
} }
} }
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
} }

2
drivers/mtd/chips/map_ram.c
View File

@ -131,8 +131,6 @@ static int mapram_erase (struct mtd_info *mtd, struct erase_info *instr)
allff = map_word_ff(map); allff = map_word_ff(map);
for (i=0; i<instr->len; i += map_bankwidth(map)) for (i=0; i<instr->len; i += map_bankwidth(map))
map_write(map, allff, instr->addr + i); map_write(map, allff, instr->addr + i);
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
} }

9
drivers/mtd/devices/bcm47xxsflash.c
View File

@ -68,7 +68,6 @@ static int bcm47xxsflash_poll(struct bcm47xxsflash *b47s, int timeout)
static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase) static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase)
{ {
struct bcm47xxsflash *b47s = mtd->priv; struct bcm47xxsflash *b47s = mtd->priv;
int err;
switch (b47s->type) { switch (b47s->type) {
case BCM47XXSFLASH_TYPE_ST: case BCM47XXSFLASH_TYPE_ST:
@ -89,13 +88,7 @@ static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase)
break; break;
} }
err = bcm47xxsflash_poll(b47s, HZ); return bcm47xxsflash_poll(b47s, HZ);
if (err)
erase->state = MTD_ERASE_FAILED;
else
erase->state = MTD_ERASE_DONE;
return err;
} }
static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len, static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,

7
drivers/mtd/devices/block2mtd.c
View File

@ -88,17 +88,12 @@ static int block2mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
size_t len = instr->len; size_t len = instr->len;
int err; int err;
instr->state = MTD_ERASING;
mutex_lock(&dev->write_mutex); mutex_lock(&dev->write_mutex);
err = _block2mtd_erase(dev, from, len); err = _block2mtd_erase(dev, from, len);
mutex_unlock(&dev->write_mutex); mutex_unlock(&dev->write_mutex);
if (err) { if (err)
pr_err("erase failed err = %d\n", err); pr_err("erase failed err = %d\n", err);
instr->state = MTD_ERASE_FAILED;
} else
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return err; return err;
} }

16
drivers/mtd/devices/docg3.c
View File

@ -1191,39 +1191,27 @@ static int doc_erase(struct mtd_info *mtd, struct erase_info *info)
{ {
struct docg3 *docg3 = mtd->priv; struct docg3 *docg3 = mtd->priv;
uint64_t len; uint64_t len;
int block0, block1, page, ret, ofs = 0; int block0, block1, page, ret = 0, ofs = 0;
doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len); doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len);
info->state = MTD_ERASE_PENDING;
calc_block_sector(info->addr + info->len, &block0, &block1, &page, calc_block_sector(info->addr + info->len, &block0, &block1, &page,
&ofs, docg3->reliable); &ofs, docg3->reliable);
ret = -EINVAL;
if (info->addr + info->len > mtd->size || page || ofs) if (info->addr + info->len > mtd->size || page || ofs)
goto reset_err; return -EINVAL;
ret = 0;
calc_block_sector(info->addr, &block0, &block1, &page, &ofs, calc_block_sector(info->addr, &block0, &block1, &page, &ofs,
docg3->reliable); docg3->reliable);
mutex_lock(&docg3->cascade->lock); mutex_lock(&docg3->cascade->lock);
doc_set_device_id(docg3, docg3->device_id); doc_set_device_id(docg3, docg3->device_id);
doc_set_reliable_mode(docg3); doc_set_reliable_mode(docg3);
for (len = info->len; !ret && len > 0; len -= mtd->erasesize) { for (len = info->len; !ret && len > 0; len -= mtd->erasesize) {
info->state = MTD_ERASING;
ret = doc_erase_block(docg3, block0, block1); ret = doc_erase_block(docg3, block0, block1);
block0 += 2; block0 += 2;
block1 += 2; block1 += 2;
} }
mutex_unlock(&docg3->cascade->lock); mutex_unlock(&docg3->cascade->lock);
if (ret)
goto reset_err;
info->state = MTD_ERASE_DONE;
return 0;
reset_err:
info->state = MTD_ERASE_FAILED;
return ret; return ret;
} }

6
drivers/mtd/devices/lart.c
View File

@ -414,10 +414,7 @@ static int flash_erase (struct mtd_info *mtd,struct erase_info *instr)
while (len) while (len)
{ {
if (!erase_block (addr)) if (!erase_block (addr))
{
instr->state = MTD_ERASE_FAILED;
return (-EIO); return (-EIO);
}
addr += mtd->eraseregions[i].erasesize; addr += mtd->eraseregions[i].erasesize;
len -= mtd->eraseregions[i].erasesize; len -= mtd->eraseregions[i].erasesize;
@ -425,9 +422,6 @@ static int flash_erase (struct mtd_info *mtd,struct erase_info *instr)
if (addr == mtd->eraseregions[i].offset + (mtd->eraseregions[i].erasesize * mtd->eraseregions[i].numblocks)) i++; if (addr == mtd->eraseregions[i].offset + (mtd->eraseregions[i].erasesize * mtd->eraseregions[i].numblocks)) i++;
} }
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return (0); return (0);
} }

4
drivers/mtd/devices/mtd_dataflash.c
View File

@ -220,10 +220,6 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
} }
mutex_unlock(&priv->lock); mutex_unlock(&priv->lock);
/* Inform MTD subsystem that erase is complete */
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
} }

3
drivers/mtd/devices/mtdram.c
View File

@ -60,8 +60,7 @@ static int ram_erase(struct mtd_info *mtd, struct erase_info *instr)
if (check_offs_len(mtd, instr->addr, instr->len)) if (check_offs_len(mtd, instr->addr, instr->len))
return -EINVAL; return -EINVAL;
memset((char *)mtd->priv + instr->addr, 0xff, instr->len); memset((char *)mtd->priv + instr->addr, 0xff, instr->len);
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
} }

7
drivers/mtd/devices/phram.c
View File

@ -39,13 +39,6 @@ static int phram_erase(struct mtd_info *mtd, struct erase_info *instr)
memset(start + instr->addr, 0xff, instr->len); memset(start + instr->addr, 0xff, instr->len);
/*
* This'll catch a few races. Free the thing before returning :)
* I don't feel at all ashamed. This kind of thing is possible anyway
* with flash, but unlikely.
*/
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
} }

2
drivers/mtd/devices/pmc551.c
View File

@ -184,12 +184,10 @@ static int pmc551_erase(struct mtd_info *mtd, struct erase_info *instr)
} }
out: out:
instr->state = MTD_ERASE_DONE;
#ifdef CONFIG_MTD_PMC551_DEBUG #ifdef CONFIG_MTD_PMC551_DEBUG
printk(KERN_DEBUG "pmc551_erase() done\n"); printk(KERN_DEBUG "pmc551_erase() done\n");
#endif #endif
mtd_erase_callback(instr);
return 0; return 0;
} }

12
drivers/mtd/devices/powernv_flash.c
View File

@ -175,19 +175,11 @@ static int powernv_flash_erase(struct mtd_info *mtd, struct erase_info *erase)
{ {
int rc; int rc;
erase->state = MTD_ERASING;
/* todo: register our own notifier to do a true async implementation */
rc = powernv_flash_async_op(mtd, FLASH_OP_ERASE, erase->addr, rc = powernv_flash_async_op(mtd, FLASH_OP_ERASE, erase->addr,
erase->len, NULL, NULL); erase->len, NULL, NULL);
if (rc)
if (rc) {
erase->fail_addr = erase->addr; erase->fail_addr = erase->addr;
erase->state = MTD_ERASE_FAILED;
} else {
erase->state = MTD_ERASE_DONE;
}
mtd_erase_callback(erase);
return rc; return rc;
} }

7
drivers/mtd/devices/slram.c
View File

@ -84,12 +84,7 @@ static int slram_erase(struct mtd_info *mtd, struct erase_info *instr)
slram_priv_t *priv = mtd->priv; slram_priv_t *priv = mtd->priv;
memset(priv->start + instr->addr, 0xff, instr->len); memset(priv->start + instr->addr, 0xff, instr->len);
/* This'll catch a few races. Free the thing before returning :)
* I don't feel at all ashamed. This kind of thing is possible anyway
* with flash, but unlikely.
*/
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return(0); return(0);
} }

3
drivers/mtd/devices/spear_smi.c
View File

@ -518,7 +518,6 @@ static int spear_mtd_erase(struct mtd_info *mtd, struct erase_info *e_info)
/* preparing the command for flash */ /* preparing the command for flash */
ret = spear_smi_erase_sector(dev, bank, command, 4); ret = spear_smi_erase_sector(dev, bank, command, 4);
if (ret) { if (ret) {
e_info->state = MTD_ERASE_FAILED;
mutex_unlock(&flash->lock); mutex_unlock(&flash->lock);
return ret; return ret;
} }
@ -527,8 +526,6 @@ static int spear_mtd_erase(struct mtd_info *mtd, struct erase_info *e_info)
} }
mutex_unlock(&flash->lock); mutex_unlock(&flash->lock);
e_info->state = MTD_ERASE_DONE;
mtd_erase_callback(e_info);
return 0; return 0;
} }

3
drivers/mtd/devices/sst25l.c
View File

@ -195,7 +195,6 @@ static int sst25l_erase(struct mtd_info *mtd, struct erase_info *instr)
err = sst25l_erase_sector(flash, addr); err = sst25l_erase_sector(flash, addr);
if (err) { if (err) {
mutex_unlock(&flash->lock); mutex_unlock(&flash->lock);
instr->state = MTD_ERASE_FAILED;
dev_err(&flash->spi->dev, "Erase failed\n"); dev_err(&flash->spi->dev, "Erase failed\n");
return err; return err;
} }
@ -205,8 +204,6 @@ static int sst25l_erase(struct mtd_info *mtd, struct erase_info *instr)
mutex_unlock(&flash->lock); mutex_unlock(&flash->lock);
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
} }

4
drivers/mtd/devices/st_spi_fsm.c
View File

@ -1825,13 +1825,9 @@ static int stfsm_mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
mutex_unlock(&fsm->lock); mutex_unlock(&fsm->lock);
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
out1: out1:
instr->state = MTD_ERASE_FAILED;
mutex_unlock(&fsm->lock); mutex_unlock(&fsm->lock);
return ret; return ret;

10
drivers/mtd/lpddr/lpddr2_nvm.c
View File

@ -380,14 +380,8 @@ out:
*/ */
static int lpddr2_nvm_erase(struct mtd_info *mtd, struct erase_info *instr) static int lpddr2_nvm_erase(struct mtd_info *mtd, struct erase_info *instr)
{ {
int ret = lpddr2_nvm_do_block_op(mtd, instr->addr, instr->len, return lpddr2_nvm_do_block_op(mtd, instr->addr, instr->len,
LPDDR2_NVM_ERASE); LPDDR2_NVM_ERASE);
if (!ret) {
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
}
return ret;
} }
/* /*

2
drivers/mtd/lpddr/lpddr_cmds.c
View File

@ -693,8 +693,6 @@ static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
ofs += size; ofs += size;
len -= size; len -= size;
} }
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
} }

1
drivers/mtd/mtdconcat.c
View File

@ -446,7 +446,6 @@ static int concat_erase(struct mtd_info *mtd, struct erase_info *instr)
erase->addr = 0; erase->addr = 0;
offset += subdev->size; offset += subdev->size;
} }
instr->state = erase->state;
kfree(erase); kfree(erase);
return err; return err;

6
drivers/mtd/mtdcore.c
View File

@ -961,11 +961,9 @@ int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
if (!(mtd->flags & MTD_WRITEABLE)) if (!(mtd->flags & MTD_WRITEABLE))
return -EROFS; return -EROFS;
if (!instr->len) { if (!instr->len)
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
}
ledtrig_mtd_activity(); ledtrig_mtd_activity();
return mtd->_erase(mtd, instr); return mtd->_erase(mtd, instr);
} }

5
drivers/mtd/mtdpart.c
View File

@ -212,11 +212,6 @@ static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
return ret; return ret;
} }
void mtd_erase_callback(struct erase_info *instr)
{
}
EXPORT_SYMBOL_GPL(mtd_erase_callback);
static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{ {
struct mtd_part *part = mtd_to_part(mtd); struct mtd_part *part = mtd_to_part(mtd);

16
drivers/mtd/nand/nand_base.c
View File

@ -4604,22 +4604,20 @@ int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
if (nand_check_wp(mtd)) { if (nand_check_wp(mtd)) {
pr_debug("%s: device is write protected!\n", pr_debug("%s: device is write protected!\n",
__func__); __func__);
instr->state = MTD_ERASE_FAILED; ret = -EIO;
goto erase_exit; goto erase_exit;
} }
/* Loop through the pages */ /* Loop through the pages */
len = instr->len; len = instr->len;
instr->state = MTD_ERASING;
while (len) { while (len) {
/* Check if we have a bad block, we do not erase bad blocks! */ /* Check if we have a bad block, we do not erase bad blocks! */
if (nand_block_checkbad(mtd, ((loff_t) page) << if (nand_block_checkbad(mtd, ((loff_t) page) <<
chip->page_shift, allowbbt)) { chip->page_shift, allowbbt)) {
pr_warn("%s: attempt to erase a bad block at page 0x%08x\n", pr_warn("%s: attempt to erase a bad block at page 0x%08x\n",
__func__, page); __func__, page);
instr->state = MTD_ERASE_FAILED; ret = -EIO;
goto erase_exit; goto erase_exit;
} }
@ -4637,7 +4635,7 @@ int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
if (status) { if (status) {
pr_debug("%s: failed erase, page 0x%08x\n", pr_debug("%s: failed erase, page 0x%08x\n",
__func__, page); __func__, page);
instr->state = MTD_ERASE_FAILED; ret = -EIO;
instr->fail_addr = instr->fail_addr =
((loff_t)page << chip->page_shift); ((loff_t)page << chip->page_shift);
goto erase_exit; goto erase_exit;
@ -4654,20 +4652,14 @@ int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
chip->select_chip(mtd, chipnr); chip->select_chip(mtd, chipnr);
} }
} }
instr->state = MTD_ERASE_DONE;
ret = 0;
erase_exit: erase_exit:
ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
/* Deselect and wake up anyone waiting on the device */ /* Deselect and wake up anyone waiting on the device */
chip->select_chip(mtd, -1); chip->select_chip(mtd, -1);
nand_release_device(mtd); nand_release_device(mtd);
/* Do call back function */
if (!ret)
mtd_erase_callback(instr);
/* Return more or less happy */ /* Return more or less happy */
return ret; return ret;
} }

17
drivers/mtd/onenand/onenand_base.c
View File

@ -2143,7 +2143,6 @@ static int onenand_multiblock_erase_verify(struct mtd_info *mtd,
if (ret) { if (ret) {
printk(KERN_ERR "%s: Failed verify, block %d\n", printk(KERN_ERR "%s: Failed verify, block %d\n",
__func__, onenand_block(this, addr)); __func__, onenand_block(this, addr));
instr->state = MTD_ERASE_FAILED;
instr->fail_addr = addr; instr->fail_addr = addr;
return -1; return -1;
} }
@ -2172,8 +2171,6 @@ static int onenand_multiblock_erase(struct mtd_info *mtd,
int ret = 0; int ret = 0;
int bdry_block = 0; int bdry_block = 0;
instr->state = MTD_ERASING;
if (ONENAND_IS_DDP(this)) { if (ONENAND_IS_DDP(this)) {
loff_t bdry_addr = this->chipsize >> 1; loff_t bdry_addr = this->chipsize >> 1;
if (addr < bdry_addr && (addr + len) > bdry_addr) if (addr < bdry_addr && (addr + len) > bdry_addr)
@ -2187,7 +2184,6 @@ static int onenand_multiblock_erase(struct mtd_info *mtd,
printk(KERN_WARNING "%s: attempt to erase a bad block " printk(KERN_WARNING "%s: attempt to erase a bad block "
"at addr 0x%012llx\n", "at addr 0x%012llx\n",
__func__, (unsigned long long) addr); __func__, (unsigned long long) addr);
instr->state = MTD_ERASE_FAILED;
return -EIO; return -EIO;
} }
len -= block_size; len -= block_size;
@ -2227,7 +2223,6 @@ static int onenand_multiblock_erase(struct mtd_info *mtd,
printk(KERN_ERR "%s: Failed multiblock erase, " printk(KERN_ERR "%s: Failed multiblock erase, "
"block %d\n", __func__, "block %d\n", __func__,
onenand_block(this, addr)); onenand_block(this, addr));
instr->state = MTD_ERASE_FAILED;
instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
return -EIO; return -EIO;
} }
@ -2247,7 +2242,6 @@ static int onenand_multiblock_erase(struct mtd_info *mtd,
if (ret) { if (ret) {
printk(KERN_ERR "%s: Failed erase, block %d\n", printk(KERN_ERR "%s: Failed erase, block %d\n",
__func__, onenand_block(this, addr)); __func__, onenand_block(this, addr));
instr->state = MTD_ERASE_FAILED;
instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
return -EIO; return -EIO;
} }
@ -2259,7 +2253,6 @@ static int onenand_multiblock_erase(struct mtd_info *mtd,
/* verify */ /* verify */
verify_instr.len = eb_count * block_size; verify_instr.len = eb_count * block_size;
if (onenand_multiblock_erase_verify(mtd, &verify_instr)) { if (onenand_multiblock_erase_verify(mtd, &verify_instr)) {
instr->state = verify_instr.state;
instr->fail_addr = verify_instr.fail_addr; instr->fail_addr = verify_instr.fail_addr;
return -EIO; return -EIO;
} }
@ -2294,8 +2287,6 @@ static int onenand_block_by_block_erase(struct mtd_info *mtd,
region_end = region->offset + region->erasesize * region->numblocks; region_end = region->offset + region->erasesize * region->numblocks;
} }
instr->state = MTD_ERASING;
/* Loop through the blocks */ /* Loop through the blocks */
while (len) { while (len) {
cond_resched(); cond_resched();
@ -2305,7 +2296,6 @@ static int onenand_block_by_block_erase(struct mtd_info *mtd,
printk(KERN_WARNING "%s: attempt to erase a bad block " printk(KERN_WARNING "%s: attempt to erase a bad block "
"at addr 0x%012llx\n", "at addr 0x%012llx\n",
__func__, (unsigned long long) addr); __func__, (unsigned long long) addr);
instr->state = MTD_ERASE_FAILED;
return -EIO; return -EIO;
} }
@ -2318,7 +2308,6 @@ static int onenand_block_by_block_erase(struct mtd_info *mtd,
if (ret) { if (ret) {
printk(KERN_ERR "%s: Failed erase, block %d\n", printk(KERN_ERR "%s: Failed erase, block %d\n",
__func__, onenand_block(this, addr)); __func__, onenand_block(this, addr));
instr->state = MTD_ERASE_FAILED;
instr->fail_addr = addr; instr->fail_addr = addr;
return -EIO; return -EIO;
} }
@ -2407,12 +2396,6 @@ static int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
/* Deselect and wake up anyone waiting on the device */ /* Deselect and wake up anyone waiting on the device */
onenand_release_device(mtd); onenand_release_device(mtd);
/* Do call back function */
if (!ret) {
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
}
return ret; return ret;
} }

3
drivers/mtd/spi-nor/spi-nor.c
View File

@ -560,9 +560,6 @@ static int spi_nor_erase(struct mtd_info *mtd, struct erase_info *instr)
erase_err: erase_err:
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE); spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
instr->state = ret ? MTD_ERASE_FAILED : MTD_ERASE_DONE;
mtd_erase_callback(instr);
return ret; return ret;
} }

3
drivers/mtd/ubi/gluebi.c
View File

@ -272,12 +272,9 @@ static int gluebi_erase(struct mtd_info *mtd, struct erase_info *instr)
if (err) if (err)
goto out_err; goto out_err;
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
out_err: out_err:
instr->state = MTD_ERASE_FAILED;
instr->fail_addr = (long long)lnum * mtd->erasesize; instr->fail_addr = (long long)lnum * mtd->erasesize;
return err; return err;
} }

11
drivers/net/ethernet/sfc/falcon/mtd.c
View File

@ -24,17 +24,8 @@
static int ef4_mtd_erase(struct mtd_info *mtd, struct erase_info *erase) static int ef4_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
{ {
struct ef4_nic *efx = mtd->priv; struct ef4_nic *efx = mtd->priv;
int rc;
rc = efx->type->mtd_erase(mtd, erase->addr, erase->len); return efx->type->mtd_erase(mtd, erase->addr, erase->len);
if (rc == 0) {
erase->state = MTD_ERASE_DONE;
} else {
erase->state = MTD_ERASE_FAILED;
erase->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
}
mtd_erase_callback(erase);
return rc;
} }
static void ef4_mtd_sync(struct mtd_info *mtd) static void ef4_mtd_sync(struct mtd_info *mtd)

11
drivers/net/ethernet/sfc/mtd.c
View File

@ -24,17 +24,8 @@
static int efx_mtd_erase(struct mtd_info *mtd, struct erase_info *erase) static int efx_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
{ {
struct efx_nic *efx = mtd->priv; struct efx_nic *efx = mtd->priv;
int rc;
rc = efx->type->mtd_erase(mtd, erase->addr, erase->len); return efx->type->mtd_erase(mtd, erase->addr, erase->len);
if (rc == 0) {
erase->state = MTD_ERASE_DONE;
} else {
erase->state = MTD_ERASE_FAILED;
erase->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
}
mtd_erase_callback(erase);
return rc;
} }
static void efx_mtd_sync(struct mtd_info *mtd) static void efx_mtd_sync(struct mtd_info *mtd)

3
drivers/staging/goldfish/goldfish_nand.c
View File

@ -119,9 +119,6 @@ static int goldfish_nand_erase(struct mtd_info *mtd, struct erase_info *instr)
return -EIO; return -EIO;
} }
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0; return 0;
invalid_arg: invalid_arg:

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

@ -30,12 +30,6 @@
#include <asm/div64.h> #include <asm/div64.h>
#define MTD_ERASE_PENDING 0x01
#define MTD_ERASING 0x02
#define MTD_ERASE_SUSPEND 0x04
#define MTD_ERASE_DONE 0x08
#define MTD_ERASE_FAILED 0x10
#define MTD_FAIL_ADDR_UNKNOWN -1LL #define MTD_FAIL_ADDR_UNKNOWN -1LL
struct mtd_info; struct mtd_info;
@ -49,7 +43,6 @@ struct erase_info {
uint64_t addr; uint64_t addr;
uint64_t len; uint64_t len;
uint64_t fail_addr; uint64_t fail_addr;
u_char state;
}; };
struct mtd_erase_region_info { struct mtd_erase_region_info {
@ -589,8 +582,6 @@ extern void register_mtd_user (struct mtd_notifier *new);
extern int unregister_mtd_user (struct mtd_notifier *old); extern int unregister_mtd_user (struct mtd_notifier *old);
void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size); void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size);
void mtd_erase_callback(struct erase_info *instr);
static inline int mtd_is_bitflip(int err) { static inline int mtd_is_bitflip(int err) {
return err == -EUCLEAN; return err == -EUCLEAN;
} }