static int param_block_write(param_data_t blk, void *buf, int len)
{
int ret;
unsigned int start, count;
struct mmc *mmc;
unsigned long offset;
unsigned char wbuf[PARAM_BLKSIZE];
memset(wbuf, 0, PARAM_BLKSIZE);
ret = get_raw_area_info("parameter", &start, &count);
if(ret < 0)
{
printf("Fail to get parameter partition\n");
return -1;
}
#ifdef DEBUG_PARAM
printf("Parameter: start = %d len = %d(~%dKB)\n", start, count, count>>10);
#endif
offset = start/PARAM_BLKSIZE + blk;
mmc = find_mmc_device(0);
memcpy(wbuf, buf, len);
ret = mmc->block_dev.block_write(0, offset, 1, wbuf);
if(ret!=1)
{
printf("Fail to write parameter partition, block %d\n", blk);
return -1;
}
return 0;
}
int setup_waveform_file(void)
{
#ifdef CONFIG_WAVEFORM_FILE_IN_MMC
int mmc_dev = mmc_get_env_devno();
ulong offset = CONFIG_WAVEFORM_FILE_OFFSET;
ulong size = CONFIG_WAVEFORM_FILE_SIZE;
ulong addr = CONFIG_WAVEFORM_BUF_ADDR;
struct mmc *mmc = find_mmc_device(mmc_dev);
uint blk_start, blk_cnt, n;
if (!mmc) {
printf("MMC Device %d not found\n", mmc_dev);
return -1;
}
if (mmc_init(mmc)) {
puts("MMC init failed\n");
return -1;
}
blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
n = mmc->block_dev.block_read(mmc_dev, blk_start,
blk_cnt, (u_char *)addr);
flush_cache((ulong)addr, blk_cnt * mmc->read_bl_len);
return (n == blk_cnt) ? 0 : -1;
#else
return -1;
#endif
}
ulong mmc_bwrite(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt,
const void *src)
#endif
{
#ifdef CONFIG_BLK
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#endif
int dev_num = block_dev->devnum;
lbaint_t cur, blocks_todo = blkcnt;
int err;
struct mmc *mmc = find_mmc_device(dev_num);
if (!mmc)
return 0;
err = blk_select_hwpart_devnum(IF_TYPE_MMC, dev_num, block_dev->hwpart);
if (err < 0)
return 0;
if (mmc_set_blocklen(mmc, mmc->write_bl_len))
return 0;
do {
cur = (blocks_todo > mmc->cfg->b_max) ?
mmc->cfg->b_max : blocks_todo;
if (mmc_write_blocks(mmc, start, cur, src) != cur)
return 0;
blocks_todo -= cur;
start += cur;
src += cur * mmc->write_bl_len;
} while (blocks_todo > 0);
return blkcnt;
}
static int do_samsung_smart(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
{
struct mmc *mmc;
int i, ret;
char *ep;
uint32_t *data = NULL;
if (argc != 2)
return cmd_usage(cmdtp);
i = simple_strtoul(argv[1], &ep, 10);
if (ep == argv[1] || *ep != '\0') {
printf("'%s' is not a number\n", argv[1]);
return cmd_usage(cmdtp);
}
mmc = find_mmc_device(i);
if (!mmc) {
printf("no mmc device at slot %x\n", i);
return 1;
}
/* Allocate space for the report to be read in to. */
data = malloc(mmc->read_bl_len);
if (!data) {
printf("%s: Error allocating SMART buffer.\n", __func__);
return 1;
}
ret = print_smart(mmc, data);
free(data);
return ret != 0;
}
unsigned long
mmc_bread(int dev_num, unsigned long start, unsigned blkcnt, void *dst)
{
unsigned cur, blocks_todo = blkcnt;
struct mmc *mmc = find_mmc_device(dev_num);
if (blkcnt == 0)
return 0;
if (!mmc)
return 0;
if ((start + blkcnt) > mmc->lba) {
mmcdbg("MMC: block number 0x%x exceeds max(0x%x)\n",
start + blkcnt, mmc->lba);
return 0;
}
if (mmc_set_blocklen(mmc, mmc->read_bl_len))
return 0;
do {
cur = (blocks_todo > mmc->b_max) ? mmc->b_max : blocks_todo;
if(mmc_read_blocks(mmc, dst, start, cur) != cur)
return 0;
blocks_todo -= cur;
start += cur;
// dst += cur * mmc->read_bl_len;
dst = (char*)dst + cur * mmc->read_bl_len;
} while (blocks_todo > 0);
return blkcnt;
}
unsigned long
mmc_bwrite(int dev_num, unsigned long start, unsigned blkcnt, const void*src)
{
unsigned cur, blocks_todo = blkcnt;
struct mmc *mmc = find_mmc_device(dev_num);
if (blkcnt == 0)
return 0;
if (!mmc)
return 0;
if (mmc_set_blocklen(mmc, mmc->write_bl_len))
return 0;
do {
cur = (blocks_todo > mmc->b_max) ? mmc->b_max : blocks_todo;
if(mmc_write_blocks(mmc, start, cur, src) != cur)
return 0;
blocks_todo -= cur;
start += cur;
// src += cur * mmc->write_bl_len;
src = (char*)src + cur * mmc->write_bl_len;
} while (blocks_todo > 0);
return blkcnt;
}
char *get_dfu_alt_boot(char *interface, char *devstr)
{
char *info = "Not supported!";
struct mmc *mmc;
char *alt_boot;
int dev_num;
if (board_is_odroidxu4())
return info;
dev_num = simple_strtoul(devstr, NULL, 10);
mmc = find_mmc_device(dev_num);
if (!mmc)
return NULL;
if (mmc_init(mmc))
return NULL;
if (IS_SD(mmc))
alt_boot = CONFIG_DFU_ALT_BOOT_SD;
else
alt_boot = CONFIG_DFU_ALT_BOOT_EMMC;
return alt_boot;
}
static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
u64 offset, void *buf, long *len)
{
struct mmc *mmc = find_mmc_device(dfu->dev_num);
u32 blk_start, blk_count, n = 0;
int ret, part_num_bkp = 0;
/*
* We must ensure that we work in lba_blk_size chunks, so ALIGN
* this value.
*/
*len = ALIGN(*len, dfu->data.mmc.lba_blk_size);
blk_start = dfu->data.mmc.lba_start +
(u32)lldiv(offset, dfu->data.mmc.lba_blk_size);
blk_count = *len / dfu->data.mmc.lba_blk_size;
if (blk_start + blk_count >
dfu->data.mmc.lba_start + dfu->data.mmc.lba_size) {
puts("Request would exceed designated area!\n");
return -EINVAL;
}
if (dfu->data.mmc.hw_partition >= 0) {
part_num_bkp = mmc->part_num;
ret = mmc_access_part(dfu, mmc, dfu->data.mmc.hw_partition);
if (ret)
return ret;
}
debug("%s: %s dev: %d start: %d cnt: %d buf: 0x%p\n", __func__,
op == DFU_OP_READ ? "MMC READ" : "MMC WRITE", dfu->dev_num,
blk_start, blk_count, buf);
switch (op) {
case DFU_OP_READ:
n = mmc->block_dev.block_read(dfu->dev_num, blk_start,
blk_count, buf);
break;
case DFU_OP_WRITE:
n = mmc->block_dev.block_write(dfu->dev_num, blk_start,
blk_count, buf);
break;
default:
error("Operation not supported\n");
}
if (n != blk_count) {
error("MMC operation failed");
if (dfu->data.mmc.hw_partition >= 0)
mmc_access_part(dfu, mmc, part_num_bkp);
return -EIO;
}
if (dfu->data.mmc.hw_partition >= 0) {
ret = mmc_access_part(dfu, mmc, part_num_bkp);
if (ret)
return ret;
}
return 0;
}
//=======================================================================
int sdcard_post_test(int flags)
{
struct mmc *mmc;
int dev_num;
dev_num = simple_strtoul("mmcinfo", NULL, 0);
mmc = find_mmc_device(dev_num);
if (mmc) {
mmc_init(mmc);
if((mmc->tran_speed == 0) || (mmc->read_bl_len == 0) || (mmc->capacity == 0)) {
post_log("<%d>%s:%d: SDCARD: %s\n", SYSTEST_INFO_L2, __FUNCTION__, __LINE__, "no MMC device available.");
return -1;
}
post_log("<%d>SDCARD: Device: %s\n", SYSTEST_INFO_L2, mmc->name);
post_log("<%d>SDCARD: Manufacturer ID: %x\n", SYSTEST_INFO_L2, mmc->cid[0] >> 24);
post_log("<%d>SDCARD: OEM: %x\n", SYSTEST_INFO_L2, (mmc->cid[0] >> 8) & 0xffff);
//post_log("<%d>SDCARD: Name: %c%c%c%c%c\n",SYSTEST_INFO_L2, mmc->cid[0] & 0xff,
// (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
// (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
post_log("<%d>SDCARD: Tran Speed: %d\n", SYSTEST_INFO_L2, mmc->tran_speed);
post_log("<%d>SDCARD: Rd Block Len: %d\n", SYSTEST_INFO_L2, mmc->read_bl_len);
post_log("<%d>SDCARD: %s version %d.%d\n", SYSTEST_INFO_L2, IS_SD(mmc) ? "SD" : "MMC",
(mmc->version >> 4) & 0xf, mmc->version & 0xf);
post_log("<%d>SDCARD: High Capacity: %s\n", SYSTEST_INFO_L2, mmc->high_capacity ? "Yes" : "No");
post_log("<%d>SDCARD: Capacity: %lld\n", SYSTEST_INFO_L2, mmc->capacity);
post_log("<%d>SDCARD: Bus Width: %d-bit\n", SYSTEST_INFO_L2, mmc->bus_width);
}
else {
static void display_board_info(void)
{
#ifdef CONFIG_GENERIC_MMC
struct mmc *mmc = find_mmc_device(0);
#endif
vidinfo_t *vid = &panel_info;
lcd_position_cursor(4, 4);
lcd_printf("%s\n\t", U_BOOT_VERSION);
lcd_puts("\n\t\tBoard Info:\n");
#ifdef CONFIG_SYS_BOARD
lcd_printf("\tBoard name: %s\n", CONFIG_SYS_BOARD);
#endif
#ifdef CONFIG_REVISION_TAG
lcd_printf("\tBoard rev: %u\n", get_board_rev());
#endif
lcd_printf("\tDRAM banks: %u\n", CONFIG_NR_DRAM_BANKS);
lcd_printf("\tDRAM size: %u MB\n", gd->ram_size / SZ_1M);
#ifdef CONFIG_GENERIC_MMC
if (mmc) {
if (!mmc->capacity)
mmc_init(mmc);
lcd_printf("\teMMC size: %llu MB\n", mmc->capacity / SZ_1M);
}
#endif
if (vid)
lcd_printf("\tDisplay resolution: %u x % u\n",
vid->vl_col, vid->vl_row);
lcd_printf("\tDisplay BPP: %u\n", 1 << vid->vl_bpix);
}
/* both ok - check serial */
if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
gd->env_valid = 2;
else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
gd->env_valid = 1;
else if (tmp_env1->flags > tmp_env2->flags)
gd->env_valid = 1;
else if (tmp_env2->flags > tmp_env1->flags)
gd->env_valid = 2;
else /* flags are equal - almost impossible */
gd->env_valid = 1;
}
free(env_ptr);
if (gd->env_valid == 1)
ep = tmp_env1;
else
ep = tmp_env2;
env_flags = ep->flags;
env_import((char *)ep, 0);
ret = 0;
fini:
fini_mmc_for_env(mmc);
err:
if (ret)
set_default_env(NULL);
#endif
}
#else /* ! CONFIG_ENV_OFFSET_REDUND */
void env_relocate_spec(void)
{
#if !defined(ENV_IS_EMBEDDED)
ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
u32 offset;
int ret;
if (init_mmc_for_env(mmc)) {
ret = 1;
goto err;
}
if (mmc_get_env_addr(mmc, 0, &offset)) {
ret = 1;
goto fini;
}
if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
ret = 1;
goto fini;
}
env_import(buf, 1);
ret = 0;
fini:
fini_mmc_for_env(mmc);
err:
if (ret)
set_default_env(NULL);
#endif
}
int sunxi_flash_handle_init(void) {
sunxi_flash_read = sunxi_flash_null_read;
sunxi_flash_write = sunxi_flash_null_write;
sunxi_flash_get_size = sunxi_flash_null_get_size;
sunxi_flash_exit = sunxi_flash_null_exit;
if(storage_type == 0) {
sunxi_flash_read = sunxi_flash_nand_read;
sunxi_flash_write = sunxi_flash_nand_write;
sunxi_flash_get_size = sunxi_flash_nand_get_size;
sunxi_flash_exit = sunxi_flash_nand_exit;
}
else if((storage_type == 1) || (storage_type == 2)) {
mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
if(!mmc) {
printf("fail to find one useful mmc card\n");
return -1;
}
if (mmc_init(mmc)) {
puts("MMC init failed\n");
return -1;
}
sunxi_flash_read = sunxi_flash_mmc_read;
sunxi_flash_write = sunxi_flash_mmc_write;
sunxi_flash_get_size = sunxi_flash_mmc_get_size;
sunxi_flash_exit = sunxi_flash_mmc_exit;
}
return 0;
}
int put_mmc_mbr(unsigned char *mbr, char *device_name)
{
int rv;
struct mmc *mmc;
int dev_num, err;
dev_num = simple_strtoul(device_name, NULL, 0);
mmc = find_mmc_device(dev_num);
if (!mmc)
{
printf("mmc/sd device is NOT founded.\n");
return -1;
}
rv = mmc->block_dev.block_write(dev_num, 0, 1, mbr);
mmc->ext_csd.boot_size_multi = 0;
err = mmc_init(mmc);
if (err) {
printf("Card NOT detected or Init Failed!!\n");
return err;
}
if(rv == 1)
return 0;
else
return -1;
}
int put_mmc_mbr(unsigned char *mbr, char *device_name)
{
int rv;
struct mmc *mmc;
int dev_num;
dev_num = simple_strtoul(device_name, NULL, 0);
mmc = find_mmc_device(dev_num);
if (!mmc)
{
printf("mmc/sd device is NOT founded.\n");
return -1;
}
rv = mmc_init(mmc);
if (rv)
{
printf("mmc/sd device's initialization is failed.\n");
return -1;
}
rv = mmc->block_dev.block_write(dev_num, 0, 1, mbr);
if(rv == 1)
return 0;
else
return -1;
}
void spl_mmc_load_image(void)
{
struct mmc *mmc;
int err;
u32 boot_mode;
mmc_initialize(gd->bd);
/* We register only one device. So, the dev id is always 0 */
mmc = find_mmc_device(0);
if (!mmc) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
puts("spl: mmc device not found!!\n");
#endif
hang();
}
err = mmc_init(mmc);
if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
printf("spl: mmc init failed: err - %d\n", err);
#endif
hang();
}
boot_mode = spl_boot_mode();
if (boot_mode == MMCSD_MODE_RAW) {
debug("boot mode - RAW\n");
#ifdef CONFIG_SPL_OS_BOOT
if (spl_start_uboot() || mmc_load_image_raw_os(mmc))
#endif
err = mmc_load_image_raw(mmc,
CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
#ifdef CONFIG_SPL_FAT_SUPPORT
} else if (boot_mode == MMCSD_MODE_FAT) {
debug("boot mode - FAT\n");
err = fat_register_device(&mmc->block_dev,
CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION);
if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
printf("spl: fat register err - %d\n", err);
#endif
hang();
}
#ifdef CONFIG_SPL_OS_BOOT
if (spl_start_uboot() || mmc_load_image_fat_os(mmc))
#endif
err = mmc_load_image_fat(mmc, CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME);
#endif
} else {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
puts("spl: wrong MMC boot mode\n");
#endif
hang();
}
if (err)
hang();
}
int get_mmc_block_count(char *device_name)
{
int rv;
struct mmc *mmc;
int block_count = 0;
int dev_num;
dev_num = simple_strtoul(device_name, NULL, 0);
mmc = find_mmc_device(dev_num);
if (!mmc)
{
printf("mmc/sd device is NOT founded.\n");
return -1;
}
rv = mmc_init(mmc);
if (rv)
{
printf("mmc/sd device's initialization is failed.\n");
return -1;
}
block_count = mmc->capacity * (mmc->read_bl_len / BLOCK_SIZE);
// printf("block_count = %d\n", block_count);
return block_count;
}
void spl_mmc_load_image(void)
{
struct mmc *mmc;
int err;
u32 boot_mode;
mmc_initialize(gd->bd);
/* We register only one device. So, the dev id is always 0 */
mmc = find_mmc_device(0);
if (!mmc) {
puts("spl: mmc device not found!!\n");
hang();
}
err = mmc_init(mmc);
if (err) {
printf("spl: mmc init failed: err - %d\n", err);
hang();
}
boot_mode = spl_boot_mode();
if (boot_mode == MMCSD_MODE_RAW) {
debug("boot mode - RAW\n");
mmc_load_image_raw(mmc);
#ifdef CONFIG_SPL_FAT_SUPPORT
} else if (boot_mode == MMCSD_MODE_FAT) {
debug("boot mode - FAT\n");
mmc_load_image_fat(mmc);
#endif
} else {
puts("spl: wrong MMC boot mode\n");
hang();
}
}
int
mmc_berase(int dev_num, unsigned long start, unsigned blkcnt)
{
int err = 0;
struct mmc *mmc = find_mmc_device(dev_num);
// unsigned blk = 0, blk_r = 0;
void* src = (void*)0x41000000;
if (!mmc)
return -1;
memset(src, 0, 512*blkcnt);
mmcinfo("erase blk %d ~ %d\n", start, start + blkcnt - 1);
err = mmc_bwrite(dev_num, start, blkcnt, src);
return err;
/*
if ((start % mmc->erase_grp_size) || (blkcnt % mmc->erase_grp_size))
mmcdbg("\n\nCaution! Your devices Erase group is 0x%x\n"
"The erase range would be change to 0x%x~0x%x\n\n",
mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1),
((start + blkcnt + mmc->erase_grp_size)
& ~(mmc->erase_grp_size - 1)) - 1);
while (blk < blkcnt) {
blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
mmc->erase_grp_size : (blkcnt - blk);
err = mmc_erase_t(mmc, start + blk, blk_r);
if (err)
break;
blk += blk_r;
}
return blk;
*/
}
static void assign_serial(void)
{
struct mmc *mmc = find_mmc_device(0);
unsigned char ssn[16];
char usb0addr[18];
char serial[33];
int i;
if (!mmc)
return;
md5((unsigned char *)mmc->cid, sizeof(mmc->cid), ssn);
snprintf(usb0addr, sizeof(usb0addr), "02:00:86:%02x:%02x:%02x",
ssn[13], ssn[14], ssn[15]);
env_set("usb0addr", usb0addr);
for (i = 0; i < 16; i++)
snprintf(&serial[2 * i], 3, "%02x", ssn[i]);
env_set("serial#", serial);
#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
env_save();
#endif
}
int saveenv(void)
{
env_t env_new;
ssize_t len;
char *res;
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
u32 offset;
if (init_mmc_for_env(mmc))
return 1;
if(mmc_get_env_addr(mmc, &offset))
return 1;
res = (char *)&env_new.data;
len = hexport_r(&env_htab, '\0', &res, ENV_SIZE);
if (len < 0) {
error("Cannot export environment: errno = %d\n", errno);
return 1;
}
env_new.crc = crc32(0, env_new.data, ENV_SIZE);
printf("Writing to MMC(%d)... ", CONFIG_SYS_MMC_ENV_DEV);
if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)&env_new)) {
puts("failed\n");
return 1;
}
puts("done\n");
return 0;
}
void env_relocate_spec(void)
{
#if !defined(ENV_IS_EMBEDDED)
char buf[CONFIG_ENV_SIZE];
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
u32 offset;
if (init_mmc_for_env(mmc)) {
use_default();
return;
}
if(mmc_get_env_addr(mmc, &offset)) {
use_default();
return ;
}
if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
use_default();
return;
}
env_import(buf, 1);
#endif
}
static size_t mmc_read_file(const char *file_name)
{
loff_t act_read = 0;
int rc;
struct mmc *mmc;
const u8 mmc_dev_num = CONFIG_SYS_MMC_ENV_DEV;
mmc = find_mmc_device(mmc_dev_num);
if (!mmc) {
printf("No SD/MMC/eMMC card found\n");
return 0;
}
if (mmc_init(mmc)) {
printf("%s(%d) init failed\n", IS_SD(mmc) ? "SD" : "MMC",
mmc_dev_num);
return 0;
}
/* Load from data partition (0) */
if (fs_set_blk_dev("mmc", "0", FS_TYPE_ANY)) {
printf("Error: MMC 0 not found\n");
return 0;
}
/* Perfrom file read */
rc = fs_read(file_name, get_load_addr(), 0, 0, &act_read);
if (rc)
return 0;
return act_read;
}
static int upgrade_sd_dect(void)
{
struct mmc *mmc = find_mmc_device(0);
sd_dect_flag = 1;
unsigned ret = mmc_init(mmc);
sd_dect_flag = 0;
return ret;
}
void env_relocate_spec(void)
{
#if !defined(ENV_IS_EMBEDDED)
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
mmc_init(mmc);
mmc->block_dev.block_read(CONFIG_SYS_MMC_ENV_DEV, CONFIG_MMC_ENV_BLOCK_OFFSET, CONFIG_MMC_ENV_BLOCK_COUNT, (u_char *)env_ptr);
#endif
}
static int emmc_init(void)
{
int ret = -1;
struct mmc *mmc = NULL;
mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
if (mmc) {
ret = mmc_init(mmc); // init eMMC/tSD+
}
return ret;
}
int saveenv(void)
{
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
mmc_init(mmc);
printf("Writing to MMC(%d)... ", CONFIG_SYS_MMC_ENV_DEV);
mmc->block_dev.block_write(CONFIG_SYS_MMC_ENV_DEV, CONFIG_MMC_ENV_BLOCK_OFFSET, CONFIG_MMC_ENV_BLOCK_COUNT, (u_char *)env_ptr);
puts("done\n");
return 0;
}
/**
* load_dev_tree(void) - Load the device tree if found.
*
* If a device tree is found within a partition then it is loaded into
* the device tree load address.
*
* The load address depends on the partition it was found in:
* Default is #define DEVICE_TREE for device_tree partition
* where the device tree is just the compiled binary or undefined.
* Otherwise the address is read from the associated header.
*
* Returns the load addres in memory of the device tree.
**/
u32 load_dev_tree(u32 atag_load_addr)
{
int ret = 0;
int sector;
int num_sectors;
int sector_sz = 0;
u32 dt_load_addr = 0;
struct mmc* mmc = NULL;
int status;
ret = find_dev_tree();
if (ret < 0) {
printf("%s: Device tree not supported\n", __func__);
dt_data->dev_tree_load_addr = atag_load_addr;
goto out;
}
mmc = find_mmc_device(1);
if (mmc == NULL) {
goto out;
}
status = mmc_init(mmc);
if (status != 0) {
printf("mmc init failed\n");
goto out;
}
sector_sz = mmc->block_dev.blksz;
sector = dt_data->pte->start;
num_sectors = (dt_data->dev_tree_sz/sector_sz);
if (num_sectors <= (dt_data->dev_tree_sz / sector_sz))
num_sectors = (dt_data->dev_tree_sz / sector_sz);
status = mmc->block_dev.block_read(1, sector, num_sectors,
(void *)dt_data->dev_tree_load_addr);
if (status < 0) {
printf("mmc read failed\n");
goto out;
}
DBG("dev_tree @ %08x (%d)\n",
dt_data->dev_tree_load_addr,
dt_data->dev_tree_sz);
out:
if (dt_data->dev_tree_load_addr) {
dt_load_addr = dt_data->dev_tree_load_addr;
}
free(dt_data);
return dt_load_addr;
}
int mmc_switch_part(int dev_num, unsigned int part_num)
{
struct mmc *mmc = find_mmc_device(dev_num);
if (!mmc)
return -1;
return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
(mmc->part_config & ~PART_ACCESS_MASK)
| (part_num & PART_ACCESS_MASK));
}
static int find_first_mmc_device(void)
{
struct mmc *mmc;
int i;
for (i = 0; (mmc = find_mmc_device(i)); i++) {
if (!mmc_init(mmc) && IS_MMC(mmc))
return i;
}
return -ENODEV;
}
int saveenv(void)
{
ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
ssize_t len;
char *res;
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
u32 offset;
int ret, copy = 0;
if (init_mmc_for_env(mmc))
return 1;
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);
ret = 1;
goto fini;
}
env_new->crc = crc32(0, &env_new->data[0], ENV_SIZE);
#ifdef CONFIG_ENV_OFFSET_REDUND
env_new->flags = ++env_flags; /* increase the serial */
if (gd->env_valid == 1)
copy = 1;
#endif
if (mmc_get_env_addr(mmc, copy, &offset)) {
ret = 1;
goto fini;
}
printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "",
CONFIG_SYS_MMC_ENV_DEV);
if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
puts("failed\n");
ret = 1;
goto fini;
}
puts("done\n");
ret = 0;
#ifdef CONFIG_ENV_OFFSET_REDUND
gd->env_valid = gd->env_valid == 2 ? 1 : 2;
#endif
fini:
fini_mmc_for_env(mmc);
return ret;
}
