/*
 * \file        sdc_keysprovider.c
 * \brief       Parse users' nankey/efusekey like PC's keysprovider.dll in sdcard burning mode
 *
 * \version     1.0.0
 * \date        2014/12/25
 * \author      Sam.Wu <yihui.wu@amlgic.com>
 *
 * Copyright (c) 2014 Amlogic. All Rights Reserved.
 *
 */
#include "../optimus_sdc_burn_i.h"
#include "sdc_bootPart_license.h"

#define _KEYS_PRV_DBG(fmt...) //DWN_MSG(fmt)
#define _KEYS_PRV_ITEM_INF_ADDR_4_CONSIST     (OPTIMUS_DOWNLOAD_DISPLAY_BUF + 48 * 1024)
#define _KEYS_PRV_ITEM_INF_ADDR_MISC          (OPTIMUS_DOWNLOAD_DISPLAY_BUF + 52 * 1024)

#define _KEY_VAL_TMP_BUF            (OPTIMUS_DOWNLOAD_TRANSFER_BUF_ADDR - OPTIMUS_DOWNLOAD_SLOT_SZ)
static struct {
        char*                   keyBuf;
        unsigned                keySize;
}_currentKey = {0};

//Note: keys which read only is not need to update license, and so not need stored in boot partition
//Typedef for keys structs in sdcard boot partition
#if 1
#define AML_BOOT_PART_KEY_IMG_OFFSET            (0X2U<<20)
#define AML_BOOT_PART_KEY_IMG_MAGIC_LEN         8
#define AML_BOOT_PART_KEY_IMG_MAGIC_V1          "AML_KEY!"
#define AML_BOOT_PART_KEY_IMG_ALIGN_SZ          512
#define AML_BOOT_PART_KEY_IMG_HEAD_SZ           (64)

#define AML_BOOT_PART_KEY_ITEM_INF_LEN          (64)
#define AML_BOOT_PART_KEY_ITEM_NAME_LEN_MAX     (16)

//struct for the keys head which stored in boot partition
#pragma pack(push, 4)
typedef struct {
        __u32           crc;
        __s32           version;

        __u8            magic[AML_BOOT_PART_KEY_IMG_MAGIC_LEN];

        __u32           imgSz;
        __u32           imgItemNum;

        __u32           alignSz;//512
        __u8            resrv[AML_BOOT_PART_KEY_IMG_HEAD_SZ - 8 * 3 - 4];

}AmlBootPartKeysHead_t;
#pragma pack(pop)

#pragma pack(push, 4)
typedef struct {
        __u8            keyName[AML_BOOT_PART_KEY_ITEM_NAME_LEN_MAX];

        __u32           itemIndex;
        __u32           itemSz;         //equl to sizeof of each key

        __u32           itemBodyOffset;
        __u32           itemHasConf;//this item name is configured in keys.conf

        __u8            resrv[32];

}KeyInfo_t;
#pragma pack(pop)

#define MAX_KEY_INF_NUM                 5       //the max key numbers supported at the same time

typedef struct {
        AmlBootPartKeysHead_t           bootPartKeyHead;
        KeyInfo_t                       keysInf[MAX_KEY_INF_NUM];
}BootPartKeyInf_t;

#endif//image for keys END #if 1

#define debugP(fmt...) //printf("L%d:", __LINE__),printf(fmt)
#define errorP(fmt...) printf("Err[keyspr]L%d:", __LINE__),printf(fmt)
#define wrnP(fmt...)   printf("Wrn[keyspr]L%d:", __LINE__),printf(fmt)
#define MsgP(fmt...)   printf("Msg[keyspr]L%d:", __LINE__),printf(fmt)

#define KEY_MAP_MAGIC   0xeeffaa00

enum {
        KEY_FMT__MAC            = 0XBB,         //string format like 00:01:02:03:04:05
        KEY_FMT__ONLEYONE             ,         //only one format means read the total license file as key value
        KEY_FMT__HDCP                 ,
        KEY_FMT__HDCP2                ,
};

//Different keyNames can have the same key format
typedef int (*pFunc_getKeyValByLic)(const char* licensePath, u8* keyVal, unsigned* keyValLen, const char* keyName);
typedef int (*pFunc_updateLic)(const char* keyName, const char* licensePath);//update the licnese file when burn succeed

typedef struct _keyFmtMapping{
        unsigned                magic;
        const char* const       keyName;
        const char* const       licenseFile;
        const unsigned          keyFmt;
        pFunc_getKeyValByLic    get_key_val;
        pFunc_updateLic         update_license;
}KeyFmtMap_t;

static int get_key_val_for_fmt_mac(const char* licenseName, u8* keyVal, unsigned* keyValLen, const char* keyName);
static int get_key_val_for_fmt_hdcp(const char* licenseName, u8* keyVal, unsigned* keyValLen, const char* keyName);
static int get_key_val_for_fmt_hdcp2rx(const char* licenseName, u8* keyVal, unsigned* keyValLen, const char* keyName);
static int get_key_val_for_fmt_onlyone(const char* licenseName, u8* keyVal, unsigned* keyValLen, const char* keyName);

static int update_lic_for_fmt_mac(const char* keyName, const char* licenseName);
static int update_lic_for_fmt_hdcp(const char* keyName, const char* licenseName);
static int update_lic_for_fmt_hdcp2rx(const char* keyName, const char* licenseName);

static const KeyFmtMap_t _keysFmtMapping[] = {
        /*     magic,           keyname                  license file name      keyFmt*/
        [0] = {KEY_MAP_MAGIC,   "mac",                  "license/mac_ether.ini"  , KEY_FMT__MAC     , get_key_val_for_fmt_mac    , update_lic_for_fmt_mac    },
        [1] = {KEY_MAP_MAGIC,   "mac_bt",               "license/mac_bt.ini"     , KEY_FMT__MAC     , get_key_val_for_fmt_mac    , update_lic_for_fmt_mac    },
        [2] = {KEY_MAP_MAGIC,   "mac_wifi",             "license/mac_wifi.ini"   , KEY_FMT__MAC     , get_key_val_for_fmt_mac    , update_lic_for_fmt_mac    },
        [3] = {KEY_MAP_MAGIC,   "hdcp",                 "license/HDCP_LIENCE"    , KEY_FMT__HDCP    , get_key_val_for_fmt_hdcp   , update_lic_for_fmt_hdcp   },
        [4] = {KEY_MAP_MAGIC,   "hdcp2",                "license/HDCP2_LIENCE"   , KEY_FMT__HDCP2   , get_key_val_for_fmt_hdcp2rx, update_lic_for_fmt_hdcp2rx},
        [5] = {KEY_MAP_MAGIC,   "secure_boot_set",      "license/SECURE_BOOT_SET", KEY_FMT__ONLEYONE, get_key_val_for_fmt_onlyone, NULL},
};
#define _SupportKeysNum (sizeof(_keysFmtMapping)/sizeof(KeyFmtMap_t))

#if 1   //mac begin
static int optimus_sdc_burn_check_mac_ini_set_is_valid(const char* setName)
{
        const char* macSets[] = {"Group1", "Group2", "Group3"};
        const int   nSet      = sizeof(macSets)/sizeof(char*);
        int         index     = 0;
        int         rc        = 0;

        for (; index < nSet && !rc; ++index)
        {
                rc = !strcmp(setName, macSets[index]);
        }

        return rc;
}

typedef struct {
        char            startMac[17 + 3];       //+2 to align 4
        char            endMac[17 + 3];         //+2 to align 4
        unsigned        total;
        unsigned        used;
}MacGroup_t;

typedef struct {
        unsigned        actualGroup;
        MacGroup_t      groups[3];//max group is 3
}KeyInf_mac_t;

typedef struct {
        const char*             start;
        const char*             end;
        unsigned                used;
        unsigned                total;//total = end + 1 - start
}MacCfg_t;

/*static KeyInf_mac_t _bootPart_keyInf_Mac;//Mac key info stored in boot partition*/

static int optimus_update_mac_str_current_val(char* startVal, unsigned used)
{
        int i = 0;

        if (17 != strlen(startVal)) {
                DWN_ERR("start(%s) fmt error.\n", startVal);
                return __LINE__;
        }

        MsgP("start[%s], used=%d\n", startVal, used);
        for (i = 5; i >= 0 && used; --i, (used >>= 8))
        {
                char* grp2       = startVal + i * 3;
                unsigned grp2Val = simple_strtoul(grp2, NULL, 16);

                DWN_DBG("gpp2(%s)grep2=%d, used=%d\n", grp2, grp2Val, used);
                grp2Val += used & 0xff;
                if (grp2Val > 0xff)
                {
                        used    += 0x100;
                        grp2Val &= 0xff;
                }
                sprintf(grp2, "%02x", grp2Val);
                DWN_DBG("grp[%d]%s\n", i, grp2);
        }
        DWN_MSG("Update mac [%s]\n", startVal);

        return 0;
}

static int _optimus_get_mac_diff(MacCfg_t* macCfg)
{
        const char* start       = macCfg->start;
        const char* end         = macCfg->end;
        __u64 startVal          = 0;
        __u64 endVal            = 0;
        int i                   = 0;

        for (i = 0; i < 6; ++i, start += 3, end += 3)
        {
                startVal += simple_strtoul(start, NULL, 16);
                endVal   += simple_strtoul(end, NULL, 16);

                startVal <<= 8;
                endVal   <<= 8;
        }
        startVal >>= 8;
        endVal   >>= 8;
        DWN_MSG("mac range[%04x%08x, %04x%08x]\n",
                        (unsigned)(startVal>>32), (unsigned)(startVal),
                        (unsigned)(endVal>>32),   (unsigned)endVal      );
        macCfg->total = (unsigned)(endVal + 1 - startVal);
        return 0;
}

//update the mac value extracted from mac.ini
//To simplest the case, currently one group is supported
static int optimus_sdc_burn_parse_mac_ini_key_value(const char* setName, const char* keyName, const char* usrKeyVal)
{
        int rc = 0;
        int grpN = 0;
        MacCfg_t* currentMacCfg = (MacCfg_t*)_KEYS_PRV_ITEM_INF_ADDR_MISC;
        char* keyBuf = (char*)_KEY_VAL_TMP_BUF;
        KeyInf_mac_t* pKeyInf4Consist = (KeyInf_mac_t*)_KEYS_PRV_ITEM_INF_ADDR_4_CONSIST;

        rc = strncmp("Group", setName, 5) || ( 6 != strlen(setName) );
        if (rc) {//mac.ini only care Groupn
                return 0;
        }
        grpN = setName[5] - '1'; //'1' not '0'
        if (grpN > 3) {
                DWN_ERR("Can only support grp1 ~ grp3 now!, grp[%s] not ok\n", setName);
                return __LINE__;
        }
        pKeyInf4Consist->actualGroup = grpN + 1;
        MacGroup_t* pKeyConsist = pKeyInf4Consist->groups + grpN;

        _KEYS_PRV_DBG("grp[%d]key=[%s], val=[%s]\n", grpN, keyName, usrKeyVal);
        //the mac cfg must be in the order: start + end (+used)
        if (!strcmp("start", keyName))
        {
                currentMacCfg->start = usrKeyVal;//value in memory
                _currentKey.keySize = strlen(usrKeyVal);
                strcpy(keyBuf, currentMacCfg->start);
                keyBuf[_currentKey.keySize] = 0;
                _currentKey.keyBuf = keyBuf;
                DWN_DBG("keybuf[%s]\n", keyBuf);
                memcpy(pKeyConsist->startMac, usrKeyVal, strlen(usrKeyVal));
        }
        else if (!strcmp("end", keyName))
        {
                currentMacCfg->end = usrKeyVal;
                _currentKey.keySize = strlen(usrKeyVal);
                _optimus_get_mac_diff(currentMacCfg);
                memcpy(pKeyConsist->endMac, usrKeyVal, strlen(usrKeyVal));
                pKeyConsist->total = currentMacCfg->total;
        }
        else if(!strcmp("used", keyName))
        {
                currentMacCfg->used = simple_strtoul(usrKeyVal, NULL, 0);
                if (currentMacCfg->used >= currentMacCfg->total) {
                        DWN_ERR("mac used(%d) >= total(%d)\n", currentMacCfg->used , currentMacCfg->total);
                        return __LINE__;
                }
                pKeyConsist->used = currentMacCfg->used;
        }

        if (17 != _currentKey.keySize) {
                errorP("key size %d of mac(%s) is error, must be 17\n", _currentKey.keySize, usrKeyVal);
                return __LINE__;
        }

        return 0;
}

static int _update_mac_with_cfg_and_bootpart(KeyInf_mac_t* pKeyInf4Consist, KeyInf_mac_t* pKeyInfInBootPart,
                u8* keyVal, unsigned* keyValLen)
{
        const int grpNum = pKeyInf4Consist->actualGroup;
        MacGroup_t* theMacGrpCfg        = NULL;
        MacGroup_t* theMacGrpInBootPart = NULL;
        unsigned    currentUsed         = 0;
        int i = 0;

        theMacGrpCfg = pKeyInf4Consist->groups;
        currentUsed  = theMacGrpCfg->used;
        for (; i < grpNum; ++i, ++theMacGrpCfg)
        {
                const unsigned leftInCfg = theMacGrpCfg->total - theMacGrpCfg->used;
                unsigned leftCnt         = leftInCfg;
                if (pKeyInfInBootPart)
                {
                        theMacGrpInBootPart             = pKeyInfInBootPart->groups + i;
                        const unsigned leftInBoot       = theMacGrpInBootPart->total - theMacGrpInBootPart->used;
                        DWN_MSG("leftInCfg=%u, leftInBoot=%u, used=%u\n", leftCnt, leftInBoot, theMacGrpInBootPart->used);
                        if (leftCnt < leftInBoot) {
                                DWN_ERR("Excp:leftInCfg[%u] < leftInBoot[%u]\n", leftCnt, leftInBoot);
                                return __LINE__;
                        }
                        if (theMacGrpInBootPart->total != theMacGrpCfg->total) {
                                DWN_ERR("Excp:cfg total[%u] != boot total[%u]\n",
                                                theMacGrpCfg->total, theMacGrpInBootPart->total);
                                return __LINE__;
                        }
                        currentUsed = ++theMacGrpInBootPart->used;//used is saved by prev burned
                }
                if (currentUsed < theMacGrpCfg->total) {//Find it
                        DWN_MSG("Found available at grp[%d], total=%u, used=%u\n",
                                        i, theMacGrpCfg->total, currentUsed);
                        break;
                }
        }

        if (i == grpNum) {
                DWN_ERR("Can't find available grp,i=%d\n", i);
                return __LINE__;
        }

        *keyValLen = strlen(theMacGrpCfg->startMac);
        memcpy(keyVal, theMacGrpCfg->startMac, *keyValLen);
        i = optimus_update_mac_str_current_val((char*)keyVal, currentUsed);
        return i;
}

//step 1: parsing license/mac.ini to get 'start' and 'used'
//step 2: search the key info in the boot key, if not existed , then append the keyinfo and update total count
//step 3: check the 'start' and 'used' is same as which in the boot partition if existed
//step 3: get the count recorded in the uboot partition
static int get_key_val_for_fmt_mac(const char* licPath, u8* keyVal, unsigned* keyValLen, const char* keyName)
{
        const int MaxLines = 256;//
        char* lines[MaxLines];
        int rc = __LINE__;
        int validLineNum = 0;
        KeyInf_mac_t* pKeyInfInBootPart = NULL;
        KeyInf_mac_t* pKeyInf4Consist = (KeyInf_mac_t*)_KEYS_PRV_ITEM_INF_ADDR_4_CONSIST;

        memset(pKeyInf4Consist, 0, sizeof(KeyInf_mac_t));
        validLineNum = parse_ini_file_2_valid_lines(licPath, (char*)keyVal, *keyValLen, lines);
        if (!validLineNum) {
                DWN_ERR("error in parse ini file\n");
                return __LINE__;
        }

        rc = optimus_ini_trans_lines_2_usr_params((const char* *)lines, validLineNum,
                        optimus_sdc_burn_check_mac_ini_set_is_valid,
                        optimus_sdc_burn_parse_mac_ini_key_value);
        if (rc) {
                DWN_ERR("Fail in get cfg from %s\n", licPath);
                return __LINE__;
        }
        *keyValLen = _currentKey.keySize;
        memcpy(keyVal, _currentKey.keyBuf, _currentKey.keySize);
        keyVal[_currentKey.keySize] = 0;

#if 1
        rc = optimus_sdc_bootPart_lic_get_key_infdata(keyName, (void**)&pKeyInfInBootPart);
        if (rc) {
                DWN_ERR("Fail in get key inf from boot part\n");
                return __LINE__;
        }
#endif
        rc = _update_mac_with_cfg_and_bootpart(pKeyInf4Consist, pKeyInfInBootPart, keyVal, keyValLen);

        return rc;
}

static int update_lic_for_fmt_mac(const char* keyName, const char* licenseName)
{
        int rc = 0;

        rc = optimus_sdc_bootPart_lic_update_key_inf(keyName, (u8*)_KEYS_PRV_ITEM_INF_ADDR_4_CONSIST, sizeof(KeyInf_mac_t));

        return rc;
}
#endif//MAC


static int get_key_val_for_fmt_hdcp(const char* licenseName, u8* keyVal, unsigned* keyValLen, const char* keyName)
{
        int rc = __LINE__;


        return rc;
}

static int get_key_val_for_fmt_hdcp2rx(const char* licenseName, u8* keyVal, unsigned* keyValLen, const char* keyName)
{
        int rc = __LINE__;


        return rc;
}

static int get_key_val_for_fmt_onlyone(const char* licenseName, u8* keyVal, unsigned* keyValLen, const char* keyName)
{
        int rc = 0;
        char _cmd[96];

        optimus_sdc_burn_switch_to_extmmc();

        sprintf(_cmd, "fatload mmc 0:1 0x%p %s", keyVal, licenseName);
        rc = run_command(_cmd, 0);
        if (rc) {
                errorP("failed in cmd[%s]\n", _cmd);
                return __LINE__;
        }

        *keyValLen = simple_strtoul(getenv("filesize"), NULL, 16);

        return rc;
}

static int update_lic_for_fmt_hdcp(const char* keyName, const char* licenseName)
{
        int rc = 0;


        return rc;
}

static int update_lic_for_fmt_hdcp2rx(const char* keyName, const char* licenseName)
{
        int rc = 0;


        return rc;
}

int optimus_sdc_keysprovider_init(void)
{
        /*return optimus_sdc_bootPart_lic_download();*/
        return 0;
}

int optimus_sdc_keysprovider_exit(void)
{
        /*return optimus_sdc_bootPart_lic_upload();*/
        return 0;
}

//check whether the key license is existed and supported
//keyName is getted from keys.conf in package like PC burning tool
int optimus_sdc_keysprovider_open(const char* keyName, const void** pHdle)
{
        int i = 0;
        int rc = __LINE__;

        const KeyFmtMap_t* pMappedKey = &_keysFmtMapping[0];
        for (i=0; i < _SupportKeysNum; ++i, ++pMappedKey) {
                rc = strcmp(keyName, pMappedKey->keyName);
                if (rc) continue;//keyName not mapped
                *pHdle = pMappedKey;
                return 0;
        }

        return rc;
}

int optimus_sdc_keysprovider_get_keyval(const void* pHdle, u8* pBuf, unsigned* keySz)
{
        const KeyFmtMap_t* pMappedKey = (const KeyFmtMap_t*)pHdle;
        const char* const  keyName    = pMappedKey->keyName;
        const char*        licPath    = pMappedKey->licenseFile;
        int rc = 0;

        if (KEY_MAP_MAGIC != pMappedKey->magic) {
                errorP("magic should be %x, but %x\n", KEY_MAP_MAGIC, pMappedKey->magic);
                return __LINE__;
        }
        rc = pMappedKey->get_key_val(licPath, pBuf, keySz, keyName);
        if (rc) {
                errorP("Fail in getKeyVal for key[%s] at lic path[%s]\n", keyName, licPath);
                return __LINE__;
        }

        return rc;
}

int optimus_sdc_keysprovider_update_license(const void* pHdle)
{
        const KeyFmtMap_t* pMappedKey = (const KeyFmtMap_t*)pHdle;
        const char* const  keyName    = pMappedKey->keyName;
        const char*        licPath    = pMappedKey->licenseFile;
        int rc = 0;

        if (KEY_MAP_MAGIC != pMappedKey->magic) {
                errorP("magic should be %x, but %x\n", KEY_MAP_MAGIC, pMappedKey->magic);
                return __LINE__;
        }
        if (!pMappedKey->update_license) return 0;

        rc = pMappedKey->update_license(keyName, licPath);
        if (rc) {
                errorP("Fail in getKeyVal for key[%s] at lic path[%s]\n", keyName, licPath);
                return __LINE__;
        }

        return 0;
}