more cwr5 work.
Change-Id: I72bb14ef25a9067ccde3e40ea989c7990512687a
diff --git a/Android.mk b/Android.mk
index 255ccd0..9155134 100644
--- a/Android.mk
+++ b/Android.mk
@@ -19,6 +19,7 @@
extendedcommands.c \
nandroid.c \
../../system/core/toolbox/reboot.c \
+ firmware.c \
edifyscripting.c \
setprop.c
@@ -36,7 +37,7 @@
RECOVERY_NAME := CWM-based Recovery
endif
-RECOVERY_VERSION := $(RECOVERY_NAME) v5.0.2.1
+RECOVERY_VERSION := $(RECOVERY_NAME) v5.0.2.2
LOCAL_CFLAGS += -DRECOVERY_VERSION="$(RECOVERY_VERSION)"
RECOVERY_API_VERSION := 2
diff --git a/bootloader.c b/bootloader.c
index d455923..d4039d8 100644
--- a/bootloader.c
+++ b/bootloader.c
@@ -179,3 +179,153 @@
}
return 0;
}
+
+/* Update Image
+ *
+ * - will be stored in the "cache" partition
+ * - bad blocks will be ignored, like boot.img and recovery.img
+ * - the first block will be the image header (described below)
+ * - the size is in BYTES, inclusive of the header
+ * - offsets are in BYTES from the start of the update header
+ * - two raw bitmaps will be included, the "busy" and "fail" bitmaps
+ * - for dream, the bitmaps will be 320x480x16bpp RGB565
+ */
+
+#define UPDATE_MAGIC "MSM-RADIO-UPDATE"
+#define UPDATE_MAGIC_SIZE 16
+#define UPDATE_VERSION 0x00010000
+
+struct update_header {
+ unsigned char MAGIC[UPDATE_MAGIC_SIZE];
+
+ unsigned version;
+ unsigned size;
+
+ unsigned image_offset;
+ unsigned image_length;
+
+ unsigned bitmap_width;
+ unsigned bitmap_height;
+ unsigned bitmap_bpp;
+
+ unsigned busy_bitmap_offset;
+ unsigned busy_bitmap_length;
+
+ unsigned fail_bitmap_offset;
+ unsigned fail_bitmap_length;
+};
+
+int write_update_for_bootloader(
+ const char *update, int update_length,
+ int bitmap_width, int bitmap_height, int bitmap_bpp,
+ const char *busy_bitmap, const char *fail_bitmap) {
+ if (ensure_path_unmounted("/cache")) {
+ LOGE("Can't unmount /cache\n");
+ return -1;
+ }
+
+ const MtdPartition *part = mtd_find_partition_by_name("cache");
+ if (part == NULL) {
+ LOGE("Can't find cache\n");
+ return -1;
+ }
+
+ MtdWriteContext *write = mtd_write_partition(part);
+ if (write == NULL) {
+ LOGE("Can't open cache\n(%s)\n", strerror(errno));
+ return -1;
+ }
+
+ /* Write an invalid (zero) header first, to disable any previous
+ * update and any other structured contents (like a filesystem),
+ * and as a placeholder for the amount of space required.
+ */
+
+ struct update_header header;
+ memset(&header, 0, sizeof(header));
+ const ssize_t header_size = sizeof(header);
+ if (mtd_write_data(write, (char*) &header, header_size) != header_size) {
+ LOGE("Can't write header to cache\n(%s)\n", strerror(errno));
+ mtd_write_close(write);
+ return -1;
+ }
+
+ /* Write each section individually block-aligned, so we can write
+ * each block independently without complicated buffering.
+ */
+
+ memcpy(&header.MAGIC, UPDATE_MAGIC, UPDATE_MAGIC_SIZE);
+ header.version = UPDATE_VERSION;
+ header.size = header_size;
+
+ off_t image_start_pos = mtd_erase_blocks(write, 0);
+ header.image_length = update_length;
+ if ((int) header.image_offset == -1 ||
+ mtd_write_data(write, update, update_length) != update_length) {
+ LOGE("Can't write update to cache\n(%s)\n", strerror(errno));
+ mtd_write_close(write);
+ return -1;
+ }
+ off_t busy_start_pos = mtd_erase_blocks(write, 0);
+ header.image_offset = mtd_find_write_start(write, image_start_pos);
+
+ header.bitmap_width = bitmap_width;
+ header.bitmap_height = bitmap_height;
+ header.bitmap_bpp = bitmap_bpp;
+
+ int bitmap_length = (bitmap_bpp + 7) / 8 * bitmap_width * bitmap_height;
+
+ header.busy_bitmap_length = busy_bitmap != NULL ? bitmap_length : 0;
+ if ((int) header.busy_bitmap_offset == -1 ||
+ mtd_write_data(write, busy_bitmap, bitmap_length) != bitmap_length) {
+ LOGE("Can't write bitmap to cache\n(%s)\n", strerror(errno));
+ mtd_write_close(write);
+ return -1;
+ }
+ off_t fail_start_pos = mtd_erase_blocks(write, 0);
+ header.busy_bitmap_offset = mtd_find_write_start(write, busy_start_pos);
+
+ header.fail_bitmap_length = fail_bitmap != NULL ? bitmap_length : 0;
+ if ((int) header.fail_bitmap_offset == -1 ||
+ mtd_write_data(write, fail_bitmap, bitmap_length) != bitmap_length) {
+ LOGE("Can't write bitmap to cache\n(%s)\n", strerror(errno));
+ mtd_write_close(write);
+ return -1;
+ }
+ mtd_erase_blocks(write, 0);
+ header.fail_bitmap_offset = mtd_find_write_start(write, fail_start_pos);
+
+ /* Write the header last, after all the blocks it refers to, so that
+ * when the magic number is installed everything is valid.
+ */
+
+ if (mtd_write_close(write)) {
+ LOGE("Can't finish writing cache\n(%s)\n", strerror(errno));
+ return -1;
+ }
+
+ write = mtd_write_partition(part);
+ if (write == NULL) {
+ LOGE("Can't reopen cache\n(%s)\n", strerror(errno));
+ return -1;
+ }
+
+ if (mtd_write_data(write, (char*) &header, header_size) != header_size) {
+ LOGE("Can't rewrite header to cache\n(%s)\n", strerror(errno));
+ mtd_write_close(write);
+ return -1;
+ }
+
+ if (mtd_erase_blocks(write, 0) != image_start_pos) {
+ LOGE("Misalignment rewriting cache\n(%s)\n", strerror(errno));
+ mtd_write_close(write);
+ return -1;
+ }
+
+ if (mtd_write_close(write)) {
+ LOGE("Can't finish header of cache\n(%s)\n", strerror(errno));
+ return -1;
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git a/firmware.c b/firmware.c
new file mode 100644
index 0000000..4e5c24f
--- /dev/null
+++ b/firmware.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bootloader.h"
+#include "common.h"
+#include "firmware.h"
+#include "roots.h"
+
+#include <errno.h>
+#include <string.h>
+#include <sys/reboot.h>
+
+static const char *update_type = NULL;
+static const char *update_data = NULL;
+static int update_length = 0;
+
+int remember_firmware_update(const char *type, const char *data, int length) {
+ if (update_type != NULL || update_data != NULL) {
+ LOGE("Multiple firmware images\n");
+ return -1;
+ }
+
+ update_type = type;
+ update_data = data;
+ update_length = length;
+ return 0;
+}
+
+// Return true if there is a firmware update pending.
+int firmware_update_pending() {
+ return update_data != NULL && update_length > 0;
+}
+
+/* Bootloader / Recovery Flow
+ *
+ * On every boot, the bootloader will read the bootloader_message
+ * from flash and check the command field. The bootloader should
+ * deal with the command field not having a 0 terminator correctly
+ * (so as to not crash if the block is invalid or corrupt).
+ *
+ * The bootloader will have to publish the partition that contains
+ * the bootloader_message to the linux kernel so it can update it.
+ *
+ * if command == "boot-recovery" -> boot recovery.img
+ * else if command == "update-radio" -> update radio image (below)
+ * else if command == "update-hboot" -> update hboot image (below)
+ * else -> boot boot.img (normal boot)
+ *
+ * Radio/Hboot Update Flow
+ * 1. the bootloader will attempt to load and validate the header
+ * 2. if the header is invalid, status="invalid-update", goto #8
+ * 3. display the busy image on-screen
+ * 4. if the update image is invalid, status="invalid-radio-image", goto #8
+ * 5. attempt to update the firmware (depending on the command)
+ * 6. if successful, status="okay", goto #8
+ * 7. if failed, and the old image can still boot, status="failed-update"
+ * 8. write the bootloader_message, leaving the recovery field
+ * unchanged, updating status, and setting command to
+ * "boot-recovery"
+ * 9. reboot
+ *
+ * The bootloader will not modify or erase the cache partition.
+ * It is recovery's responsibility to clean up the mess afterwards.
+ */
+
+int maybe_install_firmware_update(const char *send_intent) {
+ if (update_data == NULL || update_length == 0) return 0;
+
+ /* We destroy the cache partition to pass the update image to the
+ * bootloader, so all we can really do afterwards is wipe cache and reboot.
+ * Set up this instruction now, in case we're interrupted while writing.
+ */
+
+ struct bootloader_message boot;
+ memset(&boot, 0, sizeof(boot));
+ strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
+ strlcpy(boot.recovery, "recovery\n--wipe_cache\n", sizeof(boot.command));
+ if (send_intent != NULL) {
+ strlcat(boot.recovery, "--send_intent=", sizeof(boot.recovery));
+ strlcat(boot.recovery, send_intent, sizeof(boot.recovery));
+ strlcat(boot.recovery, "\n", sizeof(boot.recovery));
+ }
+ if (set_bootloader_message(&boot)) return -1;
+
+ int width = 0, height = 0, bpp = 0;
+ char *busy_image = ui_copy_image(
+ BACKGROUND_ICON_FIRMWARE_INSTALLING, &width, &height, &bpp);
+ char *fail_image = ui_copy_image(
+ BACKGROUND_ICON_FIRMWARE_ERROR, &width, &height, &bpp);
+
+ ui_print("Writing %s image...\n", update_type);
+ if (write_update_for_bootloader(
+ update_data, update_length,
+ width, height, bpp, busy_image, fail_image)) {
+ LOGE("Can't write %s image\n(%s)\n", update_type, strerror(errno));
+ format_volume("/cache"); // Attempt to clean cache up, at least.
+ return -1;
+ }
+
+ free(busy_image);
+ free(fail_image);
+
+ /* The update image is fully written, so now we can instruct the bootloader
+ * to install it. (After doing so, it will come back here, and we will
+ * wipe the cache and reboot into the system.)
+ */
+ snprintf(boot.command, sizeof(boot.command), "update-%s", update_type);
+ if (set_bootloader_message(&boot)) {
+ format_volume("/cache");
+ return -1;
+ }
+
+ reboot(RB_AUTOBOOT);
+
+ // Can't reboot? WTF?
+ LOGE("Can't reboot\n");
+ return -1;
+}
diff --git a/install.c b/install.c
index 0b35ee7..cae283c 100644
--- a/install.c
+++ b/install.c
@@ -92,6 +92,12 @@
fclose(f);
}
+ if (remember_firmware_update(type, data, data_size)) {
+ LOGE("Can't store %s image\n", type);
+ free(data);
+ return INSTALL_ERROR;
+ }
+
free(filename);
return INSTALL_SUCCESS;
diff --git a/recovery.c b/recovery.c
index d0dee32..7e4ed09 100644
--- a/recovery.c
+++ b/recovery.c
@@ -955,6 +955,9 @@
prompt_and_wait();
}
+ // If there is a radio image pending, reboot now to install it.
+ maybe_install_firmware_update(send_intent);
+
// Otherwise, get ready to boot the main system...
finish_recovery(send_intent);
if(!poweroff)
diff --git a/res/images/icon_firmware_error.png b/res/images/icon_firmware_error.png
new file mode 100644
index 0000000..0c32c9e
--- /dev/null
+++ b/res/images/icon_firmware_error.png
Binary files differ
diff --git a/res/images/icon_firmware_install.png b/res/images/icon_firmware_install.png
new file mode 100755
index 0000000..2da9e5f
--- /dev/null
+++ b/res/images/icon_firmware_install.png
Binary files differ
diff --git a/ui.c b/ui.c
index 2b9fb07..6c747c1 100644
--- a/ui.c
+++ b/ui.c
@@ -66,6 +66,8 @@
{ &gBackgroundIcon[BACKGROUND_ICON_INSTALLING], "icon_installing" },
{ &gBackgroundIcon[BACKGROUND_ICON_ERROR], "icon_error" },
{ &gBackgroundIcon[BACKGROUND_ICON_CLOCKWORK], "icon_clockwork" },
+ { &gBackgroundIcon[BACKGROUND_ICON_FIRMWARE_INSTALLING], "icon_firmware_install" },
+ { &gBackgroundIcon[BACKGROUND_ICON_FIRMWARE_ERROR], "icon_firmware_error" },
{ &gProgressBarIndeterminate[0], "indeterminate1" },
{ &gProgressBarIndeterminate[1], "indeterminate2" },
{ &gProgressBarIndeterminate[2], "indeterminate3" },
