/*
 * \file        optimus_key_burn.c
 * \brief       burning keys from sdcard like update.exe
 *
 * \version     1.0.0
 * \date        2014/12/25
 * \author      Sam.Wu <yihui.wu@amlgic.com>
 *
 * Copyright (c) 2014 Amlogic. All Rights Reserved.
 *
 */

/*
 *
 * This cmd [aml_key_burn] aim to burn keys like 'update.exe', and mainly used for myself.
 * like update.exe, the key in here is single and not need to sperate
 * e.g, for comparison, here to burn a hdcp key using aml_key_burn and update.exe
 *     0. update.exe identify .                                 <-----> aml_key_burn probe vfat sdc
 *     1. update.exe mwrite meson.dtb mem dtb normal .          <-----> aml_key_burn meson_dtb meson.dtb
 *     2, update.exe bulkcmd "key init 0x1234"                  <-----> aml_key_burn init 0x1234
 *     3, update.exe mwrite key hdcp normal hdcp308.val         <-----> aml_key_burn burn hdcp hdcp308.val
 *              other keys
 *     4, update.exe bulkcmd "key uninit"                       <-----> aml_key_burn uninit
 *
 */
#include "../optimus_sdc_burn_i.h"
#include <amlogic/keyunify.h>

#define _AML_KEY_ERR(fmt...)    sprintf(_errInfo, fmt), DWN_ERR(_errInfo)

static char _errInfo[512] = "";


typedef enum{
        DEV_FILE_FMT_VFAT       = 0xee,
        DEV_FILE_FMT_EXT2
}DevFileFmt_e;

typedef enum{
        DEV_INTF_EXT_SDMMC      = 0xdd,
        DEV_INTF_EXT_UDISK            ,
}DevIntf_e;

static struct optKeyInfo_s{
        DevFileFmt_e            fileFmt;
        DevIntf_e               intf;//interface
} _optKeyInfo;
/*
 * <aml_key_burn probe> device_format interface
 */
static int do_opt_keysburn_probe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
        int rc = 0;
        const char* device_format = argv[2];//vfat
        const char* device_interf = argv[3];//sdc/udisk

        if (4 > argc) {
                _AML_KEY_ERR("failed:argc: %d < 4\n", argc);
                return __LINE__;
        }
        if (!strcmp(device_format, "vfat")) {
                _optKeyInfo.fileFmt = DEV_FILE_FMT_VFAT;
        }
        else{
                _AML_KEY_ERR("failed:device_format %s unsupported yet\n", device_format);
                return __LINE__;
        }

        if (!strcmp("sdc", device_interf))
        {
                static int _mmcprobe = 0;

                if (!_mmcprobe)
                {
                        rc = run_command("mmcinfo", 0);
                        if (rc) {
                                _AML_KEY_ERR("failed: in mmcinfo\n");
                                return __LINE__;
                        }
                        rc = optimus_device_probe("mmc", "0");
                        if (rc) {
                                _AML_KEY_ERR("Fail to detect device mmc 0\n");
                                return __LINE__;
                        }
                        _mmcprobe = 1;
                }
                _optKeyInfo.intf = DEV_INTF_EXT_SDMMC;
        }
        else if(!strcmp("udisk", device_interf))
        {
                static int _udiskProbe = 0;

                if (!_udiskProbe)
                {
                        rc = run_command("usb start 0", 0);
                        if (rc) {
                                _AML_KEY_ERR("Fail in mmcinfo\n");
                                return __LINE__;
                        }
                        rc = optimus_device_probe("usb", "0");
                        if (rc) {
                                _AML_KEY_ERR("Fail to detect device mmc 0\n");
                                return __LINE__;
                        }
                        _udiskProbe = 1;
                }
                _optKeyInfo.intf = DEV_INTF_EXT_UDISK;
        }
        else{
                _AML_KEY_ERR("device_interf %s unsupported\n", device_interf);
                return -__LINE__;
        }

        return rc;
}

static int do_opt_keysburn_init(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
        int rc = 0;

        if (3 > argc)
        {
                cmd_usage(cmdtp);
                return __LINE__;
        }
        rc = v2_key_command(argc, argv, _errInfo);
        if (rc) {
                DWN_ERR("Fail to init key driver.\n");
                return -__LINE__;
        }

        return rc;
}

static int do_opt_keysburn_uninit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
        int rc = 0;

        rc = v2_key_command(argc, argv, _errInfo);
        if (rc) {
                DWN_ERR("Fail to init key driver.\n");
                return -__LINE__;
        }
        return rc;
}

static int do_opt_keysburn_misc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
        int rc = 0;

        --argc, ++argv;//skip the misc subcmd
        rc = v2_key_command(argc, argv, _errInfo);
        if (rc < 0) {
                return -__LINE__;
        }

        return rc;
}

static int optimus_read_keyfile_2_mem(const char* filePath, u8* buf, unsigned* keyValLen)
{
        int rc = 0;
        unsigned keySz = 0;

        if (DEV_FILE_FMT_VFAT == _optKeyInfo.fileFmt)
        {
                long hFile = -1;
                unsigned readSz = 0;

#if 1//FIXME: remove this mmcinfo
                /*rc = run_command("mmcinfo 0", 0);*/
                rc = optimus_sdc_burn_switch_to_extmmc();
                if (rc) {
                        DWN_ERR("Fail in mmcinfo\n");
                        return __LINE__;
                }
#endif//
                keySz = (unsigned)do_fat_get_fileSz(filePath);//can support both sdc and udisk
                if (!keySz) {
                        DWN_ERR("size is 0 of file [%s]\n", filePath);
                        return __LINE__;
                }

                hFile = do_fat_fopen(filePath);
                if (hFile < 0) {
                        DWN_ERR("Fail to open file[%s]\n", filePath);
                        return __LINE__;
                }

                readSz = do_fat_fread(hFile, buf, keySz);
                if (readSz != keySz) {
                        DWN_ERR("Want read %d bytes, but %d\n", keySz, readSz);
                        return __LINE__;
                }

                do_fat_fclose(hFile);
        }

        *keyValLen = keySz;
        return rc;
}

int optimus_keysburn_onekey(const char* keyName, u8* keyVal, unsigned keyValLen)
{
        int rc = 0;
        unsigned wrLen = 0;

        DWN_MSG("keyName[%s], keyValAddr=%p,len=%d\n", keyName, keyVal, keyValLen);
        wrLen = v2_key_burn(keyName, keyVal, keyValLen, _errInfo);
        DWN_MSG("writeLen=====%d\n", wrLen);
        rc = wrLen != keyValLen;
        DWN_MSG("%s in burn key[%s]\n", rc ? "failed" : "success", keyName);

        return rc;
}

static int do_opt_keysburn_burn(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
        int rc = 0;
        const char* keyName = argv[2];
        u8* keyVal = (u8*)OPTIMUS_DOWNLOAD_TRANSFER_BUF_ADDR;
        unsigned keyValLen = 0;

        if (4 > argc) {
                _AML_KEY_ERR("argc=%d < 4\n", argc);
                return __LINE__;
        }
        if (argc > 4)
        {
                keyVal          = (u8*)simple_strtoul(argv[3], NULL, 16);
                keyValLen       = simple_strtoul(argv[4], NULL, 0);
        }
        else//The key is file in the specified device
        {
                const char* filePath = argv[3];

                rc = optimus_read_keyfile_2_mem(filePath, keyVal, &keyValLen);
                if (rc) {
                        _AML_KEY_ERR("Fail to read file[%s]\n", filePath);
                        return __LINE__;
                }
        }
        rc = optimus_keysburn_onekey(keyName, keyVal, keyValLen);

        return rc;
}


static cmd_tbl_t cmd_opt_key_burn[] = {
	U_BOOT_CMD_MKENT(probe,       4, 0, do_opt_keysburn_probe, "", ""),
	U_BOOT_CMD_MKENT(init,        3, 0, do_opt_keysburn_init, "", ""),
	U_BOOT_CMD_MKENT(uninit,      2, 0, do_opt_keysburn_uninit, "", ""),
	U_BOOT_CMD_MKENT(burn,        5, 0, do_opt_keysburn_burn, "", ""),
	U_BOOT_CMD_MKENT(misc,        6, 0, do_opt_keysburn_misc, "", ""),
};

static int do_aml_key_burn(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
        int rc = 0;
	cmd_tbl_t *c;

        sprintf(_errInfo, "success");
	c = find_cmd_tbl(argv[1], cmd_opt_key_burn, ARRAY_SIZE(cmd_opt_key_burn));

        if (!c) {
                DWN_ERR("Can't find subcmd[%s]\n", argv[1]);
		return 1;
        }

        rc = c->cmd(cmdtp, flag, argc, argv);
        DWN_MSG("[key]%s\n", _errInfo);
        if (rc < 0) {
                DWN_ERR("Fail in cmd[%s %s].ret=%d\n", argv[1], argv[2], rc);
                return -__LINE__;
        }
        rc = strncmp("success", _errInfo, 7);

        return rc;
}

U_BOOT_CMD(
   aml_key_burn,      //command name
   6,               //maxargs
   0,               //repeatable
   do_aml_key_burn,   //command function
   "Burning keys from external device(sdmmc/udisk/memory) other than usb device",           //description
   "argv: aml_key_burn ...\n"//usage
   "<probe> file_system interface --- init external device/interface\n"//usage
   "    - e.g.1, for fat sdcard  : <aml_key_burn probe> vfat sdc\n"
   "    - e.g.2, for fat udisk   : <aml_key_burn probe> vfat udisk\n"
   "\n"
   "<init/uninit> random_value --- init nandkey/efusekey driver\n"//usage
   "\n"
   "<burn> keyName keyFilePath(keyBufAddr keySize) --- init external device/interface\n"//usage
   "    - e.g.1, write hdcp key with hdcp308.key from sdcard: <aml_key_burn burn> hdcp hdcp308.key\n"
   "    - e.g.2, write hdcp key in addr 0x200000 : <aml_key_burn burn> hdcp 0x200000 308\n"
   "\n"
);