blob: 76bde84a7d0a8c97e5c51622b329c8178b00d330 [file] [log] [blame] [edit]
/*
* \file efuse_usr_space_api.c
* \brief support read/write user space using keyname mode
* mapping keyname to offset by looking /efusekey in dtb
*
* \version 1.0.0
* \date 15/07/14
* \author Sam.Wu <yihui.wu@amlgic.com>
*
* Copyright (c) 2015 Amlogic. All Rights Reserved.
*
*/
#include <config.h>
#include <common.h>
#include <command.h>
#include <malloc.h>
#include <linux/ctype.h>
#define EFUSE_DBG(fmt...) //printf("[EFUSE_DBG]"fmt)
#define EFUSE_MSG(fmt...) printf("[EFUSE_MSG]"fmt)
#define EFUSE_ERR(fmt...) printf("[EFUSE_ERR]f(%s)L%d:", __func__, __LINE__),printf(fmt)
extern uint32_t efuse_get_max(void);
extern int efuse_read_usr(char *buf, size_t count, loff_t *ppos);
extern int efuse_write_usr(char *buf, size_t count, loff_t *ppos);
struct efusekey_info{
char keyname[32];
unsigned offset;
unsigned size;
};
static struct _efuseCfgInf{
unsigned initMaigc;//magic to indicate whether inited
unsigned totalCfgKeyNums;
struct efusekey_info * pKeyInf;
}
_efuseKeyInfos = {.totalCfgKeyNums = 0, .pKeyInf = NULL};
int efuse_usr_api_init_dtb(const char* dt_addr)
{
int nodeoffset, poffset = 0;
char propname[32];
const void* phandle;
int ret;
int index;
uint32_t max_size;
unsigned efusekeynum = 0;
struct efusekey_info * efusekey_infos = NULL;
ret = fdt_check_header(dt_addr);
if (ret < 0) {
EFUSE_ERR("fdt check failed [%s]\n", fdt_strerror(ret));
return __LINE__;
}
_efuseKeyInfos.initMaigc = 0;
nodeoffset = fdt_path_offset(dt_addr, "/efusekey");
if (nodeoffset < 0) {
EFUSE_ERR("not find /efusekey node [%s].\n", fdt_strerror(nodeoffset));
return __LINE__;
}
phandle = fdt_getprop(dt_addr, nodeoffset, "keynum", NULL);
efusekeynum = be32_to_cpup((u32 *)phandle);
EFUSE_MSG("keynum is %x\n", efusekeynum);
if (efusekey_infos) free(efusekey_infos) ;
efusekey_infos = (struct efusekey_info *)malloc(sizeof (struct efusekey_info) *efusekeynum);
if (!efusekey_infos) {
EFUSE_ERR("malloc err\n");
return __LINE__;
}
max_size = efuse_get_max();
for (index = 0; index < efusekeynum; index++)
{
struct efusekey_info* theKeyInf = efusekey_infos + index;
sprintf(propname, "key%d", index);
/* printf("%s: propname: %s\n",__func__,propname); */
phandle = fdt_getprop(dt_addr, nodeoffset, propname, NULL);
if (!phandle) {
EFUSE_ERR("don't find match %s\n", propname);
goto err;
}
poffset = fdt_node_offset_by_phandle(dt_addr,
be32_to_cpup((u32 *)phandle));
if (!poffset) {
EFUSE_ERR("can't find device node for key[%s]\n", propname);
goto err;
}
phandle = fdt_getprop(dt_addr, poffset, "keyname", NULL);
if (!phandle) {
EFUSE_ERR("Can't find keyname for key[%d]\n", index);
goto err;
}
strcpy(theKeyInf->keyname, phandle);
phandle = fdt_getprop(dt_addr, poffset, "offset", NULL);
if (!phandle) {
EFUSE_ERR("Can't find offset for key[%s]\n", theKeyInf->keyname);
goto err;
}
theKeyInf->offset = be32_to_cpup((u32 *)phandle);
phandle = fdt_getprop(dt_addr, poffset, "size", NULL);
if (!phandle) {
EFUSE_ERR("Can't find size for key[%s]\n", theKeyInf->keyname);
goto err;
}
theKeyInf->size = be32_to_cpup((u32 *)phandle);
EFUSE_DBG("key[%02d] name=%12s, offset=0x%04x, size=0x%04x\n",
index, theKeyInf->keyname, theKeyInf->offset, theKeyInf->size);
if (theKeyInf->offset + theKeyInf->size > max_size) {
EFUSE_ERR("\n offset (0x%x) + size (0x%x) > max [0x%x]!\n", theKeyInf->offset, theKeyInf->size, max_size);
return __LINE__;
}
}
_efuseKeyInfos.totalCfgKeyNums = efusekeynum;
_efuseKeyInfos.pKeyInf = efusekey_infos;
EFUSE_DBG("%s success!\n", __func__);
_efuseKeyInfos.initMaigc = 0xee;
return 0;
err:
free(efusekey_infos);
EFUSE_ERR("%s error!\n", __func__);
return -1;
}
static int _get_cfg_key_inf_byname(const char* keyname, const struct efusekey_info ** pKeyInf)
{
int index = 0;
struct efusekey_info* theKeyInf = _efuseKeyInfos.pKeyInf;
int ret = 0;
if (0xee != _efuseKeyInfos.initMaigc) {
EFUSE_ERR("Pls init first.\n");
return __LINE__;
}
for (; index < _efuseKeyInfos.totalCfgKeyNums; ++index, ++theKeyInf)
{
const char* theKeyname = theKeyInf->keyname;
ret = strcmp(theKeyname, keyname);
if (ret) continue;
*pKeyInf = theKeyInf;
return 0;
}
EFUSE_ERR("efuse keyname(%s) not configured\n", keyname);
return __LINE__;//Not found the matched name
}
int efuse_usr_api_get_cfg_key_size(const char* keyname, unsigned* pSz)
{
int ret = 0;
const struct efusekey_info* theCfgKeyInf = NULL;
ret = _get_cfg_key_inf_byname(keyname, &theCfgKeyInf);
if (ret) {
EFUSE_ERR("not name cfg in dts.\n");
return __LINE__;
}
*pSz = theCfgKeyInf->size;
return 0;
}
int efuse_usr_api_write_key(const char* keyname, const void* keydata, const unsigned dataSz)
{
int ret = 0;
const struct efusekey_info* theCfgKeyInf = NULL;
ret = _get_cfg_key_inf_byname(keyname, &theCfgKeyInf);
if (ret) {
EFUSE_ERR("not name cfg in dts.\n");
return __LINE__;
}
if (dataSz != theCfgKeyInf->size) {
EFUSE_ERR("dataSz 0x%x != cfg size 0x%x\n", dataSz, theCfgKeyInf->size);
return __LINE__;
}
ret = efuse_write_usr((char*)keydata, theCfgKeyInf->size, (loff_t*)&theCfgKeyInf->offset);
if (ret < 0) {
EFUSE_ERR("error: efuse write fail.\n");
return __LINE__;
}
return 0;
}
//usrefuse read mac $loadaddr (size)
int efuse_usr_api_read_key(const char* keyname, void* databuf, const unsigned bufSz)
{
int ret = 0;
const struct efusekey_info* theCfgKeyInf = NULL;
loff_t offset = 0;
ret = _get_cfg_key_inf_byname(keyname, &theCfgKeyInf);
if (ret) {
EFUSE_ERR("not name cfg in dts.\n");
return __LINE__;
}
const unsigned cfgCnt = theCfgKeyInf->size;
if (cfgCnt > bufSz && bufSz) {
EFUSE_ERR("cfg size 0x%x > bufsz 0x%x\n", cfgCnt, bufSz);
return __LINE__;
}
EFUSE_DBG("keyname=%s, databuf=%p, bufSz=%d, cfgCnt=%u\n", keyname, databuf, bufSz, cfgCnt);
offset = theCfgKeyInf->offset;
memset(databuf, cfgCnt, 0);
ret = efuse_read_usr((char*)databuf, cfgCnt, &offset);
if (ret == -1) {
EFUSE_ERR("ERROR: efuse read user data fail!, size=%u, offset=%llu\n", cfgCnt, offset);
return __LINE__;
}
if (ret != cfgCnt) {
EFUSE_ERR("ERROR: read %d byte(s) not wanted %d byte(s) data\n", ret, cfgCnt);
return __LINE__;
}
return 0;
}
static int hex_ascii_to_buf(const char* input, uint8_t* buf, const unsigned bufSz)
{
int ret = 0;
const char* tmpStr = input;
const unsigned inputLen = strlen(input);
int i = 0;
if (!inputLen) {
EFUSE_ERR("err input len 0\n");
return __LINE__;
}
if ( ((inputLen>>1)<<1) != inputLen ) {
EFUSE_ERR("inputLen %d not even\n", inputLen);
return __LINE__;
}
if (bufSz * 2 > inputLen) {
EFUSE_ERR("bufSz %d not enough\n", bufSz);
return __LINE__;
}
for (tmpStr = input; *tmpStr; ++tmpStr)
{
char c = *tmpStr;
ret = isxdigit(c);
if (!ret) {
EFUSE_ERR("input(%s) contain non xdigit, c=%c\n", input, c);
return __LINE__;
}
}
for (i = 0; i < inputLen; i += 2)
{
char tmpByte[8];
tmpByte[2] = '\0';
tmpByte[0] = input[i];
tmpByte[1] = input[i + 1];
const unsigned val = simple_strtoul(tmpByte, NULL, 16);
if (val > 0xff) {
EFUSE_ERR("Exception: val 0x%x > 0xff\n", val);
return __LINE__;
}
buf[i>>1] = val;
}
return 0;
}
static int do_usr_efuse_api(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int ret = 0;
const char* subcmd = argv[1];
if (argc < 2) return CMD_RET_USAGE;
if (!strcmp("init", subcmd))
{
const char* dtbLoadAddr = NULL;
if (argc > 2)
{
dtbLoadAddr = (char*)simple_strtoul(argv[2], NULL, 0);
}
else
{
dtbLoadAddr = getenv("dtb_mem_addr");
if (!dtbLoadAddr) {
setenv("dtb_mem_addr", simple_itoa(CONFIG_SYS_SDRAM_BASE + (16U<<20)));
}
dtbLoadAddr = (char*)simple_strtoul(dtbLoadAddr, NULL, 0);
}
ret = efuse_usr_api_init_dtb(dtbLoadAddr);
}
else if(!strcmp("size", subcmd))
{
const char* keyname = argv[2];
unsigned keysize = argc > 3 ? simple_strtoul(argv[3], NULL, 0) : 0;
ret = efuse_usr_api_get_cfg_key_size(keyname, &keysize);
EFUSE_MSG("keysize=%d\n", keysize);
}
else if(!strcmp("read", subcmd))
{
if (argc < 4) return CMD_RET_USAGE;
const char* keyname = argv[2];
char* databuf = (char*)simple_strtoul(argv[3], NULL, 16);
unsigned bufSz = argc > 4 ? simple_strtoul(argv[4], NULL, 0) : 0;
if (!bufSz)
{
ret = efuse_usr_api_get_cfg_key_size(keyname, &bufSz);
if (ret) {
EFUSE_ERR("Fail in get sz for key[%s]\n", keyname);
return __LINE__;
}
}
ret = efuse_usr_api_read_key(keyname, databuf, bufSz);
if (!ret)
{
int i = 0;
printf("efuse read data");
for (i = 0; i < bufSz; i++) {
if (i%8 == 0) printf("\n[0x%02x]:", i);
printf("%02x ", databuf[i]);
}
printf("\n");
}
}
else if(!strcmp("write", subcmd))
{
if (argc < 4) return CMD_RET_USAGE;
const char* keyname = argv[2];
char* keydata = (char*)simple_strtoul(argv[3], NULL, 16);
unsigned bufSz = argc > 4 ? simple_strtoul(argv[4], NULL, 0) : 0;
uint8_t* tmpBuf = NULL;
if (!bufSz)
{
const char* input = argv[3];
bufSz = ( strlen(input) >> 1 );
tmpBuf = malloc(bufSz);
ret = hex_ascii_to_buf(input, tmpBuf, bufSz);
if (ret) {
EFUSE_ERR("Failed in change hex ascii to buf\n");
return __LINE__;
}
keydata = (char*)tmpBuf;
}
ret = efuse_usr_api_write_key(keyname, keydata, bufSz);
if (tmpBuf) free(tmpBuf) ;
}
return ret ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
U_BOOT_CMD(
efuse_user,
5, //max argc
1, //repeatable
do_usr_efuse_api,
"efuse user space read write ops",
"init <dtbAddr> --- init efuse user space\n"
"size keyname <addr> --- get key size configured in dts\n"
"read keyname addr <size> --- read key value to mem addr \n"
"write --- write key value\n"
" efuse_user write keyname hexstring --- write key value in hex string\n"
" efuse_user write keyname addr size --- write key value, U need load you key value into mem addr first\n"
);