/*
|
* Copyright (C) 2010 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.
|
*/
|
|
/**
|
* RecoverySystem contains methods for interacting with the Android
|
* recovery system (the separate partition that can be used to install
|
* system updates, wipe user data, etc.)
|
*/
|
|
//#include <direct.h>
|
#include <linux/reboot.h>
|
//#include <io.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <sys/reboot.h>
|
#include <sys/stat.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
|
#include "update_recv/update_recv.h"
|
|
#define LOG_FILE_LEN 512
|
|
#if 0
|
#define RECOVERY_PATH "/tmp/recovery"
|
#define LOG_FILE_PATH "/tmp/recovery/log"
|
#define COMMAND_FILE_PATH "/tmp/recovery/command"
|
#else
|
#define RECOVERY_PATH "/userdata/recovery"
|
#define LOG_FILE_PATH "/userdata/recovery/log"
|
#define COMMAND_FILE_PATH "/userdata/recovery/command"
|
#endif
|
|
#define SD_UPDATE_FILE "/sdcard/update.img"
|
#define DATA_UPDATE_FILE "/userdata/update.img"
|
#define MISC_FILE_PATH "/dev/block/by-name/misc"
|
#define MISC_MSG_OFFSET 16 * 1024
|
|
/* Bootloader Message (2-KiB)
|
*
|
* This structure describes the content of a block in flash
|
* that is used for recovery and the bootloader to talk to
|
* each other.
|
*
|
* The command field is updated by linux when it wants to
|
* reboot into recovery or to update radio or bootloader firmware.
|
* It is also updated by the bootloader when firmware update
|
* is complete (to boot into recovery for any final cleanup)
|
*
|
* The status field is written by the bootloader after the
|
* completion of an "update-radio" or "update-hboot" command.
|
*
|
* The recovery field is only written by linux and used
|
* for the system to send a message to recovery or the
|
* other way around.
|
*
|
* The stage field is written by packages which restart themselves
|
* multiple times, so that the UI can reflect which invocation of the
|
* package it is. If the value is of the format "#/#" (eg, "1/3"),
|
* the UI will add a simple indicator of that status.
|
*
|
* We used to have slot_suffix field for A/B boot control metadata in
|
* this struct, which gets unintentionally cleared by recovery or
|
* uncrypt. Move it into struct bootloader_message_ab to avoid the
|
* issue.
|
*/
|
struct android_bootloader_message {
|
char command[32];
|
char status[32];
|
char recovery[768];
|
|
/* The 'recovery' field used to be 1024 bytes. It has only ever
|
* been used to store the recovery command line, so 768 bytes
|
* should be plenty. We carve off the last 256 bytes to store the
|
* stage string (for multistage packages) and possible future
|
* expansion. */
|
char stage[32];
|
|
/* The 'reserved' field used to be 224 bytes when it was initially
|
* carved off from the 1024-byte recovery field. Bump it up to
|
* 1184-byte so that the entire bootloader_message struct rounds up
|
* to 2048-byte. */
|
char reserved[1184];
|
};
|
|
|
|
/**
|
* Reboot into the recovery system with the supplied argument.
|
* @param arg to pass to the recovery utility.
|
*/
|
static void bootCommand(char *arg){
|
FILE *command_file;
|
FILE *log_file;
|
FILE *misc_file;
|
char blank[LOG_FILE_LEN];
|
|
if(!arg) return;
|
printf("command: %s\n", arg);
|
mkdir(RECOVERY_PATH,0775);
|
if((command_file = fopen(COMMAND_FILE_PATH,"wb")) == NULL){
|
printf("Open command file error.\n");
|
return;
|
}
|
|
if((log_file = fopen(LOG_FILE_PATH,"wb")) == NULL){
|
printf("Open log file error.\n");
|
return;
|
}
|
|
if((misc_file = fopen(MISC_FILE_PATH,"wb")) == NULL){
|
printf("Open misc file error.\n");
|
return;
|
}
|
|
printf("update: write command to command file: ");
|
fwrite(arg, strlen(arg), 1, command_file);
|
fwrite("\n", 1, 1, command_file);
|
fclose(command_file);
|
printf("done\n");
|
|
printf("update: write command to misc file: ");
|
fseek(misc_file, MISC_MSG_OFFSET, SEEK_SET);
|
struct android_bootloader_message msg;
|
memset(&msg, 0, sizeof(msg));
|
char recovery_str[] = "recovery\n";
|
strcpy(msg.command, "boot-recovery");
|
strcpy(msg.recovery, recovery_str);
|
memcpy(msg.recovery + strlen(recovery_str), arg, ((strlen(arg) > sizeof(msg.recovery))? sizeof(msg.recovery) : strlen(arg)));
|
msg.recovery[strlen(msg.recovery) + 1] = '\n';
|
//strlcat(msg.recovery, update_file, sizeof(msg.recovery));
|
//strlcat(msg.recovery, "\n", sizeof(msg.recovery));
|
//strlcpy(msg.systemFlag, "false", sizeof(msg.systemFlag));
|
fwrite(&msg, sizeof(msg), 1, misc_file);
|
fclose(misc_file);
|
printf("done\n");
|
|
memset(blank, 0, LOG_FILE_LEN);
|
fwrite(blank, LOG_FILE_LEN, 1, log_file);
|
fclose(log_file);
|
printf("update: reboot!\n");
|
//reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
|
// LINUX_REBOOT_CMD_RESTART2, "recovery");
|
sync();
|
reboot(RB_AUTOBOOT);
|
return;
|
}
|
|
|
/**
|
* Reboots the device in order to install the given update
|
* package.
|
* Requires the {@link android.Manifest.permission#REBOOT} permission.
|
*
|
* @param packageFile the update package to install. Must be on
|
* a partition mountable by recovery. (The set of partitions
|
* known to recovery may vary from device to device. Generally,
|
* /cache and /data are safe.)
|
*/
|
static void installPackage(char *update_file){
|
char arg[512];
|
char *str_update_package = "--update_package=";
|
int str_update_package_len = strlen(str_update_package);
|
int str_update_file_len = strlen(update_file);
|
|
memset(arg, 0, 512);
|
strcpy(arg, str_update_package);
|
strcpy(arg + str_update_package_len, update_file);
|
arg[str_update_package_len + str_update_file_len] = 0;
|
bootCommand(arg);
|
}
|
|
static void sdUpdate(){
|
installPackage(SD_UPDATE_FILE);
|
}
|
|
static void dataUpdate(){
|
installPackage(DATA_UPDATE_FILE);
|
}
|
|
/**
|
* Reboots the device and wipes the user data partition. This is
|
* sometimes called a "factory reset", which is something of a
|
* misnomer because the system partition is not restored to its
|
* factory state.
|
* Requires the {@link android.Manifest.permission#REBOOT} permission.
|
*
|
* @param context the Context to use
|
*
|
*/
|
void rebootWipeUserData(){
|
printf("update: --wipe_all\n");
|
bootCommand("--wipe_all");
|
}
|
|
int rebootUpdate(char *path){
|
|
if(path){
|
printf("find %s\n", path);
|
installPackage(path);
|
return 0;
|
}
|
|
if(access(DATA_UPDATE_FILE,F_OK) == -1){
|
printf("%s does not exist! try to use %s to update\n",
|
DATA_UPDATE_FILE, SD_UPDATE_FILE);
|
if(access(SD_UPDATE_FILE,F_OK) == -1){
|
printf("%s does not exist!\n", SD_UPDATE_FILE);
|
return -1;
|
}
|
printf("find %s\n", SD_UPDATE_FILE);
|
installPackage(SD_UPDATE_FILE);
|
return 0;
|
}
|
|
printf("find %s\n", DATA_UPDATE_FILE);
|
installPackage(DATA_UPDATE_FILE);
|
return 0;
|
}
|
|
int main(int argc, char** argv){
|
char* partition_name = "recovery";
|
printf("update: Rockchip Update Tool\n");
|
|
if(argc == 1) {
|
rebootWipeUserData();
|
} else if(argc == 2){
|
if(!strcmp(argv[1], "ota") || !strcmp(argv[1], "update"))
|
rebootUpdate(0);
|
else if(!strcmp(argv[1], "factory") || !strcmp(argv[1], "reset"))
|
rebootWipeUserData();
|
else return -1;
|
|
return 0;
|
|
} else if(argc == 3){
|
if(!strcmp(argv[1], "ota") || !strcmp(argv[1], "update")) {
|
if(argv[2]) {
|
int ret;
|
ret = WriteFwData(argv[2], partition_name);
|
if (ret < 0) {
|
if (ret == -1) {
|
printf(" Update partition %s fail \n", partition_name);
|
//means no find recovery partition in update.img
|
//return -1;
|
} else if (ret == -2) {
|
printf("Some errors happen, update process break...\n");
|
return -1;
|
}
|
} else {
|
if (!CheckFwData(argv[2], partition_name)){
|
printf(" Check partition %s fail \n", partition_name);
|
return -1;
|
}
|
}
|
return rebootUpdate(argv[2]);
|
}
|
}
|
}
|
|
return -1;
|
}
|
|
