/* this is the same as above but with blocks == 1 and a
* different function call.
* libmtd is mapping mtd_erase to mtd_erase_multi with 1 block
*/
static void test_mtd_erase(void **state)
{
struct libmtd *lib = mock_libmtd_open();
struct mtd_dev_info mtd;
struct erase_info_user ei;
struct erase_info_user64 ei64;
int eb = 0x3C;
int blocks = 1;
memset(&ei, 0, sizeof(ei));
memset(&ei64, 0, sizeof(ei64));
memset(&mtd, 0, sizeof(mtd));
mtd.bb_allowed = 1;
mtd.eb_cnt = 1024;
mtd.eb_size = 128;
ei64.start = (uint64_t)eb * mtd.eb_size;
ei64.length = (uint64_t)mtd.eb_size * blocks;
ei.start = ei64.start;
ei.length = ei64.length;
/* non offs64 first */
lib->offs64_ioctls = OFFS64_IOCTLS_NOT_SUPPORTED;
expect_ioctl(MEMERASE, 0, &ei);
int r = mtd_erase(lib, &mtd, 4, eb);
assert_int_equal(r, 0);
lib->offs64_ioctls = OFFS64_IOCTLS_SUPPORTED;
expect_ioctl(MEMERASE64, 0, &ei64);
r = mtd_erase(lib, &mtd, 4, eb);
assert_int_equal(r, 0);
libmtd_close(lib);
(void) state;
}
static int yaffs_mtd_erase(struct yaffs_dev *dev, int block_no)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
loff_t addr;
struct erase_info ei;
int retval = 0;
u32 block_size;
block_size = dev->param.total_bytes_per_chunk *
dev->param.chunks_per_block;
addr = ((loff_t) block_no) * block_size;
ei.mtd = mtd;
ei.addr = addr;
ei.len = block_size;
ei.time = 1000;
ei.retries = 2;
ei.callback = NULL;
ei.priv = (u_long) dev;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0))
retval = mtd_erase(mtd, &ei);
#else
retval = mtd->erase(mtd, &ei);
#endif
if (retval == 0)
return YAFFS_OK;
return YAFFS_FAIL;
}
static int multiblock_erase(int ebnum, int blocks)
{
int err;
struct erase_info ei;
loff_t addr = ebnum * mtd->erasesize;
memset(&ei, 0, sizeof(struct erase_info));
ei.mtd = mtd;
ei.addr = addr;
ei.len = mtd->erasesize * blocks;
err = mtd_erase(mtd, &ei);
if (err) {
printk(PRINT_PREF "error %d while erasing EB %d, blocks %d\n",
err, ebnum, blocks);
return err;
}
if (ei.state == MTD_ERASE_FAILED) {
printk(PRINT_PREF "some erase error occurred at EB %d,"
"blocks %d\n", ebnum, blocks);
return -EIO;
}
return 0;
}
static int mtd_test_erase_eraseblock(int ebnum, int blocks)
{
int err = 0;
struct erase_info ei = {0};
if(blocks == 0)
blocks = 1;
ei.mtd = mtd;
ei.addr = ebnum * mtd->erasesize;
ei.len = mtd->erasesize * blocks;
err = mtd_erase(mtd, &ei);
if (err) {
pr_err("error %d while erasing EB %d\n", err, ebnum);
return err;
}
if (ei.state == MTD_ERASE_FAILED) {
pr_err("Some erase error occurred at EB %d\n", ebnum);
return -EIO;
}
return 0;
}
/**
* do_sync_erase - synchronously erase a physical eraseblock.
* @ubi: UBI device description object
* @pnum: the physical eraseblock number to erase
*
* This function synchronously erases physical eraseblock @pnum and returns
* zero in case of success and a negative error code in case of failure. If
* %-EIO is returned, the physical eraseblock most probably went bad.
*/
static int do_sync_erase(struct ubi_device *ubi, int pnum)
{
int err, retries = 0;
struct erase_info ei;
wait_queue_head_t wq;
dbg_io("erase PEB %d", pnum);
retry:
init_waitqueue_head(&wq);
memset(&ei, 0, sizeof(struct erase_info));
ei.mtd = ubi->mtd;
ei.addr = (loff_t)pnum * ubi->peb_size;
ei.len = ubi->peb_size;
ei.callback = erase_callback;
ei.priv = (unsigned long)&wq;
err = mtd_erase(ubi->mtd, &ei);
if (err) {
if (retries++ < UBI_IO_RETRIES) {
dbg_io("error %d while erasing PEB %d, retry",
err, pnum);
yield();
goto retry;
}
ubi_err("cannot erase PEB %d, error %d", pnum, err);
ubi_dbg_dump_stack();
return err;
}
err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
ei.state == MTD_ERASE_FAILED);
if (err) {
ubi_err("interrupted PEB %d erasure", pnum);
return -EINTR;
}
if (ei.state == MTD_ERASE_FAILED) {
if (retries++ < UBI_IO_RETRIES) {
dbg_io("error while erasing PEB %d, retry", pnum);
yield();
goto retry;
}
ubi_err("cannot erase PEB %d", pnum);
ubi_dbg_dump_stack();
return -EIO;
}
err = paranoid_check_all_ff(ubi, pnum, 0, ubi->peb_size);
if (err)
return err > 0 ? -EINVAL : err;
if (ubi_dbg_is_erase_failure() && !err) {
dbg_err("cannot erase PEB %d (emulated)", pnum);
return -EIO;
}
return 0;
}
int nandmtd_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
{
struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context);
__u32 addr =
((loff_t) blockNumber) * dev->data_bytes_per_chunk
* dev->param.chunks_per_block;
struct erase_info ei;
int retval = 0;
ei.mtd = mtd;
ei.addr = addr;
ei.len = dev->data_bytes_per_chunk * dev->param.chunks_per_block;
ei.time = 1000;
ei.retries = 2;
ei.callback = NULL;
ei.priv = (u_long) dev;
/* Todo finish off the ei if required */
retval = mtd_erase(mtd, &ei);
if (retval == 0)
return YAFFS_OK;
else
return YAFFS_FAIL;
}
static int mtd_blockdev_erase_write(struct vmm_request *r,
physical_addr_t off,
physical_size_t len,
struct mtd_info *mtd)
{
struct erase_info info;
unsigned int retlen = 0;
info.mtd = mtd;
info.addr = off;
info.len = len;
info.callback = mtd_blockdev_erase_callback;
if (mtd_erase(mtd, &info)) {
dev_err(&r->bdev->dev, "Erasing at 0x%08X failed\n", off);
return VMM_EIO;
}
if (mtd_write(mtd, off, len, &retlen, r->data)) {
dev_err(&r->bdev->dev, "Writing at 0x%08X failed\n", off);
return VMM_EIO;
}
if (retlen < len) {
dev_warn(&r->bdev->dev, "Only 0x%X/0x%X bytes have been "
"written at 0x%08X\n", retlen, len, off);
return VMM_EIO;
}
return VMM_OK;
}
int nandmtd_erase_block(struct yaffs_dev *dev, int block_no)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
u32 addr =
((loff_t) block_no) * dev->param.total_bytes_per_chunk
* dev->param.chunks_per_block;
struct erase_info ei;
int retval = 0;
ei.mtd = mtd;
ei.addr = addr;
ei.len = dev->param.total_bytes_per_chunk * dev->param.chunks_per_block;
ei.time = 1000;
ei.retries = 2;
ei.callback = NULL;
ei.priv = (u_long) dev;
retval = mtd_erase(mtd, &ei);
if (retval == 0)
return YAFFS_OK;
else
return YAFFS_FAIL;
}
static int erase_eraseblock(int ebnum)
{
int err;
struct erase_info ei;
loff_t addr = ebnum * mtd->erasesize;
memset(&ei, 0, sizeof(struct erase_info));
ei.mtd = mtd;
ei.addr = addr;
ei.len = mtd->erasesize;
err = mtd_erase(mtd, &ei);
if (err) {
pr_err("error %d while erasing EB %d\n", err, ebnum);
return err;
}
if (ei.state == MTD_ERASE_FAILED) {
pr_err("some erase error occurred at EB %d\n",
ebnum);
return -EIO;
}
return 0;
}
static int _do_write_bootblock( struct bootconfig * bc, unsigned int block_idx )
{
int err;
char *page;
err = mtd_erase( bc->mtd, &bc->info, bc->fd, block_idx );
if (0 > err)
return 1;
page = malloc( bc->info.min_io_size );
if( NULL == page ) {
bc_log( LOG_ERR, "Error #%d malloc()ing %d bytes: %s.\n",
errno, bc->info.min_io_size, strerror(errno));
return -1;
}
memset( page, 0xFF, bc->info.min_io_size );
memcpy( page, &bc->blocks[ block_idx ], sizeof( *bc->blocks ) );
err = mtd_write( bc->mtd, &bc->info, bc->fd, block_idx, 0,
page, bc->info.min_io_size , NULL, 0, 0 );
free( page );
if (0 > err)
return 1;
return 0;
}
static int concat_dev_erase(struct mtd_info *mtd, struct erase_info *erase)
{
int err;
wait_queue_head_t waitq;
DECLARE_WAITQUEUE(wait, current);
/*
* This code was stol^H^H^H^Hinspired by mtdchar.c
*/
init_waitqueue_head(&waitq);
erase->mtd = mtd;
erase->callback = concat_erase_callback;
erase->priv = (unsigned long) &waitq;
/*
* FIXME: Allow INTERRUPTIBLE. Which means
* not having the wait_queue head on the stack.
*/
err = mtd_erase(mtd, erase);
if (!err) {
set_current_state(TASK_UNINTERRUPTIBLE);
add_wait_queue(&waitq, &wait);
if (erase->state != MTD_ERASE_DONE
&& erase->state != MTD_ERASE_FAILED)
schedule();
remove_wait_queue(&waitq, &wait);
set_current_state(TASK_RUNNING);
err = (erase->state == MTD_ERASE_FAILED) ? -EIO : 0;
}
return err;
}
static int mtd_op_erase(struct cdev *cdev, size_t count, loff_t offset)
{
struct mtd_info *mtd = cdev->priv;
struct erase_info erase;
uint32_t addr;
int ret;
ret = mtd_erase_align(mtd, &count, &offset);
if (ret)
return ret;
memset(&erase, 0, sizeof(erase));
erase.mtd = mtd;
addr = offset;
if (!mtd->block_isbad) {
erase.addr = addr;
erase.len = count;
return mtd_erase(mtd, &erase);
}
erase.len = mtd->erasesize;
while (count > 0) {
dev_dbg(cdev->dev, "erase %d %d\n", addr, erase.len);
if (!mtd->allow_erasebad)
ret = mtd_block_isbad(mtd, addr);
else
ret = 0;
erase.addr = addr;
if (ret > 0) {
printf("Skipping bad block at 0x%08x\n", addr);
} else {
ret = mtd_erase(mtd, &erase);
if (ret)
return ret;
}
addr += mtd->erasesize;
count -= count > mtd->erasesize ? mtd->erasesize : count;
}
return 0;
}
int mtd_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "start")) {
/* start mapping according to user request */
if (argc >= 3) {
mtd_start(argv + 2, argc - 2);
} else {
mtd_start(partition_names_default, n_partitions_default);
}
}
if (!strcmp(argv[1], "test"))
mtd_test();
if (!strcmp(argv[1], "readtest")) {
if (argc >= 3) {
mtd_readtest(argv + 2, argc - 2);
} else {
mtd_readtest(partition_names_default, n_partitions_default);
}
}
if (!strcmp(argv[1], "rwtest")) {
if (argc >= 3) {
mtd_rwtest(argv + 2, argc - 2);
} else {
mtd_rwtest(partition_names_default, n_partitions_default);
}
}
if (!strcmp(argv[1], "status"))
mtd_status();
if (!strcmp(argv[1], "erase")) {
if (argc >= 3) {
mtd_erase(argv + 2, argc - 2);
} else {
mtd_erase(partition_names_default, n_partitions_default);
}
}
}
errx(1, "expected a command, try 'start', 'erase', 'status', 'readtest', 'rwtest' or 'test'");
}
int mtd_torture(const struct mtd_dev_info *mtd, int fd, int eb)
{
int err, i, patt_count;
void *buf;
normsg("run torture test for PEB %d", eb);
patt_count = ARRAY_SIZE(patterns);
buf = malloc(mtd->eb_size);
if (!buf) {
errmsg("cannot allocate %d bytes of memory", mtd->eb_size);
return -1;
}
for (i = 0; i < patt_count; i++) {
err = mtd_erase(mtd, fd, eb);
if (err)
goto out;
/* Make sure the PEB contains only 0xFF bytes */
err = mtd_read(mtd, fd, eb, 0, buf, mtd->eb_size);
if (err)
goto out;
err = check_pattern(buf, 0xFF, mtd->eb_size);
if (err == 0) {
errmsg("erased PEB %d, but a non-0xFF byte found", eb);
errno = EIO;
goto out;
}
/* Write a pattern and check it */
memset(buf, patterns[i], mtd->eb_size);
err = mtd_write(mtd, fd, eb, 0, buf, mtd->eb_size);
if (err)
goto out;
memset(buf, ~patterns[i], mtd->eb_size);
err = mtd_read(mtd, fd, eb, 0, buf, mtd->eb_size);
if (err)
goto out;
err = check_pattern(buf, patterns[i], mtd->eb_size);
if (err == 0) {
errmsg("pattern %x checking failed for PEB %d",
patterns[i], eb);
errno = EIO;
goto out;
}
}
err = 0;
normsg("PEB %d passed torture test, do not mark it a bad", eb);
out:
free(buf);
return -1;
}
int main(void)
{
while(1){
mtd_erase();
mtd_write();
sleep(1);
}
return 0;
}
static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
{
struct mtd_part *part = PART(mtd);
int ret;
instr->addr += part->offset;
ret = mtd_erase(part->master, instr);
if (ret) {
if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
instr->fail_addr -= part->offset;
instr->addr -= part->offset;
}
return ret;
}
static int _dev_erase(const struct lfs_config *c, lfs_block_t block)
{
littlefs_desc_t *fs = c->context;
mtd_dev_t *mtd = fs->dev;
DEBUG("lfs_erase: c=%p, block=%" PRIu32 "\n", (void *)c, block);
int ret = mtd_erase(mtd, ((fs->base_addr + block) * c->block_size), c->block_size);
if (ret >= 0) {
return 0;
}
return ret;
}
static int erase_write (struct mtd_info *mtd, unsigned long pos,
int len, const char *buf)
{
struct erase_info erase;
DECLARE_WAITQUEUE(wait, current);
wait_queue_head_t wait_q;
size_t retlen;
int ret;
/*
* First, let's erase the flash block.
*/
init_waitqueue_head(&wait_q);
erase.mtd = mtd;
erase.callback = erase_callback;
erase.addr = pos;
erase.len = len;
erase.priv = (u_long)&wait_q;
set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&wait_q, &wait);
ret = mtd_erase(mtd, &erase);
if (ret) {
set_current_state(TASK_RUNNING);
remove_wait_queue(&wait_q, &wait);
printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] "
"on \"%s\" failed\n",
pos, len, mtd->name);
return ret;
}
schedule(); /* Wait for erase to finish. */
remove_wait_queue(&wait_q, &wait);
/*
* Next, write the data to flash.
*/
ret = mtd_write(mtd, pos, len, &retlen, buf);
if (ret)
return ret;
if (retlen != len)
return -EIO;
return 0;
}
int saveenv(void)
{
env_t env_new;
ssize_t len;
char *res;
struct mtd_info *mtd = &onenand_mtd;
#ifdef CONFIG_ENV_ADDR_FLEX
struct onenand_chip *this = &onenand_chip;
#endif
loff_t env_addr = CONFIG_ENV_ADDR;
size_t retlen;
struct erase_info instr = {
.callback = NULL,
};
res = (char *)&env_new.data;
len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
if (len < 0) {
error("Cannot export environment: errno = %d\n", errno);
return 1;
}
env_new.crc = crc32(0, env_new.data, ENV_SIZE);
instr.len = CONFIG_ENV_SIZE;
#ifdef CONFIG_ENV_ADDR_FLEX
if (FLEXONENAND(this)) {
env_addr = CONFIG_ENV_ADDR_FLEX;
instr.len = CONFIG_ENV_SIZE_FLEX;
instr.len <<= onenand_mtd.eraseregions[0].numblocks == 1 ?
1 : 0;
}
#endif
instr.addr = env_addr;
instr.mtd = mtd;
if (mtd_erase(mtd, &instr)) {
printf("OneNAND: erase failed at 0x%08llx\n", env_addr);
return 1;
}
if (mtd_write(mtd, env_addr, ONENAND_MAX_ENV_SIZE, &retlen,
(u_char *)&env_new)) {
printf("OneNAND: write failed at 0x%llx\n", instr.addr);
return 2;
}
return 0;
}
static int flash_erase(struct vmm_chardev *cdev,
flash_op *op)
{
struct erase_info info;
if (op->len & op->mtd->erasesize_mask) {
vmm_cprintf(cdev, "Uncorrect length 0x%X, a block size is "
"0x%08X\n", op->len, op->mtd->erasesize);
return VMM_EFAIL;
}
op->offset &= ~op->mtd->erasesize_mask;
while (op->len) {
if (mtd_block_isbad(op->mtd, op->offset)) {
vmm_cprintf(cdev, "%s block at 0x%08X is bad, "
"skipping...", op->mtd->name, op->offset);
op->offset += op->mtd->erasesize;
op->len -= op->mtd->erasesize;
continue;
}
vmm_cprintf(cdev, "This will erasing the %s block at "
"0x%08X\n", op->mtd->name, op->offset);
if (!flash_question(cdev)) {
vmm_cprintf(cdev, "Skipping...\n");
op->offset += op->mtd->erasesize;
op->len -= op->mtd->erasesize;
continue;
}
vmm_cprintf(cdev, "Erasing...\n");
memset(&info, 0, sizeof (struct erase_info));
info.mtd = op->mtd;
info.addr = op->offset;
info.len = op->len;
info.priv = (u_long)cdev;
info.callback = flash_erase_cb;
vmm_printf("Sizeof %zu, Addr 0x%p, cb 0x%p\n",
sizeof (struct erase_info),
&info, info.callback);
mtd_erase(op->mtd, &info);
}
return VMM_OK;
}
static int multiblock_erase(int ebnum, int blocks)
{
int err;
struct erase_info ei;
loff_t addr = (loff_t)ebnum * mtd->erasesize;
memset(&ei, 0, sizeof(struct erase_info));
ei.addr = addr;
ei.len = mtd->erasesize * blocks;
err = mtd_erase(mtd, &ei);
if (err) {
pr_err("error %d while erasing EB %d, blocks %d\n",
err, ebnum, blocks);
return err;
}
return 0;
}
static int env_onenand_save(void)
{
env_t env_new;
int ret;
struct mtd_info *mtd = &onenand_mtd;
#ifdef CONFIG_ENV_ADDR_FLEX
struct onenand_chip *this = &onenand_chip;
#endif
loff_t env_addr = CONFIG_ENV_ADDR;
size_t retlen;
struct erase_info instr = {
.callback = NULL,
};
ret = env_export(&env_new);
if (ret)
return ret;
instr.len = CONFIG_ENV_SIZE;
#ifdef CONFIG_ENV_ADDR_FLEX
if (FLEXONENAND(this)) {
env_addr = CONFIG_ENV_ADDR_FLEX;
instr.len = CONFIG_ENV_SIZE_FLEX;
instr.len <<= onenand_mtd.eraseregions[0].numblocks == 1 ?
1 : 0;
}
#endif
instr.addr = env_addr;
instr.mtd = mtd;
if (mtd_erase(mtd, &instr)) {
printf("OneNAND: erase failed at 0x%08llx\n", env_addr);
return 1;
}
if (mtd_write(mtd, env_addr, ONENAND_MAX_ENV_SIZE, &retlen,
(u_char *)&env_new)) {
printf("OneNAND: write failed at 0x%llx\n", instr.addr);
return 2;
}
return 0;
}
static int mtdoops_erase_block(struct mtdoops_context *cxt, int offset)
{
struct mtd_info *mtd = cxt->mtd;
u32 start_page_offset = mtd_div_by_eb(offset, mtd) * mtd->erasesize;
u32 start_page = start_page_offset / record_size;
u32 erase_pages = mtd->erasesize / record_size;
struct erase_info erase;
DECLARE_WAITQUEUE(wait, current);
wait_queue_head_t wait_q;
int ret;
int page;
init_waitqueue_head(&wait_q);
erase.mtd = mtd;
erase.callback = mtdoops_erase_callback;
erase.addr = offset;
erase.len = mtd->erasesize;
erase.priv = (u_long)&wait_q;
set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&wait_q, &wait);
ret = mtd_erase(mtd, &erase);
if (ret) {
set_current_state(TASK_RUNNING);
remove_wait_queue(&wait_q, &wait);
printk(KERN_WARNING "mtdoops: erase of region [0x%llx, 0x%llx] on \"%s\" failed\n",
(unsigned long long)erase.addr,
(unsigned long long)erase.len, mtddev);
return ret;
}
schedule(); /* Wait for erase to finish. */
remove_wait_queue(&wait_q, &wait);
/* Mark pages as unused */
for (page = start_page; page < start_page + erase_pages; page++)
mark_page_unused(cxt, page);
return 0;
}
static int erase_eraseblock(unsigned int ebnum)
{
int err = 0;
struct erase_info ei = {0};
ei.mtd = mtd;
ei.addr = ebnum * mtd->erasesize;
ei.len = mtd->erasesize;
err = mtd_erase(mtd, &ei);
if (err) {
pr_err("err %d while erasing EB %d\n", err, ebnum);
return err;
}
if (ei.state == MTD_ERASE_FAILED) {
pr_err("some erase error occurred at EB %d\n", ebnum);
return -EIO;
}
return 0;
}
static int mtdraw_erase(struct cdev *cdev, size_t count, loff_t _offset)
{
struct mtd_info *mtd = to_mtd(cdev);
struct erase_info erase;
unsigned long offset = _offset;
int ret;
offset = offset / (mtd->writesize + mtd->oobsize) * mtd->writesize;
count = count / (mtd->writesize + mtd->oobsize) * mtd->writesize;
memset(&erase, 0, sizeof(erase));
erase.mtd = mtd;
erase.addr = offset;
erase.len = mtd->erasesize;
while (count > 0) {
debug("erase %d %d\n", erase.addr, erase.len);
if (!mtd->allow_erasebad)
ret = mtd_block_isbad(mtd, erase.addr);
else
ret = 0;
if (ret > 0) {
printf("Skipping bad block at 0x%08x\n", erase.addr);
} else {
ret = mtd_erase(mtd, &erase);
if (ret)
return ret;
}
erase.addr += mtd->erasesize;
count -= count > mtd->erasesize ? mtd->erasesize : count;
}
return 0;
}
int main (int argc, char **argv)
{
int ch, i, boot, imagefd = 0, force, unlocked;
char *erase[MAX_ARGS], *device = NULL;
char *fis_layout = NULL;
size_t offset = 0, part_offset = 0, dump_len = 0;
enum {
CMD_ERASE,
CMD_WRITE,
CMD_UNLOCK,
CMD_JFFS2WRITE,
CMD_FIXTRX,
CMD_FIXSEAMA,
CMD_VERIFY,
CMD_DUMP,
} cmd = -1;
erase[0] = NULL;
boot = 0;
force = 0;
buflen = 0;
quiet = 0;
no_erase = 0;
while ((ch = getopt(argc, argv,
#ifdef FIS_SUPPORT
"F:"
#endif
"frnqe:d:s:j:p:o:l:")) != -1)
switch (ch) {
case 'f':
force = 1;
break;
case 'r':
boot = 1;
break;
case 'n':
no_erase = 1;
break;
case 'j':
jffs2file = optarg;
break;
case 's':
errno = 0;
jffs2_skip_bytes = strtoul(optarg, 0, 0);
if (errno) {
fprintf(stderr, "-s: illegal numeric string\n");
usage();
}
break;
case 'q':
quiet++;
break;
case 'e':
i = 0;
while ((erase[i] != NULL) && ((i + 1) < MAX_ARGS))
i++;
erase[i++] = optarg;
erase[i] = NULL;
break;
case 'd':
jffs2dir = optarg;
break;
case 'p':
errno = 0;
part_offset = strtoul(optarg, 0, 0);
if (errno) {
fprintf(stderr, "-p: illegal numeric string\n");
usage();
}
break;
case 'l':
errno = 0;
dump_len = strtoul(optarg, 0, 0);
if (errno) {
fprintf(stderr, "-l: illegal numeric string\n");
usage();
}
break;
case 'o':
errno = 0;
offset = strtoul(optarg, 0, 0);
if (errno) {
fprintf(stderr, "-o: illegal numeric string\n");
usage();
}
break;
#ifdef FIS_SUPPORT
case 'F':
fis_layout = optarg;
break;
#endif
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc < 2)
usage();
if ((strcmp(argv[0], "unlock") == 0) && (argc == 2)) {
cmd = CMD_UNLOCK;
device = argv[1];
} else if ((strcmp(argv[0], "erase") == 0) && (argc == 2)) {
cmd = CMD_ERASE;
device = argv[1];
} else if (((strcmp(argv[0], "fixtrx") == 0) && (argc == 2)) && mtd_fixtrx) {
cmd = CMD_FIXTRX;
device = argv[1];
} else if (((strcmp(argv[0], "fixseama") == 0) && (argc == 2)) && mtd_fixseama) {
cmd = CMD_FIXSEAMA;
device = argv[1];
} else if ((strcmp(argv[0], "verify") == 0) && (argc == 3)) {
cmd = CMD_VERIFY;
imagefile = argv[1];
device = argv[2];
} else if ((strcmp(argv[0], "dump") == 0) && (argc == 2)) {
cmd = CMD_DUMP;
device = argv[1];
} else if ((strcmp(argv[0], "write") == 0) && (argc == 3)) {
cmd = CMD_WRITE;
device = argv[2];
if (strcmp(argv[1], "-") == 0) {
imagefile = "<stdin>";
imagefd = 0;
} else {
imagefile = argv[1];
if ((imagefd = open(argv[1], O_RDONLY)) < 0) {
fprintf(stderr, "Couldn't open image file: %s!\n", imagefile);
exit(1);
}
}
if (!mtd_check(device)) {
fprintf(stderr, "Can't open device for writing!\n");
exit(1);
}
/* check trx file before erasing or writing anything */
if (!image_check(imagefd, device) && !force) {
fprintf(stderr, "Image check failed.\n");
exit(1);
}
} else if ((strcmp(argv[0], "jffs2write") == 0) && (argc == 3)) {
cmd = CMD_JFFS2WRITE;
device = argv[2];
imagefile = argv[1];
if (!mtd_check(device)) {
fprintf(stderr, "Can't open device for writing!\n");
exit(1);
}
} else {
usage();
}
sync();
i = 0;
unlocked = 0;
while (erase[i] != NULL) {
mtd_unlock(erase[i]);
mtd_erase(erase[i]);
if (strcmp(erase[i], device) == 0)
unlocked = 1;
i++;
}
switch (cmd) {
case CMD_UNLOCK:
if (!unlocked)
mtd_unlock(device);
break;
case CMD_VERIFY:
mtd_verify(device, imagefile);
break;
case CMD_DUMP:
mtd_dump(device, offset, dump_len);
break;
case CMD_ERASE:
if (!unlocked)
mtd_unlock(device);
mtd_erase(device);
break;
case CMD_WRITE:
if (!unlocked)
mtd_unlock(device);
mtd_write(imagefd, device, fis_layout, part_offset);
break;
case CMD_JFFS2WRITE:
if (!unlocked)
mtd_unlock(device);
mtd_write_jffs2(device, imagefile, jffs2dir);
break;
case CMD_FIXTRX:
if (mtd_fixtrx) {
mtd_fixtrx(device, offset);
}
case CMD_FIXSEAMA:
if (mtd_fixseama)
mtd_fixseama(device, 0);
break;
}
sync();
if (boot)
do_reboot();
return 0;
}
int mtd_main(int argc, char *argv[])
{
uint8_t test_value = 100;
if (argc >= 2) {
if (!strcmp(argv[1], "start")) {
/* start mapping according to user request */
if (argc >= 3) {
mtd_start(argv + 2, argc - 2);
} else {
mtd_start(partition_names_default, n_partitions_default);
}
}
if (!strcmp(argv[1], "test"))
if (argc >= 5) {
if (argc >= 6) {
// grab the desired value to write/check
test_value = atoi(argv[5]);
}
if (!strcmp(argv[3], "w")) {
mtd_test_custom(argv[2], true, atoi(argv[4]), test_value);
}
else {
mtd_test_custom(argv[2], false, atoi(argv[4]), test_value);
}
}
else {
mtd_test();
}
if (!strcmp(argv[1], "readtest")) {
if (argc >= 3) {
mtd_readtest(argv + 2, argc - 2);
} else {
mtd_readtest(partition_names_default, n_partitions_default);
}
}
if (!strcmp(argv[1], "rwtest")) {
if (argc >= 3) {
mtd_rwtest(argv + 2, argc - 2);
} else {
mtd_rwtest(partition_names_default, n_partitions_default);
}
}
if (!strcmp(argv[1], "status"))
mtd_status();
if (!strcmp(argv[1], "erase")) {
if (argc >= 3) {
mtd_erase(argv + 2, argc - 2);
} else {
mtd_erase(partition_names_default, n_partitions_default);
}
}
}
errx(1, "expected a command, try 'start', 'erase', 'status', 'readtest', 'rwtest' or 'test'");
}
s32 nv_emmc_remove(const s8* path)
{
s32 ret = -1;
struct nv_emmc_file_header_stru* fd = NULL;
struct erase_info erase = {0,};
struct mtd_info* mtd = NULL;
u32 i = 0;
nv_file_debug(NV_FILE_REMOVE_API,0,0,0,0);
for(i=0;i<NV_FILE_BUTT;i++)
{
if(0 == strcmp(path,g_nv_file[i].path))
{
fd = &g_nv_file[i];
break;
}
}
if(NULL == fd)
{
nv_file_debug(NV_FILE_REMOVE_API,1,0,0,0);
return -1;
}
switch(fd->emmc_type)
{
case NV_FILE_DLOAD:
g_emmc_info.nv_dload.nv_bin.magic_num = NV_FLASH_NULL;
break;
case NV_FILE_BACKUP:
memset(&g_emmc_info.bak_sec,NV_FLASH_FILL,sizeof(struct nv_file_info_stru));
goto flash_erase;
case NV_FILE_CUST_CARD_1:
g_emmc_info.nv_dload.cust_xml[0].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_CARD_1:
g_emmc_info.nv_dload.xnv_xml[0].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_CUST_CARD_2:
g_emmc_info.nv_dload.cust_xml[1].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_CARD_2:
g_emmc_info.nv_dload.xnv_xml[1].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_MAP_CARD_1:
g_emmc_info.nv_dload.xnv_map[0].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_XNV_MAP_CARD_2:
g_emmc_info.nv_dload.xnv_map[1].magic_num = NV_FLASH_NULL;
break;
case NV_FILE_DEFAULT:
memset(&g_emmc_info.def_sec,NV_FLASH_FILL,sizeof(struct nv_file_info_stru));
goto flash_erase;
case NV_FILE_SYS_NV:
memset(&g_emmc_info.sys_nv,NV_FLASH_FILL,sizeof(g_emmc_info.sys_nv));
goto flash_erase;
default:
return BSP_ERR_NV_INVALID_PARAM;
}
if(true == nv_dload_exist_file())
{
return NV_OK;
}
flash_erase:
mtd = get_mtd_device_nm(fd->name);
if(IS_ERR(mtd))
{
printf("[%s]:get mtd device err! %s\n",__func__,fd->name);
return -1;
}
erase.addr = 0;
erase.mtd = mtd;
erase.len = mtd->size;
erase.callback = NULL;
erase.priv = 0;
erase.time = 10000;
erase.retries = 2;
ret = mtd_erase(mtd,&erase);
mtd_sync(mtd);
put_mtd_device(mtd);
if(ret)
{
nv_file_debug(NV_FILE_REMOVE_API,2,(u32)ret,fd->emmc_type,0);
printf("[%s]:ret 0x%x,mtd->name %s\n",__func__,ret,mtd->name);
return ret;
}
return NV_OK;
}
/*===========================================================================
FUNCTION FLASH_UPDATE_SHARE_REGION_INFO
DESCRIPTION
update user flag,nv_mbn,and iso header info in the share region.
This function use page to store these info,
Page 0: Share region Info:
Magic:
Sub region len:
Page 1: Nv restore flag:
In Used Flag Magic: 4 Byte
Auto Restore Magic: 4Byte
Auto Restore Flag:
Page 2:
In User Flag Magic:
MBN Magic:
MBN Info Num:
MBN: Version:
MBN nv data
Page 3:
ISO Header Info;
We use two block to implement this feature, when the first time to update this feature directly write it to the
first available block,and then we update this info then firstly read the page info to cache, update the cache value
and then write it to another block, erase lasted block.
Author: ChenFeng 2010-3-20
RETURN VALUE
TRUE if Op Succeed
FALSE if Op Failure
SIDE EFFECTS
None
===========================================================================*/
boolean flash_update_share_region_info(rgn_pos_e_type region_type,void* data)
{
unsigned int block_index = 0;
unsigned int start_index = 0;
unsigned int blk_size = 0;
unsigned int blk_count = 0;
unsigned int max_rgn_num = 0;
unsigned int dest_block = 0;
unsigned int current_block = INVALID_BLOCK_ID;
unsigned int current_page = INVALID_PAGE_ID;
unsigned int dest_page = INVALID_PAGE_ID;
rgn_hd_type* rgn_hd = NULL;
unsigned int offset = 0;
unsigned int page_size = 0;
uint8 * cache_buf = NULL;
unsigned int start_offset = 0;
struct erase_info instr;
int retlength = 0;
rgn_hd_type rgn_hd_1 = {0};
/*入参条件检测*/
if (region_type >= RGN_MAX_NUM || NULL == data)
{
printk(KERN_ERR "Input parm error \n");
return FALSE;
}
if(NULL == flash_nand_oper_region_init(SHARE_REGION))
{
printk(KERN_ERR "flash_update_share_region_info init error \n");
return FALSE;
}
/*Get Partition and Device Info*/
blk_count = child_region[SHARE_REGION].length;
blk_size = operation_region[SHARE_REGION].block_size;
start_offset = operation_region[SHARE_REGION].start_addr;
page_size = operation_region[SHARE_REGION].page_size;
cache_buf = operation_region[SHARE_REGION].buffer;
instr.mtd = g_mtd;
instr.len = g_mtd->erasesize;
instr.callback = NULL;
instr.priv = 0;
/*instr.addr*/
for (block_index = 0; block_index < blk_count; block_index++)
{
offset = start_offset + blk_size * block_index;
/*If the blk is bad blk or it is erase */
if (mtd_block_isbad(g_mtd, offset))
{
printk(KERN_DEBUG "Find Current Block ID = 0x%x is bad block \n",(offset / blk_size));
continue;
}
/*lint -e64*/
if (!mtd_read(g_mtd, offset, page_size, &retlength, (unsigned char*)cache_buf))
/*lint +e64*/
{
/*Firstly we need to check the Share Region Info,If it was a valid block
then read corresponding page*/
rgn_hd = (rgn_hd_type*)cache_buf;
if (SHARE_RGN_MAGIC == rgn_hd->magic)
{
current_page = block_index * blk_size;
max_rgn_num = rgn_hd->sub_rgn_num;
current_block = block_index;
printk(KERN_DEBUG "Print entery current page = 0x%x max_rgn_num = 0x%x \n",
current_page, max_rgn_num);
break;
}
else
{
instr.addr = offset;
if (mtd_erase(g_mtd, &instr))
{
printk(KERN_DEBUG "Current Erase error ,Mark bad block \n");
/* mark bad */
mtd_block_markbad(g_mtd, offset);
}
printk(KERN_DEBUG "Print nand_erase offset = 0x%x \n", offset);
continue;
}
}
else
{
printk(KERN_ERR "Nand_read error !\n");
return FALSE;
}
}
printk(KERN_DEBUG "Print first current page = %u \n", current_page);
if(block_index != blk_count)
{
/*从 当前block 的 下一个block 分区开始寻找下一个 没使用的BLOCK*/
dest_block = (block_index + 1) % blk_count;
}
/*Find the first unused block*/
for (block_index = 0; block_index < blk_count; block_index++)
{
offset = start_offset + dest_block * blk_size;
if (mtd_block_isbad(g_mtd, offset))
{
printk(KERN_DEBUG "Find Dest Block ID = 0x%x is bad block \n", (offset / blk_size));
continue;
}
else
{
if (current_block != dest_block)
{
instr.addr = offset;
if (mtd_erase(g_mtd, &instr))
{
/* mark bad */
mtd_block_markbad(g_mtd, offset);
dest_block = (dest_block + 1) % blk_count;
printk(KERN_DEBUG "Dest Erase error ,Mark bad block \n");
continue;
}
dest_page = dest_block * blk_size;
break;
}
}
dest_block = (dest_block + 1) % blk_count;
}
/*将当前页的数据和更新的数据分别取出写入目标BLOCK*/
if (INVALID_PAGE_ID != dest_page)
{
start_index = 0;
/*第一次升级SHARE RGN分区 或者RGN_MAX_NUM有变化*/
if ((unsigned int)region_type >= max_rgn_num)
{
offset = start_offset;
memset(cache_buf,0xFF, page_size); /*flash 操作buf 清为0XFF*/
rgn_hd_1.magic = SHARE_RGN_MAGIC;
rgn_hd_1.sub_rgn_num = RGN_MAX_NUM;
memcpy(cache_buf,(void *)&rgn_hd_1,sizeof(rgn_hd_type));
printk(KERN_DEBUG "Print First Dest page = %u \n",dest_page);
/*擦除当前BLOCK*/
if ((INVALID_BLOCK_ID == current_block) || (0 < max_rgn_num))
{
offset = offset + dest_page;
}
else
{
offset = offset + current_page;
}
/*lint -e64*/
if (mtd_write(g_mtd, offset, page_size, &retlength,
(unsigned char*)cache_buf))
/*lint +e64*/
{
printk(KERN_ERR "nand_write rgn_hd error \n");
goto FalseQuit;
}
memset(cache_buf,0xFF, page_size); /*flash 操作buf 清为0XFF*/
memcpy(cache_buf,data,page_size);
/*lint -e64*/
if (mtd_write(g_mtd, (offset + region_type * page_size),
page_size, &retlength, (unsigned char*)cache_buf))
/*lint +e64*/
{
printk(KERN_ERR "nand_write region page error \n");
goto FalseQuit;
}
start_index = 1;
}
if (INVALID_PAGE_ID != current_page && dest_page != current_page)
{
offset = start_offset;
printk(KERN_DEBUG "Print not First Dest page = %u \n",dest_page);
printk(KERN_DEBUG "Print last current page = %u \n",current_page);
for (; start_index < max_rgn_num; start_index++)
{
if (start_index != region_type)
{
memset(cache_buf,0xFF, page_size); /*flash 操作buf 清为0XFF*/
/*lint -e64*/
if (!mtd_read(g_mtd,(offset + current_page + start_index * page_size),
page_size, &retlength,(unsigned char*)cache_buf))
/*lint +e64*/
{
if (0 == start_index)
{
rgn_hd_type *temp_hd = NULL;
temp_hd = (rgn_hd_type *)cache_buf;
printk(KERN_DEBUG "magic = 0x%x max_num = 0x%x \n", (unsigned int)temp_hd->magic,
(unsigned int)temp_hd->sub_rgn_num);
}
/*lint -e64*/
if (mtd_write(g_mtd, (offset + dest_page
+ start_index * page_size),
page_size, &retlength, (unsigned char*)cache_buf))
/*lint -e64*/
{
printk(KERN_DEBUG "nand_write start_index = %u offset = 0x%x\n",
start_index, (offset + dest_page
+ region_type * page_size));
continue;
}
}
}
else
{
memset(cache_buf,0xFF, page_size); /*flash 操作buf 清为0XFF*/
memcpy(cache_buf,data,page_size);
/*lint -e64*/
if (mtd_write(g_mtd, (offset + dest_page + region_type * page_size),
page_size, &retlength, (unsigned char*)cache_buf))
/*lint -e64*/
{
printk(KERN_ERR "nand_write error \n");
goto FalseQuit;
}
printk(KERN_DEBUG "Write offset = 0x%x ! \n",
(offset + dest_page + region_type * page_size));
}
}
instr.addr = offset + current_page;
if (!mtd_erase(g_mtd, &instr))
{
printk(KERN_DEBUG "nand_erase offset = 0x%x ! \n",(offset + current_page));
}
else
{
printk(KERN_DEBUG "Last Erase current error ,Mark bad block \n");
/* mark bad */
mtd_block_markbad(g_mtd, offset);
goto FalseQuit;
}
}
else if (dest_page == current_page)
{
printk(KERN_DEBUG "Error dest_page == current_page offset = 0x%x \n", current_page);
goto FalseQuit;
}
flash_nand_oper_region_close(SHARE_REGION);
return TRUE;
}
FalseQuit:
printk(KERN_ERR "flash_update_share_region_info error \n");
flash_nand_oper_region_close(SHARE_REGION);
return FALSE;
}
/*
* Flash API: ra_mtd_read, ra_mtd_write
* Arguments:
* - num: specific the mtd number
* - to/from: the offset to read from or written to
* - len: length
* - buf: data to be read/written
* Returns:
* - return -errno if failed
* - return the number of bytes read/written if successed
*/
int ra_mtd_write_nm(char *name, loff_t to, size_t len, const u_char *buf)
{
int ret = -1;
size_t rdlen, wrlen;
struct mtd_info *mtd;
struct erase_info ei;
u_char *bak = NULL;
mtd = get_mtd_device_nm(name);
if (IS_ERR(mtd)) {
ret = (int)mtd;
goto out;
}
if (len > mtd->erasesize) {
put_mtd_device(mtd);
ret = -E2BIG;
goto out;
}
bak = kzalloc(mtd->erasesize, GFP_KERNEL);
if (bak == NULL) {
put_mtd_device(mtd);
ret = -ENOMEM;
goto out;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)
ret = mtd_read(mtd, 0, mtd->erasesize, &rdlen, bak);
#else
ret = mtd->read(mtd, 0, mtd->erasesize, &rdlen, bak);
#endif
if (ret) {
goto free_out;
}
if (rdlen != mtd->erasesize)
printk("warning: ra_mtd_write_nm: rdlen is not equal to erasesize\n");
memcpy(bak + to, buf, len);
ei.mtd = mtd;
ei.callback = NULL;
ei.addr = 0;
ei.len = mtd->erasesize;
ei.priv = 0;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)
ret = mtd_erase(mtd, &ei);
#else
ret = mtd->erase(mtd, &ei);
#endif
if (ret != 0)
goto free_out;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)
ret = mtd_write(mtd, 0, mtd->erasesize, &wrlen, bak);
#else
ret = mtd->write(mtd, 0, mtd->erasesize, &wrlen, bak);
#endif
udelay(10); /* add delay after write */
free_out:
if (mtd)
put_mtd_device(mtd);
if (bak)
kfree(bak);
out:
return ret;
}
