/*
 * (C) Copyright 2003
 * Kyle Harris, kharris@nexus-tech.net
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>
#include <malloc.h>
#include <command.h>
#include <linux/ctype.h>
#include <mmc.h>
#include <partition_table.h>
#include <emmc_partitions.h>
#include <asm/arch/cpu_sdio.h>
#include <asm/arch/sd_emmc.h>
#include <linux/sizes.h>
#include <asm/cpu_id.h>

extern int mmc_key_erase(void);
extern int find_dev_num_by_partition_name (char *name);
extern int mmc_get_ext_csd(struct mmc *mmc, u8 *ext_csd);
extern int mmc_set_ext_csd(struct mmc *mmc, u8 index, u8 value);
extern void mmc_write_cali_mattern(void *addr);

/* info system. */
#define dtb_err(fmt, ...) printf( "%s()-%d: " fmt , \
                  __func__, __LINE__, ##__VA_ARGS__)

#define dtb_wrn(fmt, ...) printf( "%s()-%d: " fmt , \
                  __func__, __LINE__, ##__VA_ARGS__)

/* for detail debug info */
#define dtb_info(fmt, ...) printf( "%s()-%d: " fmt , \
                  __func__, __LINE__, ##__VA_ARGS__)

struct aml_dtb_rsv {
	u8 data[DTB_BLK_SIZE*DTB_BLK_CNT - 4*sizeof(u32)];
	u32 magic;
	u32 version;
	u32 timestamp;
	u32 checksum;
};

struct aml_dtb_info {
	u32 stamp[2];
	u8 valid[2];
};

#define stamp_after(a,b)   ((int)(b) - (int)(a)  < 0)
/* glb dtb infos */
static struct aml_dtb_info dtb_infos = {{0, 0}, {0, 0}};

#define CONFIG_SECURITYKEY

#if !defined(CONFIG_SYS_MMC_BOOT_DEV)
    #define CONFIG_SYS_MMC_BOOT_DEV (CONFIG_SYS_MMC_ENV_DEV)
#endif

#define GXB_START_BLK   0
#define GXL_START_BLK   1
#define UBOOT_SIZE  (0x1000) // uboot size  2MB
int info_disprotect = 0;
bool emmckey_is_protected (struct mmc *mmc)
{
#ifdef CONFIG_STORE_COMPATIBLE
#ifdef CONFIG_SECURITYKEY
    if (info_disprotect & DISPROTECT_KEY) { // disprotect
        printf("emmckey_is_protected : disprotect\n ");
        return 0;
    }else{
        printf("emmckey_is_protected : protect\n ");
    // protect
        return 1;
    }
#else
        return 0;
#endif
#else
#ifdef CONFIG_SECURITYKEY
        //return mmc->key_protect;
        return 0; /* fixme, */
#else
        return 0;
#endif
#endif
}

unsigned emmc_cur_partition = 0;

int mmc_read_status(struct mmc *mmc, int timeout)
{
    struct mmc_cmd cmd;
    int err, retries = 5;
    int status;

    cmd.cmdidx = MMC_CMD_SEND_STATUS;
    cmd.resp_type = MMC_RSP_R1;
    if (!mmc_host_is_spi(mmc))
        cmd.cmdarg = mmc->rca << 16;
    do {
        err = mmc_send_cmd(mmc, &cmd, NULL);
        if (!err) {
            if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) &&
                (cmd.response[0] & MMC_STATUS_CURR_STATE) !=
                 MMC_STATE_PRG)
                break;
            else if (cmd.response[0] & MMC_STATUS_MASK) {
                printf("Status Error: 0x%08X\n",
                    cmd.response[0]);
                return COMM_ERR;
            }
        } else if (--retries < 0)
            return err;

        udelay(1000);

    } while (timeout--);

    status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9;
    printf("CURR STATE:%d, status = 0x%x\n", status, cmd.response[0]);

    if (timeout <= 0) {
        printf("read status Timeout waiting card ready\n");
        return TIMEOUT;
    }
    if (cmd.response[0] & MMC_STATUS_SWITCH_ERROR) {
        printf("mmc status swwitch error status =0x%x\n", status);
        return SWITCH_ERR;
    }
    return 0;
}


static int get_off_size(struct mmc * mmc, char * name, uint64_t offset, uint64_t  size, u64 * blk, u64 * cnt, u64 * sz_byte)
{
        struct partitions *part_info = NULL;
        uint64_t off = 0;
        int blk_shift = 0;

        blk_shift =  ffs(mmc->read_bl_len) - 1;
        // printf("blk_shift:%d , off:0x%llx , size:0x%llx.\n ",blk_shift,off,size );
        part_info = find_mmc_partition_by_name(name);
        if (part_info == NULL) {
                printf("get partition info failed !!\n");
                return -1;
        }
        off = part_info->offset + offset;

        // printf("part_info->offset:0x%llx , off:0x%llx , size:0x%llx.\n",part_info->offset ,off,size);

        *blk = off >>  blk_shift ;
        *cnt = size >>  blk_shift ;
        *sz_byte = size - ((*cnt)<<blk_shift) ;

        // printf("get_partition_off_size : blk:0x%llx , cnt:0x%llx.\n",*blk,*cnt);
        return 0;
}

static int get_partition_size(unsigned char* name, uint64_t* addr)
{
        struct partitions *part_info = NULL;
        part_info = find_mmc_partition_by_name((char *)name);
        if (part_info == NULL) {
                printf("get partition info failed !!\n");
                return -1;
        }

        *addr = part_info->size >> 9; // unit: 512 bytes
        return 0;
}

static inline int isstring(char *p)
{
        char *endptr = p;
        while (*endptr != '\0') {
                if (!(((*endptr >= '0') && (*endptr <= '9'))
                                        || ((*endptr >= 'a') && (*endptr <= 'f'))
                                        || ((*endptr >= 'A') && (*endptr <= 'F'))
                                        || (*endptr == 'x') || (*endptr == 'X')))
                        return 1;
                endptr++;
        }

        return 0;
}


int do_amlmmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
        int rc = 0;
        /*printf("%s:%d\n",__func__,__LINE__);*/
        /*printf("argc = %d\n",argc);*/
        switch (argc) {
                case 3:
                        if (strcmp(argv[1], "rescan") == 0) {
                                int dev = simple_strtoul(argv[2], NULL, 10);
                                if (dev < 0) {
                                        printf("Cannot find dev.\n");
                                        return 1;
                                }
                                struct mmc *mmc = find_mmc_device(dev);

                                if (!mmc)
                                        return 1;

                                return mmc_init(mmc);
                        } else if (strncmp(argv[1], "part", 4) == 0) {
                                int dev = simple_strtoul(argv[2], NULL, 10);
                                block_dev_desc_t *mmc_dev;
                                struct mmc *mmc = find_mmc_device(dev);

                                if (!mmc) {
                                        puts("no mmc devices available\n");
                                        return 1;
                                }
                                mmc_init(mmc);
                                mmc_dev = mmc_get_dev(dev);
                                if (mmc_dev != NULL &&
                                                mmc_dev->type != DEV_TYPE_UNKNOWN) {
                                        print_part(mmc_dev);
                                        return 0;
                                }

                                puts("get mmc type error!\n");
                                return 1;
                        } else if (strcmp(argv[1], "erase") == 0) {
                                char *name = NULL;
                                int dev;
                                u32 n=0;
                                bool is_part = false;//is argv[2] partition name
                                bool protect_cache = false;
                                bool non_loader = false;
                                int blk_shift;
                                u64 cnt=0, blk =0,start_blk =0;
                                struct partitions *part_info;

                                if (isstring(argv[2])) {
                                        if (!strcmp(argv[2], "whole")) {
                                                name = "logo";
                                                dev = find_dev_num_by_partition_name (name);
                                        }else if(!strcmp(argv[2], "non_cache")){
                                                name = "logo";
                                                dev = find_dev_num_by_partition_name (name);
                                                protect_cache = true;
                                        }
                                        else if(!strcmp(argv[2], "non_loader")){
                                                dev = 1;
                                                non_loader = true;
                                        }
                                        else{
                                                name = argv[2];
                                                dev = find_dev_num_by_partition_name (name);
                                                is_part = true;
                                        }
                                }else if(isdigit(argv[2][0])){
                                        dev = simple_strtoul(argv[2], NULL, 10);
                                }else{
                                        printf("Input is invalid, nothing happen.\n");
                                        return 1;
                                }

                                if (dev < 0) {
                                        printf("Cannot find dev.\n");
                                        return 1;
                                }
                                struct mmc *mmc = find_mmc_device(dev);

                                if (!mmc)
                                        return 1;

                                mmc_init(mmc);

                                blk_shift = ffs(mmc->read_bl_len) -1;
                                if (is_part) { // erase only one partition
                                        if (emmckey_is_protected(mmc)
                                                        && (strncmp(name, MMC_RESERVED_NAME, sizeof(MMC_RESERVED_NAME)) == 0x00)) {
                                                printf("\"%s-partition\" is been protecting and should no be erased!\n", MMC_RESERVED_NAME);
                                                return 1;
                                        }

                                        part_info = find_mmc_partition_by_name(name);
                                        if (part_info == NULL) {
                                                return 1;
                                        }

                                        blk = part_info->offset>> blk_shift;
                                        if (emmc_cur_partition && !strncmp(name, "bootloader", strlen("bootloader"))) {

                                                cnt = mmc->boot_size>> blk_shift;
                                        }
                                        else
                                                cnt = part_info->size>> blk_shift;
                                        n = mmc->block_dev.block_erase(dev, blk, cnt);
                                } else { // erase the whole card if possible

                                        if (non_loader) {
                                                part_info = find_mmc_partition_by_name(MMC_BOOT_NAME);
                                                if (part_info == NULL) {
                                                        start_blk = 0;
                                                        printf("no uboot partition for eMMC boot, just erase from 0\n");
                                                }
                                                else{
                                                        start_blk = (part_info->offset + part_info->size) >> blk_shift;
                                                }
                                        }
                                        else{
                                                start_blk = 0;
                                        }

                                        if (emmckey_is_protected(mmc)) {
                                                part_info = find_mmc_partition_by_name(MMC_RESERVED_NAME);
                                                if (part_info == NULL) {
                                                        return 1;
                                                }

                                                blk = part_info->offset;
                                                if (blk > 0) { // it means: there should be other partitions before reserve-partition.
                                                        blk -= PARTITION_RESERVED;
                                                }
                                                blk >>= blk_shift;
                                                blk -= start_blk;

                                                n=0;

                                                // (1) erase all the area before reserve-partition
                                                if (blk > 0) {
                                                        n = mmc->block_dev.block_erase(dev, start_blk, blk);
                                                        // printf("(1) erase blk: 0 --> %llx %s\n", blk, (n == 0) ? "OK" : "ERROR");
                                                }
                                                if (n == 0) { // not error
                                                        // (2) erase all the area after reserve-partition
                                                        if (protect_cache) {
                                                                part_info = find_mmc_partition_by_name(MMC_CACHE_NAME);
                                                                if (part_info == NULL) {
                                                                        return 1;
                                                                }
                                                        }
                                                        start_blk = (part_info->offset + part_info->size + PARTITION_RESERVED) >> blk_shift;
                                                        u64 erase_cnt = (mmc->capacity >> blk_shift) - 1 - start_blk;
                                                        n = mmc->block_dev.block_erase(dev, start_blk, erase_cnt);
                                                        // printf("(2) erase blk: %#llx --> %#llx %s\n", start_blk, start_blk+erase_cnt, (n == 0) ? "OK" : "ERROR");
                                                }

                                        } else {
                                                n = mmc->block_dev.block_erase(dev, start_blk, 0); // erase the whole card
                                        }

                                        //erase boot partition
                                        if (mmc->boot_size && (n == 0) && (non_loader == false)) {

                                                for (cnt=0;cnt<2;cnt++) {
                                                        rc = mmc_switch_part(dev, cnt+1);
                                                        if (rc != 0) {
                                                                printf("mmc switch %s failed\n", (cnt == 0)?"boot0":"boot1");
                                                                break;
                                                        }

                                                        n = mmc->block_dev.block_erase(dev, 0, mmc->boot_size>>blk_shift);
                                                        if (n != 0) {
                                                                printf("mmc erase %s failed\n", (cnt == 0)?"boot0":"boot1");
                                                                break;
                                                        }
                                                }

                                                rc = mmc_switch_part(dev, 0);
                                                if (rc != 0) {
                                                        printf("mmc switch back to user failed\n");
                                                }
                                        }
                                }

                                // printf("dev # %d, %s, # %#llx blocks erased %s\n",
                                // dev, (is_part == 0) ? "card":(argv[2]) ,
                                // (cnt == 0) ? (int)(mmc->block_dev.lba): cnt ,
                                // (n == 0) ? "OK" : "ERROR");
                                return (n == 0) ? 0 : 1;
                        } else if (strcmp(argv[1], "status") == 0) {
                            int dev = simple_strtoul(argv[2], NULL, 10);
                            if (dev < 0) {
                                printf("Cannot find dev.\n");
                                return 1;
                            }
                            struct mmc *mmc = find_mmc_device(dev);

                            if (!mmc)
                                return 1;
                            if (!mmc->has_init) {
                                printf("mmc dev %d has not been initialed\n", dev);
                                    return 1;
                            }
                            rc = mmc_read_status(mmc, 1000);
                            if (rc)
                                return 1;
                            else
                                return 0;
                        } else if (strcmp(argv[1], "response") == 0) {
                            int dev = simple_strtoul(argv[2], NULL, 10);
                            if (dev < 0) {
                                printf("Cannot find dev.\n");
                                return 1;
                            }
                            struct mmc *mmc = find_mmc_device(dev);
                            if (!mmc)
                                return 1;
                            if (!mmc->has_init) {
                                printf("mmc dev %d has not been initialed\n", dev);
                                return 1;
                            }
                            struct aml_card_sd_info *aml_priv = mmc->priv;
                            struct sd_emmc_global_regs *sd_emmc_reg = aml_priv->sd_emmc_reg;

                            printf("last cmd = %d, response0 = 0x%x\n",
                                (sd_emmc_reg->gcmd_cfg & 0x3f), sd_emmc_reg->gcmd_rsp0);
                            return 0;
                        } else if (strcmp(argv[1], "controller") == 0) {
                            int dev = simple_strtoul(argv[2], NULL, 10);
                            if (dev < 0) {
                                printf("Cannot find dev.\n");
                                return 1;
                            }
                            struct mmc *mmc = find_mmc_device(dev);
                            if (!mmc)
                                return 1;
                            struct aml_card_sd_info *aml_priv = mmc->priv;
                            struct sd_emmc_global_regs *sd_emmc_reg = aml_priv->sd_emmc_reg;
                            printf("sd_emmc_reg->gclock = 0x%x\n", sd_emmc_reg->gclock);
                            printf("sd_emmc_reg->gdelay = 0x%x\n", sd_emmc_reg->gdelay);
                            printf("sd_emmc_reg->gadjust = 0x%x\n", sd_emmc_reg->gadjust);
                            printf("sd_emmc_reg->gcalout = 0x%x\n", sd_emmc_reg->gcalout);
                            if (!mmc->has_init) {
                                printf("mmc dev %d has not been initialed\n", dev);
                                return 1;
                            }
                            printf("sd_emmc_reg->gstart = 0x%x\n", sd_emmc_reg->gstart);
                            printf("sd_emmc_reg->gcfg = 0x%x\n", sd_emmc_reg->gcfg);
                            printf("sd_emmc_reg->gstatus = 0x%x\n", sd_emmc_reg->gstatus);
                            printf("sd_emmc_reg->girq_en = 0x%x\n", sd_emmc_reg->girq_en);
                            printf("sd_emmc_reg->gcmd_cfg = 0x%x\n", sd_emmc_reg->gcmd_cfg);
                            printf("sd_emmc_reg->gcmd_arg = 0x%x\n", sd_emmc_reg->gcmd_arg);
                            printf("sd_emmc_reg->gcmd_dat = 0x%x\n", sd_emmc_reg->gcmd_dat);
                            printf("sd_emmc_reg->gcmd_rsp0 = 0x%x\n", sd_emmc_reg->gcmd_rsp0);
                            printf("sd_emmc_reg->gcmd_rsp1 = 0x%x\n", sd_emmc_reg->gcmd_rsp1);
                            printf("sd_emmc_reg->gcmd_rsp2 = 0x%x\n", sd_emmc_reg->gcmd_rsp2);
                            printf("sd_emmc_reg->gcmd_rsp3 = 0x%x\n", sd_emmc_reg->gcmd_rsp3);
                            return 0;
                        } else {
                                return cmd_usage(cmdtp);
                        }

                case 0:
                case 1:
                        return CMD_RET_USAGE;
                case 4:
                        if (strcmp(argv[1], "switch") == 0) {
                                int dev = simple_strtoul(argv[2], NULL, 10);
                                struct mmc* mmc = find_mmc_device(dev);
                                if (!mmc) {
                                        puts("no mmc devices available\n");
                                        return 1;
                                }
                                mmc_init(mmc);
                                printf("mmc switch to ");
                                if (strcmp(argv[3], "boot0") == 0) {
                                        rc = mmc_switch_part(dev, 1);
                                        if (rc == 0) {
                                                emmc_cur_partition = 1;
                                                printf("boot0 success\n");
                                        } else {
                                                printf("boot0 failed\n");
                                        }
                                }
                                else if(strcmp(argv[3], "boot1") == 0) {
                                        rc = mmc_switch_part(dev, 2);
                                        if (rc == 0) {
                                                emmc_cur_partition = 2;
                                                printf("boot1 success\n");
                                        } else {
                                                printf("boot1 failed\n");
                                        }
                                }
                                else if(strcmp(argv[3], "user") == 0) {
                                        rc = mmc_switch_part(dev, 0);
                                        if (rc == 0) {
                                                emmc_cur_partition = 0;
                                                printf("user success\n");
                                        } else {
                                                printf("user failed\n");
                                       }
                                }
#ifdef CONFIG_SUPPORT_EMMC_RPMB
                                else if(strcmp(argv[3], "rpmb") == 0) {
                                        rc = mmc_switch_part(dev, 3);
                                        if (rc == 0) {
                                                emmc_cur_partition = 3;
                                                printf("rpmb success\n");
                                        } else {
                                                printf("rpmb failed\n");
                                        }
                                }
#endif
                                else
                                        printf("%s failed\n", argv[3]);
                                return rc;
                        } else if (strcmp(argv[1], "ext_csd") == 0) {
                            int ret;
                            u8 ext_csd[512] = {0};
                            int dev = simple_strtoul(argv[2], NULL, 10);
                            int bit = simple_strtoul(argv[3], NULL, 10);
                            if ((bit > 511) || (bit < 0)) {
                                printf("bit is out of area!\n");
                                return 1;
                            }
                            struct mmc* mmc = find_mmc_device(dev);
                            if (!mmc) {
                                puts("no mmc devices available\n");
                                return 1;
                            }
                            mmc_init(mmc);
                            ret = mmc_get_ext_csd(mmc, ext_csd);
                            printf("read EXT_CSD bit[%d] val[0x%x] %s\n",
                                    bit, ext_csd[bit], (ret == 0) ? "ok" : "fail");
                            return ret;
                        } else if (strcmp(argv[1], "size") == 0) {
                            char *name;
                            uint64_t* addr =NULL;
                            name = argv[2];
                            addr = (uint64_t *)simple_strtoul(argv[3], NULL, 16);
                            if (!strcmp(name, "wholeDev")) {
                                int dev = CONFIG_SYS_MMC_BOOT_DEV;
                                struct mmc* mmc = find_mmc_device(dev);
                                if (!mmc) {
                                    puts("no mmc devices available\n");
                                    return 1;
                                }
                                mmc_init(mmc);

                                *addr = mmc->capacity >> 9; // unit: 512 bytes
                                return 0;
                            }
                            return get_partition_size((unsigned char *)name, addr);
                        }
                        return cmd_usage(cmdtp);

                case 2:
                        if (!strcmp(argv[1], "list")) {
                                print_mmc_devices('\n');
                                return 0;
                        }

                        if (strcmp(argv[1], "env") == 0) {
                                printf("herh\n");
                                env_relocate();
                                return 0 ;
                        }

#ifdef CONFIG_SECURITYKEY
                        if (strcmp(argv[1], "key") == 0) {
                                struct mmc* mmc;
                                //char *name = "logo";
                                int dev = CONFIG_SYS_MMC_BOOT_DEV;
                                mmc = find_mmc_device(dev);
                                if (!mmc) {
                                        printf("device %d is invalid\n",dev);
                                        return 1;
                                }
                                //mmc->key_protect = 0;
#ifdef CONFIG_STORE_COMPATIBLE
                                info_disprotect |= DISPROTECT_KEY;  //disprotect
                                printf("emmc disprotect key\n");
#endif
                                return 0;
                        }
#endif
                        return cmd_usage(cmdtp);

                default: /* at least 5 args */
                        if (strcmp(argv[1], "read") == 0) {
                                int dev;
                                void *addr =NULL;
                                u32 flag =0;
                                u64 cnt =0,n =0, blk =0, sz_byte =0;
                                char *name=NULL;
                                u64 offset =0,size =0;

                                if (argc != 6) {
                                        printf("Input is invalid, nothing happen.\n");
                                        return 1;
                                }

                                if (isstring(argv[2])) {
                                        name = argv[2];
                                        dev = find_dev_num_by_partition_name (name);
                                        addr = (void *)simple_strtoul(argv[3], NULL, 16);
                                        size = simple_strtoull(argv[5], NULL, 16);
                                        offset  = simple_strtoull(argv[4], NULL, 16);
                                        /*printf("offset %llx size %llx\n",offset,size);*/
                                        flag = 1;
                                        if ((strcmp(argv[2], "card") == 0)) {
                                                flag = 2;
                                        }
                                }else{
                                        dev = simple_strtoul(argv[2], NULL, 10);
                                        addr = (void *)simple_strtoul(argv[3], NULL, 16);
                                        cnt = simple_strtoull(argv[5], NULL, 16);
                                        blk = simple_strtoull(argv[4], NULL, 16);
                                }
                                if (dev < 0) {
                                        printf("Cannot find dev.\n");
                                        return 1;
                                }
                                struct mmc *mmc = find_mmc_device(dev);
                                if (!mmc) {
                                        printf("dev = %d;, no mmc device found",dev);
                                        return 1;
                                }

                                if (flag == 1) { // emmc or tsd
                                        /*printf("offset %#llx size %#llx\n",offset,size);*/
                                        get_off_size(mmc, name, offset, size, &blk, &cnt, &sz_byte);
                                }
                                else if(flag == 2){ // card
                                        int blk_shift = ffs( mmc->read_bl_len) -1;
                                        cnt = size >> blk_shift;
                                        blk = offset >> blk_shift;
                                        sz_byte = size - (cnt<<blk_shift);
                                }


                                /*printf("MMC read: dev # %d, block # %#llx, count # %#llx ...\n",*/
                                                /*dev, blk, cnt);*/
                                mmc_init(mmc);

                                n = mmc->block_dev.block_read(dev, blk, cnt, addr);
                                //read sz_byte bytes
                                if ((n == cnt) && (sz_byte != 0)) {
                                        /*printf("sz_byte=%#llx bytes\n",sz_byte);*/
                                        void *addr_tmp = malloc(mmc->read_bl_len);
                                        void *addr_byte = (void *)(addr+cnt*(mmc->read_bl_len));
                                        ulong start_blk = blk+cnt;

                                        if (addr_tmp == NULL) {
                                                printf("mmc read: malloc fail\n");
                                                return 1;
                                        }

                                        if (mmc->block_dev.block_read(dev, start_blk, 1, addr_tmp) != 1) { // read 1 block
                                                free(addr_tmp);
                                                printf("mmc read 1 block fail\n");
                                                return 1;
                                        }

                                        memcpy(addr_byte, addr_tmp, sz_byte);
                                        free(addr_tmp);
                                }

                                /* flush cache after read */
                                //flush_cache((ulong)addr, cnt * 512); /* FIXME */

                                //printf("MMC read: dev # %d, block # %#llx, count # %#llx, byte_size # %#llx %s!\n",
                                //                        dev, blk, cnt, sz_byte, (n==cnt) ? "OK" : "ERROR");
                                return (n == cnt) ? 0 : 1;
                        } else if (strcmp(argv[1], "write") == 0) {
                                int dev;
                                void *addr =NULL;
                                u32 flag =0;
                                u64 cnt =0,n =0, blk =0,sz_byte =0;
                                char *name=NULL;
                                u64 offset =0,size =0;
                                cpu_id_t cpu_id = get_cpu_id();
                                if (argc != 6) {
                                        printf("Input is invalid, nothing happen.\n");
                                        return 1;
                                }

                                if (isstring(argv[2])) {
                                        name = argv[2];
                                        if (strcmp(name, "bootloader") == 0)
                                            dev = CONFIG_SYS_MMC_BOOT_DEV;
                                        else
                                            dev = find_dev_num_by_partition_name (name);
                                        addr = (void *)simple_strtoul(argv[3], NULL, 16);
                                        offset  = simple_strtoull(argv[4], NULL, 16);
                                        size = simple_strtoull(argv[5], NULL, 16);
                                        flag = 1;
                                        if ((strcmp(argv[2], "card") == 0)) {
                                            flag = 2;
                                        }
                                }else{
                                        dev = simple_strtoul(argv[2], NULL, 10);
                                        addr = (void *)simple_strtoul(argv[3], NULL, 16);
                                        blk = simple_strtoull(argv[4], NULL, 16);
                                        cnt = simple_strtoull(argv[5], NULL, 16);
                                }
                                if (dev < 0) {
                                        printf("Cannot find dev.\n");
                                        return 1;
                                }
                                struct mmc *mmc = find_mmc_device(dev);

                                if (flag == 1) { // tsd or emmc
                                        if (strcmp(name, "bootloader") == 0) {
                                            cnt = UBOOT_SIZE;
                                            if (cpu_id.family_id >= MESON_CPU_MAJOR_ID_GXL) {
                                                blk = GXL_START_BLK;
                                                cnt -= GXL_START_BLK;
                                            }
                                            else
                                                blk = GXB_START_BLK;
                                            sz_byte = 0;
                                        } else
                                            get_off_size(mmc, name, offset, size, &blk, &cnt, &sz_byte);
                                }
                                else if(flag == 2){ // card
                                        int blk_shift = ffs( mmc->read_bl_len) -1;
                                        cnt = size >> blk_shift;
                                        blk = offset >> blk_shift;
                                        sz_byte = size - (cnt<<blk_shift);
                                }

                                if (!mmc)
                                        return 1;

                                 //printf("MMC write: dev # %d, block # %#llx, count # %#llx ... ",
                                 //dev, blk, cnt);

                                mmc_init(mmc);

                                n = mmc->block_dev.block_write(dev, blk, cnt, addr);

                                //write sz_byte bytes
                                if ((n == cnt) && (sz_byte != 0)) {
                                        // printf("sz_byte=%#llx bytes\n",sz_byte);
                                        void *addr_tmp = malloc(mmc->write_bl_len);
                                        void *addr_byte = (void*)(addr+cnt*(mmc->write_bl_len));
                                        ulong start_blk = blk+cnt;

                                        if (addr_tmp == NULL) {
                                                printf("mmc write: malloc fail\n");
                                                return 1;
                                        }

                                        if (mmc->block_dev.block_read(dev, start_blk, 1, addr_tmp) != 1) { // read 1 block
                                                free(addr_tmp);
                                                printf("mmc read 1 block fail\n");
                                                return 1;
                                        }

                                        memcpy(addr_tmp, addr_byte, sz_byte);
                                        if (mmc->block_dev.block_write(dev, start_blk, 1, addr_tmp) != 1) { // write 1 block
                                                free(addr_tmp);
                                                printf("mmc write 1 block fail\n");
                                                return 1;
                                        }
                                        free(addr_tmp);
                                }
                                //printf("%#llx blocks , %#llx bytes written: %s\n", n, sz_byte, (n==cnt) ? "OK" : "ERROR");
                                return (n == cnt) ? 0 : 1;
                        }
                        else if (strcmp(argv[1], "erase") == 0) {

                                int dev=0;
                                u32 flag=0;
                                u64 cnt = 0, blk = 0, n = 0, sz_byte =0;
                                char *name=NULL;
                                u64 offset_addr =0, size=0;

                                if (argc != 5) {
                                        printf("Input is invalid, nothing happen.\n");
                                        return 1;
                                }

                                if (isstring(argv[2])) {
                                        name = argv[2];
                                        dev = find_dev_num_by_partition_name (name);
                                        offset_addr = simple_strtoull(argv[3], NULL, 16);
                                        size = simple_strtoull(argv[4], NULL, 16);
                                        flag = 1;
                                        if ((strcmp(argv[2], "card") == 0)) {
                                                flag = 2;
                                        }
                                }else if(isdigit(argv[2][0])){
                                        dev = simple_strtoul(argv[2], NULL, 10);
                                        blk = simple_strtoull(argv[3], NULL, 16);
                                        cnt = simple_strtoull(argv[4], NULL, 16);
                                }

                                if (dev < 0) {
                                        printf("Cannot find dev.\n");
                                        return 1;
                                }

                                struct mmc *mmc = find_mmc_device(dev);

                                if (flag == 1) { // mmc write logo add offset size
                                        struct partitions *part_info  = find_mmc_partition_by_name(name);

                                        if (offset_addr >= part_info->size) {
                                                printf("Start address out #%s# partition'address region,(addr_byte < 0x%llx)\n",
                                                                name, part_info->size);
                                                return 1;
                                        }
                                        if ((offset_addr+size) > part_info->size) {
                                                printf("End address exceeds #%s# partition,(offset = 0x%llx,size = 0x%llx)\n",
                                                                name, part_info->offset,part_info->size);
                                                return 1;
                                        }
                                        get_off_size(mmc, name, offset_addr, size, &blk, &cnt, &sz_byte);
                                }
                                else if(flag == 2){
                                        int tmp_shift = ffs( mmc->read_bl_len) -1;
                                        cnt = size >> tmp_shift;
                                        blk = offset_addr >> tmp_shift;
                                        sz_byte = size - (cnt<<tmp_shift);
                                }

                                if (!mmc)
                                        return 1;

                                printf("MMC erase: dev # %d, start_erase_address(in block) # %#llx, several blocks  # %lld will be erased ...\n ",
                                                dev, blk, cnt);

                                mmc_init(mmc);

                                if (cnt != 0)
                                        n = mmc->block_dev.block_erase(dev, blk, cnt);

                                printf("dev # %d, %s, several blocks erased %s\n",
                                                dev, (flag == 0) ? " ":(argv[2]),(n == 0) ? "OK" : "ERROR");

                                return (n == 0) ? 0 : 1;

                        } else if (strcmp(argv[1], "ext_csd") == 0) {
                            int ret;
                            int dev = simple_strtoul(argv[2], NULL, 10);
                            int bit = simple_strtoul(argv[3], NULL, 10);
                            int val = simple_strtoul(argv[4], NULL, 16);
                            if ((bit > 191) || (bit < 0)) {
                                printf("bit is not able to write!\n");
                                return 1;
                            }
                            struct mmc* mmc = find_mmc_device(dev);
                            if (!mmc) {
                                puts("no mmc devices available\n");
                                return 1;
                            }
                            mmc_init(mmc);
                            ret = mmc_set_ext_csd(mmc, bit, val);
                            printf("write EXT_CSD bit[%d] val[0x%x] %s\n",
                                    bit, val, (ret == 0) ? "ok" : "fail");
                            return ret;

                        } else
                                rc = cmd_usage(cmdtp);

                        return rc;
        }
}

U_BOOT_CMD(
    amlmmc, 6, 1, do_amlmmcops,
    "AMLMMC sub system",
    "read  <partition_name> ram_addr addr_byte# cnt_byte\n"
    "amlmmc write <partition_name> ram_addr addr_byte# cnt_byte\n"
    "amlmmc erase <partition_name> addr_byte# cnt_byte\n"
    "amlmmc erase <partition_name>/<device num>\n"
    "amlmmc rescan <device_num>\n"
    "amlmmc part <device_num> - show partition infomation of mmc\n"
    "amlmmc list - lists available devices\n"
    "amlmmc switch <device_num> <part name> - part name : boot0, boot1, user\n"
    "amlmmc status <device_num> - read sd/emmc device status\n"
    "amlmmc ext_csd <bit> <value> - read/write sd/emmc device EXT_CSD [bit] value\n"
    "amlmmc response <device_num> - read sd/emmc last command response\n"
    "amlmmc controller <device_num> - read sd/emmc controller register\n");

/* dtb read&write operation with backup updates */
static u32 _calc_dtb_checksum(struct aml_dtb_rsv * dtb)
{
    int i = 0;
    int size = sizeof(struct aml_dtb_rsv) - sizeof(u32);
    u32 * buffer;
    u32 checksum = 0;

	if ((u64)dtb % 4 != 0) {
        BUG();
    }

    size = size >> 2;
    buffer = (u32*) dtb;
	while (i < size)
        checksum += buffer[i++];

    return checksum;
}

static int _verify_dtb_checksum(struct aml_dtb_rsv * dtb)
{
    u32 checksum;

    checksum = _calc_dtb_checksum(dtb);
    dtb_info("calc %x, store %x\n", checksum, dtb->checksum);

    return !(checksum == dtb->checksum);
}

static int _dtb_read(struct mmc *mmc, u64 blk, u64 cnt, void * addr)
{
    int dev = EMMC_DTB_DEV;
    u64 n;
    n = mmc->block_dev.block_read(dev, blk, cnt, addr);
	if (n != cnt) {
        dtb_err("%s: dev # %d, block # %#llx, count # %#llx ERROR!\n",
                __func__, dev, blk, cnt);
    }

    return (n != cnt);
}
static int _dtb_write(struct mmc *mmc, u64 blk, u64 cnt, void * addr)
{
    int dev = EMMC_DTB_DEV;
    u64 n;
    n = mmc->block_dev.block_write(dev, blk, cnt, addr);
	if (n != cnt) {
        dtb_err("%s: dev # %d, block # %#llx, count # %#llx ERROR!\n",
                __func__, dev, blk, cnt);
    }

    return (n != cnt);
}

static struct mmc *_dtb_init(void)
{
    struct mmc *mmc = find_mmc_device(EMMC_DTB_DEV);
	if (!mmc) {
        dtb_err("not find mmc\n");
        return NULL;
    }

	if (mmc_init(mmc)) {
        dtb_err("mmc init failed\n");
        return NULL;
    }

    return mmc;
}

static int dtb_read_shortcut(struct mmc * mmc, void *addr)
{
    u64 blk, cnt, dtb_glb_offset;
    int dev = EMMC_DTB_DEV;
    struct aml_dtb_info *info = &dtb_infos;
    struct partitions * part = NULL;
    struct virtual_partition *vpart = NULL;
    vpart = aml_get_virtual_partition_by_name(MMC_DTB_NAME);
    part = aml_get_partition_by_name(MMC_RESERVED_NAME);
    dtb_glb_offset = part->offset + vpart->offset;
    /* short cut */
	if (info->valid[0]) {
        dtb_info("short cut in...\n");
        blk = dtb_glb_offset / mmc->read_bl_len;
        cnt = vpart->size / mmc->read_bl_len;
		if (_dtb_read(mmc, blk, cnt, addr)) {
            dtb_err("%s: dev # %d, block # %#llx,cnt # %#llx ERROR!\n",
                    __func__, dev, blk, cnt);
            /*try dtb2 if it's valid */
			if (info->valid[1]) {
				blk = (dtb_glb_offset + vpart->size) / mmc->read_bl_len;
				cnt = vpart->size / mmc->read_bl_len;
				if (_dtb_read(mmc, blk, cnt, addr)) {
					dtb_err("%s: dev # %d, block # %#llx, cnt # %#llx ERROR!\n",
						__func__, dev, blk, cnt);
                    return -1;
                }
            }
        }
        return 0;
    }

    return -2;
}

int dtb_read(void *addr)
{
    int ret = 0, dev = EMMC_DTB_DEV;
    u64 blk, cnt, dtb_glb_offset;
    struct aml_dtb_rsv * dtb = (struct aml_dtb_rsv *) addr;
    struct aml_dtb_info *info = &dtb_infos;
    int cpy = 1, valid = 0;
    struct mmc * mmc;
    struct partitions * part = NULL;
    struct virtual_partition *vpart = NULL;
    vpart = aml_get_virtual_partition_by_name(MMC_DTB_NAME);
    part = aml_get_partition_by_name(MMC_RESERVED_NAME);
    dtb_glb_offset = part->offset + vpart->offset;

    mmc = _dtb_init();
	if (NULL == mmc)
        return -10;

	if (0 == dtb_read_shortcut(mmc, addr))
        return ret;

    /* read dtb2 1st, for compatibility without checksum. */
	while (cpy >= 0) {
		blk = (dtb_glb_offset + cpy * (vpart->size)) / mmc->read_bl_len;
		cnt = vpart->size / mmc->read_bl_len;
		if (_dtb_read(mmc, blk, cnt, addr)) {
			dtb_err("%s: dev # %d, block # %#llx, cnt # %#llx ERROR!\n",
				__func__, dev, blk, cnt);
        } else {
            ret = _verify_dtb_checksum(dtb);
            /* check magic avoid whole 0 issue */
			if (!ret && (dtb->magic != 0)) {
                info->stamp[cpy] = dtb->timestamp;
                info->valid[cpy] = 1;
            }
            else
                dtb_wrn("cpy %d is not valid\n", cpy);
        }
        valid += info->valid[cpy];
        cpy --;
    }
    dtb_info("total valid %d\n", valid);
    /* check valid */
	switch (valid) {
        /* none is valid, using the 1st one for compatibility*/
        case 0:
            ret = -1;
            goto _out;
        break;
        /* only 1 is valid, using the valid one */
        case 1:
			if (info->valid[1]) {
				blk = (dtb_glb_offset + vpart->size) / mmc->read_bl_len;
				if (_dtb_read(mmc, blk, cnt, addr)) {
				dtb_err("%s: dev # %d, block # %#llx,cnt # %#llx ERROR!\n",
						__func__, dev, blk, cnt);
                    ret = -2;
                }
                /* fixme, update the invalid one - dtb1 */
                blk = (dtb_glb_offset) / mmc->read_bl_len;
				if (_dtb_write(mmc, blk, cnt, addr)) {
                    dtb_err("%s: dev # %d, block # %#llx,cnt # %#llx ERROR!\n",
                        __func__, dev, blk, cnt);
                    ret = -4;
                }
                info->valid[0] = 1;
                info->stamp[0] = dtb->timestamp;
                ret = 0;
            } else {
                dtb_info("update dtb2");
                blk = (dtb_glb_offset + vpart->size) / mmc->read_bl_len;
				if (_dtb_write(mmc, blk, cnt, addr)) {
                    dtb_err("%s: dev # %d, block # %#llx,cnt # %#llx ERROR!\n",
                        __func__, dev, blk, cnt);
                    ret = -2;
                }
                info->valid[1] = 1;
                info->stamp[1] = dtb->timestamp;
            }
        break;
        /* both are valid, pickup new one. */
        case 2:
			if (stamp_after(info->stamp[1], info->stamp[0])) {
				blk = (dtb_glb_offset + vpart->size) / mmc->read_bl_len;
				if (_dtb_read(mmc, blk, cnt, addr)) {
					dtb_err("%s: dev # %d, block # %#llx,cnt # %#llx ERROR!\n",
							__func__, dev, blk, cnt);
                    ret = -3;
                }
                /*update dtb1*/
                blk = dtb_glb_offset / mmc->read_bl_len;
				if (_dtb_write(mmc, blk, cnt, addr)) {
                    dtb_err("%s: dev # %d, block # %#llx,cnt # %#llx ERROR!\n",
                            __func__, dev, blk, cnt);
                    ret = -3;
                }
                info->stamp[0] = dtb->timestamp;
                ret = 0;
            } else if (stamp_after(info->stamp[0], info->stamp[1])) {
                /*update dtb2*/
                blk = (dtb_glb_offset + vpart->size) / mmc->read_bl_len;
				if (_dtb_write(mmc, blk, cnt, addr)) {
                    dtb_err("%s: dev # %d, block # %#llx,cnt # %#llx ERROR!\n",
                            __func__, dev, blk, cnt);
                    ret = -3;
                }
                info->stamp[1] = dtb->timestamp;
            } else {
                dtb_info("do nothing\n");
            }
        break;
        default:
            dtb_err("impossble valid values.\n");
            BUG();
        break;
    }

_out:
    return ret;
}


int dtb_write(void *addr)
{
    int ret = 0;
    struct aml_dtb_rsv * dtb = (struct aml_dtb_rsv *) addr;
    struct aml_dtb_info *info = &dtb_infos;
    u64 blk, cnt, dtb_glb_offset;
    int cpy, valid;
    struct mmc * mmc;
    struct partitions * part = NULL;
    struct virtual_partition *vpart = NULL;
    vpart = aml_get_virtual_partition_by_name(MMC_DTB_NAME);
    part = aml_get_partition_by_name(MMC_RESERVED_NAME);
    dtb_glb_offset = part->offset + vpart->offset;

    mmc = _dtb_init();
	if (NULL == mmc)
        return -10;

    /* stamp */
    valid = info->valid[0] + info->valid[1];
    dtb_info("valid %d\n", valid);
	if (0 == valid)
        dtb->timestamp = 0;
    else if (1 == valid) {
        dtb->timestamp = 1 + info->stamp[info->valid[0]?0:1];
    } else {
        /* both are valid */
		if (info->stamp[0] != info->stamp[1]) {
            dtb_wrn("timestamp are not same %d:%d\n",
                info->stamp[0], info->stamp[1]);
            dtb->timestamp = 1 + stamp_after(info->stamp[1], info->stamp[0])?
                info->stamp[1]:info->stamp[0];
        } else
            dtb->timestamp = 1 + info->stamp[0];
    }
    /*setting version and magic*/
    dtb->version = 1; /* base version */
    dtb->magic = 0x00447e41; /*A~D\0*/
    dtb->checksum = _calc_dtb_checksum(dtb);
    dtb_info("new stamp %d, checksum 0x%x, version %d, magic %s\n",
        dtb->timestamp, dtb->checksum, dtb->version, (char *)&dtb->magic);

	for (cpy = 0; cpy < DTB_COPIES; cpy++) {
		blk = (dtb_glb_offset + cpy * (vpart->size)) / mmc->read_bl_len;
		cnt = vpart->size / mmc->read_bl_len;
		ret |= _dtb_write(mmc, blk, cnt, addr);
        info->valid[cpy] = 1;
        info->stamp[cpy] = dtb->timestamp;
    }

    return ret;
}

extern int check_valid_dts(unsigned char *buffer);
int renew_partition_tbl(unsigned char *buffer)
{
    int ret = 0;
    /* todo, check new dts imcoming.... */
    ret = check_valid_dts(buffer);
    /* only the dts new is valid */
    if (!ret) {
        free_partitions();
        get_partition_from_dts(buffer);
        if (0 == mmc_device_init(_dtb_init())) {
            printf("partition table success\n");
            ret = 0;
            goto _out;
        }
        printf("partition table error\n");
        ret = 1;
    }

_out:
    return ret;
}

int do_amlmmc_dtb_key(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
    int dev, ret = 0;
    void *addr = NULL;
    u64 cnt = 0, n = 0, blk = 0;
    //u64 size;
    struct partitions *part = NULL;
    struct virtual_partition *vpart = NULL;
    vpart = aml_get_virtual_partition_by_name(MMC_DTB_NAME);
    part = aml_get_partition_by_name(MMC_RESERVED_NAME);

    switch (argc) {
        case 3:
            if (strcmp(argv[1], "erase") == 0) {
                if (strcmp(argv[2], "dtb") == 0) {
                    printf("start erase dtb......\n");
                    dev = EMMC_DTB_DEV;
                    struct mmc *mmc = find_mmc_device(dev);
                    if (!mmc) {
                        printf("not find mmc\n");
                        return 1;
                    }
                    blk = (part->offset + vpart->offset) / mmc->read_bl_len;
                    cnt = (vpart->size * 2) / mmc->read_bl_len;
                    if (cnt != 0)
                        n = mmc->block_dev.block_erase(dev, blk, cnt);
                    printf("dev # %d, %s, several blocks erased %s\n",
                            dev, (flag == 0) ? " ":(argv[2]),(n == 0) ? "OK" : "ERROR");
                    return (n == 0) ? 0 : 1;
                }else if (strcmp(argv[2], "key") == 0){
                    printf("start erase key......\n");
                    dev = 1;
                    struct mmc *mmc = find_mmc_device(dev);
                    if (!mmc) {
                        printf("not find mmc\n");
                        return 1;
                    }
                    n = mmc_key_erase();
                    printf("dev # %d, %s, several blocks erased %s\n",
                            dev, (flag == 0) ? " ":(argv[2]),(n == 0) ? "OK" : "ERROR");
                    return (n == 0) ? 0 : 1;
                }
            } else if (strcmp(argv[1], "cali_pattern") == 0) {

				if (strcmp(argv[2], "write") == 0) {
                    dev = EMMC_DTB_DEV;
                    struct mmc *mmc = find_mmc_device(dev);
                    if (!mmc) {
                        printf("not find mmc\n");
                        return 1;
                    }
                    addr = (void *)malloc(CALI_PATTERN_SIZE);
                    mmc_write_cali_mattern(addr);
                    vpart = aml_get_virtual_partition_by_name(MMC_PATTERN_NAME);
                    part = aml_get_partition_by_name(MMC_RESERVED_NAME);
                    blk = (part->offset + vpart->offset) / mmc->read_bl_len;
                    cnt = vpart->size / mmc->read_bl_len;
                    if (cnt != 0)
                        n = mmc->block_dev.block_write(dev, blk, cnt, addr);
                    printf("dev # %d, %s, several calibration pattern blocks write %s\n",
                            dev, (flag == 0) ? " ":(argv[2]),(n == cnt) ? "OK" : "ERROR");
                    free(addr);
                    return (n == cnt) ? 0 : 1;
                }
            }
        case 4:
            addr = (void *)simple_strtoul(argv[2], NULL, 16);
            if (strcmp(argv[1], "dtb_read") == 0) {
                /* fixme, */
                ret = dtb_read(addr);
                return 0;

            } else if (strcmp(argv[1], "dtb_write") == 0) {
                /* fixme, should we check the return value? */
                ret = dtb_write(addr);

                ret |= renew_partition_tbl(addr);
                return ret;
            }
            return 0;
        default:
            break;
    }
    return 1;
}

int emmc_update_mbr(unsigned char *buffer)
{
    int ret = 0;
    cpu_id_t cpu_id = get_cpu_id();

    if (cpu_id.family_id < MESON_CPU_MAJOR_ID_GXL) {
        ret = -1;
        printf("MBR not support, try dtb\n");
        goto _out;
    }
#ifndef DTB_BIND_KERNEL
    dtb_write(buffer);
#endif
    ret = get_partition_from_dts(buffer);
    if (ret) {
        printf("Fail to get partition talbe from dts\n");
        goto _out;
    }
    ret = mmc_device_init(_dtb_init());
    printf("%s: update mbr %s\n", __func__, ret?"Fail":"Success");
_out:
    return ret;
}

U_BOOT_CMD(
    emmc, 4, 1, do_amlmmc_dtb_key,
    "EMMC sub system",
    "emmc dtb_read addr size\n"
    "emmc dtb_write addr size\n"
    "emmc erase dtb\n"
    "emmc erase key\n");