| #include "../v2_burning_i.h" |
| #include "usb_pcd.h" |
| #include "../../platform.h" |
| //#include <partition_table.h> |
| #include <asm/arch/cpu_id.h> |
| |
| #define MYDBG(fmt ...) printf("OPT]"fmt) |
| |
| #ifdef CONFIG_CMD_AML |
| #define USB_BURN_POWER_CONTROL 1 |
| #endif// #ifdef CONFIG_CMD_AML |
| |
| static inline int str2longlong(char *p, unsigned long long *num) |
| { |
| char *endptr; |
| |
| *num = simple_strtoull(p, &endptr, 16); |
| if (*endptr != '\0') |
| { |
| switch (*endptr) |
| { |
| case 'g': |
| case 'G': |
| *num<<=10; |
| case 'm': |
| case 'M': |
| *num<<=10; |
| case 'k': |
| case 'K': |
| *num<<=10; |
| endptr++; |
| break; |
| } |
| } |
| |
| return (*p != '\0' && *endptr == '\0') ? 1 : 0; |
| } |
| |
| int optimus_mem_md (int argc, char * const argv[], char *info) |
| { |
| ulong addr, length = 0x100; |
| int size; |
| int rc = 0; |
| |
| if ((size = cmd_get_data_size(argv[0], 4)) < 0) |
| return 1; |
| |
| /* Address is specified since argc > 1 |
| */ |
| addr = simple_strtoul(argv[1], NULL, 16); |
| |
| /* If another parameter, it is the length to display. |
| * Length is the number of objects, not number of bytes. |
| */ |
| if (argc > 2) |
| length = simple_strtoul(argv[2], NULL, 16); |
| |
| /* Print the lines. */ |
| print_buffer(addr, (void*)addr, size, length, 16/size); |
| strcpy(info, "success"); |
| return rc; |
| } |
| |
| int set_low_power_for_usb_burn(int arg, char* buff) |
| { |
| if (OPTIMUS_WORK_MODE_USB_PRODUCE == optimus_work_mode_get()) { |
| return 0;//just return ok as usb producing mode as LCD not initialized yet! |
| } |
| |
| #if defined(CONFIG_VIDEO_AMLLCD) |
| int ret1=0; |
| //axp to low power off LCD, no-charging |
| MYDBG("To close LCD\n"); |
| ret1 = run_command("video dev disable", 0); |
| if (ret1) { |
| if (buff) sprintf(buff, "Fail to close back light") ; |
| printf("Fail to close back light\n"); |
| /*return __LINE__;*/ |
| } |
| #endif// #if defined(CONFIG_VIDEO_AMLLCD) |
| |
| #if USB_BURN_POWER_CONTROL |
| int ret2=0; |
| //limit vbus curretn to 500mA, i.e, if hub is 4A, 8 devices at most, arg3 to not set_env as it's not inited yet!! |
| MYDBG("set_usbcur_limit 500 0\n"); |
| ret2 = run_command("set_usbcur_limit 500 0", 0); |
| if (ret2) { |
| if (buff) sprintf(buff, "Fail to set_usb_cur_limit") ; |
| printf("Fail to set_usb_cur_limit\n"); |
| return __LINE__; |
| } |
| #endif//#if USB_BURN_POWER_CONTROL |
| |
| return 0; |
| } |
| |
| int cb_4_dis_connect_intr(void) |
| { |
| if (optimus_burn_complete(OPTIMUS_BURN_COMPLETE__QUERY)) |
| { |
| close_usb_phy_clock(0);//disconnect to avoid k200 platfrom which can't relally poweroff |
| DWN_MSG("User Want poweroff after disconnect\n"); |
| optimus_poweroff(); |
| } |
| |
| return 0; |
| } |
| |
| static int _cpu_temp_in_valid_range(int argc, char* argv[], char* errInfo) |
| { |
| int ret = 0; |
| int minTemp = 0; |
| int maxTemp = 0; |
| int cpu_temp = 0; |
| char* env_cpu_temp = NULL; |
| |
| if (3 > argc) { |
| sprintf(errInfo, "argc %d < 3 is invalid\n", argc); |
| return __LINE__; |
| } |
| minTemp = simple_strtol(argv[1], NULL, 0); |
| maxTemp = simple_strtol(argv[2], NULL, 0); |
| if (minTemp <=0 || maxTemp <= 0 || minTemp >= maxTemp) { |
| sprintf(errInfo, "Invalid:minTemp=%s, maxTemp=%s\n", argv[1], argv[2]); |
| return __LINE__; |
| } |
| ret = run_command("read_temp", 0); |
| if (ret < 0) { |
| sprintf(errInfo, "cmd[cpu_temp] failed\n"); |
| return __LINE__; |
| } |
| env_cpu_temp = getenv("tempa"); |
| if (!env_cpu_temp) { |
| sprintf(errInfo, "Can't get cpu_temp, cpu is not calibrated.\n"); |
| return __LINE__; |
| } |
| cpu_temp = simple_strtol(env_cpu_temp, NULL, 0); |
| ret = (cpu_temp >= minTemp && cpu_temp <= maxTemp) ? 0 : __LINE__; |
| if (!ret) { |
| sprintf(errInfo, "%s", env_cpu_temp); |
| } |
| else{ |
| sprintf(errInfo, "%s is out of temp range[%d, %d], errInfo[%s]\n", env_cpu_temp, minTemp, maxTemp, getenv("err_info_tempa")); |
| } |
| |
| return ret; |
| } |
| |
| static int _get_chipid(char* buff) |
| { |
| int i = 0; |
| unsigned char chipid[16]; |
| int ret = get_chip_id(chipid, 16); |
| if ( ret ) { |
| DWN_ERR("_get_chipid %d", ret); |
| return ret; |
| } |
| |
| buff[0] = ':', buff[1]='\0'; |
| for (; i < 12; ++i) { |
| sprintf(buff, "%s%02x", buff, chipid[15-i]); |
| } |
| return 0; |
| } |
| |
| int optimus_working (const char *cmd, char* buff) |
| { |
| static char cmdBuf[CMD_BUFF_SIZE] = {0}; |
| int ret = 0; |
| int argc = 33; |
| char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */ |
| const char* optCmd = NULL; |
| |
| memset(buff, 0, CMD_BUFF_SIZE); |
| memcpy(cmdBuf, cmd, CMD_BUFF_SIZE); |
| if ((argc = cli_simple_parse_line(cmdBuf, argv)) == 0) |
| { |
| strcpy(buff, "failed:no command at all"); |
| printf("no command at all\n"); |
| return -1; /* no command at all */ |
| } |
| optCmd = argv[0]; |
| |
| if (!strcmp("low_power", optCmd)) |
| { |
| ret = set_low_power_for_usb_burn(1, buff); |
| } |
| else if(strcmp(optCmd, "disk_initial") == 0) |
| { |
| unsigned erase = argc > 1 ? simple_strtoul(argv[1], NULL, 0) : 0; |
| |
| ret = optimus_storage_init(erase); |
| } |
| else if(!strcmp(optCmd, "bootloader_is_old")) |
| { |
| ret = is_tpl_loaded_from_usb(); |
| if (ret)sprintf(buff, "Failed, bootloader is new\n") ; |
| } |
| else if(!strcmp(optCmd, "erase_bootloader")) |
| { |
| ret = optimus_erase_bootloader("usb"); |
| |
| if (ret)sprintf(buff, "Failed to erase bootloader\n") ; |
| } |
| else if(strcmp(optCmd, "reset") == 0) |
| { |
| close_usb_phy_clock(0); |
| optimus_reset(OPTIMUS_BURN_COMPLETE__REBOOT_NORMAL); |
| } |
| else if(strcmp(optCmd, "poweroff") == 0) |
| { |
| optimus_poweroff(); |
| } |
| else if(strncmp(optCmd, "md", 2) == 0) |
| { |
| ret = optimus_mem_md(argc, argv, buff); |
| } |
| else if(!strcmp(optCmd, "download") || !strcmp("upload", optCmd)) |
| { |
| ret = optimus_parse_download_cmd(argc, argv); |
| } |
| else if(!strcmp("key", optCmd)) |
| { |
| ret = v2_key_command(argc, argv, buff); |
| } |
| else if(!strcmp("verify", optCmd)) |
| { |
| ret = optimus_media_download_verify(argc, argv, buff); |
| } |
| else if(!strcmp("save_setting", optCmd)) |
| { |
| ret = optimus_set_burn_complete_flag(); |
| } |
| else if(!strcmp("burn_complete", optCmd)) |
| { |
| unsigned choice = simple_strtoul(argv[1], NULL, 0);//0 is poweroff, 1 is reset system |
| |
| if (OPTIMUS_BURN_COMPLETE__POWEROFF_AFTER_DISCONNECT != choice) {//disconnect except OPTIMUS_BURN_COMPLETE__POWEROFF_AFTER_DISCONNECT |
| close_usb_phy_clock(0);//some platform can't poweroff but dis-connect needed by pc |
| } |
| ret = optimus_burn_complete(choice); |
| } |
| else if(!strcmp(optCmd, "support_tempcontrol")) |
| { |
| #ifndef CONFIG_CMD_CPU_TEMP |
| ret = __LINE__; |
| #else |
| ret = 0; |
| #endif// #ifdef CONFIG_CMD_CPU_TEMP |
| sprintf(buff + 7, "cpu temp control cmd %s supported.\n", ret ? "NOT" : "DO");//7 == strlen("failed") |
| } |
| else if(!strcmp(optCmd, "tempcontrol")) |
| { |
| ret = _cpu_temp_in_valid_range(argc, argv, buff + 7); |
| } |
| else if(!strcmp(optCmd, "get_chipid")) |
| { |
| ret = _get_chipid(buff + 7); |
| } |
| else |
| { |
| int flag = 0; |
| ret = run_command(cmd, flag); |
| DWN_MSG("ret = %d\n", ret); |
| /*ret = ret < 0 ? ret : 0;*/ |
| } |
| |
| if (ret) |
| { |
| memcpy(buff, "failed:", strlen("failed:"));//use memcpy but not strcpy to not overwrite storage/key info |
| } |
| else |
| { |
| memcpy(buff, "success", strlen("success"));//use memcpy but not strcpy to not overwrite storage/key info |
| } |
| |
| printf("[info]%s\n",buff); |
| return ret; |
| } |
| |