if (!erase)
             return -ENOMEM;
 
-    erase->mtd = part->mbd.mtd;
     erase->addr = xfer->Offset;
     erase->len = 1 << part->header.EraseUnitSize;
 
 
                        if (ip->Reserved0 != ip->firstUnit) {
                                struct erase_info *instr = &inftl->instr;
 
-                               instr->mtd = inftl->mbd.mtd;
-
                                /*
                                 *      Most likely this is using the
                                 *      undocumented qiuck mount feature.
           _first_? */
 
        /* Use async erase interface, test return code */
-       instr->mtd = inftl->mbd.mtd;
        instr->addr = block * inftl->EraseSize;
        instr->len = inftl->mbd.mtd->erasesize;
        /* Erase one physical eraseblock at a time, even though the NAND api
 
        /*
         * First, let's erase the flash block.
         */
-       erase.mtd = mtd;
        erase.addr = pos;
        erase.len = len;
 
 
                                erase->addr = einfo32.start;
                                erase->len = einfo32.length;
                        }
-                       erase->mtd = mtd;
 
                        ret = mtd_erase(mtd, erase);
                        kfree(erase);
 
                        erase->len = length;
 
                length -= erase->len;
-               erase->mtd = subdev;
                if ((err = mtd_erase(subdev, erase))) {
                        /* sanity check: should never happen since
                         * block alignment has been checked above */
 
        int ret;
        int page;
 
-       erase.mtd = mtd;
        erase.addr = offset;
        erase.len = mtd->erasesize;
 
 
 
        instr->addr += part->offset;
        ret = part->parent->_erase(part->parent, instr);
-       if (ret) {
-               if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
-                       instr->fail_addr -= part->offset;
-               instr->addr -= part->offset;
-       }
+       if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
+               instr->fail_addr -= part->offset;
+       instr->addr -= part->offset;
+
        return ret;
 }
 
 void mtd_erase_callback(struct erase_info *instr)
 {
-       if (instr->mtd->_erase == part_erase) {
-               struct mtd_part *part = mtd_to_part(instr->mtd);
-
-               if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
-                       instr->fail_addr -= part->offset;
-               instr->addr -= part->offset;
-       }
 }
 EXPORT_SYMBOL_GPL(mtd_erase_callback);
 
 
 
 retry:
        memset(&erase, 0, sizeof(struct erase_info));
-
-       erase.mtd       = mtd;
        erase.addr      = mtdswap_eb_offset(d, eb);
        erase.len       = mtd->erasesize;
 
 
 
                /* Attempt erase before marking OOB */
                memset(&einfo, 0, sizeof(einfo));
-               einfo.mtd = mtd;
                einfo.addr = ofs;
                einfo.len = 1ULL << chip->phys_erase_shift;
                nand_erase_nand(mtd, &einfo, 0);
 
                }
 
                memset(&einfo, 0, sizeof(einfo));
-               einfo.mtd = mtd;
                einfo.addr = to;
                einfo.len = 1 << this->bbt_erase_shift;
                res = nand_erase_nand(mtd, &einfo, 1);
 
        memset(instr, 0, sizeof(struct erase_info));
 
        /* XXX: use async erase interface, XXX: test return code */
-       instr->mtd = nftl->mbd.mtd;
        instr->addr = block * nftl->EraseSize;
        instr->len = nftl->EraseSize;
        if (mtd_erase(mtd, instr)) {
 
        if (!erase)
                return -ENOMEM;
 
-       erase->mtd = part->mbd.mtd;
        erase->addr = part->blocks[block].offset;
        erase->len = part->block_size;
 
 
        struct mtd_info *mtd = ftl->trans->mtd;
        struct erase_info erase;
 
-       erase.mtd = mtd;
        erase.addr = sm_mkoffset(ftl, zone_num, block, 0);
        erase.len = ftl->block_size;
 
 
        loff_t addr = (loff_t)ebnum * mtd->erasesize;
 
        memset(&ei, 0, sizeof(struct erase_info));
-       ei.mtd  = mtd;
        ei.addr = addr;
        ei.len  = mtd->erasesize;
 
 
        loff_t addr = (loff_t)ebnum * mtd->erasesize;
 
        memset(&ei, 0, sizeof(struct erase_info));
-       ei.mtd  = mtd;
        ei.addr = addr;
        ei.len  = mtd->erasesize * blocks;
 
 
 retry:
        memset(&ei, 0, sizeof(struct erase_info));
 
-       ei.mtd      = ubi->mtd;
        ei.addr     = (loff_t)pnum * ubi->peb_size;
        ei.len      = ubi->peb_size;
 
 
 
        memset(instr, 0, sizeof(*instr));
 
-       instr->mtd = c->mtd;
        instr->addr = jeb->offset;
        instr->len = c->sector_size;
 
 
 
 #define MTD_FAIL_ADDR_UNKNOWN -1LL
 
+struct mtd_info;
+
 /*
  * If the erase fails, fail_addr might indicate exactly which block failed. If
  * fail_addr = MTD_FAIL_ADDR_UNKNOWN, the failure was not at the device level
  * or was not specific to any particular block.
  */
 struct erase_info {
-       struct mtd_info *mtd;
        uint64_t addr;
        uint64_t len;
        uint64_t fail_addr;