static struct f_fastboot *fastboot_func;
static unsigned int download_size;
static unsigned int download_bytes;
+#ifdef CONFIG_SYSTEM_RAMDISK_SUPPORT
+static bool is_recovery_mode;
+#endif
+
static int strcmp_l1(const char *s1, const char *s2);
static struct usb_endpoint_descriptor fs_ep_in = {
printf("Writing '%s' DONE!\n", ptn->name);
fastboot_okay("");
}
+ if (strncmp(ptn->name, "gpt", 3) == 0) {
+ /* will force scan the device,
+ so dev_desc can be re-inited
+ with the latest data */
+ run_command(mmc_dev, 0);
+ }
}
}
} else {
#endif
+#if defined(CONFIG_FASTBOOT_STORAGE_MMC)
+static void process_erase_mmc(const char *cmdbuf, char *response)
+{
+ int mmc_no = 0;
+ lbaint_t blks, blks_start, blks_size, grp_size;
+ struct mmc *mmc;
+ struct blk_desc *dev_desc;
+ struct fastboot_ptentry *ptn;
+ disk_partition_t info;
+
+ ptn = fastboot_flash_find_ptn(cmdbuf);
+ if ((ptn == NULL) || (ptn->flags & FASTBOOT_PTENTRY_FLAGS_UNERASEABLE)) {
+ sprintf(response, "FAILpartition does not exist or uneraseable");
+ return;
+ }
+
+ mmc_no = fastboot_devinfo.dev_id;
+ printf("erase target is MMC:%d\n", mmc_no);
+
+ mmc = find_mmc_device(mmc_no);
+ if ((mmc == NULL) || mmc_init(mmc)) {
+ printf("MMC card init failed!\n");
+ return;
+ }
+
+ dev_desc = blk_get_dev("mmc", mmc_no);
+ if (NULL == dev_desc) {
+ printf("Block device MMC %d not supported\n",
+ mmc_no);
+ sprintf(response, "FAILnot valid MMC card");
+ return;
+ }
+
+ if (part_get_info(dev_desc,
+ ptn->partition_index, &info)) {
+ printf("Bad partition index:%d for partition:%s\n",
+ ptn->partition_index, ptn->name);
+ sprintf(response, "FAILerasing of MMC card");
+ 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) {
+ printf("failed erasing from device %d", dev_desc->devnum);
+ sprintf(response, "FAILerasing of MMC card");
+ return;
+ }
+
+ printf("........ erased " LBAFU " bytes from '%s'\n",
+ blks_size * info.blksz, cmdbuf);
+ sprintf(response, "OKAY");
+
+ return;
+}
+#endif
-static int rx_process_erase(const char *cmdbuf)
+#if defined(CONFIG_FASTBOOT_STORAGE_SATA)
+static void process_erase_sata(const char *cmdbuf, char *response)
{
+ return;
+}
+#endif
#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+static int process_erase_nand(const char *cmdbuf, char *response)
+{
struct fastboot_ptentry *ptn;
ptn = fastboot_flash_find_ptn(cmdbuf);
- if (ptn == 0) {
+ if (ptn == NULL || (ptn->flags & FASTBOOT_PTENTRY_FLAGS_UNERASEABLE)) {
fastboot_fail("partition does not exist");
} else {
int status, repeat, repeat_max;
fastboot_okay("");
}
}
- return 0;
-#else
- printf("Not support erase command for EMMC\n");
- return -1;
+ return;
+}
#endif
+static void rx_process_erase(const char *cmdbuf, char *response)
+{
+ switch (fastboot_devinfo.type) {
+#if defined(CONFIG_FASTBOOT_STORAGE_SATA)
+ case DEV_SATA:
+ process_erase_sata(cmdbuf, response);
+ break;
+#endif
+#if defined(CONFIG_FASTBOOT_STORAGE_MMC)
+ case DEV_MMC:
+ process_erase_mmc(cmdbuf, response);
+ break;
+#endif
+#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+ case DEV_NAND:
+ process_erase_nand(cmdbuf, response);
+ break;
+#endif
+ default:
+ printf("Not support flash command for current device %d\n",
+ fastboot_devinfo.type);
+ sprintf(response,
+ "FAILfailed to flash device");
+ break;
+ }
}
static void rx_process_flash(const char *cmdbuf)
int mmc_dos_partition_index,
int mmc_partition_index,
const char *name,
+ const char *fstype,
struct blk_desc *dev_desc,
struct fastboot_ptentry *ptable)
{
ptable[ptable_index].length = info.size;
ptable[ptable_index].partition_id = mmc_partition_index;
ptable[ptable_index].partition_index = mmc_dos_partition_index;
-#ifdef CONFIG_EFI_PARTITION
strcpy(ptable[ptable_index].name, (const char *)info.name);
-#else
- strcpy(ptable[ptable_index].name, name);
-#endif
+ strcpy(ptable[ptable_index].fstype, (const char *)info.type);
#ifdef CONFIG_PARTITION_UUIDS
strcpy(ptable[ptable_index].uuid, (const char *)info.uuid);
ptable[PTN_GPT_INDEX].start = ANDROID_GPT_OFFSET / dev_desc->blksz;
ptable[PTN_GPT_INDEX].length = ANDROID_GPT_SIZE / dev_desc->blksz;
ptable[PTN_GPT_INDEX].partition_id = user_partition;
+ ptable[PTN_GPT_INDEX].flags = FASTBOOT_PTENTRY_FLAGS_UNERASEABLE;
/* Bootloader */
strcpy(ptable[PTN_BOOTLOADER_INDEX].name, FASTBOOT_PARTITION_BOOTLOADER);
ptable[PTN_BOOTLOADER_INDEX].start =
ptable[PTN_BOOTLOADER_INDEX].length =
ANDROID_BOOTLOADER_SIZE / dev_desc->blksz;
ptable[PTN_BOOTLOADER_INDEX].partition_id = boot_partition;
+ ptable[PTN_BOOTLOADER_INDEX].flags = FASTBOOT_PTENTRY_FLAGS_UNERASEABLE;
int tbl_idx;
int part_idx = 1;
part_idx++,
user_partition,
NULL,
+ NULL,
dev_desc, ptable);
if (ret)
break;
char serial[17];
get_board_serial(&serialnr);
- sprintf(serial, "%u%u", serialnr.high, serialnr.low);
+ sprintf(serial, "%08x%08x", serialnr.high, serialnr.low);
g_dnl_set_serialnumber(serial);
/*execute board relevant initilizations for preparing fastboot */
return boot_mode;
}
+#ifdef CONFIG_SYSTEM_RAMDISK_SUPPORT
+/* Setup booargs for taking the system parition as ramdisk */
+static void fastboot_setup_system_boot_args(const char *slot)
+{
+ const char *system_part_name = NULL;
+ if(slot == NULL)
+ return;
+ if(!strncmp(slot, "_a", strlen("_a")) || !strncmp(slot, "boot_a", strlen("boot_a"))) {
+ system_part_name = FASTBOOT_PARTITION_SYSTEM_A;
+ }
+ else if(!strncmp(slot, "_b", strlen("_b")) || !strncmp(slot, "boot_b", strlen("boot_b"))) {
+ system_part_name = FASTBOOT_PARTITION_SYSTEM_B;
+ }
+ struct fastboot_ptentry *ptentry = fastboot_flash_find_ptn(system_part_name);
+ if(ptentry != NULL) {
+ char bootargs_3rd[ANDR_BOOT_ARGS_SIZE];
+#if defined(CONFIG_FASTBOOT_STORAGE_MMC)
+ u32 dev_no = mmc_map_to_kernel_blk(mmc_get_env_dev());
+ sprintf(bootargs_3rd, "skip_initramfs root=/dev/mmcblk%dp%d",
+ dev_no,
+ ptentry->partition_index);
+ setenv("bootargs_3rd", bootargs_3rd);
+#endif
+ //TBD to support NAND ubifs system parition boot directly
+ }
+}
+#endif
/* export to lib_arm/board.c */
void fastboot_run_bootmode(void)
{
printf("no valid slot found, enter to recovery\n");
ptn = "recovery";
}
+#ifdef CONFIG_SYSTEM_RAMDISK_SUPPORT
+ else {
+ fastboot_setup_system_boot_args(ptn);
+ }
+#endif
use_given_ptn:
printf("use slot %s\n", ptn);
}
return false;
}
+static char *get_serial(void)
+{
+#ifdef CONFIG_SERIAL_TAG
+ struct tag_serialnr serialnr;
+ static char serial[32];
+ get_board_serial(&serialnr);
+ sprintf(serial, "%08x%08x", serialnr.high, serialnr.low);
+ return serial;
+#else
+ return NULL;
+#endif
+}
+
+#if !defined(PRODUCT_NAME)
+#define PRODUCT_NAME "NXP i.MX"
+#endif
+
+#if !defined(VARIANT_NAME)
+#define VARIANT_NAME "NXP i.MX"
+#endif
+
+static int get_block_size(void) {
+ int mmc_no = 0;
+ struct blk_desc *dev_desc;
+ mmc_no = fastboot_devinfo.dev_id;
+ dev_desc = blk_get_dev("mmc", mmc_no);
+ if (NULL == dev_desc) {
+ printf("** Block device MMC %d not supported\n",
+ mmc_no);
+ return 0;
+ }
+ return dev_desc->blksz;
+}
+
static void cb_getvar(struct usb_ep *ep, struct usb_request *req)
{
char *cmd = req->buf;
strncat(response, FASTBOOT_VAR_NO, chars_left);
#endif
}
- if (!strcmp_l1("version", cmd)) {
- strncat(response, FASTBOOT_VERSION, chars_left);
- } else if (!strcmp_l1("bootloader-version", cmd)) {
+
+ char *str = cmd;
+ if ((str = strstr(cmd, "partition-size:"))) {
+ str +=strlen("partition-size:");
+ struct fastboot_ptentry* fb_part;
+ fb_part = fastboot_flash_find_ptn(str);
+ if (!fb_part) {
+ strncat(response, "Wrong partition name.", chars_left);
+ goto fail;
+ } else {
+ char str_num[20];
+ sprintf(str_num, "0x%016x", fb_part->length * get_block_size());
+ strncat(response, str_num, chars_left);
+ }
+ } else if ((str = strstr(cmd, "partition-type:"))) {
+ str +=strlen("partition-type:");
+ struct fastboot_ptentry* fb_part;
+ fb_part = fastboot_flash_find_ptn(str);
+ if (!fb_part) {
+ strncat(response, "Wrong partition name.", chars_left);
+ goto fail;
+ } else {
+ strncat(response, fb_part->fstype, chars_left);
+ }
+ } else if (!strcmp_l1("all", cmd)) {
+ /* FIXME need to return all vars here */
+ } else if (!strcmp_l1("version-baseband", cmd)) {
+ strncat(response, "N/A", chars_left);
+ } else if (!strcmp_l1("version-bootloader", cmd) ||
+ !strcmp_l1("bootloader-version", cmd)) {
strncat(response, U_BOOT_VERSION, chars_left);
+ } else if (!strcmp_l1("version", cmd)) {
+ strncat(response, FASTBOOT_VERSION, chars_left);
+ } else if (!strcmp_l1("battery-voltage", cmd)) {
+ strncat(response, "0mV", chars_left);
+ } else if (!strcmp_l1("battery-soc-ok", cmd)) {
+ strncat(response, "yes", chars_left);
+ } else if (!strcmp_l1("variant", cmd)) {
+ strncat(response, VARIANT_NAME, chars_left);
+ } else if (!strcmp_l1("off-mode-charge", cmd)) {
+ strncat(response, "1", chars_left);
} else if (!strcmp_l1("downloadsize", cmd) ||
!strcmp_l1("max-download-size", cmd)) {
char str_num[12];
sprintf(str_num, "0x%08x", CONFIG_FASTBOOT_BUF_SIZE);
strncat(response, str_num, chars_left);
} else if (!strcmp_l1("serialno", cmd)) {
- s = getenv("serial#");
+ s = get_serial();
if (s)
strncat(response, s, chars_left);
- else
- strcpy(response, "FAILValue not set");
+ else {
+ strncat(response, "FAILValue not set", chars_left);
+ goto fail;
+ }
} else if (!strcmp_l1("product", cmd)) {
- strncat(response, "Freescale i.MX", chars_left);
+ strncat(response, PRODUCT_NAME, chars_left);
}
#ifdef CONFIG_FASTBOOT_LOCK
else if (!strcmp_l1("secure", cmd)) {
#endif
+static int partition_table_valid(void)
+{
+ int status, mmc_no;
+ struct blk_desc *dev_desc;
+ disk_partition_t info;
+ mmc_no = fastboot_devinfo.dev_id;
+ dev_desc = blk_get_dev("mmc", mmc_no);
+ status = part_get_info(dev_desc, 1, &info);
+ return (status == 0);
+}
+
#ifdef CONFIG_FASTBOOT_FLASH
static void cb_flash(struct usb_ep *ep, struct usb_request *req)
{
fastboot_fail("no flash device defined");
#ifdef CONFIG_FSL_FASTBOOT
+#ifdef CONFIG_FASTBOOT_LOCK
+ int gpt_valid_pre = 0;
+ int gpt_valid_pst = 0;
+ if (strncmp(cmd, "gpt", 3) == 0)
+ gpt_valid_pre = partition_table_valid();
+#endif
rx_process_flash(cmd);
-#else
-#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
- fb_mmc_flash_write(cmd, (void *)CONFIG_FASTBOOT_BUF_ADDR,
- download_bytes);
+#ifdef CONFIG_FASTBOOT_LOCK
+ if (strncmp(cmd, "gpt", 3) == 0) {
+ gpt_valid_pst = partition_table_valid();
+ /* If gpt is valid, load partitons table into memory.
+ So if the next command is "fastboot reboot bootloader",
+ it can find the "misc" partition to r/w. */
+ if(gpt_valid_pst)
+ _fastboot_load_partitions();
+ /* If gpt invalid -> valid, write unlock status, also wipe data. */
+ if ((gpt_valid_pre == 0) && (gpt_valid_pst == 1))
+ do_fastboot_unlock(true);
+ }
+
#endif
#ifdef CONFIG_FASTBOOT_FLASH_NAND_DEV
fb_nand_flash_write(cmd,
/* initialize the response buffer */
fb_response_str = response;
- fastboot_fail("no flash device defined");
-#ifdef CONFIG_FSL_FASTBOOT
- rx_process_erase(cmd);
-#else
-#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
- fb_mmc_erase(cmd);
-#endif
-#ifdef CONFIG_FASTBOOT_FLASH_NAND_DEV
- fb_nand_erase(cmd);
-#endif
+#ifdef CONFIG_FASTBOOT_LOCK
+ FbLockState status;
+ status = fastboot_get_lock_stat();
+ if (status == FASTBOOT_LOCK) {
+ error("device is LOCKed!\n");
+ strcpy(response, "FAIL device is locked.");
+ fastboot_tx_write_str(response);
+ return;
+ } else if (status == FASTBOOT_LOCK_ERROR) {
+ error("write lock status into device!\n");
+ fastboot_set_lock_stat(FASTBOOT_LOCK);
+ strcpy(response, "FAIL device is locked.");
+ fastboot_tx_write_str(response);
+ return;
+ }
#endif
+ rx_process_erase(cmd, response);
fastboot_tx_write_str(response);
}
#endif
projects / u-boot.git / commitdiff