/*
* Copyright (C) 2017 Amlogic, Inc. All rights reserved.
* *
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.
* *
Description:
*/

#include <command.h>
#include <watchdog.h>
#include <malloc.h>
#include <common.h>
#include <linux/ctype.h>
#include <asm/byteorder.h>
#include <div64.h>
#include <linux/err.h>
#include <partition_table.h>
#include <mmc.h>

#define DbgP(fmt...)   //printf("[burnupDbg]"fmt)
#define MsgP(fmt...)   printf("[burnup]"fmt)
#define ErrP(fmt...)   printf("[burnup]Err:%s,L%d:", __func__, __LINE__),printf(fmt)

static unsigned char *cmd_name = (unsigned char *)("store");
const char*   _usbDownPartImgType = "";

#define MtdAlignBits    (12) //32k
#define MtdAlignSz      (1U << MtdAlignBits)
#define MtdAlignMask    (MtdAlignSz - 1)

/***
upgrade_read_ops:

partition_name: env / logo / recovery /boot / system /cache /media

 ***/

int store_read_ops(unsigned char *partition_name,unsigned char * buf, uint64_t off, uint64_t size)
{
        unsigned char *name;
        uint64_t addr;
        char	str[128];
        int ret =0;

        if (!buf) {
                ErrP("upgrade: no buf!!");
                return -1;
        }

        name = partition_name;
        addr = (unsigned long)buf;

#if CONFIG_AML_MTD
        if ((size & MtdAlignMask) && (NAND_BOOT_FLAG == device_boot_flag )) {
                MsgP("Rd:Up sz 0x%llx to align 0x%x\n", size, MtdAlignSz);
                size = ((size + MtdAlignMask)>>MtdAlignBits) << MtdAlignBits;
        }
#if defined(UBIFS_IMG) || defined(CONFIG_CMD_UBIFS)
        if (!strcmp(_usbDownPartImgType, "ubifs")) {
                sprintf(str, "%s  read 0x%llx %s 0x%llx", "ubi", addr, name, size);
                MsgP("cmd[%s]", str);
        } else
#endif
#endif//#if CONFIG_AML_MTD
        {// not ubi part
                sprintf(str, "%s  read %s 0x%llx  0x%llx  0x%llx", cmd_name, name, addr, off, size);
        }

        DbgP("run cmd[%s]\n", str);
        ret = run_command(str, 0);
        if (ret != 0) {
                ErrP("cmd failed, ret=%d, [%s]\n", ret, str);
                return -1;
        }

        return 0;
}

/***
upgrade_write_ops:

partition_name: env / logo / recovery /boot / system /cache /media

 ***/

int store_write_ops(unsigned char *partition_name,unsigned char * buf, uint64_t off, uint64_t size)
{
        unsigned char *name;
        uint64_t addr;
        char	str[128];
        int ret =0;

        if (!buf) {
                store_msg("upgrade: no buf!!");
                return -1;
        }

        name = partition_name;
        addr = (unsigned long)buf;
        if ((EMMC_BOOT_FLAG == device_boot_flag) && !strcmp("1", (char*)name))
        {
            if (off & 0x1ff) {
                ErrP("emmc1 invalid offset 0x%llx\n", off);
                return -__LINE__;
            }
            if (size & 0xff) {
                MsgP("NOT align sz 0x%llx\n", size);
            }
            sprintf(str, "mmc write 0x%p 0x%llx 0x%llx", buf, (off>>9), (size>>9));
            ret = run_command(str, 0);
            if (ret) {
                ErrP("Fail in cmd[%s]\n", str);
                return -__LINE__;
            }
            return ret;
        }

#if CONFIG_AML_MTD
        if ((size & MtdAlignMask) && (NAND_BOOT_FLAG == device_boot_flag )) {
                MsgP("Wr:Up sz 0x%llx to align 0x%x\n", size, MtdAlignSz);
                size = ((size + MtdAlignMask)>>MtdAlignBits) << MtdAlignBits;
        }
#if defined(UBIFS_IMG) || defined(CONFIG_CMD_UBIFS)
        if (!strcmp(_usbDownPartImgType, "ubifs")) {//ubi part
                sprintf(str, "%s  write 0x%llx %s 0x%llx  ", "ubi", addr, name, size);
        } else
#endif// #if defined(UBIFS_IMG) || defined(CONFIG_CMD_UBIFS)
#endif// #if CONFIG_AML_MTD
        {
                sprintf(str, "%s  write %s 0x%llx  0x%llx  0x%llx", cmd_name, name, addr, off, size);
        }

        DbgP("run cmd[%s]\n", str);
        ret = run_command(str, 0);
        if (ret != 0) {
                ErrP("cmd [%s] failed ", str);
                return -1;
        }

        return 0;
}


/***
upgrade_write_ops:

partition_name: env / logo / recovery /boot / system /cache /media

 ***/

int store_get_partititon_size(unsigned char *partition_name, uint64_t *size)
{
    char	str[128];
    int ret=0;

    if (isdigit(*partition_name) && 1 == strlen((char*)partition_name))
    {
        const int curDev = *partition_name - '0';
        sprintf(str, "mmc dev %d", curDev);
        MsgP("cmd[%s]\n", str);
        if (run_command(str, 0)) {
            ErrP("Fail probe dev %d\n", curDev);
            return 0;
        }
        struct mmc *mmc = find_mmc_device(curDev);
        if (!mmc) {
            ErrP("Fail find mmc  %s\n", partition_name);
            return 0;
        }
        if (mmc_init(mmc)) {
            ErrP("FAil init mmc %s\n", partition_name);
            return 0;
        }
        MsgP("mmc %s capacity 0x%llx\n", partition_name, mmc->capacity);
        *size = mmc->capacity;
        run_command("store disprotect key", 0);
        MsgP("cmd[%s]\n", str);
        return 0;
    }

    sprintf(str, "%s  size %s 0x%p ",cmd_name, partition_name, size);
    store_dbg("command:	%s", str);
    ret = run_command(str, 0);
    if (ret != 0) {
        ErrP("cmd [%s] size failed ", str);
        return -1;
    }

    return ret;
}


/***
upgrade_erase_ops:

partition_name: boot / data

flag = 0; indicate erase partition ;
flag = 1; indicate scurb whole nand;

 ***/
int store_erase_ops(unsigned char *par_name, uint64_t off, uint64_t size, unsigned char flag)
{
        unsigned char *name;
        char	str[128];
        int ret=0;

        name = par_name;
        if (flag == 0) {
                sprintf(str, "%s  erase %s 0x%llx  0x%llx",cmd_name, name, off, size);
                store_dbg("command:	%s", str);
                ret = run_command(str, 0);
                if (ret != 0) {
                        store_msg("cmd %s erase failed",cmd_name);
                        return -1;
                }

        }else if(flag == 1){

                sprintf(str, "%s  rom_protect off ",cmd_name);
                store_dbg("command:	%s", str);
                ret = run_command(str, 0);
                if (ret != 0) {
                        store_msg("cmd %s scrub failed ",cmd_name);
                        return -1;
                }

                sprintf(str, "%s  scrub  0x%llx ",cmd_name, (long long unsigned int)0);
                store_dbg("command:	%s", str);
                ret = run_command(str, 0);
                if (ret != 0) {
                        store_msg("cmd %s scrub failed",cmd_name);
                        return -1;
                }
        }

        return 0;
}

/***
bootloader:
 ***/
int store_boot_read(unsigned char * buf, uint64_t off, uint64_t size)
{
        //unsigned char *name;
        uint64_t addr;
        char	str[128];
        int ret =0;

        if (!buf) {
                store_msg("upgrade: no buf!!");
                return -1;
        }

        addr = (unsigned long)buf;
        store_dbg("store_boot_read: addr 0x%llx\n",addr);

        sprintf(str, "%s  rom_read 0x%llx  0x%llx  0x%llx",cmd_name, addr, off, size);
        store_dbg("command:	%s", str);
        ret = run_command(str, 0);
        if (ret != 0) {
                store_msg("cmd %s  rom_read failed",cmd_name);
                return -1;
        }

        return 0;

}

int store_boot_write(unsigned char * buf,uint64_t off, uint64_t size)
{
        //unsigned char *name;
        uint64_t addr;
        char	str[128];
        int ret =0;

        if (!buf) {
                store_msg("upgrade: no buf!!");
                return -1;
        }

        addr = (unsigned long)buf;

        sprintf(str, "%s  rom_write 0x%llx  0x%llx  0x%llx",cmd_name, addr, off, size);
        store_dbg("command:	%s", str);
        ret = run_command(str, 0);
        if (ret != 0) {
                store_msg("cmd %s rom_write failed",cmd_name);
                return -1;
        }

        return 0;

}


int store_init(unsigned  flag)
{
        //unsigned char *name;
        //unsigned long addr;
        char	str[128];
        int ret =0;
        store_dbg("flag : %d",flag);

        sprintf(str, "%s  init %d",cmd_name,flag);
        store_dbg("command:	%s", str);
        ret = run_command(str, 0);
        if (ret != 0) {
                store_msg("cmd [%s] init failed ",str);
                return -1;
        }
        return 0;
}


int store_exit(void)
{
        //unsigned char *name;
        //unsigned long addr;
        char	str[128];
        int ret =0;

        sprintf(str, "%s  exit",cmd_name);
        printf("command:	%s\n", str);
        ret = run_command(str, 0);
        if (ret != 0) {
                store_msg("cmd %s exit failed",cmd_name);
                return -1;
        }

        return 0;

}

//store dtb read/write buf sz
//@rwFlag: 0---read, 1---write, 2---iread
int store_dtb_rw(void* buf, unsigned dtbSz, int rwFlag)
{
    char _cmdBuf[128];
    char* ops = !rwFlag ? "read" : ((1==rwFlag) ? "write" : "iread");

    sprintf(_cmdBuf, "store dtb %s 0x%p 0x%x", ops, buf, dtbSz);
    return run_command(_cmdBuf, 0);
}

#if 0
int do_store_test(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
        int i, init_flag=0,dev, ret = 0;
        ulong addr;
        uint64_t off, size;
        char *cmd, *s, *area;
        char	str[128];
        unsigned char *buf;

        cmd = argv[1];

        buf = malloc(0x400000);
        if (!buf) {
                printf("do_store_test : malloc failed\n");
                return -1;
        }

        area ="logo";

        if (strcmp(cmd, "read") == 0) {
                ret = store_read_ops(area,buf,0x0,0x40000);
                if (ret < 0) {
                        printf("store read failed\n");
                        return -1;
                }
                printf("store read OK\n");
        }

        if (strcmp(cmd, "boot_read") == 0) {
                ret = store_boot_read(buf,0x0,0x60000);
                if (ret < 0) {
                        printf("store boot_read failed\n");
                        return -1;
                }
                printf("store boot_read OK\n");
        }

        if (strcmp(cmd, "init") == 0) {
                ret = store_init(0x0);
                if (ret < 0) {
                        printf("store init failed\n");
                        return -1;
                }
                printf("store init OK\n");
        }

        if (strcmp(cmd, "write") == 0) {
                memset(buf,0xa5,0x400000);
                ret = store_write_ops(area,buf,0x0,0x40000);
                if (ret < 0) {
                        printf("store write failed\n");
                        return -1;
                }
                printf("store write OK\n");
        }

        if (strcmp(cmd, "erase") == 0) {
                area = "data";
                ret = store_erase_ops(area,0x0,0,0);
                if (ret < 0) {
                        printf("store write failed\n");
                        return -1;
                }
        }

        if (strcmp(cmd, "size") == 0) {
                uint64_t off=0, size;

                ret = store_get_partititon_size(area,&size);
                if (ret < 0) {
                        printf("store write failed\n");
                        return -1;
                }
                printf("off =%llx size=%llx\n",off,size);
        }

        if (buf)
                kfree(buf);
        return 0;

}

U_BOOT_CMD(store_test, CONFIG_SYS_MAXARGS, 1, do_store_test,
                "NAND sub-system",
                "store read name addr off|partition size\n"
                "    read 'size' bytes starting at offset 'off'\n"
                "    to/from memory address 'addr', skipping bad blocks.\n"
                "store write name addr off|partition size\n"
                "    write 'size' bytes starting at offset 'off'\n"
                "    to/from memory address 'addr', skipping bad blocks.\n"
                "store erase boot/data: \n"
                "erase the area which is uboot or datas \n"
                "store scrub off|partition size\n"
                "scrub the area from offset and size \n"
          );
#endif