static void set_env(char *var, char *val)
{
char *setenv[4] = { "setenv", NULL, NULL, NULL, };
setenv[1] = var;
setenv[2] = val;
do_setenv(NULL, 0, 3, setenv);
}
void do_builtins(t_lst *list, char **cmd) //, char **paths)
{
t_lst *new_list;
new_list = NULL;
if (check_is_builtin(cmd[0]) == 1)
do_cd(list, cmd);
if (check_is_builtin(cmd[0]) == 2)
do_setenv(list, cmd, 1);
else if (check_is_builtin(cmd[0]) == 3)
do_unsetenv(list, cmd);
else if (check_is_builtin(cmd[0]) == 4)
do_env(list, cmd); //, paths);
}
void builtin_setenv(t_env *env)
{
const char error[] = "setenv: Too many arguments.\n";
char *ptr;
char *name;
char *extra_ptr;
ptr = env->line + sizeof("setenv") - 1;
name = NULL;
while (*ptr == ' ' || *ptr == '\t')
++ptr;
if (!*ptr)
builtin_env(env);
else
{
name = ptr;
while (*ptr && !(*ptr == ' ' | *ptr == '\t'))
++ptr;
while (*ptr == ' ' || *ptr == '\t')
++ptr;
if (!*ptr)
do_setenv(env, name, "");
else
{
extra_ptr = ptr;
while (*extra_ptr && !(*extra_ptr == ' ' || *extra_ptr == '\t' || *extra_ptr == '\n'))
++extra_ptr;
while (*extra_ptr == ' ' || *extra_ptr == '\t' || *extra_ptr == '\n')
++extra_ptr;
if (*extra_ptr)
write(2, error, sizeof(error) - 1);
else
do_setenv(env, name, ptr);
}
}
}
static int do_arg(t_lst *node, char *arg)
{
int i;
char **cmd;
i = 0;
cmd = ft_strsplit_ws(arg);
if (!*cmd)
return (-1);
if (ft_strcmp(*cmd, "exit") == 0)
i = do_exit(arg);
else if (ft_strcmp(*cmd, "env") == 0)
i = deal_with_env(node, arg);
else if (ft_strcmp(*cmd, "setenv") == 0)
i = do_setenv(node, arg);
else if (ft_strcmp(*cmd, "unsetenv") == 0)
i = do_unsetenv(node, arg);
else if (ft_strcmp(*cmd, "cd") == 0)
i = do_cd(node, arg);
else if (*cmd)
i = deal_with_command(node, cmd);
ft_strdel(cmd);
return (i);
}
static void save_block_values(struct fastboot_ptentry *ptn,
unsigned int offset,
unsigned int size)
{
struct fastboot_ptentry *env_ptn;
char var[64], val[32];
char start[32], length[32];
char ecc_type[32];
char *lock[5] = { "nand", "lock", NULL, NULL, NULL, };
char *unlock[5] = { "nand", "unlock", NULL, NULL, NULL, };
char *ecc[4] = { "nand", "ecc", NULL, NULL, };
char *setenv[4] = { "setenv", NULL, NULL, NULL, };
char *saveenv[2] = { "setenv", NULL, };
setenv[1] = var;
setenv[2] = val;
lock[2] = unlock[2] = start;
lock[3] = unlock[3] = length;
printf ("saving it..\n");
if (size == 0)
{
/* The error case, where the variables are being unset */
sprintf (var, "%s_nand_offset", ptn->name);
sprintf (val, "");
do_setenv (NULL, 0, 3, setenv);
sprintf (var, "%s_nand_size", ptn->name);
sprintf (val, "");
do_setenv (NULL, 0, 3, setenv);
}
else
{
/* Normal case */
sprintf (var, "%s_nand_offset", ptn->name);
sprintf (val, "0x%x", offset);
printf ("%s %s %s\n", setenv[0], setenv[1], setenv[2]);
do_setenv (NULL, 0, 3, setenv);
sprintf (var, "%s_nand_size", ptn->name);
sprintf (val, "0x%x", size);
printf ("%s %s %s\n", setenv[0], setenv[1], setenv[2]);
do_setenv (NULL, 0, 3, setenv);
}
/* Warning :
The environment is assumed to be in a partition named 'enviroment'.
It is very possible that your board stores the enviroment
someplace else. */
env_ptn = fastboot_flash_find_ptn("environment");
if (env_ptn)
{
/* Some flashing requires the nand's ecc to be set */
ecc[2] = ecc_type;
if ((env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_HW_ECC) &&
(env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_SW_ECC))
{
/* Both can not be true */
printf ("Warning can not do hw and sw ecc for partition '%s'\n", ptn->name);
printf ("Ignoring these flags\n");
}
else if (env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_HW_ECC)
{
sprintf (ecc_type, "hw");
CFG_FASTBOOT_FLASHCMD (NULL, 0, 3, ecc);
}
else if (env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_SW_ECC)
{
sprintf (ecc_type, "sw");
CFG_FASTBOOT_FLASHCMD (NULL, 0, 3, ecc);
}
sprintf (start, "0x%x", env_ptn->start);
sprintf (length, "0x%x", env_ptn->length);
/* This could be a problem is there is an outstanding lock */
CFG_FASTBOOT_FLASHCMD (NULL, 0, 4, unlock);
}
do_saveenv (NULL, 0, 1, saveenv);
if (env_ptn)
{
CFG_FASTBOOT_FLASHCMD (NULL, 0, 4, lock);
}
}
int do_mmc_read_img (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int device_num = 1;
int dev_id = 0;
ulong kernel_addr,ramdisk_addr;
ulong blk_cnt_kenel, blk_cnt_ramdisk, page_cnt_kenel, page_cnt_ramdisk;
ulong ret;
static unsigned char data[512];
block_dev_desc_t *dev_desc=NULL;
int dev=0;
ulong part=1;
char *ep;
unsigned int page_size, kernel_size, ramdisk_size, total_size;
char var[64], val[32];
char *setenv[4] = { "setenv", NULL, NULL, NULL, };
char *saveenv[2] = { "setenv", NULL, };
setenv[1] = var;
setenv[2] = val;
/*printf("%s\n", __FUNCTION__);*/
if (argc < 4) {
printf("Usage:\n%s\n", cmdtp->usage);
return 1;
}
/*get device id*/
dev_id = (int)simple_strtoul (argv[2], &ep, 16);
if (dev_id == 0 || dev_id == 1 || dev_id == 2 || dev_id == 3)
device_num = dev_id;
else {
printf("dev_id Invalid\n");
return 1;
}
/*get mmc dev descriptor*/
dev_desc=get_dev(argv[1], dev_id);
if (dev_desc==NULL) {
puts ("\n** Invalid boot device **\n");
return 1;
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
/*printf("dev_id:%x,part:%x\n",dev_id,part);*/
/* init mmc controller */
if (mmc_init(1, device_num)) {
printf("mmc init failed?\n");
return 1;
}
if (mmc_register_device(dev_desc, part) != 0) {
printf ("\n** Unable to use %s %d:%d for fatload **\n", argv[1], dev_id, part);
return 1;
}
/*get kernel memory address*/
kernel_addr = simple_strtoul (argv[3], NULL, 16);
if (kernel_addr < 0) {
printf("kernel addr Invalid\n");
return 1;
}
/*get ramdisk memory address*/
ramdisk_addr = simple_strtoul (argv[4], NULL, 16);
if (ramdisk_addr < 0) {
printf("ramdisk addr Invalid\n");
return 1;
}
/*mmc block read partition offset sectors*/
ret = mmc_bread(device_num, mmc_part_offset, 1, (void *)data);
if (ret == -1 ) {
printf("Read Data Fail\n");
return 1;
} else {
printf("Read Data Success\n");
}
/*memdump ((void *) data, 512);*/
struct fastboot_boot_img_hdr *fb_hdr = (struct fastboot_boot_img_hdr *)data;
if (memcmp(data, "ANDROID!", 8)) {
printf(" boot.img partition table not found\n");
return -1;
}
/*kernel size change to sectors*/
kernel_size = fb_hdr->kernel_size ;
ramdisk_size = fb_hdr->ramdisk_size;
page_size = fb_hdr->page_size ;
total_size = 1*page_size + kernel_size + ramdisk_size;
/* calculate transfer block count */
blk_cnt_kenel= (fb_hdr->kernel_size / 512);
if (fb_hdr->kernel_size % 512)
blk_cnt_kenel++;
page_cnt_kenel= (fb_hdr->kernel_size / page_size);
if (fb_hdr->kernel_size % page_size)
page_cnt_kenel++;
/* load kernel image from mmc boot image to kernel_addr */
/*printf(" mmc_part_offset + page_size:0x%x, fb_hdr->kernel_size:0x%x, mem kernel_addr:0x%x\n",
mmc_part_offset + page_size / 512, fb_hdr->kernel_size, kernel_addr);*/
ret = mmc_bread(device_num, mmc_part_offset + page_size / 512, blk_cnt_kenel, kernel_addr);
if (ret == -1 ) {
printf("Read Kernel Data Fail\n");
return 1;
} else {
printf("Read Kernel Data Success\n");
}
blk_cnt_ramdisk= (fb_hdr->ramdisk_size / 512);
if (fb_hdr->ramdisk_size % 512)
blk_cnt_ramdisk++;
page_cnt_ramdisk= (fb_hdr->kernel_size / page_size);
if (fb_hdr->kernel_size % page_size)
page_cnt_ramdisk++;
/* load ramdisk image from mmc boot image to ramdisk_addr */
/*printf("mmc_part_offset + page_size + blk_cnt_kenel:0x%x, fb_hdr->ramdisk_size:0x%x, mem ramdisk_addr:0x%x\n",
mmc_part_offset + page_size /512 + page_cnt_kenel *(page_size/512), fb_hdr->ramdisk_size, ramdisk_addr);*/
ret = mmc_bread(device_num, mmc_part_offset + page_size /512 + page_cnt_kenel *(page_size /512), blk_cnt_ramdisk, ramdisk_addr);
if (ret == -1 ) {
printf("Read Ramdisk Data Fail\n");
return 1;
} else {
printf("Read Ramdisk Data Success\n");
}
/*save ramdisk size to env argv[4]*/
sprintf (var, "%s", argv[5]);
sprintf (val, "%x", fb_hdr->ramdisk_size);
do_setenv (NULL, 0, 3, setenv);
printf("%s %s %s\n", setenv[0], setenv[1], setenv[2]);
/*do_saveenv (NULL, 0, 1, saveenv);*/
return 0;
}
