berlin_tools/bootloader/common/drivers/flash/flash_adaptor.c - manifest_repos/bootloader - Git at Google

 #include "io.h"
 #include "string.h"
 #include "debug.h"

 #include "flash_adaptor.h"

 static int g_block_size = 0;
 static int g_page_size = 0;
 static int g_addr_cycle = 0;

 /*################################################################*/
 /*##############below are the real function #################################*/

 #ifdef ENABLE_EMMC
 #include "sdmmc_api.h"


 #ifndef UNUSED
 #define UNUSED(var) do { (void)(var); } while(0)
 #endif

 static unsigned int current_part = 0xF;
 extern int do_emmcinit(void);
 extern int do_emmcread(unsigned int start, unsigned int blks, unsigned char * buffer);
 extern int do_emmc_switch_part(UINT32 PartitionNumber);
 extern long long do_emmc_capacity(void);
 static void init_emmc()
 {
 	int ret = 0;
 	g_block_size = 0x80000;
 	g_page_size = 8192;
 	g_addr_cycle = 0;
 	ret = do_emmcinit() ;
 	if (ret) {
 		ERR("emmc init fail.\n");
 		//FIXME
 		//reset_soc();
 	}
 }

 // part 0(user area), 1(b1), 2(b2)
 static int switch_emmc_part(unsigned int part)
 {
 	if(part > 2)
 		return FLASH_SWITCH_PART_NOEXIST;

 	if(current_part != part)
 		current_part = part;
 	else
 		return 0; // if we have switched to this part, just return

 	if(do_emmc_switch_part(part)){
 		ERR("EMMC: switch to boot partion %d error.\n", part);
 		return FLASH_OP_ERR;
 	}
 	return 0;
 }

 static long long read_emmc(long long start, unsigned int size, unsigned char *buff)
 {
 	long long ret;
 	int cur, offset = 0;
 	int blks = (size + SDIO_BLK_SIZE - 1) / SDIO_BLK_SIZE;

 	if(start % SDIO_BLK_SIZE) {
 		ERR("The start address should be %d bytes aligned for EMMC.\n", SDIO_BLK_SIZE);
 		return -1;
 	}

 	do {
 		/*
 		 * The 65535 constraint comes from some hardware has
 		 * only 16 bit width block number counter
 		 */
 		cur = (blks > 65535) ? 65535 : blks;

 		ret = do_emmcread(start + offset * SDIO_BLK_SIZE, cur, buff + offset * SDIO_BLK_SIZE);
 		if (ret != 0){
 			ERR("EMMC: read emmc image fail.\n");
 			return ret;
 		} else {
 			//ADAP_PRN(PRN_RES, "start 0x%08x, size 0x%08x, buff 0x%08x\n",
 			//	(start + offset * SDIO_BLK_SIZE), cur, (buff + offset * SDIO_BLK_SIZE));
 		}

 		blks -= cur;
 		offset += cur;
 	} while (blks > 0);
 	return 0;
 }

 extern int do_emmcwrite(unsigned int start, unsigned int blks, unsigned char * buffer);
 static long long write_emmc(long long start, unsigned int size, unsigned char *buff)
 {
 	long long ret;
 	unsigned int blks = (size + SDIO_BLK_SIZE - 1) / SDIO_BLK_SIZE;
 	ret = do_emmcwrite(start, blks, buff);
 	return ret;
 }

 static unsigned int emmc_dev_id_inc(unsigned int dev_id)
 {
 	dev_id++;
 #ifndef CONFIG_GPT
 	/* if we reach EBR area, need add 1 to skip it */
 	if (dev_id == 4)
 		dev_id++;
 #endif
 	return dev_id;
 }
 #endif


 #ifdef ENABLE_NAND
 #include "nand_priv.h"
 // nand is a problem because there is gap between the driver in sys_init and bootloader
 #ifdef NAND_SECURE_BOOT // for sys_init
 #include "memmap.h"
 #include "global.h"
 extern int mv_nand_chip_reinit(void);
 extern int mv_nand_reset_chip(int getchip);
 #endif

 #define CRC32_SIZE      (4)

 extern struct mv_nand_data nand_data ;
 extern int init_nand_data(struct mv_nand_data * board);
 extern int mv_nand_block_bad(loff_t ofs, int getchip);
 extern int mv_nand_read_block(long long nand_start, char* data_buf, int data_size);

 //FIXME: different funciton in sys_init and bootloader
 unsigned char partition_type_s[16];

 //FIXME: i don't like such fixed address
 #define NW_START 0x01F00000

 static void init_nand()
 {
 	unsigned int nand_param_buff[4];

 	nand_data.szofpg = g_page_size;
 	nand_data.t = g_addr_cycle;
 	nand_data.szofblk = g_block_size;

 	if((g_page_size != 512) && (g_page_size != 2048) &&
 		(g_page_size != 4096) && (g_page_size != 8192)) {

 		memcpy((char*)nand_param_buff, (char *)(NW_START + 16), 16);
 		nand_data.szofpg = nand_param_buff[0];
 		nand_data.t = nand_param_buff[1];
 		nand_data.szofblk = nand_param_buff[2];
 		set_flash_parameters(nand_data.szofblk, nand_data.szofpg, nand_data.t);
 		NOTICE("[%s:%d] get nand parameters from tz_loder (block_size=%d, page_size=%d, ecc=%d)\n",
 			__func__, __LINE__, nand_data.szofblk, nand_data.szofpg, nand_data.t);
 	} else {
 		NOTICE("\nNAND block size %d, page size %d, ecc_strength %d\n",
 	                nand_data.szofblk, nand_data.szofpg, nand_data.t);
 	}
 	//FIXME: this is for nand driver of google
 	strncpy((CHAR *)partition_type_s, "eslc", 4);
 	init_nand_data(&nand_data);
 }

 //part 1 - 8 for nand
 static int switch_nand_part(unsigned int part)
 {
 	if(part > 8)
 		return FLASH_SWITCH_PART_NOEXIST;

 	//if part = 0, return 0
 	return (part * nand_data.szofblk);
 }

 static long long read_nand(long long start, unsigned int size, unsigned char *buff)
 {
 	long long ret = 0;
 	int block_num = 0;
 	int data_size = size;
 	unsigned int block_start_addr = 0, read_addr = start;
 	char * data_buf = (char *)buff;
 	unsigned int i = 0;
 	unsigned int block_size;

 	block_size = get_block_size();

 	block_start_addr = start & (~(block_size - 1));
 	block_num = (data_size / block_size);

 	//read the data in first block
 	do {
 		if(mv_nand_block_bad((loff_t)block_start_addr, 0)) {
 			ERR("bad block found 0x%08x!!!\n", block_start_addr);
 			if(block_start_addr <= (8 * block_size))// the first 9 blocks are defined as boot blocks
 				return -1;
 			block_start_addr += block_size;
 			start += block_size;
 			continue;
 		}
 		ret = mv_nand_read_block(start, data_buf, size);//return the size of read
 		if(size == ret) // read finish
 			return 0;
 		if(ret < 0) // error
 			return ret;
 		//block_start_addr = start + ret;
 		data_buf += ret;
 		data_size = size - ret; // remain size
 		read_addr = start + ret;
 		break;
 	}while(1);

 	for(i = 0; i < (unsigned int)block_num;) {
 		//2. check if the block is bad
 		if(mv_nand_block_bad((loff_t)read_addr, 0)) {
 			ERR("bad block found 0x%08x!!!\n", read_addr);
 			read_addr += block_size;
 			continue;
 		}
 		ret = mv_nand_read_block(read_addr, data_buf, block_size);

 		if(ret < 0)
 			return ret;

 		data_buf += block_size; // move data buffer forward
 		read_addr += block_size; // move read address forward
 		data_size -= block_size; // decrease the size
 		i++;
 	}

 	//read the rest data
 	if(data_size > 0) {
 		do {
 			if(mv_nand_block_bad((loff_t)read_addr, 0)) {
 				ERR("bad block found 0x%08x!!!\n", read_addr);
 				read_addr += block_size;
 				continue;
 			}
 			ret = mv_nand_read_block(read_addr, data_buf, data_size);

 			if(ret < 0)
 				return ret;

 			break;
 		} while(1);
 	}

 	return 0;
 }

 static unsigned int nand_dev_id_inc(unsigned int dev_id)
 {
 	dev_id++;
 	return dev_id;
 }
 #endif

 #ifdef NOR_BOOT
 extern void SPIReadFlash(unsigned int, unsigned int, unsigned int);
 static void init_nor()
 {
 	g_block_size = 0x10000;
 	g_page_size = 512;
 	g_addr_cycle = 0;
 	//NULL
 }

 static int switch_nor_part(unsigned int part)
 {
 	if(part > 1)
 		return FLASH_SWITCH_PART_NOEXIST;

 	//if part = 0, return 0
 	return 0;
 }

 static long long read_nor(unsigned int start, unsigned int size, unsigned char *buff)
 {
 	//we read spi 4bytes by 4bytes
 	int mod = size % 4;
 	size = size/4;
 	if(mod) {
 		size++;
 	}
 	SPIReadFlash((start + 0xF0000000), size,(uintptr_t)buff);
 	return 0;
 }

 static unsigned int nor_dev_id_inc(unsigned int dev_id)
 {
 	dev_id++;
 	return dev_id;
 }
 #endif


 /*##################################################################*/
 /*##############below are the unified function #################################*/
 /*##################################################################*/

 void set_flash_parameters(int blocksize, int pagesize, int addrcycle)
 {
 #ifdef ENABLE_EMMC
 	g_block_size = 0x80000;
 	g_page_size = 8192;
 	g_addr_cycle = 0;
 	UNUSED(blocksize);
 	UNUSED(pagesize);
 	UNUSED(addrcycle);
 #endif
 #ifdef ENABLE_NAND
 	g_block_size = blocksize;
 	g_page_size = pagesize;
 	g_addr_cycle = addrcycle;
 #endif
 #ifdef NOR_BOOT
 	g_block_size = 0x10000;
 	g_page_size = 512;
 	g_addr_cycle = 0;
 	UNUSED(blocksize);
 	UNUSED(pagesize);
 	UNUSED(addrcycle);
 #endif
 	INFO("block: %d, page: %d, cycle: %d\n", g_block_size, g_page_size, g_addr_cycle);
 }

 inline int get_block_size()
 {
 	return g_block_size;
 }

 int get_page_size()
 {
 	return g_page_size;
 }

 int get_addr_cycle()
 {
 	return g_addr_cycle;
 }

 int get_boot_partition_number(void)
 {
 #ifdef ENABLE_EMMC
 	return 2;
 #endif
 #ifdef ENABLE_NAND
 	return 8;
 #endif
 #ifdef NOR_BOOT
 	return 1;
 #endif
 }

 void init_flash()
 {
 #ifdef ENABLE_EMMC
 	set_flash_parameters(0, 0, 0);
 	init_emmc();
 #endif
 #ifdef ENABLE_NAND
 	init_nand();
 	//FIXME: there is something difference between nand init in sys_init and bl
 #endif
 #ifdef NOR_BOOT
 	//FIXME: nor driver is only for sys_int->u-boot, not support boot gtv from nor
 	set_flash_parameters(0, 0, 0);
 	init_nor();
 #endif
 }

 //return value is the start address in part
 //this function is only for reading bootloader.subimg
 int switch_flash_part(unsigned int part)
 {
 #ifdef ENABLE_EMMC
 	return switch_emmc_part(part);
 #endif
 #ifdef ENABLE_NAND
 	return switch_nand_part(part);
 #endif
 #ifdef NOR_BOOT
 	return switch_nor_part(part);
 #endif
 	return 0;
 }

 long long read_flash(long long start, unsigned int size, unsigned char *buff)
 {
 #ifdef ENABLE_EMMC
 	return read_emmc(start, size, buff);
 #endif
 #ifdef ENABLE_NAND
 	return read_nand(start, size, buff);
 		//there is something difference about nand init in sys_init
 #endif
 #ifdef NOR_BOOT
 	return read_nor(start, size, buff);
 #endif
 }

 long long get_flash_capacity(void)
 {
 #ifdef ENABLE_EMMC
 	return do_emmc_capacity();
 #else
 	return 0; // don't support
 #endif
 }

 long long read_flash_from_part(unsigned int part, long long start, unsigned int size, unsigned char *buff)
 {
 	int part_addr = 0;

 	//switch to specific part
 	part_addr = switch_flash_part(part);
 	if(part_addr < 0) {
 		ERR("flash: error when switch to boot partion %d(err = %d).\n", part, part_addr);
 		return FLASH_OP_ERR;
 	}
 	return read_flash((part_addr + start), size, buff);
 }

 long long write_flash(long long start, unsigned int size, unsigned char *buff)
 {
 #ifdef ENABLE_EMMC
 	return write_emmc(start, size, buff);
 #else
 	// don't support now
 	ERR("flash: not support API %s !\n", __func__);
 	return 0;
 #endif
 }

 unsigned int flash_dev_id_inc(unsigned int dev_id)
 {
 #ifdef ENABLE_EMMC
 	return emmc_dev_id_inc(dev_id);
 #endif
 #ifdef ENABLE_NAND
 	return nand_dev_id_inc(dev_id);
 		//there is something difference about nand init in sys_init
 #endif
 #ifdef NOR_BOOT
 	return nor_dev_id_inc(dev_id);
 #endif
 }

 #if 0
 static flash_adaptor_t flash_adaptor_interface = {
 	get_block_size,
 	get_page_size,
 	get_addr_cycle,
 	get_boot_partition_number,
 	init_flash,
 	switch_flash_part,
 	flash_dev_id_inc,
 	read_flash
 };

 void * get_flash_adaptor_if(void)
 {
 	return (void *)(&flash_adaptor_interface);
 }
 #endif
	#include "io.h"
	#include "string.h"
	#include "debug.h"

	#include "flash_adaptor.h"

	static int g_block_size = 0;
	static int g_page_size = 0;
	static int g_addr_cycle = 0;

	/################################################################/
	/##############below are the real function #################################/

	#ifdef ENABLE_EMMC
	#include "sdmmc_api.h"


	#ifndef UNUSED
	#define UNUSED(var) do { (void)(var); } while(0)
	#endif

	static unsigned int current_part = 0xF;
	extern int do_emmcinit(void);
	extern int do_emmcread(unsigned int start, unsigned int blks, unsigned char * buffer);
	extern int do_emmc_switch_part(UINT32 PartitionNumber);
	extern long long do_emmc_capacity(void);
	static void init_emmc()
	{
	int ret = 0;
	g_block_size = 0x80000;
	g_page_size = 8192;
	g_addr_cycle = 0;
	ret = do_emmcinit() ;
	if (ret) {
	ERR("emmc init fail.\n");
	//FIXME
	//reset_soc();
	}
	}

	// part 0(user area), 1(b1), 2(b2)
	static int switch_emmc_part(unsigned int part)
	{
	if(part > 2)
	return FLASH_SWITCH_PART_NOEXIST;

	if(current_part != part)
	current_part = part;
	else
	return 0; // if we have switched to this part, just return

	if(do_emmc_switch_part(part)){
	ERR("EMMC: switch to boot partion %d error.\n", part);
	return FLASH_OP_ERR;
	}
	return 0;
	}

	static long long read_emmc(long long start, unsigned int size, unsigned char *buff)
	{
	long long ret;
	int cur, offset = 0;
	int blks = (size + SDIO_BLK_SIZE - 1) / SDIO_BLK_SIZE;

	if(start % SDIO_BLK_SIZE) {
	ERR("The start address should be %d bytes aligned for EMMC.\n", SDIO_BLK_SIZE);
	return -1;
	}

	do {
	/*
	* The 65535 constraint comes from some hardware has
	* only 16 bit width block number counter
	*/
	cur = (blks > 65535) ? 65535 : blks;

	ret = do_emmcread(start + offset * SDIO_BLK_SIZE, cur, buff + offset * SDIO_BLK_SIZE);
	if (ret != 0){
	ERR("EMMC: read emmc image fail.\n");
	return ret;
	} else {
	//ADAP_PRN(PRN_RES, "start 0x%08x, size 0x%08x, buff 0x%08x\n",
	// (start + offset * SDIO_BLK_SIZE), cur, (buff + offset * SDIO_BLK_SIZE));
	}

	blks -= cur;
	offset += cur;
	} while (blks > 0);
	return 0;
	}

	extern int do_emmcwrite(unsigned int start, unsigned int blks, unsigned char * buffer);
	static long long write_emmc(long long start, unsigned int size, unsigned char *buff)
	{
	long long ret;
	unsigned int blks = (size + SDIO_BLK_SIZE - 1) / SDIO_BLK_SIZE;
	ret = do_emmcwrite(start, blks, buff);
	return ret;
	}

	static unsigned int emmc_dev_id_inc(unsigned int dev_id)
	{
	dev_id++;
	#ifndef CONFIG_GPT
	/* if we reach EBR area, need add 1 to skip it */
	if (dev_id == 4)
	dev_id++;
	#endif
	return dev_id;
	}
	#endif


	#ifdef ENABLE_NAND
	#include "nand_priv.h"
	// nand is a problem because there is gap between the driver in sys_init and bootloader
	#ifdef NAND_SECURE_BOOT // for sys_init
	#include "memmap.h"
	#include "global.h"
	extern int mv_nand_chip_reinit(void);
	extern int mv_nand_reset_chip(int getchip);
	#endif

	#define CRC32_SIZE (4)

	extern struct mv_nand_data nand_data ;
	extern int init_nand_data(struct mv_nand_data * board);
	extern int mv_nand_block_bad(loff_t ofs, int getchip);
	extern int mv_nand_read_block(long long nand_start, char* data_buf, int data_size);

	//FIXME: different funciton in sys_init and bootloader
	unsigned char partition_type_s[16];

	//FIXME: i don't like such fixed address
	#define NW_START 0x01F00000

	static void init_nand()
	{
	unsigned int nand_param_buff[4];

	nand_data.szofpg = g_page_size;
	nand_data.t = g_addr_cycle;
	nand_data.szofblk = g_block_size;

	if((g_page_size != 512) && (g_page_size != 2048) &&
	(g_page_size != 4096) && (g_page_size != 8192)) {

	memcpy((char)nand_param_buff, (char )(NW_START + 16), 16);
	nand_data.szofpg = nand_param_buff[0];
	nand_data.t = nand_param_buff[1];
	nand_data.szofblk = nand_param_buff[2];
	set_flash_parameters(nand_data.szofblk, nand_data.szofpg, nand_data.t);
	NOTICE("[%s:%d] get nand parameters from tz_loder (block_size=%d, page_size=%d, ecc=%d)\n",
	__func__, __LINE__, nand_data.szofblk, nand_data.szofpg, nand_data.t);
	} else {
	NOTICE("\nNAND block size %d, page size %d, ecc_strength %d\n",
	nand_data.szofblk, nand_data.szofpg, nand_data.t);
	}
	//FIXME: this is for nand driver of google
	strncpy((CHAR *)partition_type_s, "eslc", 4);
	init_nand_data(&nand_data);
	}

	//part 1 - 8 for nand
	static int switch_nand_part(unsigned int part)
	{
	if(part > 8)
	return FLASH_SWITCH_PART_NOEXIST;

	//if part = 0, return 0
	return (part * nand_data.szofblk);
	}

	static long long read_nand(long long start, unsigned int size, unsigned char *buff)
	{
	long long ret = 0;
	int block_num = 0;
	int data_size = size;
	unsigned int block_start_addr = 0, read_addr = start;
	char * data_buf = (char *)buff;
	unsigned int i = 0;
	unsigned int block_size;

	block_size = get_block_size();

	block_start_addr = start & (~(block_size - 1));
	block_num = (data_size / block_size);

	//read the data in first block
	do {
	if(mv_nand_block_bad((loff_t)block_start_addr, 0)) {
	ERR("bad block found 0x%08x!!!\n", block_start_addr);
	if(block_start_addr <= (8 * block_size))// the first 9 blocks are defined as boot blocks
	return -1;
	block_start_addr += block_size;
	start += block_size;
	continue;
	}
	ret = mv_nand_read_block(start, data_buf, size);//return the size of read
	if(size == ret) // read finish
	return 0;
	if(ret < 0) // error
	return ret;
	//block_start_addr = start + ret;
	data_buf += ret;
	data_size = size - ret; // remain size
	read_addr = start + ret;
	break;
	}while(1);

	for(i = 0; i < (unsigned int)block_num;) {
	//2. check if the block is bad
	if(mv_nand_block_bad((loff_t)read_addr, 0)) {
	ERR("bad block found 0x%08x!!!\n", read_addr);
	read_addr += block_size;
	continue;
	}
	ret = mv_nand_read_block(read_addr, data_buf, block_size);

	if(ret < 0)
	return ret;

	data_buf += block_size; // move data buffer forward
	read_addr += block_size; // move read address forward
	data_size -= block_size; // decrease the size
	i++;
	}

	//read the rest data
	if(data_size > 0) {
	do {
	if(mv_nand_block_bad((loff_t)read_addr, 0)) {
	ERR("bad block found 0x%08x!!!\n", read_addr);
	read_addr += block_size;
	continue;
	}
	ret = mv_nand_read_block(read_addr, data_buf, data_size);

	if(ret < 0)
	return ret;

	break;
	} while(1);
	}

	return 0;
	}

	static unsigned int nand_dev_id_inc(unsigned int dev_id)
	{
	dev_id++;
	return dev_id;
	}
	#endif

	#ifdef NOR_BOOT
	extern void SPIReadFlash(unsigned int, unsigned int, unsigned int);
	static void init_nor()
	{
	g_block_size = 0x10000;
	g_page_size = 512;
	g_addr_cycle = 0;
	//NULL
	}

	static int switch_nor_part(unsigned int part)
	{
	if(part > 1)
	return FLASH_SWITCH_PART_NOEXIST;

	//if part = 0, return 0
	return 0;
	}

	static long long read_nor(unsigned int start, unsigned int size, unsigned char *buff)
	{
	//we read spi 4bytes by 4bytes
	int mod = size % 4;
	size = size/4;
	if(mod) {
	size++;
	}
	SPIReadFlash((start + 0xF0000000), size,(uintptr_t)buff);
	return 0;
	}

	static unsigned int nor_dev_id_inc(unsigned int dev_id)
	{
	dev_id++;
	return dev_id;
	}
	#endif


	/##################################################################/
	/##############below are the unified function #################################/
	/##################################################################/

	void set_flash_parameters(int blocksize, int pagesize, int addrcycle)
	{
	#ifdef ENABLE_EMMC
	g_block_size = 0x80000;
	g_page_size = 8192;
	g_addr_cycle = 0;
	UNUSED(blocksize);
	UNUSED(pagesize);
	UNUSED(addrcycle);
	#endif
	#ifdef ENABLE_NAND
	g_block_size = blocksize;
	g_page_size = pagesize;
	g_addr_cycle = addrcycle;
	#endif
	#ifdef NOR_BOOT
	g_block_size = 0x10000;
	g_page_size = 512;
	g_addr_cycle = 0;
	UNUSED(blocksize);
	UNUSED(pagesize);
	UNUSED(addrcycle);
	#endif
	INFO("block: %d, page: %d, cycle: %d\n", g_block_size, g_page_size, g_addr_cycle);
	}

	inline int get_block_size()
	{
	return g_block_size;
	}

	int get_page_size()
	{
	return g_page_size;
	}

	int get_addr_cycle()
	{
	return g_addr_cycle;
	}

	int get_boot_partition_number(void)
	{
	#ifdef ENABLE_EMMC
	return 2;
	#endif
	#ifdef ENABLE_NAND
	return 8;
	#endif
	#ifdef NOR_BOOT
	return 1;
	#endif
	}

	void init_flash()
	{
	#ifdef ENABLE_EMMC
	set_flash_parameters(0, 0, 0);
	init_emmc();
	#endif
	#ifdef ENABLE_NAND
	init_nand();
	//FIXME: there is something difference between nand init in sys_init and bl
	#endif
	#ifdef NOR_BOOT
	//FIXME: nor driver is only for sys_int->u-boot, not support boot gtv from nor
	set_flash_parameters(0, 0, 0);
	init_nor();
	#endif
	}

	//return value is the start address in part
	//this function is only for reading bootloader.subimg
	int switch_flash_part(unsigned int part)
	{
	#ifdef ENABLE_EMMC
	return switch_emmc_part(part);
	#endif
	#ifdef ENABLE_NAND
	return switch_nand_part(part);
	#endif
	#ifdef NOR_BOOT
	return switch_nor_part(part);
	#endif
	return 0;
	}

	long long read_flash(long long start, unsigned int size, unsigned char *buff)
	{
	#ifdef ENABLE_EMMC
	return read_emmc(start, size, buff);
	#endif
	#ifdef ENABLE_NAND
	return read_nand(start, size, buff);
	//there is something difference about nand init in sys_init
	#endif
	#ifdef NOR_BOOT
	return read_nor(start, size, buff);
	#endif
	}

	long long get_flash_capacity(void)
	{
	#ifdef ENABLE_EMMC
	return do_emmc_capacity();
	#else
	return 0; // don't support
	#endif
	}

	long long read_flash_from_part(unsigned int part, long long start, unsigned int size, unsigned char *buff)
	{
	int part_addr = 0;

	//switch to specific part
	part_addr = switch_flash_part(part);
	if(part_addr < 0) {
	ERR("flash: error when switch to boot partion %d(err = %d).\n", part, part_addr);
	return FLASH_OP_ERR;
	}
	return read_flash((part_addr + start), size, buff);
	}

	long long write_flash(long long start, unsigned int size, unsigned char *buff)
	{
	#ifdef ENABLE_EMMC
	return write_emmc(start, size, buff);
	#else
	// don't support now
	ERR("flash: not support API %s !\n", __func__);
	return 0;
	#endif
	}

	unsigned int flash_dev_id_inc(unsigned int dev_id)
	{
	#ifdef ENABLE_EMMC
	return emmc_dev_id_inc(dev_id);
	#endif
	#ifdef ENABLE_NAND
	return nand_dev_id_inc(dev_id);
	//there is something difference about nand init in sys_init
	#endif
	#ifdef NOR_BOOT
	return nor_dev_id_inc(dev_id);
	#endif
	}

	#if 0
	static flash_adaptor_t flash_adaptor_interface = {
	get_block_size,
	get_page_size,
	get_addr_cycle,
	get_boot_partition_number,
	init_flash,
	switch_flash_part,
	flash_dev_id_inc,
	read_flash
	};

	void * get_flash_adaptor_if(void)
	{
	return (void *)(&flash_adaptor_interface);
	}
	#endif