mtdcore.c

使用Linux ARM GCC编译器来编译

    		}
		} else printk("skipping bad block:%08lx\n",to);
	}

	if (offs<size)
	    return -1;

	return 0;
}

static int 
write_to_nand(struct mtd_info *mtd, loff_t ofs, size_t len, 
             const u_char *buf, int flag)
{
	struct erase_info instr;
	int ret = 0;
	__u32 retlen = 0;
	mtd_partition_t *part;
	size_t blk_size = find_erase_size(mtd, ofs, len);
	ulong offs;

	printk("Found block size = 0x%08lx\n", blk_size);

	instr.addr = ofs;
	instr.len = blk_size;

	if (!(flag & MF_BONFS)) {
		if (1||flag & MF_YAFFS) {
		    // erase all the part
		    part = find_mtd_partition(ofs);
		    if (part) {
		        instr.addr = part->offset;
	            instr.len = part->size;
	        }
		}
		printk("Erasing...   "/*, 
			instr.addr, instr.addr + instr.len*/);
		ret = mtd->erase(mtd, &instr);
		if (ret) {
			printk(" ... failed\n");
			return ret;
		}
			printk(" ... done\n");
	}

	printk("Writing...   ");
	retlen = 0;
	if (flag & MF_BONFS) {
#ifdef CONFIG_MTD_SMC
		read_bon_partition(mtd);
		ret = write_bon_image(mtd, (ulong)ofs, (char *)buf, (long)len);
		retlen = len;
#endif
	} else if (flag & MF_YAFFS) {
	    ret = write_yaffs_image(mtd, (ulong)ofs, (char *)buf, (long)len);
		retlen = len;
	} else {
		for(offs=0; offs<len && ofs<instr.addr+instr.len; ofs += mtd->erasesize)
	  {
		  //ret = mtd->write(mtd, ofs, len, &retlen, buf);
		  if (!(mtd->block_isbad(mtd,ofs))) {
		    ret = mtd->write(mtd, ofs, mtd->erasesize, &retlen, &buf[offs]);
		    if ((ret < 0) || (retlen != mtd->erasesize) ) {
		      mtd->block_markbad(mtd, ofs);
		      continue;
		    }
		    offs += mtd->erasesize;
		  }
		}
		if (offs<len) {
		  ret = -1;
		} else {
		  ret = 0;
		  retlen = len;
		}
	}
	if ((ret < 0) || (retlen != len)) {
		printk(" ... failed\n\tretlen = %d, ret = %d\n", retlen, ret);
		return ret;
	} else {
		printk(" ... done\n");
	}

	/* OK. well done. */
	printk("NAND Written %d bytes\n", retlen);
	return 0;
}
/*
 * write_to_flash(): write buffer to MTD device
 *
 * There are five stages.
 *    Stage 1: Unlock a region if you want.
 *    Stage 2: Erase a region.
 *    Stage 3: Write the buffer to a region.
 *    Stage 4: Verify result of previous stage.
 *    Stage 5: Lock a region if you want.
 *
 * Arguments:
 *    ofs: offset to write.
 *    len: length of data to write.
 *    buf: location of buffers.
 *   flag: a flag of a mtd partiton.
 *
 */
int write_to_flash(loff_t ofs, size_t len, const u_char *buf, int flag)
{
	struct mtd_info *mtd = mtd_get(ofs, len);

	if (mtd == NULL) {
		printk("Error. invalid MTD informations\n");
		return -1;
	}

	switch (mtd->type) {
	case MTD_NORFLASH:
		write_to_nor(mtd, ofs, len, buf, flag);
		break;
	case MTD_NANDFLASH:
		write_to_nand(mtd, ofs, len, buf, flag);
		break;
	default:
		printk("Not support this MTD\n");
		return -1;
	}
	return 0;
}


/*
 * User commands
 */
static user_subcommand_t flash_cmds[];

static void command_erase(int argc, const char **argv)
{
	struct mtd_info *mtd;
	struct erase_info instr;
	int ret;


	if ((argc != 2) && (argc != 3)) {
		printk("invalid 'flash erase' command: too few(many) arguments\n");
		return;
	}

	if (argc == 2) {
		mtd_partition_t *part = get_mtd_partition(argv[1]);
		if (part == NULL) {
			printk("Could not found partition \"%s\"\n", argv[1]);
			return;
		}
		printk("Erasing \"%s\" parittion\n", argv[1]);
		instr.addr = part->offset;
		instr.len = part->size;
		goto do_erase;
	} else {
		instr.addr = strtoul(argv[1], NULL, 0, &ret);
		instr.len = strtoul(argv[2], NULL, 0, &ret);
		printk("Erasing block from 0x%08lx to 0x%08lx\n", 
			instr.addr, instr.addr + instr.len);
		goto do_erase;
	}

do_erase:
	printk("Erasing block from 0x%08lx to 0x%08lx... ", 
		instr.addr, instr.addr + instr.len);
	mtd = mtd_get(instr.addr, instr.len);
	ret = mtd->erase(mtd, &instr);
	if (ret < 0)
		printk(" ... failed\n");
	else
		printk(" ... done\n");
}

//#define __NANDDEBUG
#ifdef __NANDDEBUG
typedef unsigned char uchar;
static void command_nandload(int argc, const char **argv)
{
	struct mtd_info *mtd;// = mymtd;
	loff_t	ofs;
	size_t blk_size, len;
	size_t retlen;
	int ret;
	uchar *	to;

	if (argc != 3) {
		putstr("invalid 'flash nandload' command: too few(many) arguments\r\n");
		return;
	}

	ofs = (loff_t)strtoul(argv[1], NULL, 0, NULL);
	to = (uchar *)strtoul(argv[2], NULL, 0, NULL);
	//to = (loff_t)0x30008000;

	printk("Read from NAND 0x%08lx to 0x%08lx ... ", (u32)ofs, (u32)to);
		
	//mtd = mtd_typeget(MTD_NANDFLASH);
	mtd = mtd_get(ofs, 0x20000);
	if (!mtd) {
	    putstr("failed\r\nmtd=null\r\n");
	    return;
	}
	
	printk("name:%s mtd_type:%x mtd_size:0x%08lx mtd_baseaddr:0x%08lx ... ", mtd->name, mtd->type, mtd->size, mtd->baseaddr);
	
	if (!mtd->read) {
	    putstr("failed\r\nmtd->read=null\r\n");
	    return;
	}
	if (!mtd->read_oob) {
	    putstr("failed\r\nmtd->read_oob=null\r\n");
	    return;
	}

	ret = mtd->read(mtd, ofs-mtd->baseaddr, mtd->oobblock, &retlen, (uchar *)0x30008000);
	if (ret<0) {
	    putstr("failed\r\n");
	    return;
	}
	
	ret = mtd->read_oob(mtd, ofs-mtd->baseaddr, mtd->oobsize, &retlen, (uchar *)0x30008000+mtd->oobblock);
	if (ret<0) {
	    putstr("failed\r\n");
	    return;
	}
	
	putstr("done\r\n");
}
#endif

static void command_lock(int argc, const char **argv)
{
	struct mtd_info *mtd;
	loff_t	ofs;
	size_t blk_size, len;

	if (argc != 3) {
		putstr("invalid 'flash lock' command: too few(many) arguments\r\n");
		return;
	}

	ofs = (loff_t)strtoul(argv[1], NULL, 0, NULL);
	len = (size_t)strtoul(argv[2], NULL, 0, NULL);
	mtd = mtd_get(ofs, len);
	blk_size = find_erase_size(mtd, ofs, len);
	printk("Locking blocks 0x%08lx-0x%08lx... ", ofs, ofs+blk_size);

	if (mtd->lock(mtd, ofs, blk_size) < 0)
		putstr("failed\r\n");
	else
		putstr("done\r\n");
}

static void command_unlock(int argc, const char **argv)
{
	struct mtd_info *mtd;
	loff_t	ofs;
	size_t blk_size, len;

	if (argc != 3) {
		putstr("invalid 'flash unlock' command: too few(many) arguments\r\n");
		return;
	}

	ofs = (loff_t)strtoul(argv[1], NULL, 0, NULL);
	len = (size_t)strtoul(argv[2], NULL, 0, NULL);
	mtd = mtd_get(ofs, len);
	blk_size = find_erase_size(mtd, ofs, len);
	printk("Unlocking blocks 0x%08lx-0x%08lx... ", ofs, ofs+blk_size);

	if (mtd->unlock(mtd, ofs, blk_size) < 0)
		putstr("failed\r\n");
	else
		putstr("done\r\n");
}

static void command_info(int argc, const char **argv)
{
    /*struct mtd_info *mtd = mymtd;
    struct map_info *map = (struct map_info *)(mtd->priv);
    struct cfi_private *cfi = (struct cfi_private *)(map->fldrv_priv);
    struct mtd_erase_region_info *eri = mtd->eraseregions;

    printk("Flash Memory Information\n"
	   "------------------------\n"
	   "%s: Found %d x%d devices in %d-bit mode\n"
	   "    total size:  0x%08lx (%4ldM) bytes\n"
	   "    erase block: 0x%08lx (%4ldk) x %d blocks\n\n",
	   map->name, cfi->interleave, cfi->device_type*8, map->buswidth*8,
	   mtd->size, (mtd->size)/(SZ_1M),
	   eri->erasesize, (eri->erasesize)/(SZ_1K), eri->numblocks);*/
	int i;
    struct mtd_info *mtd;
    struct map_info *map;
    struct cfi_private *cfi;
    struct mtd_erase_region_info *eri;

    for (i=0;(mtd=mtd_nget(i)) && (mtd->type==MTD_NORFLASH);i++)
    {
        map = (struct map_info *)(mtd->priv);
        cfi = (struct cfi_private *)(map->fldrv_priv);
        eri = mtd->eraseregions;
        printk("Flash Memory Information\n"
    	   "------------------------\n"
    	   "%s: Found %d x%d devices in %d-bit mode\n"
    	   "    total size:  0x%08lx (%4ldM) bytes\n"
    	   "    erase block: 0x%08lx (%4ldk) x %d blocks\n\n",
    	   map->name, cfi->interleave, cfi->device_type*8, map->buswidth*8,
    	   mtd->size, (mtd->size)/(SZ_1M),
    	   eri->erasesize, (eri->erasesize)/(SZ_1K), eri->numblocks);
	}
}

static void command_help(int argc, const char **argv)
{
	print_usage("flash", flash_cmds);
}

static user_subcommand_t flash_cmds[] = {
{
	"help",
	command_help,
	"help"
}, {
	"erase",
	command_erase,
	"erase [<partition>] or [<start_addr> <length>]" 
}, { 
	"lock",
	command_lock,	
	"lock <start_addr> <length>" 
}, { 
	"unlock",
	command_unlock,	
	"unlock <start_addr> <length>" 
}, 
#ifdef __NANDDEBUG
{ 
	"nandload",
	command_nandload,	
	"nandload <page_addr> <load_addr>" 
}, 
#endif
{ 
	"info",
	command_info,	
	"info" 
}, { 
	NULL,
	NULL,	
	NULL }
};

void command_flash(int argc, const char **argv)
{
	if (mtd_nget(0) == NULL) {
		printk("Error: Can not find MTD information\n");
		return;
	}

	if (argc == 1) {
		printk("invalid 'flash' command: too few arguments\n");
		command_help(0, NULL);
		return;
	}
	execsubcmd(flash_cmds, argc-1, argv+1);
}

static user_command_t flash_cmd = {
	"flash",
	command_flash,
	NULL,
	"flash [{cmds}] \t\t\t-- Manage Flash memory"
};

/*
 * Initialise
 */
extern int mtd_init(void);

int mtd_dev_init(void)
{
	int ret = 0;
	int i;

#ifdef CONFIG_DEBUG
	printk("Initialize MTD device\n");
#endif
	mtdnum = 0;
	mtd_baseaddr = 0;
	for (i=0;i<MAXFLASH;i++)
    {
        mtd_tbl[i] = NULL;
    }
    
	ret = mtd_init();

	add_command(&flash_cmd);

	return ret;
}