static void getvar_has_slot(char *part_name, char *response)
{
if (part_name && (!strcmp(part_name, "boot") ||
!strcmp(part_name, "system")))
fastboot_okay("yes", response);
else
fastboot_okay("no", response);
}
int fastboot_oem_lock(const char *arg, void *data, unsigned sz)
{
int ret = B_OK;
char msg[128] = {0};
int inFactory = 0;
int requireConfirmation = 0;
ret = sec_is_in_factory(&inFactory);
if (ret)
return ret;
requireConfirmation = inFactory ? 0 : 1;
lock_warranty();
while(1)
{
if(mtk_detect_key(MT65XX_MENU_SELECT_KEY) || !requireConfirmation) //VOL_UP
{
fastboot_info("Start lock flow\n");
//Invoke security check after confiming "yes" by user
ret = fastboot_oem_lock_chk();
if(ret != B_OK)
{
sprintf(msg, "\nlock failed - Err:0x%x \n", ret);
video_printf("lock failed...return to fastboot in 3s\n");
mdelay(3000);
fastboot_boot_menu();
fastboot_fail(msg);
}
else
{
video_printf("lock Pass...return to fastboot in 3s\n");
mdelay(3000);
fastboot_boot_menu();
fastboot_okay("");
}
break;
}
else if(mtk_detect_key(MT65XX_MENU_OK_KEY))//VOL_DOWN
{
video_printf("return to fastboot in 3s\n");
mdelay(3000);
fastboot_boot_menu();
fastboot_okay("");
break;
}
else
{
//If we press other keys, discard it.
}
}
return ret;
}
static void cmd_getvar(const char *arg, void *data, unsigned sz)
{
struct fastboot_var *var;
for (var = varlist; var; var = var->next) {
if (!strcmp(var->name, arg)) {
fastboot_okay(var->value);
return;
}
}
fastboot_okay("");
}
void cmd_reboot_bootloader(const char *arg, void *data, unsigned sz)
{
dprintf(INFO, "rebooting the device to bootloader\n");
fastboot_okay("");
Set_Clr_RTC_PDN1_bit13(true); //Set RTC fastboot bit
mtk_arch_reset(1); //bypass pwr key when reboot
}
void cmd_flash_mmc(const char *arg, void *data, unsigned sz)
{
unsigned long long ptn = 0;
unsigned long long size = 0;
ptn = mmc_ptn_offset(arg);
if(ptn == 0) {
fastboot_fail("partition table doesn't exist");
return;
}
if (!strcmp(arg, "boot") || !strcmp(arg, "recovery")) {
if (memcmp((void *)data, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
fastboot_fail("image is not a boot image");
return;
}
}
size = mmc_ptn_size(arg);
if (ROUND_TO_PAGE(sz,511) > size) {
fastboot_fail("size too large");
return;
}
if (mmc_write(ptn , sz, (unsigned int *)data)) {
fastboot_fail("flash write failure");
return;
}
fastboot_okay("");
return;
}
static void write_raw_image(block_dev_desc_t *dev_desc, disk_partition_t *info,
const char *part_name, void *buffer,
unsigned int download_bytes)
{
lbaint_t blkcnt;
lbaint_t blks;
/* determine number of blocks to write */
blkcnt = ((download_bytes + (info->blksz - 1)) & ~(info->blksz - 1));
blkcnt = blkcnt / info->blksz;
if (blkcnt > info->size) {
error("too large for partition: '%s'\n", part_name);
fastboot_fail("too large for partition");
return;
}
puts("Flashing Raw Image\n");
blks = dev_desc->block_write(dev_desc->dev, info->start, blkcnt,
buffer);
if (blks != blkcnt) {
error("failed writing to device %d\n", dev_desc->dev);
fastboot_fail("failed writing to device");
return;
}
printf("........ wrote " LBAFU " bytes to '%s'\n", blkcnt * info->blksz,
part_name);
fastboot_okay("");
}
static void cmd_erase(struct protocol_handle *phandle, const char *arg)
{
int partition_fd;
char path[PATH_MAX];
D(DEBUG, "cmd_erase %s\n", arg);
if (flash_find_entry(arg, path, PATH_MAX)) {
fastboot_fail(phandle, "partition table doesn't exist");
return;
}
if (path == NULL) {
fastboot_fail(phandle, "Couldn't find partition");
return;
}
partition_fd = flash_get_partiton(path);
if (partition_fd < 0) {
fastboot_fail(phandle, "partiton file does not exists");
}
if (flash_erase(partition_fd)) {
fastboot_fail(phandle, "failed to erase partition");
flash_close(partition_fd);
return;
}
if (flash_close(partition_fd) < 0) {
D(ERR, "could not close device %s", strerror(errno));
fastboot_fail(phandle, "failed to erase partition");
return;
}
fastboot_okay(phandle, "");
}
static int oem_uniqueid_handler(int argc, char **argv)
{
int retval = -1;
ST_RESULT result;
uint8_t uniqueKey[SECURE_TOKEN_UNIQUE_KEY_SIZE_IN_BYTES];
char hexuniqueKey[SECURE_TOKEN_UNIQUE_KEY_SIZE_IN_BYTES * 3 + 2];
DX_CC_HostInit();
result = sep_sectoken_request_token(uniqueKey);
pr_info("sep_sectoken_request_token() == 0x%x\n", result);
if (ST_FAIL_SEP_DRIVER_OP == result)
pr_info("sep_sectoken_request_token() ==" "ST_FAIL_SEP_DRIVER_OP\n");
retval = (result != ST_SUCCESSFUL);
if (retval != 0)
fastboot_fail("cannot get uniqueid");
else {
snhexdump(hexuniqueKey, sizeof(hexuniqueKey) - 1, uniqueKey,
SECURE_TOKEN_UNIQUE_KEY_SIZE_IN_BYTES);
pr_info("%s\n", hexuniqueKey);
hexdump_buffer(uniqueKey, SECURE_TOKEN_UNIQUE_KEY_SIZE_IN_BYTES, fastboot_info, 16);
}
fastboot_okay("");
DX_CC_HostFinish();
return retval;
}
static void cmd_download(struct protocol_handle *phandle, const char *arg)
{
unsigned len = strtoul(arg, NULL, 16);
int old_fd;
if (len > 256 * 1024 * 1024) {
fastboot_fail(phandle, "data too large");
return;
}
fastboot_data(phandle, len);
old_fd = protocol_get_download(phandle);
if (old_fd >= 0) {
off_t len = lseek(old_fd, 0, SEEK_END);
D(INFO, "disposing of unused fd %d, size %ld", old_fd, len);
close(old_fd);
}
phandle->download_fd = protocol_handle_download(phandle, len);
if (phandle->download_fd < 0) {
fastboot_fail(phandle, "download failed");
return;
}
fastboot_okay(phandle, "");
}
void fb_nand_erase(const char *cmd)
{
struct part_info *part;
struct mtd_info *mtd = NULL;
int ret;
ret = fb_nand_lookup(cmd, &mtd, &part);
if (ret) {
error("invalid NAND device");
fastboot_fail("invalid NAND device");
return;
}
ret = board_fastboot_erase_partition_setup(part->name);
if (ret)
return;
ret = _fb_nand_erase(mtd, part);
if (ret) {
error("failed erasing from device %s", mtd->name);
fastboot_fail("failed erasing from device");
return;
}
fastboot_okay("");
}
void fb_nand_erase(const char *partname, char *response)
{
struct part_info *part;
nand_info_t *nand = NULL;
int ret;
/* initialize the response buffer */
response_str = response;
ret = fb_nand_lookup(partname, response, &nand, &part);
if (ret) {
error("invalid NAND device");
fastboot_fail(response_str, "invalid NAND device");
return;
}
ret = board_fastboot_erase_partition_setup(part->name);
if (ret)
return;
ret = _fb_nand_erase(nand, part);
if (ret) {
error("failed erasing from device %s", nand->name);
fastboot_fail(response_str, "failed erasing from device");
return;
}
fastboot_okay(response_str, "");
}
void cmd_flash_nand(const char *arg, void *data, unsigned sz)
{
u8 msg[128] = {0};
if(sz == 0)
{
fastboot_okay("");
return;
}
//Please DO NOT get any data for reference if security check is not passed
if(!security_check(&data, &sz, 0, arg))
{
sprintf(msg, "\nSecurity deny - Err:0x%x \n", sec_error());
dprintf(DBG_LV, msg);
fastboot_fail_wrapper(msg);
return;
}
dprintf(DBG_LV, "cmd_flash_nand, data:0x%x\n",*(int*)data);
if(cmd_flash_nand_img(arg,data,sz))
{
//[Security] Notify security check that is the end.
sz = 0;
security_check(&data, &sz, IMAGE_TRUNK_SIZE, arg);
}
}
void fb_mmc_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes)
{
struct blk_desc *dev_desc;
disk_partition_t info;
dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
return;
}
if (strcmp(cmd, CONFIG_FASTBOOT_GPT_NAME) == 0) {
printf("%s: updating MBR, Primary and Backup GPT(s)\n",
__func__);
if (is_valid_gpt_buf(dev_desc, download_buffer)) {
printf("%s: invalid GPT - refusing to write to flash\n",
__func__);
fastboot_fail("invalid GPT partition");
return;
}
if (write_mbr_and_gpt_partitions(dev_desc, download_buffer)) {
printf("%s: writing GPT partitions failed\n", __func__);
fastboot_fail(
"writing GPT partitions failed");
return;
}
printf("........ success\n");
fastboot_okay("");
return;
} else if (part_get_info_efi_by_name_or_alias(dev_desc, cmd, &info)) {
error("cannot find partition: '%s'\n", cmd);
fastboot_fail("cannot find partition");
return;
}
if (is_sparse_image(download_buffer)) {
struct fb_mmc_sparse sparse_priv;
struct sparse_storage sparse;
sparse_priv.dev_desc = dev_desc;
sparse.blksz = info.blksz;
sparse.start = info.start;
sparse.size = info.size;
sparse.write = fb_mmc_sparse_write;
sparse.reserve = fb_mmc_sparse_reserve;
printf("Flashing sparse image at offset " LBAFU "\n",
sparse.start);
sparse.priv = &sparse_priv;
write_sparse_image(&sparse, cmd, download_buffer,
download_bytes);
} else {
write_raw_image(dev_desc, &info, cmd, download_buffer,
download_bytes);
}
}
int download_ex(u32 data_length)//Big image and parallel transfer.
{
thread_t *thr;
init_engine_context(&ctx);
init_sto_info(&sto_info, FALSE); //no checksum enabled.
sto_info.to_write_data_len = data_length;
thr = thread_create("fastboot", write_storage_proc, 0, DEFAULT_PRIORITY, 16*1024);
if (!thr)
{
return -1;
}
thread_resume(thr);
TIME_START;
read_usb_proc(&data_length);
//wait for write thread end.
event_wait(&ctx.thr_end_ev);
destroy_engine(&ctx);
if(ctx.b_error)
{
fastboot_fail_wrapper("\n@DOWNLOAD ERROR@\nPlease re-plug your USB cable\n");
fastboot_state = STATE_ERROR;
}else
{
fastboot_okay("");
}
return 0;
}
void tboot_config_keywords(void)
{
int i;
if (!tboot_config) {
pr_error("tboot config wasn't init.\n");
return;
}
fastboot_info("\n");
fastboot_info("Keyword Current value\n");
fastboot_info("---------------------------------\n");
for (i = 0; tc_keys[i]; i++) {
char *buf;
int len = 0;
int left = 0;
if (asprintf(&buf, "%-20s%s\n", tc_keys[i],
tboot_config_get(tc_keys[i])) == -1)
continue;
fastboot_info(buf);
free(buf);
}
fastboot_info("\n");
fastboot_okay("");
}
static void cmd_getvar(struct protocol_handle *phandle, const char *arg)
{
const char *value;
D(DEBUG, "cmd_getvar %s\n", arg);
value = fastboot_getvar(arg);
fastboot_okay(phandle, value);
}
static void getvar_product(char *var_parameter, char *response)
{
const char *board = env_get("board");
if (board)
fastboot_okay(board, response);
else
fastboot_fail("Board not set", response);
}
static void cmd_oem(struct protocol_handle *phandle, const char *arg) {
const char *response = "";
//TODO: Maybe it should get download descriptor also
if (trigger_oem_cmd(arg, &response))
fastboot_fail(phandle, response);
else
fastboot_okay(phandle, response);
}
static void getvar_platform(char *var_parameter, char *response)
{
const char *p = env_get("platform");
if (p)
fastboot_okay(p, response);
else
fastboot_fail("platform not set", response);
}
static void cmd_continue(struct protocol_handle *phandle, const char *arg)
{
fastboot_okay(phandle, "");
#if 0
udc_stop();
boot_linux_from_flash();
#endif
}
static void getvar_serialno(char *var_parameter, char *response)
{
const char *tmp = env_get("serial#");
if (tmp)
fastboot_okay(tmp, response);
else
fastboot_fail("Value not set", response);
}
void cmd_continue(const char *arg, void *data, unsigned sz)
{
g_boot_mode = NORMAL_BOOT;
fastboot_okay("");
udc_stop();
mtk_wdt_init(); //re-open wdt
/*Will not return*/
boot_linux_from_storage();
}
void cmd_continue(const char *arg, void *data, unsigned sz)
{
g_boot_mode = NORMAL_BOOT;
if(has_set_p2u)
{
set_p2u(has_set_p2u);
fastboot_info("phone will continue boot up after 5s...");
fastboot_okay("");
mdelay(5000);
}
else
{
fastboot_okay("");
}
udc_stop();
mtk_wdt_init(); //re-open wdt
/*Will not return*/
boot_linux_from_storage();
}
void fb_nand_flash_write(const char *partname, unsigned int session_id,
void *download_buffer, unsigned int download_bytes,
char *response)
{
struct part_info *part;
nand_info_t *nand = NULL;
int ret;
/* initialize the response buffer */
response_str = response;
ret = fb_nand_lookup(partname, response, &nand, &part);
if (ret) {
error("invalid NAND device");
fastboot_fail(response_str, "invalid NAND device");
return;
}
ret = board_fastboot_write_partition_setup(part->name);
if (ret)
return;
if (is_sparse_image(download_buffer)) {
struct fb_nand_sparse sparse_priv;
sparse_storage_t sparse;
sparse_priv.nand = nand;
sparse_priv.part = part;
sparse.block_sz = nand->writesize;
sparse.start = part->offset / sparse.block_sz;
sparse.size = part->size / sparse.block_sz;
sparse.name = part->name;
sparse.write = fb_nand_sparse_write;
ret = store_sparse_image(&sparse, &sparse_priv, session_id,
download_buffer);
} else {
printf("Flashing raw image at offset 0x%llx\n",
part->offset);
ret = _fb_nand_write(nand, part, download_buffer, part->offset,
download_bytes, NULL);
printf("........ wrote %u bytes to '%s'\n",
download_bytes, part->name);
}
if (ret) {
fastboot_fail(response_str, "error writing the image");
return;
}
fastboot_okay(response_str, "");
}
void fb_nand_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes)
{
struct part_info *part;
struct mtd_info *mtd = NULL;
int ret;
ret = fb_nand_lookup(cmd, &mtd, &part);
if (ret) {
error("invalid NAND device");
fastboot_fail("invalid NAND device");
return;
}
ret = board_fastboot_write_partition_setup(part->name);
if (ret)
return;
if (is_sparse_image(download_buffer)) {
struct fb_nand_sparse sparse_priv;
struct sparse_storage sparse;
sparse_priv.mtd = mtd;
sparse_priv.part = part;
sparse.blksz = mtd->writesize;
sparse.start = part->offset / sparse.blksz;
sparse.size = part->size / sparse.blksz;
sparse.write = fb_nand_sparse_write;
sparse.reserve = fb_nand_sparse_reserve;
printf("Flashing sparse image at offset " LBAFU "\n",
sparse.start);
sparse.priv = &sparse_priv;
write_sparse_image(&sparse, cmd, download_buffer,
download_bytes);
} else {
printf("Flashing raw image at offset 0x%llx\n",
part->offset);
ret = _fb_nand_write(mtd, part, download_buffer, part->offset,
download_bytes, NULL);
printf("........ wrote %u bytes to '%s'\n",
download_bytes, part->name);
}
if (ret) {
fastboot_fail("error writing the image");
return;
}
fastboot_okay("");
}
void cmd_getvar(const char *arg, void *data, unsigned sz)
{
struct fastboot_var *var;
char response[MAX_RSP_SIZE];
if(!strcmp(arg, "all")){
for (var = varlist; var; var = var->next){
snprintf(response, MAX_RSP_SIZE,"\t%s: %s", var->name, var->value);
fastboot_info(response);
}
fastboot_okay("Done!!");
return;
}
for (var = varlist; var; var = var->next) {
if (!strcmp(var->name, arg)) {
fastboot_okay(var->value);
return;
}
}
fastboot_okay("");
}
void cmd_flash_emmc(const char *arg, void *data, unsigned sz)
{
sparse_header_t *sparse_header;
/* 8 Byte Magic + 2048 Byte xml + Encrypted Data */
unsigned int *magic_number = (unsigned int *) data;
int ret=0;
#if 0
if (magic_number[0] == DECRYPT_MAGIC_0 &&
magic_number[1] == DECRYPT_MAGIC_1)
{
#ifdef SSD_ENABLE
ret = decrypt_scm((u32 **) &data, &sz);
#endif
if (ret != 0)
{
dprintf(CRITICAL, "ERROR: Invalid secure image\n");
return;
}
}
else if (magic_number[0] == ENCRYPT_MAGIC_0 &&
magic_number[1] == ENCRYPT_MAGIC_1)
{
#ifdef SSD_ENABLE
ret = encrypt_scm((u32 **) &data, &sz);
#endif
if (ret != 0)
{
dprintf(CRITICAL, "ERROR: Encryption Failure\n");
return;
}
}
#endif
if(sz == 0)
{
fastboot_okay("");
return;
}
sparse_header = (sparse_header_t *) data;
dprintf(DBG_LV, "cmd_flash_emmc, data:0x%x,, n sparse_header->magic = 0x%x\n",*(int*)data, sparse_header->magic );
if (sparse_header->magic != SPARSE_HEADER_MAGIC)
{
cmd_flash_emmc_img(arg, data, sz);
}
else
{
cmd_flash_emmc_sparse_img(arg, data, sz);
}
return;
}
void fb_mmc_erase(const char *cmd)
{
int ret;
struct blk_desc *dev_desc;
disk_partition_t info;
lbaint_t blks, blks_start, blks_size, grp_size;
struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (mmc == NULL) {
error("invalid mmc device");
fastboot_fail("invalid mmc device");
return;
}
dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device");
fastboot_fail("invalid mmc device");
return;
}
ret = part_get_info_efi_by_name_or_alias(dev_desc, cmd, &info);
if (ret) {
error("cannot find partition: '%s'", cmd);
fastboot_fail("cannot find partition");
return;
}
/* Align blocks to erase group size to avoid erasing other partitions */
grp_size = mmc->erase_grp_size;
blks_start = (info.start + grp_size - 1) & ~(grp_size - 1);
if (info.size >= grp_size)
blks_size = (info.size - (blks_start - info.start)) &
(~(grp_size - 1));
else
blks_size = 0;
printf("Erasing blocks " LBAFU " to " LBAFU " due to alignment\n",
blks_start, blks_start + blks_size);
blks = dev_desc->block_erase(dev_desc, blks_start, blks_size);
if (blks != blks_size) {
error("failed erasing from device %d", dev_desc->devnum);
fastboot_fail("failed erasing from device");
return;
}
printf("........ erased " LBAFU " bytes from '%s'\n",
blks_size * info.blksz, cmd);
fastboot_okay("");
}
void cmd_oem_reboot2recovery(const char *arg, void *data, unsigned sz)
{
extern void Set_RTC_Recovery_Mode(bool flag)__attribute__((weak));
if(Set_RTC_Recovery_Mode)
{
Set_RTC_Recovery_Mode(1);
fastboot_okay("");
mtk_arch_reset(1); //bypass pwr key when reboot
}
else
{
fastboot_fail("Not support this function (need RTC porting)");
}
}
static void getvar_partition_type(char *part_name, char *response)
{
int r;
struct blk_desc *dev_desc;
disk_partition_t part_info;
r = fastboot_mmc_get_part_info(part_name, &dev_desc, &part_info,
response);
if (r >= 0) {
r = fs_set_blk_dev_with_part(dev_desc, r);
if (r < 0)
fastboot_fail("failed to set partition", response);
else
fastboot_okay(fs_get_type_name(), response);
}
}