1121 lines
22 KiB
C
Executable File
1121 lines
22 KiB
C
Executable File
/*
|
|
* Copyright 2008 Freescale Semiconductor, Inc.
|
|
*
|
|
* 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 <config.h>
|
|
#include <command.h>
|
|
#include <malloc.h>
|
|
#include <pmu.h>
|
|
#include <sys_config.h>
|
|
#include <asm/arch/intc.h>
|
|
#include <asm/arch/timer.h>
|
|
#include <smc.h>
|
|
#include <securestorage.h>
|
|
|
|
#ifdef CONFIG_SUNXI_SECURE_SYSTEM
|
|
#include <sunxi_efuse.h>
|
|
#endif
|
|
|
|
struct timer_list timer0_t;
|
|
struct timer_list timer1_t;
|
|
static int timer_test_flag[2];
|
|
#ifdef CONFIG_AUTO_UPDATE
|
|
static u32 sunxi_sprite_next_action = 1;
|
|
#endif
|
|
extern int sprite_led_init(void);
|
|
extern int sprite_led_exit(int status);
|
|
extern int sunxi_card_update_main(void);
|
|
extern int sunxi_udisk_update_main(void);
|
|
|
|
|
|
static void timer0_test_func(void *p)
|
|
{
|
|
struct timer_list *timer_t;
|
|
|
|
timer_t = (struct timer_list *)p;
|
|
debug("timer number = %d\n", timer_t->timer_num);
|
|
printf("this is timer test\n");
|
|
|
|
del_timer(timer_t);
|
|
timer_test_flag[0] = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
int do_timer_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int base_count = 1000;
|
|
|
|
if(timer_test_flag[0])
|
|
{
|
|
printf("can not test timer 0 now\n");
|
|
|
|
return -1;
|
|
}
|
|
|
|
if(argc == 2)
|
|
{
|
|
base_count = simple_strtol(argv[1], NULL, 10);
|
|
}
|
|
timer0_t.data = (unsigned long)&timer0_t;
|
|
timer0_t.expires = base_count;
|
|
timer0_t.function = timer0_test_func;
|
|
|
|
init_timer(&timer0_t);
|
|
add_timer(&timer0_t);
|
|
timer_test_flag[0] = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
U_BOOT_CMD(
|
|
timer_test, 2, 0, do_timer_test,
|
|
"do a timer and int test",
|
|
"[delay time]"
|
|
);
|
|
|
|
static void timer1_test_func(void *p)
|
|
{
|
|
struct timer_list *timer_t;
|
|
|
|
timer_t = (struct timer_list *)p;
|
|
debug("timer number = %d\n", timer_t->timer_num);
|
|
printf("this is timer test\n");
|
|
|
|
del_timer(timer_t);
|
|
timer_test_flag[1] = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
int do_timer_test1(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int base_count = 1000;
|
|
|
|
if(timer_test_flag[1])
|
|
{
|
|
printf("can not test timer 1 now\n");
|
|
|
|
return -1;
|
|
}
|
|
|
|
if(argc == 2)
|
|
{
|
|
base_count = simple_strtol(argv[1], NULL, 10);
|
|
}
|
|
timer1_t.data = (unsigned long)&timer1_t;
|
|
timer1_t.expires = base_count;
|
|
timer1_t.function = timer1_test_func;
|
|
|
|
init_timer(&timer1_t);
|
|
add_timer(&timer1_t);
|
|
|
|
timer_test_flag[1] = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
U_BOOT_CMD(
|
|
timer_test1, 2, 0, do_timer_test1,
|
|
"do a timer and int test",
|
|
"[delay time]"
|
|
);
|
|
|
|
#ifndef CONFIG_SUNXI_SPINOR_PLATFORM
|
|
int sunxi_usb_dev_register(uint dev_name);
|
|
void sunxi_usb_main_loop(int mode);
|
|
int sunxi_card_sprite_main(int workmode, char *name);
|
|
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
|
|
int do_sprite_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int ret;
|
|
printf("work mode=0x%x\n", uboot_spare_head.boot_data.work_mode);
|
|
if(uboot_spare_head.boot_data.work_mode == WORK_MODE_USB_PRODUCT)
|
|
{
|
|
printf("run usb efex\n");
|
|
if(sunxi_usb_dev_register(2))
|
|
{
|
|
printf("sunxi usb test: invalid usb device\n");
|
|
}
|
|
sunxi_usb_main_loop(2500);
|
|
}
|
|
else if(uboot_spare_head.boot_data.work_mode == WORK_MODE_CARD_PRODUCT)
|
|
{
|
|
printf("run card sprite\n");
|
|
sprite_led_init();
|
|
ret = sunxi_card_sprite_main(0, NULL);
|
|
sprite_led_exit(ret);
|
|
return ret;
|
|
}
|
|
#ifdef CONFIG_AUTO_UPDATE
|
|
else if(uboot_spare_head.boot_data.work_mode == WORK_MODE_USB_UPDATE)
|
|
{
|
|
printf("run udisk update\n");
|
|
ret = sunxi_udisk_update_main();
|
|
#ifdef CONFIG_UDISK_AUTO_CHECK
|
|
sunxi_flashing_led();
|
|
sunxi_set_rtc3_flag(SUNXI_UDDISK_SPRITE_OVER_FLAG);
|
|
#endif
|
|
if (!ret)
|
|
{
|
|
script_parser_fetch("update", "next_action", (int *)&sunxi_sprite_next_action, 1);
|
|
if(sunxi_sprite_next_action == SUNXI_UPDATE_NEXT_ACTION_REBOOT)
|
|
{
|
|
/*default is reboot*/
|
|
printf("update finish,going to reboot the system...\n");
|
|
reset_cpu(0);
|
|
}else if(sunxi_sprite_next_action == SUNXI_UPDATE_NEXT_ACTION_SHUTDOWN){
|
|
printf("update finish,going to shutdown the system...\n");
|
|
sunxi_board_shutdown();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
else if(uboot_spare_head.boot_data.work_mode == WORK_MODE_CARD_UPDATE)
|
|
{
|
|
printf("run card update\n");
|
|
sprite_led_init();
|
|
ret = sunxi_card_update_main();
|
|
sunxi_flashing_led();
|
|
if (!ret)
|
|
{
|
|
script_parser_fetch("update", "next_action", (int *)&sunxi_sprite_next_action, 1);
|
|
if(sunxi_sprite_next_action == SUNXI_UPDATE_NEXT_ACTION_REBOOT)
|
|
{
|
|
/*default is reboot*/
|
|
printf("update finish,going to reboot the system...\n");
|
|
reset_cpu(0);
|
|
}else if(sunxi_sprite_next_action == SUNXI_UPDATE_NEXT_ACTION_SHUTDOWN){
|
|
printf("update finish,going to shutdown the system...\n");
|
|
sunxi_board_shutdown();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
#endif
|
|
else if(uboot_spare_head.boot_data.work_mode == WORK_MODE_USB_DEBUG)
|
|
{
|
|
unsigned int val;
|
|
|
|
printf("run usb debug\n");
|
|
if(sunxi_usb_dev_register(2))
|
|
{
|
|
printf("sunxi usb test: invalid usb device\n");
|
|
}
|
|
|
|
asm("mrc p15, 0, %0, c1, c0, 0 @ get CR" : "=r" (val) : : "cc");
|
|
val &= ~(1<<2);
|
|
asm volatile("mcr p15, 0, %0, c1, c0, 0 @ set CR" : : "r" (val) : "cc");
|
|
|
|
sunxi_usb_main_loop(0);
|
|
}
|
|
else if(uboot_spare_head.boot_data.work_mode == WORK_MODE_SPRITE_RECOVERY)
|
|
{
|
|
printf("run sprite recovery\n");
|
|
sprite_led_init();
|
|
ret = sprite_form_sysrecovery();
|
|
sprite_led_exit(ret);
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
printf("others\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
sprite_test, 2, 0, do_sprite_test,
|
|
"do a sprite test",
|
|
"NULL"
|
|
);
|
|
|
|
|
|
|
|
int do_fastboot_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
printf("run usb fastboot\n");
|
|
if(sunxi_usb_dev_register(3))
|
|
{
|
|
printf("sunxi usb test: invalid usb device\n");
|
|
}
|
|
sunxi_usb_main_loop(0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
U_BOOT_CMD(
|
|
fastboot_test, 2, 0, do_fastboot_test,
|
|
"do a sprite test",
|
|
"NULL"
|
|
);
|
|
|
|
int do_mass_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
printf("run usb mass\n");
|
|
if(sunxi_usb_dev_register(1))
|
|
{
|
|
printf("sunxi usb test: invalid usb device\n");
|
|
}
|
|
sunxi_usb_main_loop(0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
U_BOOT_CMD(
|
|
mass_test, 2, 0, do_mass_test,
|
|
"do a usb mass test",
|
|
"NULL"
|
|
);
|
|
|
|
int do_efex_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
printf("run usb efex_test\n");
|
|
if(sunxi_usb_dev_register(5))
|
|
{
|
|
printf("sunxi usb test: invalid usb device\n");
|
|
}
|
|
sunxi_usb_main_loop(2500);
|
|
|
|
return 0;
|
|
}
|
|
U_BOOT_CMD(
|
|
efex_test, 2, 0, do_efex_test,
|
|
"do a usb efex test",
|
|
"NULL"
|
|
);
|
|
#endif
|
|
|
|
int do_memcpy_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
uint size = 64 * 1024 * 1024;
|
|
|
|
tick_printf("memcpy test start\n");
|
|
memcpy((void *)MEMCPY_TEST_DST, (void *)MEMCPY_TEST_SRC, size);
|
|
tick_printf("memcpy test end\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
U_BOOT_CMD(
|
|
memcpy_test, 2, 0, do_memcpy_test,
|
|
"do a memcpy test",
|
|
"NULL"
|
|
);
|
|
|
|
int do_delay_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
tick_printf("delay 1000ms\n");
|
|
__msdelay(1000);
|
|
tick_printf("delay test end\n");
|
|
|
|
tick_printf("delay 1000ms\n");
|
|
__usdelay(1000 * 1000);
|
|
tick_printf("delay test end\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
U_BOOT_CMD(
|
|
delay_test, 2, 0, do_delay_test,
|
|
"do a delay test",
|
|
"NULL"
|
|
);
|
|
|
|
int do_sysconfig(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
char *main_key, *sub_key;
|
|
int buffer[64];
|
|
int ret;
|
|
|
|
memset(buffer, 0, 256);
|
|
if(argc == 2)
|
|
{
|
|
char sub_name[32];
|
|
uint main_hd;
|
|
int index;
|
|
|
|
main_key = argv[1];
|
|
|
|
main_hd = script_parser_fetch_subkey_start(main_key);
|
|
if(!main_hd)
|
|
{
|
|
printf("the [%s] cant be found\n", main_key);
|
|
|
|
return -1;
|
|
}
|
|
printf("[%s]:\n", main_key);
|
|
index = 0;
|
|
do
|
|
{
|
|
memset(sub_name, 0, 32);
|
|
ret = script_parser_fetch_subkey_next(main_hd, sub_name, buffer, &index);
|
|
if(ret < 0)
|
|
{
|
|
printf("find [%s] to end\n", main_key);
|
|
|
|
break;
|
|
}
|
|
printf("--------- %s = 0x%x\n", sub_name, buffer[0]);
|
|
}
|
|
while(1);
|
|
|
|
return 0;
|
|
}
|
|
else if(argc == 3)
|
|
{
|
|
main_key = argv[1];
|
|
sub_key = argv[2];
|
|
|
|
ret = script_parser_fetch(main_key, sub_key, buffer, 64);
|
|
if(ret < 0)
|
|
{
|
|
printf("the [%s]:%s cant be found\n", main_key, sub_key);
|
|
|
|
return -1;
|
|
}
|
|
printf("[%s]:%s = %x\n", main_key, sub_key, buffer[0]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
printf("the sys_config args is invalid\n");
|
|
|
|
return -1;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
sys_config, 3, 0, do_sysconfig,
|
|
"show the sys config value",
|
|
"sys_config [main_key]\n"
|
|
"sys_config [main_key] [sub_key]"
|
|
);
|
|
|
|
|
|
int do_power_probe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
char *power_name, *pmu_type;
|
|
int power_value;
|
|
|
|
if(argc == 3)
|
|
{
|
|
pmu_type = argv[1];
|
|
power_name = argv[2];
|
|
|
|
power_value = axp_probe_supply_status_byname(pmu_type, power_name);
|
|
if(power_value > 0)
|
|
{
|
|
printf(" %s %s output voltage = %d\n", pmu_type, power_name, power_value);
|
|
}
|
|
else
|
|
{
|
|
printf(" probe %s %s output voltage failed\n", pmu_type, power_name);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
cmd_usage(cmdtp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
power_probe, 3, 0, do_power_probe,
|
|
"probe the axp output",
|
|
"usage: power_probe pmu_type axp_name"
|
|
);
|
|
|
|
|
|
#ifdef CONFIG_BOOT_A15
|
|
|
|
#include <asm/arch/cpu_switch.h>
|
|
|
|
extern void sunxi_set_rtc_flag(u8 flag);
|
|
|
|
int do_reboot_boot_cpu(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
if(argc == 1)
|
|
{
|
|
sunxi_board_restart(0);
|
|
}
|
|
else if(argc == 2)
|
|
{
|
|
char *boot_cpu = argv[1];
|
|
|
|
if(!strcmp(boot_cpu, "a7"))
|
|
{
|
|
sunxi_set_rtc_flag(BOOT_A7_FLAG);
|
|
sunxi_board_restart(0);
|
|
}
|
|
else if(!strcmp(boot_cpu, "a15"))
|
|
{
|
|
sunxi_set_rtc_flag(BOOT_A15_FLAG);
|
|
sunxi_board_restart(0);
|
|
}
|
|
}
|
|
|
|
cmd_usage(cmdtp);
|
|
|
|
return -1;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
reboot, 3, 0, do_reboot_boot_cpu,
|
|
"reboot by a7 or a15",
|
|
"usage: reboot [a7] or [a15]"
|
|
);
|
|
#endif
|
|
|
|
#ifdef CONFIG_SUNXI_SECURE_SYSTEM
|
|
int do_efuse_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
char *efuse_name;
|
|
char buffer[32];
|
|
int ret;
|
|
|
|
if(argc != 2)
|
|
{
|
|
printf("the efuse item name is empty\n");
|
|
|
|
return -1;
|
|
}
|
|
efuse_name = argv[1];
|
|
printf("try to read %s\n", efuse_name);
|
|
memset(buffer, 0, 32);
|
|
|
|
ret = sunxi_efuse_read(efuse_name, buffer);
|
|
if(ret)
|
|
{
|
|
printf("read efuse key [%s] failed\n", efuse_name);
|
|
}
|
|
else
|
|
{
|
|
printf("read efuse key [%s] successed\n", efuse_name);
|
|
sunxi_dump(buffer, 32);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
efuse_read, 3, 0, do_efuse_read,
|
|
"read efuse key",
|
|
"usage: efuse_read efusename"
|
|
);
|
|
|
|
int do_huk_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
char buffer[32];
|
|
int ret;
|
|
|
|
printf("try to create huk\n");
|
|
memset(buffer, 0, 32);
|
|
ret = smc_create_huk(buffer, 32);
|
|
if(ret < 0)
|
|
{
|
|
printf("create huk failed\n");
|
|
}
|
|
else if(ret == 1)
|
|
{
|
|
printf("create huk has been burned\n");
|
|
|
|
sunxi_dump(buffer, 32);
|
|
}
|
|
else
|
|
{
|
|
printf("create huk successed\n");
|
|
|
|
sunxi_dump(buffer, 32);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
huk_test, 3, 0, do_huk_test,
|
|
"create a huk as a test",
|
|
"usage: huk_test"
|
|
);
|
|
|
|
int do_hdcp_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int ret, data_len;
|
|
char buffer[4096];
|
|
|
|
printf("try to test hdcp\n");
|
|
memset(buffer, 0, 4096);
|
|
ret = sunxi_secure_storage_init();
|
|
if(ret)
|
|
{
|
|
printf("sunxi init secure storage failed\n");
|
|
}
|
|
else
|
|
{
|
|
ret = sunxi_secure_storage_read("hdcpkey", buffer, 4096, &data_len);
|
|
if(ret)
|
|
{
|
|
printf("probe hdcp key failed\n");
|
|
}
|
|
else
|
|
{
|
|
printf("source data in secure storage\n");
|
|
sunxi_dump(buffer, (data_len+3)&(~0x3));
|
|
ret = smc_aes_bssk_decrypt_to_keysram(buffer, data_len);
|
|
if(ret)
|
|
{
|
|
printf("push hdcp key failed\n");
|
|
}
|
|
else
|
|
{
|
|
printf("push hdcp key ok\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
hdcp_test, 3, 0, do_hdcp_test,
|
|
"test the hdcp key",
|
|
"usage: hdcp_test"
|
|
);
|
|
|
|
#endif
|
|
|
|
|
|
#ifdef CONFIG_AES_TEST
|
|
|
|
#define AES_RSSK_TEST_SOURCE_DATA_LEN (512)
|
|
int do_hdcp_rssk_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
u8 source[AES_RSSK_TEST_SOURCE_DATA_LEN];
|
|
u8 dest[AES_RSSK_TEST_SOURCE_DATA_LEN];
|
|
u8 cmp[AES_RSSK_TEST_SOURCE_DATA_LEN];
|
|
u8 md5_buf_keysram[16], md5_buf_dram[16];
|
|
u32 data_len = 288, i;
|
|
int ret;
|
|
|
|
for(i=0;i<AES_RSSK_TEST_SOURCE_DATA_LEN;i++)
|
|
{
|
|
source[i] = (i&0xff) + 0x80;
|
|
}
|
|
memset(dest, 0, AES_RSSK_TEST_SOURCE_DATA_LEN);
|
|
memset(cmp, 0, AES_RSSK_TEST_SOURCE_DATA_LEN);
|
|
|
|
printf("aes rssk test: source data:\n");
|
|
sunxi_dump(source, data_len);
|
|
ret = sunxi_aes_decrypt_rssk_hdcp_to_keysram(source, data_len);
|
|
if(ret)
|
|
{
|
|
printf("%s:fail to calculate hdcp key to keysram\n",__func__);
|
|
|
|
return -1;
|
|
}
|
|
ret = sunxi_md5_keysram_calcute((void *)md5_buf_keysram, 16);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate md5 in keysram\n",__func__);
|
|
|
|
return -1;
|
|
}
|
|
printf("aes rssk test: keysram buf md5:\n");
|
|
sunxi_dump(md5_buf_keysram, 16);
|
|
ret = sunxi_aes_decrypt_rssk_hdcp_to_dram(source, data_len, dest);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate hdcp key for source data\n",__func__ );
|
|
|
|
return -1;
|
|
}
|
|
printf("aes rssk test: decrypt data:\n");
|
|
sunxi_dump(dest, data_len);
|
|
|
|
ret = sunxi_md5_dram_calcute((void *)dest, data_len, (void *)md5_buf_dram, 16);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate md5 for source data\n",__func__ );
|
|
|
|
return -1;
|
|
}
|
|
printf("aes rssk test: dram buf md5:\n");
|
|
sunxi_dump(md5_buf_dram, 16);
|
|
|
|
ret = sunxi_aes_encrypt_rssk_hdcp_to_dram(cmp, dest, data_len);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to encrypt hdcp rssk for source data\n",__func__ );
|
|
|
|
return -1;
|
|
}
|
|
printf("aes rssk test: encrypt data:\n");
|
|
sunxi_dump(cmp, data_len);
|
|
|
|
for(i=0;i<16;i++)
|
|
{
|
|
if(md5_buf_keysram[i] != md5_buf_dram[i])
|
|
{
|
|
printf("%s: compare the md5 between keysram and source data failed\n", __func__);
|
|
|
|
printf("md5_buf_keysram:\n");
|
|
sunxi_dump(md5_buf_keysram, 16);
|
|
|
|
printf("md5_buf_source:\n");
|
|
sunxi_dump(md5_buf_dram, 16);
|
|
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
printf("%s: compare the md5 between keysram and source data successed\n", __func__);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
U_BOOT_CMD(
|
|
hdcp_rssk_test, CONFIG_SYS_MAXARGS,1, do_hdcp_rssk_test,
|
|
"test the aes rssk to keysram method",
|
|
"usage: hdcp_rssk_test\n"
|
|
"now there is no any parameters\n"
|
|
);
|
|
|
|
|
|
#define AES_TEST_SOURCE_DATA_LEN (512)
|
|
#define AES_TEST_BLOCK_DATA_LEN (512)
|
|
int do_aes_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
u8 source[AES_TEST_SOURCE_DATA_LEN];
|
|
u8 dest[AES_TEST_SOURCE_DATA_LEN];
|
|
u8 cmp[AES_TEST_SOURCE_DATA_LEN];
|
|
u8 key_buf[256], iv_buf[128];
|
|
u32 key_type=2, aes_mode=0;
|
|
int ret, i;
|
|
|
|
if(argc == 1)
|
|
{
|
|
;
|
|
}
|
|
else if(argc == 2)
|
|
{
|
|
key_type = simple_strtol(argv[1], NULL, 10);
|
|
}
|
|
else if(argc == 3)
|
|
{
|
|
key_type = simple_strtol(argv[1], NULL, 10);
|
|
aes_mode = simple_strtol(argv[2], NULL, 10);
|
|
}
|
|
else
|
|
{
|
|
printf("Too much parameters\n");
|
|
|
|
goto return_err;
|
|
}
|
|
|
|
if(key_type == 0)
|
|
{
|
|
printf("AES KEY: 128bit\n");
|
|
}
|
|
else if(key_type == 1)
|
|
{
|
|
printf("AES KEY: 192bit\n");
|
|
}
|
|
else if(key_type == 2)
|
|
{
|
|
printf("AES KEY: 256bit\n");
|
|
}
|
|
else
|
|
{
|
|
printf("the AES KEY TYPE is invalid\n");
|
|
|
|
goto return_err;
|
|
}
|
|
|
|
if(aes_mode == 0)
|
|
{
|
|
printf("AES MODE: ECB\n");
|
|
}
|
|
else if(aes_mode == 1)
|
|
{
|
|
printf("AES MODE: CBC\n");
|
|
}
|
|
else
|
|
{
|
|
printf("the AES MODE is invalid\n");
|
|
|
|
goto return_err;
|
|
}
|
|
|
|
for(i=0;i<AES_TEST_SOURCE_DATA_LEN;i++)
|
|
{
|
|
source[i] = (i&0xff) + 0x80;
|
|
}
|
|
for(i=0;i<256;i++)
|
|
{
|
|
key_buf[i] = (i&0xff) + 0x5A;
|
|
}
|
|
|
|
printf("aes test: source data:\n");
|
|
sunxi_dump(source, AES_TEST_SOURCE_DATA_LEN);
|
|
|
|
printf("try to encrypt\n");
|
|
memset(dest , 0, AES_TEST_SOURCE_DATA_LEN);
|
|
|
|
if(aes_mode == SS_AES_MODE_ECB)
|
|
{
|
|
ret = TNHALCryptoAESEcb(source, AES_TEST_SOURCE_DATA_LEN, dest, key_buf, key_type, SS_DIR_ENCRYPT);
|
|
}
|
|
else
|
|
{
|
|
memset(iv_buf, 0x5A, 128);
|
|
ret = TNHALCryptoAESCbc(source, AES_TEST_SOURCE_DATA_LEN, dest, key_buf, key_type, iv_buf, SS_DIR_ENCRYPT);
|
|
}
|
|
if(ret)
|
|
{
|
|
printf("%s:fail to encrypt\n",__func__);
|
|
|
|
goto return_err;
|
|
}
|
|
printf("the encrypt value:\n");
|
|
sunxi_dump(dest, AES_TEST_SOURCE_DATA_LEN);
|
|
|
|
printf("try to decrypt\n");
|
|
memset(cmp , 0, AES_TEST_SOURCE_DATA_LEN);
|
|
|
|
if(aes_mode == SS_AES_MODE_ECB)
|
|
{
|
|
ret = TNHALCryptoAESEcb(dest, AES_TEST_SOURCE_DATA_LEN, cmp, key_buf, key_type, SS_DIR_DECRYPT);
|
|
}
|
|
else
|
|
{
|
|
memset(iv_buf, 0x5A, 128);
|
|
ret = TNHALCryptoAESCbc(dest, AES_TEST_SOURCE_DATA_LEN, cmp, key_buf, key_type, iv_buf, SS_DIR_DECRYPT);
|
|
}
|
|
|
|
if(ret)
|
|
{
|
|
printf("%s:fail to decrypt\n",__func__);
|
|
|
|
goto return_err;
|
|
}
|
|
printf("the decrypt value:\n");
|
|
sunxi_dump(cmp, AES_TEST_SOURCE_DATA_LEN);
|
|
|
|
for(i=0;i<AES_TEST_SOURCE_DATA_LEN;i++)
|
|
{
|
|
if(source[i] != cmp[i])
|
|
{
|
|
printf("the aes fail: source[%d]:%02x is not equal to cmp[%d]:%02x\n", i, source[i], i, cmp[i]);
|
|
|
|
goto return_err;
|
|
}
|
|
}
|
|
|
|
printf("aes successed\n");
|
|
|
|
return 0;
|
|
|
|
return_err:
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
aes_test, CONFIG_SYS_MAXARGS,1, do_aes_test,
|
|
"test the aes encrypt and decrypt",
|
|
"usage: aes_test [key_type] [aes_mode]\n"
|
|
"key type: 0 , 128BIT\n"
|
|
" 1 , 192BIT\n"
|
|
" 2 default, 256BIT\n"
|
|
"aes mode: 0 default, ECB\n"
|
|
" : 1 , CBC\n"
|
|
);
|
|
|
|
#define SHAX_TEST_BLOCK_DATA_LEN (512)
|
|
static u8 *__shax_prepare(int argc, char * const argv[], u32 *len)
|
|
{
|
|
u8 *data_buf;
|
|
u32 data_len;
|
|
|
|
if(argc == 1)
|
|
{
|
|
data_len = 2048;
|
|
}
|
|
else if(argc == 2)
|
|
{
|
|
data_len = simple_strtol(argv[1], NULL, 10);
|
|
}
|
|
else
|
|
{
|
|
printf("Too much parameters\n");
|
|
|
|
return NULL;
|
|
}
|
|
data_buf = (u8 *)malloc(data_len + 1);
|
|
if(data_buf == NULL)
|
|
{
|
|
printf("the input data length is invalid\n");
|
|
|
|
return NULL;
|
|
}
|
|
memset(data_buf, 'A', data_len);
|
|
|
|
printf("the data bytes: %d\n", data_len);
|
|
data_buf[data_len] = '\0';
|
|
//printf("the source data:\n");
|
|
//sunxi_dump(data_buf, data_len);
|
|
*len = data_len;
|
|
|
|
return data_buf;
|
|
|
|
}
|
|
int do_md5_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
u8 *source, *tmp_src;
|
|
u8 md5_buf[64];
|
|
u32 data_len, tmp_data_len;
|
|
int ret;
|
|
|
|
source = __shax_prepare(argc, argv, &data_len);
|
|
if(source == NULL)
|
|
{
|
|
printf("The source addr is invalid\n");
|
|
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
tmp_src = source;
|
|
tmp_data_len = data_len;
|
|
while(tmp_data_len > SHAX_TEST_BLOCK_DATA_LEN)
|
|
{
|
|
ret = TNHALCryptoMD5(tmp_src, SHAX_TEST_BLOCK_DATA_LEN, 0, md5_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate md5 for source data\n",__func__ );
|
|
|
|
goto __md5_test_err;
|
|
}
|
|
tmp_src += SHAX_TEST_BLOCK_DATA_LEN;
|
|
tmp_data_len -= SHAX_TEST_BLOCK_DATA_LEN;
|
|
}
|
|
ret = TNHALCryptoMD5(tmp_src, tmp_data_len, 1, md5_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate md5 for source data\n",__func__ );
|
|
|
|
goto __md5_test_err;
|
|
}
|
|
|
|
printf("md5 test: dram buf md5:\n");
|
|
sunxi_dump(md5_buf, 16);
|
|
|
|
free(source);
|
|
|
|
return 0;
|
|
__md5_test_err:
|
|
free(source);
|
|
|
|
return cmd_usage(cmdtp);
|
|
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
md5, CONFIG_SYS_MAXARGS,1, do_md5_test,
|
|
"test the md5",
|
|
"usage: md [data_len]\n"
|
|
"if null, default value is 512 "
|
|
);
|
|
|
|
int do_sha1_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
u8 *source, *tmp_src;
|
|
u8 sha1_buf[64];
|
|
u32 data_len, tmp_data_len;
|
|
int ret;
|
|
|
|
source = __shax_prepare(argc, argv, &data_len);
|
|
if(source == NULL)
|
|
{
|
|
printf("The source addr is invalid\n");
|
|
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
tmp_src = source;
|
|
tmp_data_len = data_len;
|
|
while(tmp_data_len > SHAX_TEST_BLOCK_DATA_LEN)
|
|
{
|
|
ret = TNHALCryptoSHA1(tmp_src, SHAX_TEST_BLOCK_DATA_LEN, 0, sha1_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate sha1 for source data\n",__func__ );
|
|
|
|
goto __sha1_test_err;
|
|
}
|
|
tmp_src += SHAX_TEST_BLOCK_DATA_LEN;
|
|
tmp_data_len -= SHAX_TEST_BLOCK_DATA_LEN;
|
|
}
|
|
ret = TNHALCryptoSHA1(tmp_src, tmp_data_len, 1, sha1_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate sha1 for source data\n",__func__ );
|
|
|
|
goto __sha1_test_err;
|
|
}
|
|
|
|
printf("sha1 test: dram buf sha1:\n");
|
|
sunxi_dump(sha1_buf, 20);
|
|
free(source);
|
|
|
|
return 0;
|
|
__sha1_test_err:
|
|
free(source);
|
|
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
sha1, CONFIG_SYS_MAXARGS,1, do_sha1_test,
|
|
"test the sha1",
|
|
"usage: sha1 [data_len]\n"
|
|
"if null, default value is 512 "
|
|
);
|
|
|
|
int do_sha256_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
u8 *source, *tmp_src;
|
|
u8 sha256_buf[64];
|
|
u32 data_len, tmp_data_len;
|
|
int ret;
|
|
|
|
source = __shax_prepare(argc, argv, &data_len);
|
|
if(source == NULL)
|
|
{
|
|
printf("The source addr is invalid\n");
|
|
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
tmp_src = source;
|
|
tmp_data_len = data_len;
|
|
while(tmp_data_len > SHAX_TEST_BLOCK_DATA_LEN)
|
|
{
|
|
ret = TNHALCryptoSHA256(tmp_src, SHAX_TEST_BLOCK_DATA_LEN, 0, sha256_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate sha256 for source data\n",__func__ );
|
|
|
|
goto __sha256_test_err;
|
|
}
|
|
tmp_src += SHAX_TEST_BLOCK_DATA_LEN;
|
|
tmp_data_len -= SHAX_TEST_BLOCK_DATA_LEN;
|
|
}
|
|
ret = TNHALCryptoSHA256(tmp_src, tmp_data_len, 1, sha256_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate sha256 for source data\n",__func__ );
|
|
|
|
goto __sha256_test_err;
|
|
}
|
|
printf("sha256 test: dram buf sha256:\n");
|
|
sunxi_dump(sha256_buf, 32);
|
|
free(source);
|
|
|
|
return 0;
|
|
__sha256_test_err:
|
|
free(source);
|
|
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
sha256, CONFIG_SYS_MAXARGS,1, do_sha256_test,
|
|
"test the sha256",
|
|
"usage: sha256 [data_len]\n"
|
|
"if null, default value is 512 "
|
|
);
|
|
|
|
int do_sha512_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
u8 *source, *tmp_src;
|
|
u8 sha512_buf[64];
|
|
u32 data_len, tmp_data_len;
|
|
int ret;
|
|
|
|
source = __shax_prepare(argc, argv, &data_len);
|
|
if(source == NULL)
|
|
{
|
|
printf("The source addr is invalid\n");
|
|
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
tmp_src = source;
|
|
tmp_data_len = data_len;
|
|
while(tmp_data_len > SHAX_TEST_BLOCK_DATA_LEN)
|
|
{
|
|
ret = TNHALCryptoSHA512(tmp_src, SHAX_TEST_BLOCK_DATA_LEN, 0, sha512_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate sha512 for source data\n",__func__ );
|
|
|
|
goto __sha512_test_err;
|
|
}
|
|
tmp_src += SHAX_TEST_BLOCK_DATA_LEN;
|
|
tmp_data_len -= SHAX_TEST_BLOCK_DATA_LEN;
|
|
}
|
|
ret = TNHALCryptoSHA512(tmp_src, tmp_data_len, 1, sha512_buf);
|
|
if(ret)
|
|
{
|
|
printf("%s: fail to calculate sha512 for source data\n",__func__ );
|
|
|
|
goto __sha512_test_err;
|
|
}
|
|
|
|
printf("sha512 test: dram buf sha512:\n");
|
|
sunxi_dump(sha512_buf, 64);
|
|
free(source);
|
|
|
|
return 0;
|
|
__sha512_test_err:
|
|
free(source);
|
|
|
|
return cmd_usage(cmdtp);
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
sha512, CONFIG_SYS_MAXARGS,1, do_sha512_test,
|
|
"test the sha512",
|
|
"usage: sha512 [data_len]\n"
|
|
"if null, default value is 512 "
|
|
);
|
|
#endif
|
|
|