2401 lines
59 KiB
C
2401 lines
59 KiB
C
/*
|
|
* (C) Copyright 2008 - 2009
|
|
* Windriver, <www.windriver.com>
|
|
* Tom Rix <Tom.Rix@windriver.com>
|
|
*
|
|
* Copyright 2011 Sebastian Andrzej Siewior <bigeasy@linutronix.de>
|
|
*
|
|
* Copyright 2014 Linaro, Ltd.
|
|
* Rob Herring <robh@kernel.org>
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
*/
|
|
#include <config.h>
|
|
#include <common.h>
|
|
#include <console.h>
|
|
#include <android_bootloader.h>
|
|
#include <errno.h>
|
|
#include <fastboot.h>
|
|
#include <malloc.h>
|
|
#include <linux/usb/ch9.h>
|
|
#include <linux/usb/gadget.h>
|
|
#include <linux/usb/composite.h>
|
|
#include <linux/compiler.h>
|
|
#include <u-boot/sha256.h>
|
|
#include <version.h>
|
|
#include <g_dnl.h>
|
|
#include <fs.h>
|
|
#include <android_avb/avb_ops_user.h>
|
|
#include <android_avb/rk_avb_ops_user.h>
|
|
#include <dm/uclass.h>
|
|
#include <power/fuel_gauge.h>
|
|
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
|
|
#include <fb_mmc.h>
|
|
#endif
|
|
#ifdef CONFIG_FASTBOOT_FLASH_NAND_DEV
|
|
#include <fb_nand.h>
|
|
#endif
|
|
#ifdef CONFIG_OPTEE_CLIENT
|
|
#include <optee_include/OpteeClientInterface.h>
|
|
#endif
|
|
#include <boot_rkimg.h>
|
|
#include <optee_include/tee_client_api.h>
|
|
#ifdef CONFIG_FASTBOOT_OEM_UNLOCK
|
|
#include <keymaster.h>
|
|
#endif
|
|
#ifdef CONFIG_ANDROID_AB
|
|
#include <android_ab.h>
|
|
#endif
|
|
|
|
#define FASTBOOT_VERSION "0.4"
|
|
|
|
#define FASTBOOT_INTERFACE_CLASS 0xff
|
|
#define FASTBOOT_INTERFACE_SUB_CLASS 0x42
|
|
#define FASTBOOT_INTERFACE_PROTOCOL 0x03
|
|
|
|
#define RX_ENDPOINT_MAXIMUM_PACKET_SIZE_2_0 (0x0200)
|
|
#define RX_ENDPOINT_MAXIMUM_PACKET_SIZE_1_1 (0x0040)
|
|
#define TX_ENDPOINT_MAXIMUM_PACKET_SIZE (0x0040)
|
|
|
|
#define EP_BUFFER_SIZE 4096
|
|
#define SLEEP_COUNT 20000
|
|
#define MAX_PART_NUM_STR_SIZE 4
|
|
#define PARTITION_TYPE_STRINGS "partition-type"
|
|
|
|
/*
|
|
* EP_BUFFER_SIZE must always be an integral multiple of maxpacket size
|
|
* (64 or 512 or 1024), else we break on certain controllers like DWC3
|
|
* that expect bulk OUT requests to be divisible by maxpacket size.
|
|
*/
|
|
|
|
struct f_fastboot {
|
|
struct usb_function usb_function;
|
|
|
|
/* IN/OUT EP's and corresponding requests */
|
|
struct usb_ep *in_ep, *out_ep;
|
|
struct usb_request *in_req, *out_req;
|
|
};
|
|
|
|
static inline struct f_fastboot *func_to_fastboot(struct usb_function *f)
|
|
{
|
|
return container_of(f, struct f_fastboot, usb_function);
|
|
}
|
|
|
|
static struct f_fastboot *fastboot_func;
|
|
static unsigned int download_size;
|
|
static unsigned int download_bytes;
|
|
static unsigned int upload_size;
|
|
static unsigned int upload_bytes;
|
|
static bool start_upload;
|
|
static unsigned intthread_wakeup_needed;
|
|
|
|
static struct usb_endpoint_descriptor fs_ep_in = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(64),
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor fs_ep_out = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(64),
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor hs_ep_in = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(512),
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor hs_ep_out = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(512),
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor ss_ep_in = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(1024),
|
|
};
|
|
|
|
static struct usb_ss_ep_comp_descriptor ss_ep_in_comp_desc = {
|
|
.bLength = sizeof(ss_ep_in_comp_desc),
|
|
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
|
|
/* .bMaxBurst = DYNAMIC, */
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor ss_ep_out = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(1024),
|
|
};
|
|
|
|
static struct usb_ss_ep_comp_descriptor ss_ep_out_comp_desc = {
|
|
.bLength = sizeof(ss_ep_out_comp_desc),
|
|
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
|
|
/* .bMaxBurst = DYNAMIC, */
|
|
};
|
|
|
|
static struct usb_interface_descriptor interface_desc = {
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 0x00,
|
|
.bAlternateSetting = 0x00,
|
|
.bNumEndpoints = 0x02,
|
|
.bInterfaceClass = FASTBOOT_INTERFACE_CLASS,
|
|
.bInterfaceSubClass = FASTBOOT_INTERFACE_SUB_CLASS,
|
|
.bInterfaceProtocol = FASTBOOT_INTERFACE_PROTOCOL,
|
|
};
|
|
|
|
static struct usb_descriptor_header *fb_fs_function[] = {
|
|
(struct usb_descriptor_header *)&interface_desc,
|
|
(struct usb_descriptor_header *)&fs_ep_in,
|
|
(struct usb_descriptor_header *)&fs_ep_out,
|
|
};
|
|
|
|
static struct usb_descriptor_header *fb_hs_function[] = {
|
|
(struct usb_descriptor_header *)&interface_desc,
|
|
(struct usb_descriptor_header *)&hs_ep_in,
|
|
(struct usb_descriptor_header *)&hs_ep_out,
|
|
NULL,
|
|
};
|
|
|
|
static struct usb_descriptor_header *fb_ss_function[] = {
|
|
(struct usb_descriptor_header *)&interface_desc,
|
|
(struct usb_descriptor_header *)&ss_ep_in,
|
|
(struct usb_descriptor_header *)&ss_ep_in_comp_desc,
|
|
(struct usb_descriptor_header *)&ss_ep_out,
|
|
(struct usb_descriptor_header *)&ss_ep_out_comp_desc,
|
|
NULL,
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor *
|
|
fb_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *fs,
|
|
struct usb_endpoint_descriptor *hs,
|
|
struct usb_endpoint_descriptor *ss,
|
|
struct usb_ss_ep_comp_descriptor *comp_desc,
|
|
struct usb_ep *ep)
|
|
{
|
|
struct usb_endpoint_descriptor *speed_desc = NULL;
|
|
|
|
/* select desired speed */
|
|
switch (g->speed) {
|
|
case USB_SPEED_SUPER:
|
|
if (gadget_is_superspeed(g)) {
|
|
speed_desc = ss;
|
|
ep->comp_desc = comp_desc;
|
|
break;
|
|
}
|
|
/* else: Fall trough */
|
|
case USB_SPEED_HIGH:
|
|
if (gadget_is_dualspeed(g)) {
|
|
speed_desc = hs;
|
|
break;
|
|
}
|
|
/* else: fall through */
|
|
default:
|
|
speed_desc = fs;
|
|
}
|
|
|
|
return speed_desc;
|
|
}
|
|
|
|
/*
|
|
* static strings, in UTF-8
|
|
*/
|
|
static const char fastboot_name[] = "Android Fastboot";
|
|
|
|
static struct usb_string fastboot_string_defs[] = {
|
|
[0].s = fastboot_name,
|
|
{ } /* end of list */
|
|
};
|
|
|
|
static struct usb_gadget_strings stringtab_fastboot = {
|
|
.language = 0x0409, /* en-us */
|
|
.strings = fastboot_string_defs,
|
|
};
|
|
|
|
static struct usb_gadget_strings *fastboot_strings[] = {
|
|
&stringtab_fastboot,
|
|
NULL,
|
|
};
|
|
|
|
static void rx_handler_command(struct usb_ep *ep, struct usb_request *req);
|
|
static int strcmp_l1(const char *s1, const char *s2);
|
|
static void wakeup_thread(void)
|
|
{
|
|
intthread_wakeup_needed = false;
|
|
}
|
|
|
|
static void busy_indicator(void)
|
|
{
|
|
static int state;
|
|
|
|
switch (state) {
|
|
case 0:
|
|
puts("\r|"); break;
|
|
case 1:
|
|
puts("\r/"); break;
|
|
case 2:
|
|
puts("\r-"); break;
|
|
case 3:
|
|
puts("\r\\"); break;
|
|
case 4:
|
|
puts("\r|"); break;
|
|
case 5:
|
|
puts("\r/"); break;
|
|
case 6:
|
|
puts("\r-"); break;
|
|
case 7:
|
|
puts("\r\\"); break;
|
|
default:
|
|
state = 0;
|
|
}
|
|
if (state++ == 8)
|
|
state = 0;
|
|
}
|
|
|
|
static int fb_get_fstype(const char *ifname, const int part_num,
|
|
const char **fs_type)
|
|
{
|
|
char part_num_str[MAX_PART_NUM_STR_SIZE] = {0};
|
|
|
|
snprintf(part_num_str, ARRAY_SIZE(part_num_str), ":%x", part_num);
|
|
|
|
if (fs_set_blk_dev(ifname, part_num_str, FS_TYPE_ANY))
|
|
return -1;
|
|
|
|
if (fs_get_fstype(fs_type))
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sleep_thread(void)
|
|
{
|
|
int rc = 0;
|
|
int i = 0, k = 0;
|
|
|
|
/* Wait until a signal arrives or we are woken up */
|
|
for (;;) {
|
|
if (!intthread_wakeup_needed)
|
|
break;
|
|
|
|
if (++i == SLEEP_COUNT) {
|
|
busy_indicator();
|
|
i = 0;
|
|
k++;
|
|
}
|
|
|
|
if (k == 10) {
|
|
/* Handle CTRL+C */
|
|
if (ctrlc())
|
|
return -EPIPE;
|
|
|
|
/* Check cable connection */
|
|
if (!g_dnl_board_usb_cable_connected())
|
|
return -EIO;
|
|
|
|
k = 0;
|
|
}
|
|
|
|
usb_gadget_handle_interrupts(0);
|
|
}
|
|
intthread_wakeup_needed = true;
|
|
return rc;
|
|
}
|
|
|
|
static void fastboot_complete(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
int status = req->status;
|
|
|
|
wakeup_thread();
|
|
if (!status)
|
|
return;
|
|
printf("status: %d ep '%s' trans: %d\n", status, ep->name, req->actual);
|
|
}
|
|
|
|
static int fastboot_bind(struct usb_configuration *c, struct usb_function *f)
|
|
{
|
|
int id;
|
|
struct usb_gadget *gadget = c->cdev->gadget;
|
|
struct f_fastboot *f_fb = func_to_fastboot(f);
|
|
const char *s;
|
|
|
|
/* DYNAMIC interface numbers assignments */
|
|
id = usb_interface_id(c, f);
|
|
if (id < 0)
|
|
return id;
|
|
interface_desc.bInterfaceNumber = id;
|
|
|
|
id = usb_string_id(c->cdev);
|
|
if (id < 0)
|
|
return id;
|
|
fastboot_string_defs[0].id = id;
|
|
interface_desc.iInterface = id;
|
|
|
|
f_fb->in_ep = usb_ep_autoconfig(gadget, &fs_ep_in);
|
|
if (!f_fb->in_ep)
|
|
return -ENODEV;
|
|
f_fb->in_ep->driver_data = c->cdev;
|
|
|
|
f_fb->out_ep = usb_ep_autoconfig(gadget, &fs_ep_out);
|
|
if (!f_fb->out_ep)
|
|
return -ENODEV;
|
|
f_fb->out_ep->driver_data = c->cdev;
|
|
|
|
f->descriptors = fb_fs_function;
|
|
|
|
if (gadget_is_dualspeed(gadget)) {
|
|
/* Assume endpoint addresses are the same for both speeds */
|
|
hs_ep_in.bEndpointAddress = fs_ep_in.bEndpointAddress;
|
|
hs_ep_out.bEndpointAddress = fs_ep_out.bEndpointAddress;
|
|
/* copy HS descriptors */
|
|
f->hs_descriptors = fb_hs_function;
|
|
}
|
|
|
|
if (gadget_is_superspeed(gadget)) {
|
|
/* Assume endpoint addresses are the same as full speed */
|
|
ss_ep_in.bEndpointAddress = fs_ep_in.bEndpointAddress;
|
|
ss_ep_out.bEndpointAddress = fs_ep_out.bEndpointAddress;
|
|
/* copy SS descriptors */
|
|
f->ss_descriptors = fb_ss_function;
|
|
}
|
|
|
|
s = env_get("serial#");
|
|
if (s)
|
|
g_dnl_set_serialnumber((char *)s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void fastboot_unbind(struct usb_configuration *c, struct usb_function *f)
|
|
{
|
|
memset(fastboot_func, 0, sizeof(*fastboot_func));
|
|
}
|
|
|
|
static void fastboot_disable(struct usb_function *f)
|
|
{
|
|
struct f_fastboot *f_fb = func_to_fastboot(f);
|
|
|
|
usb_ep_disable(f_fb->out_ep);
|
|
usb_ep_disable(f_fb->in_ep);
|
|
|
|
if (f_fb->out_req) {
|
|
free(f_fb->out_req->buf);
|
|
usb_ep_free_request(f_fb->out_ep, f_fb->out_req);
|
|
f_fb->out_req = NULL;
|
|
}
|
|
if (f_fb->in_req) {
|
|
free(f_fb->in_req->buf);
|
|
usb_ep_free_request(f_fb->in_ep, f_fb->in_req);
|
|
f_fb->in_req = NULL;
|
|
}
|
|
}
|
|
|
|
static struct usb_request *fastboot_start_ep(struct usb_ep *ep)
|
|
{
|
|
struct usb_request *req;
|
|
|
|
req = usb_ep_alloc_request(ep, 0);
|
|
if (!req)
|
|
return NULL;
|
|
|
|
req->length = EP_BUFFER_SIZE;
|
|
req->buf = memalign(CONFIG_SYS_CACHELINE_SIZE, EP_BUFFER_SIZE);
|
|
if (!req->buf) {
|
|
usb_ep_free_request(ep, req);
|
|
return NULL;
|
|
}
|
|
|
|
memset(req->buf, 0, req->length);
|
|
return req;
|
|
}
|
|
|
|
static int fastboot_set_alt(struct usb_function *f,
|
|
unsigned interface, unsigned alt)
|
|
{
|
|
int ret;
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
struct usb_gadget *gadget = cdev->gadget;
|
|
struct f_fastboot *f_fb = func_to_fastboot(f);
|
|
const struct usb_endpoint_descriptor *d;
|
|
|
|
debug("%s: func: %s intf: %d alt: %d\n",
|
|
__func__, f->name, interface, alt);
|
|
|
|
d = fb_ep_desc(gadget, &fs_ep_out, &hs_ep_out, &ss_ep_out,
|
|
&ss_ep_out_comp_desc, f_fb->out_ep);
|
|
ret = usb_ep_enable(f_fb->out_ep, d);
|
|
if (ret) {
|
|
puts("failed to enable out ep\n");
|
|
return ret;
|
|
}
|
|
|
|
f_fb->out_req = fastboot_start_ep(f_fb->out_ep);
|
|
if (!f_fb->out_req) {
|
|
puts("failed to alloc out req\n");
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
f_fb->out_req->complete = rx_handler_command;
|
|
|
|
d = fb_ep_desc(gadget, &fs_ep_in, &hs_ep_in, &ss_ep_in,
|
|
&ss_ep_in_comp_desc, f_fb->in_ep);
|
|
ret = usb_ep_enable(f_fb->in_ep, d);
|
|
if (ret) {
|
|
puts("failed to enable in ep\n");
|
|
goto err;
|
|
}
|
|
|
|
f_fb->in_req = fastboot_start_ep(f_fb->in_ep);
|
|
if (!f_fb->in_req) {
|
|
puts("failed alloc req in\n");
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
f_fb->in_req->complete = fastboot_complete;
|
|
|
|
ret = usb_ep_queue(f_fb->out_ep, f_fb->out_req, 0);
|
|
if (ret)
|
|
goto err;
|
|
|
|
return 0;
|
|
err:
|
|
fastboot_disable(f);
|
|
return ret;
|
|
}
|
|
|
|
static int fastboot_add(struct usb_configuration *c)
|
|
{
|
|
struct f_fastboot *f_fb = fastboot_func;
|
|
int status;
|
|
|
|
debug("%s: cdev: 0x%p\n", __func__, c->cdev);
|
|
|
|
if (!f_fb) {
|
|
f_fb = memalign(CONFIG_SYS_CACHELINE_SIZE, sizeof(*f_fb));
|
|
if (!f_fb)
|
|
return -ENOMEM;
|
|
|
|
fastboot_func = f_fb;
|
|
memset(f_fb, 0, sizeof(*f_fb));
|
|
}
|
|
|
|
f_fb->usb_function.name = "f_fastboot";
|
|
f_fb->usb_function.bind = fastboot_bind;
|
|
f_fb->usb_function.unbind = fastboot_unbind;
|
|
f_fb->usb_function.set_alt = fastboot_set_alt;
|
|
f_fb->usb_function.disable = fastboot_disable;
|
|
f_fb->usb_function.strings = fastboot_strings;
|
|
|
|
status = usb_add_function(c, &f_fb->usb_function);
|
|
if (status) {
|
|
free(f_fb);
|
|
fastboot_func = f_fb;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
DECLARE_GADGET_BIND_CALLBACK(usb_dnl_fastboot, fastboot_add);
|
|
|
|
static int fastboot_tx_write(const char *buffer, unsigned int buffer_size)
|
|
{
|
|
struct usb_request *in_req = fastboot_func->in_req;
|
|
int ret;
|
|
|
|
memcpy(in_req->buf, buffer, buffer_size);
|
|
in_req->length = buffer_size;
|
|
|
|
usb_ep_dequeue(fastboot_func->in_ep, in_req);
|
|
|
|
ret = usb_ep_queue(fastboot_func->in_ep, in_req, 0);
|
|
if (ret)
|
|
printf("Error %d on queue\n", ret);
|
|
return 0;
|
|
}
|
|
|
|
static int fastboot_tx_write_str(const char *buffer)
|
|
{
|
|
int ret;
|
|
|
|
ret = sleep_thread();
|
|
if (ret < 0)
|
|
printf("warning: 0x%x, usb transmission is abnormal!\n", ret);
|
|
|
|
return fastboot_tx_write(buffer, strlen(buffer));
|
|
}
|
|
|
|
static void compl_do_reset(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
do_reset(NULL, 0, 0, NULL);
|
|
}
|
|
|
|
int __weak fb_set_reboot_flag(void)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
static void cb_reboot(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
|
|
if (!strcmp_l1("reboot-bootloader", cmd)) {
|
|
if (fb_set_reboot_flag()) {
|
|
fastboot_tx_write_str("FAILCannot set reboot flag");
|
|
return;
|
|
}
|
|
}
|
|
#ifdef CONFIG_ANDROID_BOOTLOADER
|
|
if (!strcmp_l1("reboot-fastboot", cmd)) {
|
|
if (android_bcb_write("boot-fastboot")) {
|
|
fastboot_tx_write_str("FAILCannot set boot-fastboot");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!strcmp_l1("reboot-recovery", cmd)) {
|
|
if (android_bcb_write("boot-recovery")) {
|
|
fastboot_tx_write_str("FAILCannot set boot-recovery");
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
fastboot_func->in_req->complete = compl_do_reset;
|
|
fastboot_tx_write_str("OKAY");
|
|
}
|
|
|
|
static int strcmp_l1(const char *s1, const char *s2)
|
|
{
|
|
if (!s1 || !s2)
|
|
return -1;
|
|
return strncmp(s1, s2, strlen(s1));
|
|
}
|
|
|
|
struct name_string {
|
|
const char *str;
|
|
int expects_args;
|
|
char delim;
|
|
};
|
|
|
|
#define NAME_NO_ARGS(s) {.str = s, .expects_args = 0}
|
|
#define NAME_ARGS(s, d) {.str = s, .expects_args = 1, .delim = d}
|
|
|
|
static size_t name_check_match(const char *str, size_t len,
|
|
const struct name_string *name)
|
|
{
|
|
size_t str_len = strlen(name->str);
|
|
|
|
/* If name len is greater than input, return 0. */
|
|
if (str_len > len)
|
|
return 0;
|
|
|
|
/* If name str does not match input string, return 0. */
|
|
if (memcmp(name->str, str, str_len))
|
|
return 0;
|
|
|
|
if (name->expects_args) {
|
|
/* string should have space for delim */
|
|
if (len == str_len)
|
|
return 0;
|
|
|
|
/* Check delim match */
|
|
if (name->delim != str[str_len])
|
|
return 0;
|
|
} else {
|
|
/* Name str len should match input len */
|
|
if (str_len != len)
|
|
return 0;
|
|
}
|
|
|
|
return str_len + name->expects_args;
|
|
}
|
|
|
|
static void fb_add_string(char *dst, size_t chars_left,
|
|
const char *str, const char *args)
|
|
{
|
|
if (!str)
|
|
return;
|
|
|
|
int ret = snprintf(dst, chars_left, str, args);
|
|
|
|
if (ret < 0)
|
|
pr_err("snprintf is error!");
|
|
}
|
|
|
|
static void fb_add_number(char *dst, size_t chars_left,
|
|
const char *format, size_t num)
|
|
{
|
|
if (!format)
|
|
return;
|
|
|
|
int ret = snprintf(dst, chars_left, format, num);
|
|
|
|
if (ret > chars_left)
|
|
pr_err("snprintf is error!");
|
|
}
|
|
|
|
static int fb_read_var(char *cmd, char *response,
|
|
fb_getvar_t var, size_t chars_left)
|
|
{
|
|
const char *s;
|
|
int ret = 0;
|
|
|
|
switch (var) {
|
|
case FB_VERSION:
|
|
fb_add_string(response, chars_left, FASTBOOT_VERSION, NULL);
|
|
break;
|
|
case FB_BOOTLOADER_VERSION:
|
|
fb_add_string(response, chars_left, U_BOOT_VERSION, NULL);
|
|
break;
|
|
case FB_BASEBAND_VERSION:
|
|
fb_add_string(response, chars_left, "N/A", NULL);
|
|
break;
|
|
case FB_PRODUCT:
|
|
fb_add_string(response, chars_left, CONFIG_SYS_BOARD, NULL);
|
|
break;
|
|
case FB_SERIAL_NO:
|
|
s = env_get("serial#");
|
|
if (s)
|
|
fb_add_string(response, chars_left, s, NULL);
|
|
else
|
|
ret = -1;
|
|
break;
|
|
case FB_SECURE:
|
|
fb_add_string(response, chars_left, "yes", NULL);
|
|
break;
|
|
case FB_VARIANT:
|
|
fb_add_string(response, chars_left, "userdebug", NULL);
|
|
break;
|
|
case FB_DWNLD_SIZE:
|
|
fb_add_number(response, chars_left, "0x%08x",
|
|
CONFIG_FASTBOOT_BUF_SIZE);
|
|
break;
|
|
case FB_PART_SIZE:
|
|
case FB_PART_TYPE: {
|
|
char *part_name = cmd;
|
|
|
|
cmd = strsep(&part_name, ":");
|
|
if (!cmd || !part_name) {
|
|
fb_add_string(response, chars_left,
|
|
"argument Invalid!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
|
|
disk_partition_t part_info;
|
|
struct blk_desc *dev_desc;
|
|
int part_num = -1;
|
|
const char *fs_type = NULL;
|
|
|
|
#ifdef CONFIG_RKIMG_BOOTLOADER
|
|
dev_desc = rockchip_get_bootdev();
|
|
#else
|
|
dev_desc = NULL;
|
|
#endif
|
|
if (!dev_desc) {
|
|
fb_add_string(response, chars_left,
|
|
"block device not found", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
part_num = part_get_info_by_name(dev_desc, part_name,
|
|
&part_info);
|
|
if (part_num < 0) {
|
|
fb_add_string(response, chars_left,
|
|
"partition not found", NULL);
|
|
ret = -1;
|
|
} else if (!strncmp(PARTITION_TYPE_STRINGS, cmd,
|
|
strlen(PARTITION_TYPE_STRINGS))) {
|
|
if (fb_get_fstype("mmc", part_num, &fs_type)) {
|
|
fb_add_string(response, chars_left,
|
|
(char *)part_info.type, NULL);
|
|
} else {
|
|
fb_add_string(response, chars_left,
|
|
fs_type, NULL);
|
|
}
|
|
} else if (!strncmp("partition-size", cmd, 14)) {
|
|
u64 part_size;
|
|
|
|
part_size = (uint64_t)part_info.size;
|
|
snprintf(response, chars_left, "0x%llx",
|
|
part_size * dev_desc->blksz);
|
|
}
|
|
#else
|
|
fb_add_string(response, chars_left, "not implemented", NULL);
|
|
ret = -1;
|
|
#endif
|
|
break;
|
|
}
|
|
case FB_BLK_SIZE: {
|
|
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
|
|
struct blk_desc *dev_desc;
|
|
|
|
#ifdef CONFIG_RKIMG_BOOTLOADER
|
|
dev_desc = rockchip_get_bootdev();
|
|
#else
|
|
dev_desc = NULL;
|
|
#endif
|
|
if (!dev_desc) {
|
|
fb_add_string(response, chars_left,
|
|
"block device not found", NULL);
|
|
ret = -1;
|
|
} else {
|
|
fb_add_number(response, chars_left,
|
|
"0x%lx", dev_desc->blksz);
|
|
}
|
|
#else
|
|
fb_add_string(response, chars_left, "not implemented", NULL);
|
|
ret = -1;
|
|
#endif
|
|
break;
|
|
}
|
|
case FB_ERASE_SIZE: {
|
|
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
|
|
lbaint_t erase_grp_size;
|
|
|
|
erase_grp_size = fb_mmc_get_erase_grp_size();
|
|
if (erase_grp_size < 0) {
|
|
fb_add_string(response, chars_left,
|
|
"block device not found", NULL);
|
|
ret = -1;
|
|
} else {
|
|
fb_add_number(response, chars_left, "0x"LBAF"",
|
|
erase_grp_size);
|
|
}
|
|
#else
|
|
fb_add_string(response, chars_left, "not implemented", NULL);
|
|
ret = -1;
|
|
#endif
|
|
break;
|
|
}
|
|
case FB_UNLOCKED: {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
uint8_t flash_lock_state = 0;
|
|
|
|
if (rk_avb_read_flash_lock_state(&flash_lock_state))
|
|
fb_add_string(response, chars_left, "yes", NULL);
|
|
else
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
#else
|
|
fb_add_string(response, chars_left, "not implemented", NULL);
|
|
ret = -1;
|
|
#endif
|
|
break;
|
|
}
|
|
case FB_OFF_MODE_CHARGE: {
|
|
fb_add_string(response, chars_left, "not implemented", NULL);
|
|
break;
|
|
}
|
|
case FB_BATT_VOLTAGE: {
|
|
fb_add_string(response, chars_left, "not implemented", NULL);
|
|
break;
|
|
}
|
|
case FB_BATT_SOC_OK: {
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
break;
|
|
}
|
|
case FB_IS_USERSPACE: {
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
break;
|
|
}
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
case FB_HAS_COUNT: {
|
|
char slot_count[2];
|
|
char temp;
|
|
|
|
slot_count[1] = '\0';
|
|
if (rk_avb_read_slot_count(&temp) < 0) {
|
|
fb_add_number(response, chars_left, "%d", 0);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
slot_count[0] = temp + 0x30;
|
|
fb_add_string(response, chars_left, slot_count, NULL);
|
|
break;
|
|
}
|
|
case FB_HAS_SLOT: {
|
|
char *part_name = cmd;
|
|
int has_slot = -1;
|
|
|
|
cmd = strsep(&part_name, ":");
|
|
if (!cmd || !part_name) {
|
|
fb_add_string(response, chars_left,
|
|
"argument Invalid!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
has_slot = rk_avb_get_part_has_slot_info(part_name);
|
|
if (has_slot < 0)
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
else
|
|
fb_add_string(response, chars_left, "yes", NULL);
|
|
break;
|
|
}
|
|
case FB_CURR_SLOT: {
|
|
char slot_surrent[8] = {0};
|
|
|
|
if (!rk_avb_get_current_slot(slot_surrent)) {
|
|
fb_add_string(response, chars_left,
|
|
slot_surrent + 1, NULL);
|
|
} else {
|
|
fb_add_string(response, chars_left, "get error", NULL);
|
|
ret = -1;
|
|
}
|
|
break;
|
|
}
|
|
case FB_SLOT_SUFFIXES: {
|
|
char slot_suffixes_temp[4] = {0};
|
|
char slot_suffixes[9] = {0};
|
|
int slot_cnt = 0;
|
|
|
|
rk_avb_read_slot_suffixes(slot_suffixes_temp);
|
|
while (slot_suffixes_temp[slot_cnt] != '\0') {
|
|
slot_suffixes[slot_cnt * 2]
|
|
= slot_suffixes_temp[slot_cnt];
|
|
slot_suffixes[slot_cnt * 2 + 1] = ',';
|
|
slot_cnt++;
|
|
}
|
|
|
|
slot_suffixes[(slot_cnt - 1) * 2 + 1] = '\0';
|
|
fb_add_string(response, chars_left, slot_suffixes, NULL);
|
|
break;
|
|
}
|
|
case FB_SLOT_SUCCESSFUL:{
|
|
char *slot_name = cmd;
|
|
AvbABData ab_info;
|
|
|
|
cmd = strsep(&slot_name, ":");
|
|
if (!cmd || !slot_name) {
|
|
fb_add_string(response, chars_left,
|
|
"argument Invalid!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
if (rk_avb_get_ab_info(&ab_info) < 0) {
|
|
fb_add_string(response, chars_left,
|
|
"get ab info failed!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
if (!strcmp(slot_name, "a")) {
|
|
if (ab_info.slots[0].successful_boot)
|
|
fb_add_string(response, chars_left,
|
|
"yes", NULL);
|
|
else
|
|
fb_add_string(response, chars_left,
|
|
"no", NULL);
|
|
} else if (!strcmp(slot_name, "b")) {
|
|
if (ab_info.slots[1].successful_boot)
|
|
fb_add_string(response, chars_left,
|
|
"yes", NULL);
|
|
else
|
|
fb_add_string(response, chars_left,
|
|
"no", NULL);
|
|
} else {
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
}
|
|
break;
|
|
}
|
|
case FB_SLOT_UNBOOTABLE: {
|
|
char *slot_name = cmd;
|
|
AvbABData ab_info;
|
|
|
|
cmd = strsep(&slot_name, ":");
|
|
|
|
if (!cmd || !slot_name) {
|
|
fb_add_string(response, chars_left,
|
|
"argument Invalid!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
if (rk_avb_get_ab_info(&ab_info) < 0) {
|
|
fb_add_string(response, chars_left,
|
|
"get ab info failed!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
if (!strcmp(slot_name, "a")) {
|
|
if (!ab_info.slots[0].successful_boot &&
|
|
!ab_info.slots[0].tries_remaining &&
|
|
!ab_info.slots[0].priority)
|
|
fb_add_string(response, chars_left,
|
|
"yes", NULL);
|
|
else
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
} else if (!strcmp(slot_name, "b")) {
|
|
if (!ab_info.slots[1].successful_boot &&
|
|
!ab_info.slots[1].tries_remaining &&
|
|
!ab_info.slots[1].priority)
|
|
fb_add_string(response, chars_left,
|
|
"yes", NULL);
|
|
else
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
} else {
|
|
fb_add_string(response, chars_left, "no", NULL);
|
|
}
|
|
break;
|
|
}
|
|
case FB_SLOT_RETRY_COUNT: {
|
|
char *slot_name = cmd;
|
|
AvbABData ab_info;
|
|
|
|
cmd = strsep(&slot_name, ":");
|
|
if (!cmd || !slot_name) {
|
|
fb_add_string(response, chars_left,
|
|
"argument Invalid!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
if (rk_avb_get_ab_info(&ab_info) < 0) {
|
|
fb_add_string(response, chars_left,
|
|
"get ab info failed!", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
if (!strcmp(slot_name, "a")) {
|
|
fb_add_number(response, chars_left,
|
|
"%d", ab_info.slots[0].tries_remaining);
|
|
} else if (!strcmp(slot_name, "b")) {
|
|
fb_add_number(response, chars_left, "%d",
|
|
ab_info.slots[1].tries_remaining);
|
|
|
|
} else {
|
|
strcpy(response, "FAILno");
|
|
}
|
|
break;
|
|
}
|
|
case FB_AT_VBST: {
|
|
char vbst[VBOOT_STATE_SIZE] = {0};
|
|
char *p_vbst;
|
|
|
|
strcpy(response, "INFO");
|
|
rk_avb_get_at_vboot_state(vbst);
|
|
p_vbst = vbst;
|
|
do {
|
|
cmd = strsep(&p_vbst, "\n");
|
|
if (strlen(cmd) > 0) {
|
|
memcpy(&response[4], cmd, chars_left);
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
} while (strlen(cmd));
|
|
break;
|
|
}
|
|
case FB_SNAPSHOT_STATUS: {
|
|
#ifdef CONFIG_ANDROID_AB
|
|
struct misc_virtual_ab_message state;
|
|
|
|
memset(&state, 0x0, sizeof(state));
|
|
if (read_misc_virtual_ab_message(&state) != 0) {
|
|
printf("FB_SNAPSHOT_STATUS read_misc_virtual_ab_message failed!\n");
|
|
fb_add_string(response, chars_left, "get error", NULL);
|
|
ret = -1;
|
|
}
|
|
|
|
if (state.magic != MISC_VIRTUAL_AB_MAGIC_HEADER) {
|
|
printf("FB_SNAPSHOT_STATUS not virtual A/B metadata!\n");
|
|
fb_add_string(response, chars_left, "get error", NULL);
|
|
ret = -1;
|
|
}
|
|
|
|
if (state.merge_status == ENUM_MERGE_STATUS_MERGING) {
|
|
fb_add_string(response, chars_left, "merging", NULL);
|
|
} else if (state.merge_status == ENUM_MERGE_STATUS_SNAPSHOTTED) {
|
|
fb_add_string(response, chars_left, "snapshotted", NULL);
|
|
} else {
|
|
fb_add_string(response, chars_left, "none", NULL);
|
|
}
|
|
#else
|
|
fb_add_string(response, chars_left, "get error", NULL);
|
|
ret = -1;
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
#endif
|
|
#ifdef CONFIG_OPTEE_CLIENT
|
|
case FB_AT_DH: {
|
|
char dhbuf[ATTEST_DH_SIZE];
|
|
uint32_t dh_len = ATTEST_DH_SIZE;
|
|
uint32_t res = trusty_attest_dh((uint8_t *)dhbuf, &dh_len);
|
|
|
|
if (res) {
|
|
fb_add_string(response, chars_left, "dh not set", NULL);
|
|
ret = -1;
|
|
} else {
|
|
fb_add_string(response, chars_left, dhbuf, NULL);
|
|
}
|
|
break;
|
|
}
|
|
case FB_AT_UUID: {
|
|
char uuid[ATTEST_UUID_SIZE] = {0};
|
|
uint32_t uuid_len = ATTEST_UUID_SIZE;
|
|
uint32_t res = trusty_attest_uuid((uint8_t *)uuid, &uuid_len);
|
|
|
|
uuid[ATTEST_UUID_SIZE - 1] = 0;
|
|
if (res) {
|
|
fb_add_string(response, chars_left, "dh not set", NULL);
|
|
ret = -1;
|
|
} else {
|
|
fb_add_string(response, chars_left, uuid, NULL);
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
default: {
|
|
char *envstr;
|
|
|
|
envstr = malloc(strlen("fastboot.") + strlen(cmd) + 1);
|
|
if (!envstr) {
|
|
fb_add_string(response, chars_left,
|
|
"malloc error", NULL);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
sprintf(envstr, "fastboot.%s", cmd);
|
|
s = env_get(envstr);
|
|
if (s) {
|
|
strncat(response, s, chars_left);
|
|
} else {
|
|
printf("WARNING: unknown variable: %s\n", cmd);
|
|
fb_add_string(response, chars_left,
|
|
"not implemented", NULL);
|
|
}
|
|
|
|
free(envstr);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const struct {
|
|
/*
|
|
*any changes to this array require an update to the corresponding
|
|
*enum in fastboot.h
|
|
*/
|
|
struct name_string name;
|
|
fb_getvar_t var;
|
|
} getvar_table[] = {
|
|
{ NAME_NO_ARGS("version"), FB_VERSION},
|
|
{ NAME_NO_ARGS("version-bootloader"), FB_BOOTLOADER_VERSION},
|
|
{ NAME_NO_ARGS("version-baseband"), FB_BASEBAND_VERSION},
|
|
{ NAME_NO_ARGS("product"), FB_PRODUCT},
|
|
{ NAME_NO_ARGS("serialno"), FB_SERIAL_NO},
|
|
{ NAME_NO_ARGS("secure"), FB_SECURE},
|
|
{ NAME_NO_ARGS("max-download-size"), FB_DWNLD_SIZE},
|
|
{ NAME_NO_ARGS("logical-block-size"), FB_BLK_SIZE},
|
|
{ NAME_NO_ARGS("erase-block-size"), FB_ERASE_SIZE},
|
|
{ NAME_ARGS("partition-type", ':'), FB_PART_TYPE},
|
|
{ NAME_ARGS("partition-size", ':'), FB_PART_SIZE},
|
|
{ NAME_NO_ARGS("unlocked"), FB_UNLOCKED},
|
|
{ NAME_NO_ARGS("off-mode-charge"), FB_OFF_MODE_CHARGE},
|
|
{ NAME_NO_ARGS("battery-voltage"), FB_BATT_VOLTAGE},
|
|
{ NAME_NO_ARGS("variant"), FB_VARIANT},
|
|
{ NAME_NO_ARGS("battery-soc-ok"), FB_BATT_SOC_OK},
|
|
{ NAME_NO_ARGS("is-userspace"), FB_IS_USERSPACE},
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
/* Slots related */
|
|
{ NAME_NO_ARGS("slot-count"), FB_HAS_COUNT},
|
|
{ NAME_ARGS("has-slot", ':'), FB_HAS_SLOT},
|
|
{ NAME_NO_ARGS("current-slot"), FB_CURR_SLOT},
|
|
{ NAME_NO_ARGS("slot-suffixes"), FB_SLOT_SUFFIXES},
|
|
{ NAME_ARGS("slot-successful", ':'), FB_SLOT_SUCCESSFUL},
|
|
{ NAME_ARGS("slot-unbootable", ':'), FB_SLOT_UNBOOTABLE},
|
|
{ NAME_ARGS("slot-retry-count", ':'), FB_SLOT_RETRY_COUNT},
|
|
{ NAME_NO_ARGS("at-vboot-state"), FB_AT_VBST},
|
|
{ NAME_NO_ARGS("snapshot-update-status"), FB_SNAPSHOT_STATUS},
|
|
#endif
|
|
/*
|
|
* OEM specific :
|
|
* Spec says names starting with lowercase letter are reserved.
|
|
*/
|
|
#ifdef CONFIG_OPTEE_CLIENT
|
|
{ NAME_NO_ARGS("at-attest-dh"), FB_AT_DH},
|
|
{ NAME_NO_ARGS("at-attest-uuid"), FB_AT_UUID},
|
|
#endif
|
|
};
|
|
|
|
static int fb_getvar_single(char *cmd, char *response, size_t chars_left)
|
|
{
|
|
int i;
|
|
size_t match_len = 0;
|
|
size_t len = strlen(cmd);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(getvar_table); i++) {
|
|
match_len = name_check_match(cmd, len, &getvar_table[i].name);
|
|
if (match_len)
|
|
break;
|
|
}
|
|
|
|
if (match_len == 0) {
|
|
fb_add_string(response, chars_left, "unknown variable", NULL);
|
|
return -1;
|
|
}
|
|
|
|
if (fb_read_var(cmd, response, getvar_table[i].var, chars_left) < 0)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void fb_getvar_all(void)
|
|
{
|
|
char response[FASTBOOT_RESPONSE_LEN] = {0};
|
|
char resp_tmp[FASTBOOT_RESPONSE_LEN] = {0};
|
|
char *actual_resp;
|
|
size_t chars_left;
|
|
int i, p;
|
|
disk_partition_t part_info;
|
|
struct blk_desc *dev_desc;
|
|
|
|
strcpy(response, "INFO");
|
|
chars_left = sizeof(response) - strlen(response) - 1;
|
|
actual_resp = response + strlen(response);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(getvar_table); i++) {
|
|
fb_getvar_t var = getvar_table[i].var;
|
|
|
|
switch (var) {
|
|
case FB_PART_TYPE:
|
|
case FB_PART_SIZE: {
|
|
const char *fs_type = NULL;
|
|
#ifdef CONFIG_RKIMG_BOOTLOADER
|
|
dev_desc = rockchip_get_bootdev();
|
|
#else
|
|
dev_desc = NULL;
|
|
#endif
|
|
if (!dev_desc) {
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:block device not found",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
break;
|
|
}
|
|
|
|
for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
|
|
if (part_get_info(dev_desc, p,
|
|
&part_info) < 0) {
|
|
break;
|
|
}
|
|
|
|
if (var == FB_PART_TYPE) {
|
|
fs_type = NULL;
|
|
if (fb_get_fstype("mmc", p,
|
|
&fs_type)) {
|
|
fb_add_string(
|
|
resp_tmp,
|
|
FASTBOOT_RESPONSE_LEN,
|
|
(char *)part_info.type,
|
|
NULL);
|
|
} else {
|
|
fb_add_string(
|
|
resp_tmp,
|
|
FASTBOOT_RESPONSE_LEN,
|
|
fs_type,
|
|
NULL);
|
|
}
|
|
|
|
snprintf(actual_resp,
|
|
chars_left,
|
|
"%s:%s:%s",
|
|
getvar_table[i].name.str,
|
|
part_info.name,
|
|
resp_tmp);
|
|
} else {
|
|
uint64_t part_size;
|
|
|
|
part_size = (uint64_t)part_info.size;
|
|
snprintf(actual_resp,
|
|
chars_left,
|
|
"%s:%s:0x%llx",
|
|
getvar_table[i].name.str,
|
|
part_info.name,
|
|
part_size * dev_desc->blksz);
|
|
}
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
break;
|
|
}
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
case FB_HAS_SLOT: {
|
|
uchar *ptr_name_tmp;
|
|
char c = '_';
|
|
int has_slot = -1;
|
|
|
|
#ifdef CONFIG_RKIMG_BOOTLOADER
|
|
dev_desc = rockchip_get_bootdev();
|
|
#else
|
|
dev_desc = NULL;
|
|
#endif
|
|
if (!dev_desc) {
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:block device not found",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
break;
|
|
}
|
|
|
|
for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
|
|
if (part_get_info(dev_desc, p,
|
|
&part_info) < 0) {
|
|
break;
|
|
} else {
|
|
ptr_name_tmp = (uchar *)strrchr(
|
|
(char *)part_info.name, c);
|
|
if (ptr_name_tmp &&
|
|
part_info.name[ptr_name_tmp -
|
|
part_info.name + 2] == '\0')
|
|
fb_add_string(
|
|
resp_tmp,
|
|
ptr_name_tmp -
|
|
part_info.name + 1,
|
|
(char *)part_info.name,
|
|
NULL);
|
|
else
|
|
strcpy(resp_tmp,
|
|
(char *)part_info.name);
|
|
|
|
has_slot = rk_avb_get_part_has_slot_info(
|
|
resp_tmp);
|
|
if (has_slot < 0) {
|
|
snprintf(actual_resp,
|
|
chars_left,
|
|
"%s:%s:no",
|
|
getvar_table[i].name.str,
|
|
resp_tmp);
|
|
} else {
|
|
snprintf(actual_resp,
|
|
chars_left,
|
|
"%s:%s:yes",
|
|
getvar_table[i].name.str,
|
|
resp_tmp);
|
|
p++;
|
|
}
|
|
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case FB_SLOT_SUCCESSFUL: {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
AvbABData ab_info;
|
|
|
|
if (rk_avb_get_ab_info(&ab_info) < 0) {
|
|
fb_add_string(actual_resp,
|
|
chars_left,
|
|
"%s:get ab info failed!",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
break;
|
|
}
|
|
|
|
if (ab_info.slots[0].successful_boot)
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:a:yes",
|
|
getvar_table[i].name.str);
|
|
else
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:a:no",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
|
|
if (ab_info.slots[1].successful_boot)
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:b:yes",
|
|
getvar_table[i].name.str);
|
|
else
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:b:no",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
#else
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:not find ab info!",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
case FB_SLOT_UNBOOTABLE: {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
AvbABData ab_info;
|
|
|
|
if (rk_avb_get_ab_info(&ab_info) < 0) {
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:not find ab info!",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
break;
|
|
}
|
|
|
|
if (!ab_info.slots[0].successful_boot &&
|
|
!ab_info.slots[0].tries_remaining &&
|
|
!ab_info.slots[0].priority)
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:a:yes",
|
|
getvar_table[i].name.str);
|
|
else
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:a:no",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
|
|
if (!ab_info.slots[1].successful_boot &&
|
|
!ab_info.slots[1].tries_remaining &&
|
|
!ab_info.slots[1].priority)
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:b:yes",
|
|
getvar_table[i].name.str);
|
|
else
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:b:no",
|
|
getvar_table[i].name.str);
|
|
|
|
fastboot_tx_write_str(response);
|
|
#else
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:not find ab info!",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
case FB_SLOT_RETRY_COUNT: {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
AvbABData ab_info;
|
|
|
|
if (rk_avb_get_ab_info(&ab_info) < 0) {
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:not find ab info!",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
break;
|
|
}
|
|
|
|
snprintf(actual_resp, chars_left, "%s:a:%d",
|
|
getvar_table[i].name.str,
|
|
ab_info.slots[1].tries_remaining);
|
|
fastboot_tx_write_str(response);
|
|
snprintf(actual_resp, chars_left, "%s:b:%d",
|
|
getvar_table[i].name.str,
|
|
ab_info.slots[1].tries_remaining);
|
|
fastboot_tx_write_str(response);
|
|
#else
|
|
fb_add_string(actual_resp, chars_left,
|
|
"%s:not find ab info!",
|
|
getvar_table[i].name.str);
|
|
fastboot_tx_write_str(response);
|
|
#endif
|
|
break;
|
|
}
|
|
#endif
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
case FB_AT_VBST:
|
|
break;
|
|
#endif
|
|
default:
|
|
fb_getvar_single((char *)getvar_table[i].name.str,
|
|
resp_tmp, FASTBOOT_RESPONSE_LEN);
|
|
snprintf(actual_resp, chars_left, "%s:%s",
|
|
getvar_table[i].name.str, resp_tmp);
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_ANDROID_AB
|
|
static int get_current_slot(void)
|
|
{
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
char cmd[8] = {0};
|
|
unsigned int slot_number = -1;
|
|
|
|
memset(cmd, 0x0, sizeof(cmd));
|
|
rk_avb_get_current_slot(cmd);
|
|
if (strncmp("_a", cmd, 2) == 0) {
|
|
slot_number = 0;
|
|
} else if (strncmp("_b", cmd, 2) == 0) {
|
|
slot_number = 1;
|
|
} else {
|
|
pr_err("%s: FAILunkown slot name\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
return slot_number;
|
|
#else
|
|
pr_err("%s: FAILnot implemented\n", __func__);
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
#ifdef CONFIG_FASTBOOT_FLASH
|
|
static int should_prevent_userdata_wipe(void)
|
|
{
|
|
struct misc_virtual_ab_message state;
|
|
|
|
memset(&state, 0x0, sizeof(state));
|
|
if (read_misc_virtual_ab_message(&state) != 0) {
|
|
pr_err("%s: read_misc_virtual_ab_message failed!\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
if (state.magic != MISC_VIRTUAL_AB_MAGIC_HEADER) {
|
|
pr_err("%s: NOT virtual A/B metadata!\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
if (state.merge_status == (uint8_t)ENUM_MERGE_STATUS_MERGING ||
|
|
(state.merge_status == (uint8_t)ENUM_MERGE_STATUS_SNAPSHOTTED &&
|
|
state.source_slot != get_current_slot())) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int get_virtual_ab_merge_status(void)
|
|
{
|
|
struct misc_virtual_ab_message state;
|
|
|
|
memset(&state, 0x0, sizeof(state));
|
|
if (read_misc_virtual_ab_message(&state) != 0) {
|
|
pr_err("%s: read_misc_virtual_ab_message failed!\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
if (state.magic != MISC_VIRTUAL_AB_MAGIC_HEADER) {
|
|
pr_err("%s: NOT virtual A/B metadata!\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
return state.merge_status;
|
|
}
|
|
#endif
|
|
|
|
static void cb_getvar(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
char response[FASTBOOT_RESPONSE_LEN] = {0};
|
|
const char *str_read_all = "all";
|
|
size_t len = 0;
|
|
size_t chars_left;
|
|
|
|
strsep(&cmd, ":");
|
|
if (!cmd) {
|
|
pr_err("missing variable");
|
|
fastboot_tx_write_str("FAILmissing var");
|
|
return;
|
|
}
|
|
|
|
len = strlen(cmd);
|
|
if (len == strlen(str_read_all) &&
|
|
(strncmp(cmd, str_read_all, len) == 0)) {
|
|
fb_getvar_all();
|
|
fastboot_tx_write_str("OKAYDone!");
|
|
} else {
|
|
strcpy(response, "OKAY");
|
|
chars_left = sizeof(response) - strlen(response) - 1;
|
|
|
|
if (fb_getvar_single(cmd, &response[strlen(response)],
|
|
chars_left) < 0) {
|
|
strcpy(cmd, "FAILunknown variable");
|
|
strncat(cmd, &response[strlen(response)], chars_left);
|
|
fastboot_tx_write_str(cmd);
|
|
return;
|
|
}
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static unsigned int rx_bytes_expected(struct usb_ep *ep)
|
|
{
|
|
int rx_remain = download_size - download_bytes;
|
|
unsigned int rem;
|
|
unsigned int maxpacket = ep->maxpacket;
|
|
|
|
if (rx_remain <= 0)
|
|
return 0;
|
|
else if (rx_remain > EP_BUFFER_SIZE)
|
|
return EP_BUFFER_SIZE;
|
|
|
|
/*
|
|
* Some controllers e.g. DWC3 don't like OUT transfers to be
|
|
* not ending in maxpacket boundary. So just make them happy by
|
|
* always requesting for integral multiple of maxpackets.
|
|
* This shouldn't bother controllers that don't care about it.
|
|
*/
|
|
rem = rx_remain % maxpacket;
|
|
if (rem > 0)
|
|
rx_remain = rx_remain + (maxpacket - rem);
|
|
|
|
return rx_remain;
|
|
}
|
|
|
|
#define BYTES_PER_DOT 0x20000
|
|
static void rx_handler_dl_image(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char response[FASTBOOT_RESPONSE_LEN];
|
|
unsigned int transfer_size = download_size - download_bytes;
|
|
const unsigned char *buffer = req->buf;
|
|
unsigned int buffer_size = req->actual;
|
|
unsigned int pre_dot_num, now_dot_num;
|
|
|
|
if (req->status != 0) {
|
|
printf("Bad status: %d\n", req->status);
|
|
return;
|
|
}
|
|
|
|
if (buffer_size < transfer_size)
|
|
transfer_size = buffer_size;
|
|
|
|
memcpy((void *)CONFIG_FASTBOOT_BUF_ADDR + download_bytes,
|
|
buffer, transfer_size);
|
|
|
|
pre_dot_num = download_bytes / BYTES_PER_DOT;
|
|
download_bytes += transfer_size;
|
|
now_dot_num = download_bytes / BYTES_PER_DOT;
|
|
|
|
if (pre_dot_num != now_dot_num) {
|
|
putc('.');
|
|
if (!(now_dot_num % 74))
|
|
putc('\n');
|
|
}
|
|
|
|
/* Check if transfer is done */
|
|
if (download_bytes >= download_size) {
|
|
/*
|
|
* Reset global transfer variable, keep download_bytes because
|
|
* it will be used in the next possible flashing command
|
|
*/
|
|
download_size = 0;
|
|
req->complete = rx_handler_command;
|
|
req->length = EP_BUFFER_SIZE;
|
|
|
|
strcpy(response, "OKAY");
|
|
fastboot_tx_write_str(response);
|
|
|
|
printf("\ndownloading of %d bytes finished\n", download_bytes);
|
|
} else {
|
|
req->length = rx_bytes_expected(ep);
|
|
}
|
|
|
|
req->actual = 0;
|
|
usb_ep_queue(ep, req, 0);
|
|
}
|
|
|
|
static void cb_download(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
char response[FASTBOOT_RESPONSE_LEN];
|
|
|
|
strsep(&cmd, ":");
|
|
download_size = simple_strtoul(cmd, NULL, 16);
|
|
download_bytes = 0;
|
|
|
|
printf("Starting download of %d bytes\n", download_size);
|
|
|
|
if (0 == download_size) {
|
|
strcpy(response, "FAILdata invalid size");
|
|
} else if (download_size > CONFIG_FASTBOOT_BUF_SIZE) {
|
|
download_size = 0;
|
|
strcpy(response, "FAILdata too large");
|
|
} else {
|
|
sprintf(response, "DATA%08x", download_size);
|
|
req->complete = rx_handler_dl_image;
|
|
req->length = rx_bytes_expected(ep);
|
|
}
|
|
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
|
|
static void tx_handler_ul(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
unsigned int xfer_size = 0;
|
|
unsigned int pre_dot_num, now_dot_num;
|
|
unsigned int remain_size = 0;
|
|
unsigned int transferred_size = req->actual;
|
|
|
|
if (req->status != 0) {
|
|
printf("Bad status: %d\n", req->status);
|
|
return;
|
|
}
|
|
|
|
if (start_upload) {
|
|
pre_dot_num = upload_bytes / BYTES_PER_DOT;
|
|
upload_bytes += transferred_size;
|
|
now_dot_num = upload_bytes / BYTES_PER_DOT;
|
|
|
|
if (pre_dot_num != now_dot_num) {
|
|
putc('.');
|
|
if (!(now_dot_num % 74))
|
|
putc('\n');
|
|
}
|
|
}
|
|
|
|
remain_size = upload_size - upload_bytes;
|
|
xfer_size = (remain_size > EP_BUFFER_SIZE) ?
|
|
EP_BUFFER_SIZE : remain_size;
|
|
|
|
debug("%s: remain_size=%d, transferred_size=%d",
|
|
__func__, remain_size, transferred_size);
|
|
debug("xfer_size=%d, upload_bytes=%d, upload_size=%d!\n",
|
|
xfer_size, upload_bytes, upload_size);
|
|
|
|
if (remain_size <= 0) {
|
|
fastboot_func->in_req->complete = fastboot_complete;
|
|
wakeup_thread();
|
|
fastboot_tx_write_str("OKAY");
|
|
printf("\nuploading of %d bytes finished\n", upload_bytes);
|
|
upload_bytes = 0;
|
|
upload_size = 0;
|
|
start_upload = false;
|
|
return;
|
|
}
|
|
|
|
/* Remove the transfer callback which response the upload */
|
|
/* request from host */
|
|
if (!upload_bytes)
|
|
start_upload = true;
|
|
|
|
fastboot_tx_write((char *)((phys_addr_t)CONFIG_FASTBOOT_BUF_ADDR + \
|
|
upload_bytes),
|
|
xfer_size);
|
|
}
|
|
|
|
static void cb_upload(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char response[FASTBOOT_RESPONSE_LEN];
|
|
|
|
printf("Starting upload of %d bytes\n", upload_size);
|
|
|
|
if (0 == upload_size) {
|
|
strcpy(response, "FAILdata invalid size");
|
|
} else {
|
|
start_upload = false;
|
|
sprintf(response, "DATA%08x", upload_size);
|
|
fastboot_func->in_req->complete = tx_handler_ul;
|
|
}
|
|
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
|
|
static void do_bootm_on_complete(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char boot_addr_start[12];
|
|
char *bootm_args[] = { "bootm", boot_addr_start, NULL };
|
|
|
|
puts("Booting kernel..\n");
|
|
|
|
sprintf(boot_addr_start, "0x%lx", (long)CONFIG_FASTBOOT_BUF_ADDR);
|
|
do_bootm(NULL, 0, 2, bootm_args);
|
|
|
|
/* This only happens if image is somehow faulty so we start over */
|
|
do_reset(NULL, 0, 0, NULL);
|
|
}
|
|
|
|
static void cb_boot(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
fastboot_func->in_req->complete = do_bootm_on_complete;
|
|
fastboot_tx_write_str("OKAY");
|
|
}
|
|
|
|
static void do_exit_on_complete(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
g_dnl_trigger_detach();
|
|
}
|
|
|
|
static void cb_continue(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
fastboot_func->in_req->complete = do_exit_on_complete;
|
|
fastboot_tx_write_str("OKAY");
|
|
}
|
|
|
|
static void cb_set_active(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
|
|
debug("%s: %s\n", __func__, cmd);
|
|
|
|
strsep(&cmd, ":");
|
|
if (!cmd) {
|
|
pr_err("missing slot name");
|
|
fastboot_tx_write_str("FAILmissing slot name");
|
|
return;
|
|
}
|
|
#ifdef CONFIG_ANDROID_AB
|
|
if (get_virtual_ab_merge_status() == ENUM_MERGE_STATUS_MERGING) {
|
|
pr_err("virtual A/B is merging, abort the operation");
|
|
fastboot_tx_write_str("FAILvirtual A/B is merging, abort");
|
|
return;
|
|
}
|
|
#endif
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
unsigned int slot_number;
|
|
if (strncmp("a", cmd, 1) == 0) {
|
|
slot_number = 0;
|
|
rk_avb_set_slot_active(&slot_number);
|
|
} else if (strncmp("b", cmd, 1) == 0) {
|
|
slot_number = 1;
|
|
rk_avb_set_slot_active(&slot_number);
|
|
} else {
|
|
fastboot_tx_write_str("FAILunkown slot name");
|
|
return;
|
|
}
|
|
|
|
fastboot_tx_write_str("OKAY");
|
|
return;
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
#ifdef CONFIG_FASTBOOT_FLASH
|
|
static void cb_flash(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
char response[FASTBOOT_RESPONSE_LEN] = {0};
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
uint8_t flash_lock_state;
|
|
|
|
if (rk_avb_read_flash_lock_state(&flash_lock_state)) {
|
|
/* write the device flashing unlock when first read */
|
|
if (rk_avb_write_flash_lock_state(1)) {
|
|
fastboot_tx_write_str("FAILflash lock state write failure");
|
|
return;
|
|
}
|
|
if (rk_avb_read_flash_lock_state(&flash_lock_state)) {
|
|
fastboot_tx_write_str("FAILflash lock state read failure");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (flash_lock_state == 0) {
|
|
fastboot_tx_write_str("FAILThe device is locked, can not flash!");
|
|
printf("The device is locked, can not flash!\n");
|
|
return;
|
|
}
|
|
#endif
|
|
strsep(&cmd, ":");
|
|
if (!cmd) {
|
|
pr_err("missing partition name");
|
|
fastboot_tx_write_str("FAILmissing partition name");
|
|
return;
|
|
}
|
|
#ifdef CONFIG_ANDROID_AB
|
|
if ((strcmp(cmd, PART_USERDATA) == 0) || (strcmp(cmd, PART_METADATA) == 0)) {
|
|
if (should_prevent_userdata_wipe()) {
|
|
pr_err("FAILThe virtual A/B merging, can not flash userdata or metadata!\n");
|
|
fastboot_tx_write_str("FAILvirtual A/B merging,abort flash!");
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
fastboot_fail("no flash device defined", response);
|
|
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
|
|
fb_mmc_flash_write(cmd, (void *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
download_bytes, response);
|
|
#endif
|
|
#ifdef CONFIG_FASTBOOT_FLASH_NAND_DEV
|
|
fb_nand_flash_write(cmd, (void *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
download_bytes, response);
|
|
#endif
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
|
|
static void cb_flashing(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
|
|
if (strncmp("lock", cmd + 9, 4) == 0) {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
uint8_t flash_lock_state;
|
|
flash_lock_state = 0;
|
|
if (rk_avb_write_flash_lock_state(flash_lock_state))
|
|
fastboot_tx_write_str("FAILflash lock state"
|
|
" write failure");
|
|
else
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
} else if (strncmp("unlock", cmd + 9, 6) == 0) {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
uint8_t flash_lock_state;
|
|
flash_lock_state = 1;
|
|
if (rk_avb_write_flash_lock_state(flash_lock_state))
|
|
fastboot_tx_write_str("FAILflash lock state"
|
|
" write failure");
|
|
else
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
} else if (strncmp("lock_critical", cmd + 9, 12) == 0) {
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
} else if (strncmp("unlock_critical", cmd + 9, 14) == 0) {
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
} else if (strncmp("get_unlock_ability", cmd + 9, 17) == 0) {
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
} else if (strncmp("get_unlock_bootloader_nonce", cmd + 4, 27) == 0) {
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
} else if (strncmp("unlock_bootloader", cmd + 9, 17) == 0) {
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
} else if (strncmp("lock_bootloader", cmd + 9, 15) == 0) {
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
} else {
|
|
fastboot_tx_write_str("FAILunknown flashing command");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void cb_oem_perm_attr(void)
|
|
{
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
#ifndef CONFIG_ROCKCHIP_PRELOADER_PUB_KEY
|
|
sha256_context ctx;
|
|
uint8_t digest[SHA256_SUM_LEN] = {0};
|
|
uint8_t digest_temp[SHA256_SUM_LEN] = {0};
|
|
uint8_t perm_attr_temp[PERM_ATTR_TOTAL_SIZE] = {0};
|
|
uint8_t flag = 0;
|
|
#endif
|
|
if (PERM_ATTR_TOTAL_SIZE != download_bytes) {
|
|
printf("Permanent attribute size is not equal!\n");
|
|
fastboot_tx_write_str("FAILincorrect perm attribute size");
|
|
return;
|
|
}
|
|
#ifndef CONFIG_ROCKCHIP_PRELOADER_PUB_KEY
|
|
if (rk_avb_read_perm_attr_flag(&flag)) {
|
|
printf("rk_avb_read_perm_attr_flag error!\n");
|
|
fastboot_tx_write_str("FAILperm attr read failed");
|
|
return;
|
|
}
|
|
|
|
if (flag == PERM_ATTR_SUCCESS_FLAG) {
|
|
if (rk_avb_read_attribute_hash(digest_temp,
|
|
SHA256_SUM_LEN)) {
|
|
printf("The efuse IO can not be used!\n");
|
|
fastboot_tx_write_str("FAILefuse IO can not be used");
|
|
return;
|
|
}
|
|
|
|
if (memcmp(digest, digest_temp, SHA256_SUM_LEN) != 0) {
|
|
if (rk_avb_read_permanent_attributes(perm_attr_temp,
|
|
PERM_ATTR_TOTAL_SIZE)) {
|
|
printf("rk_avb_write_permanent_attributes error!\n");
|
|
fastboot_tx_write_str("FAILread perm attr error");
|
|
return;
|
|
}
|
|
|
|
sha256_starts(&ctx);
|
|
sha256_update(&ctx,
|
|
(const uint8_t *)perm_attr_temp,
|
|
PERM_ATTR_TOTAL_SIZE);
|
|
sha256_finish(&ctx, digest);
|
|
if (memcmp(digest, digest_temp, SHA256_SUM_LEN) == 0) {
|
|
printf("The hash has been written!\n");
|
|
fastboot_tx_write_str("OKAY");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (rk_avb_write_perm_attr_flag(0)) {
|
|
fastboot_tx_write_str("FAILperm attr flag write failure");
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
if (rk_avb_write_permanent_attributes((uint8_t *)
|
|
CONFIG_FASTBOOT_BUF_ADDR,
|
|
download_bytes)) {
|
|
if (rk_avb_write_perm_attr_flag(0)) {
|
|
fastboot_tx_write_str("FAILperm attr flag write failure");
|
|
return;
|
|
}
|
|
fastboot_tx_write_str("FAILperm attr write failed");
|
|
return;
|
|
}
|
|
#ifndef CONFIG_ROCKCHIP_PRELOADER_PUB_KEY
|
|
memset(digest, 0, SHA256_SUM_LEN);
|
|
sha256_starts(&ctx);
|
|
sha256_update(&ctx, (const uint8_t *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
PERM_ATTR_TOTAL_SIZE);
|
|
sha256_finish(&ctx, digest);
|
|
|
|
if (rk_avb_write_attribute_hash((uint8_t *)digest,
|
|
SHA256_SUM_LEN)) {
|
|
if (rk_avb_read_attribute_hash(digest_temp,
|
|
SHA256_SUM_LEN)) {
|
|
printf("The efuse IO can not be used!\n");
|
|
fastboot_tx_write_str("FAILefuse IO can not be used");
|
|
return;
|
|
}
|
|
if (memcmp(digest, digest_temp, SHA256_SUM_LEN) != 0) {
|
|
if (rk_avb_write_perm_attr_flag(0)) {
|
|
fastboot_tx_write_str("FAILperm attr flag write failure");
|
|
return;
|
|
}
|
|
printf("The hash has been written, but is different!\n");
|
|
fastboot_tx_write_str("FAILhash comparison failure");
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
if (rk_avb_write_perm_attr_flag(PERM_ATTR_SUCCESS_FLAG)) {
|
|
fastboot_tx_write_str("FAILperm attr flag write failure");
|
|
return;
|
|
}
|
|
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
}
|
|
|
|
static void cb_oem_perm_attr_rsa_cer(void)
|
|
{
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
if (download_bytes != 256) {
|
|
printf("Permanent attribute rsahash size is not equal!\n");
|
|
fastboot_tx_write_str("FAILperm attribute rsahash size error");
|
|
return;
|
|
}
|
|
|
|
if (rk_avb_set_perm_attr_cer((uint8_t *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
download_bytes)) {
|
|
fastboot_tx_write_str("FAILSet perm attr cer fail!");
|
|
return;
|
|
}
|
|
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
}
|
|
|
|
static void cb_oem(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
|
|
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
|
|
if (strncmp("format", cmd + 4, 6) == 0) {
|
|
char cmdbuf[32];
|
|
sprintf(cmdbuf, "gpt write mmc %x $partitions",
|
|
CONFIG_FASTBOOT_FLASH_MMC_DEV);
|
|
#ifdef CONFIG_ANDROID_AB
|
|
if (should_prevent_userdata_wipe()) {
|
|
printf("FAILThe virtual A/B merging, can not format!\n");
|
|
fastboot_tx_write_str("FAILvirtual A/B merging,abort format!");
|
|
} else {
|
|
if (run_command(cmdbuf, 0))
|
|
fastboot_tx_write_str("FAILmmc write failure");
|
|
else
|
|
fastboot_tx_write_str("OKAY");
|
|
}
|
|
#else
|
|
if (run_command(cmdbuf, 0))
|
|
fastboot_tx_write_str("FAILmmc write failure");
|
|
else
|
|
fastboot_tx_write_str("OKAY");
|
|
#endif
|
|
} else
|
|
#endif
|
|
if (strncmp("unlock", cmd + 4, 8) == 0) {
|
|
#ifdef CONFIG_FASTBOOT_OEM_UNLOCK
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#else
|
|
uint8_t unlock = 0;
|
|
TEEC_Result result;
|
|
debug("oem unlock\n");
|
|
result = trusty_read_oem_unlock(&unlock);
|
|
if (result) {
|
|
printf("read oem unlock status with error : 0x%x\n", result);
|
|
fastboot_tx_write_str("FAILRead oem unlock status failed");
|
|
return;
|
|
}
|
|
if (unlock) {
|
|
printf("oem unlock ignored, device already unlocked\n");
|
|
fastboot_tx_write_str("FAILalready unlocked");
|
|
return;
|
|
}
|
|
printf("oem unlock requested:\n");
|
|
printf("\tUnlocking forces a factory reset and could\n");
|
|
printf("\topen your device up to a world of hurt. If you\n");
|
|
printf("\tare sure you know what you're doing, then accept\n");
|
|
printf("\tvia 'fastboot oem unlock_accept'.\n");
|
|
env_set("unlock", "unlock");
|
|
fastboot_tx_write_str("OKAY");
|
|
#endif
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#endif
|
|
} else if (strncmp("unlock_accept", cmd + 4, 13) == 0) {
|
|
#ifdef CONFIG_FASTBOOT_OEM_UNLOCK
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#else
|
|
char *unlock = env_get("unlock");
|
|
TEEC_Result result;
|
|
debug("oem unlock_accept\n");
|
|
if (unlock == NULL || strncmp("unlock", unlock, 6) != 0) {
|
|
printf("oem unlock_accept ignored, not pending\n");
|
|
fastboot_tx_write_str("FAILoem unlock not requested");
|
|
return;
|
|
}
|
|
env_set("unlock", "");
|
|
printf("Erasing userdata partition\n");
|
|
struct blk_desc *dev_desc;
|
|
disk_partition_t part_info;
|
|
dev_desc = rockchip_get_bootdev();
|
|
if (!dev_desc) {
|
|
printf("%s: dev_desc is NULL!\n", __func__);
|
|
return;
|
|
}
|
|
int ret = part_get_info_by_name(dev_desc, "userdata",
|
|
&part_info);
|
|
if (ret < 0) {
|
|
printf("not found userdata partition");
|
|
printf("Erase failed with error %d\n", ret);
|
|
fastboot_tx_write_str("FAILErasing userdata failed");
|
|
return;
|
|
}
|
|
ret = blk_derase(dev_desc, part_info.start, part_info.size);
|
|
if (ret != part_info.size) {
|
|
printf("Erase failed with error %d\n", ret);
|
|
fastboot_tx_write_str("FAILErasing userdata failed");
|
|
return;
|
|
}
|
|
printf("Erasing succeeded\n");
|
|
|
|
result = trusty_write_oem_unlock(1);
|
|
if (result) {
|
|
printf("write oem unlock status with error : 0x%x\n", result);
|
|
fastboot_tx_write_str("FAILWrite oem unlock status failed");
|
|
return;
|
|
}
|
|
fastboot_tx_write_str("OKAY");
|
|
|
|
/*
|
|
* now reboot into recovery to do a format of the
|
|
* userdata partition so it's ready to use on next boot
|
|
*/
|
|
board_run_recovery_wipe_data();
|
|
#endif
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#endif
|
|
} else if (strncmp("lock", cmd + 4, 8) == 0) {
|
|
#ifdef CONFIG_FASTBOOT_OEM_UNLOCK
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#else
|
|
TEEC_Result result;
|
|
uint8_t unlock = 0;
|
|
trusty_read_oem_unlock(&unlock);
|
|
if (!unlock) {
|
|
printf("oem lock ignored, already locked\n");
|
|
fastboot_tx_write_str("FAILalready locked");
|
|
return;
|
|
}
|
|
|
|
result = trusty_write_oem_unlock(0);
|
|
if (result) {
|
|
printf("write oem unlock status with error : 0x%x\n", result);
|
|
fastboot_tx_write_str("FAILWrite oem unlock status failed");
|
|
return;
|
|
}
|
|
fastboot_tx_write_str("OKAY");
|
|
#endif
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#endif
|
|
} else if (strncmp("at-get-ca-request", cmd + 4, 17) == 0) {
|
|
#ifdef CONFIG_OPTEE_CLIENT
|
|
uint8_t out[ATTEST_CA_OUT_SIZE];
|
|
uint32_t operation_size = download_bytes;
|
|
uint32_t out_len = ATTEST_CA_OUT_SIZE;
|
|
uint32_t res = 0;
|
|
|
|
res = trusty_attest_get_ca((uint8_t *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
&operation_size, out, &out_len);
|
|
if (res) {
|
|
fastboot_tx_write_str("FAILtrusty_attest_get_ca failed");
|
|
return;
|
|
}
|
|
upload_size = out_len;
|
|
memcpy((void *)CONFIG_FASTBOOT_BUF_ADDR, out, out_len);
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#endif
|
|
} else if (strncmp("at-set-ca-response", cmd + 4, 18) == 0) {
|
|
#ifdef CONFIG_OPTEE_CLIENT
|
|
uint32_t ca_response_size = download_bytes;
|
|
uint32_t res = 0;
|
|
|
|
res = trusty_attest_set_ca((uint8_t *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
&ca_response_size);
|
|
if (res)
|
|
fastboot_tx_write_str("FAILtrusty_attest_set_ca failed");
|
|
else
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#endif
|
|
} else if (strncmp("at-get-vboot-unlock-challenge", cmd + 4, 29) == 0) {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
uint32_t challenge_len = 0;
|
|
int ret = 0;
|
|
|
|
ret = rk_generate_unlock_challenge((void *)CONFIG_FASTBOOT_BUF_ADDR, &challenge_len);
|
|
if (ret == 0) {
|
|
upload_size = challenge_len;
|
|
fastboot_tx_write_str("OKAY");
|
|
} else {
|
|
fastboot_tx_write_str("FAILgenerate unlock challenge fail!");
|
|
}
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
return;
|
|
#endif
|
|
} else if (strncmp("at-lock-vboot", cmd + 4, 13) == 0) {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
uint8_t lock_state;
|
|
lock_state = 0;
|
|
if (rk_avb_write_lock_state(lock_state))
|
|
fastboot_tx_write_str("FAILwrite lock state failed");
|
|
else
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
} else if (strncmp("at-unlock-vboot", cmd + 4, 15) == 0) {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
uint8_t lock_state;
|
|
char out_is_trusted = true;
|
|
|
|
if (rk_avb_read_lock_state(&lock_state))
|
|
fastboot_tx_write_str("FAILlock sate read failure");
|
|
if (lock_state >> 1 == 1) {
|
|
fastboot_tx_write_str("FAILThe vboot is disable!");
|
|
} else {
|
|
lock_state = 1;
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_ENABLE_ATH_UNLOCK
|
|
if (rk_auth_unlock((void *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
&out_is_trusted)) {
|
|
printf("rk_auth_unlock ops error!\n");
|
|
fastboot_tx_write_str("FAILrk_auth_unlock ops error!");
|
|
return;
|
|
}
|
|
#endif
|
|
if (out_is_trusted == true) {
|
|
if (rk_avb_write_lock_state(lock_state))
|
|
fastboot_tx_write_str("FAILwrite lock state failed");
|
|
else
|
|
fastboot_tx_write_str("OKAY");
|
|
} else {
|
|
fastboot_tx_write_str("FAILauthenticated unlock fail");
|
|
}
|
|
}
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
} else if (strncmp("fuse at-perm-attr", cmd + 4, 16) == 0) {
|
|
cb_oem_perm_attr();
|
|
} else if (strncmp("fuse at-rsa-perm-attr", cmd + 4, 25) == 0) {
|
|
cb_oem_perm_attr_rsa_cer();
|
|
} else if (strncmp("fuse at-bootloader-vboot-key", cmd + 4, 27) == 0) {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
sha256_context ctx;
|
|
uint8_t digest[SHA256_SUM_LEN];
|
|
|
|
if (download_bytes != VBOOT_KEY_HASH_SIZE) {
|
|
fastboot_tx_write_str("FAILinvalid vboot key length");
|
|
printf("The vboot key size error!\n");
|
|
return;
|
|
}
|
|
|
|
sha256_starts(&ctx);
|
|
sha256_update(&ctx, (const uint8_t *)CONFIG_FASTBOOT_BUF_ADDR,
|
|
VBOOT_KEY_SIZE);
|
|
sha256_finish(&ctx, digest);
|
|
|
|
if (rk_avb_write_vbootkey_hash((uint8_t *)digest,
|
|
SHA256_SUM_LEN)) {
|
|
fastboot_tx_write_str("FAILvbootkey hash write failure");
|
|
return;
|
|
}
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
} else if (strncmp("init-ab-metadata", cmd + 4, 16) == 0) {
|
|
#ifdef CONFIG_RK_AVB_LIBAVB_USER
|
|
if (rk_avb_init_ab_metadata()) {
|
|
fastboot_tx_write_str("FAILinit ab data fail!");
|
|
return;
|
|
}
|
|
fastboot_tx_write_str("OKAY");
|
|
#else
|
|
fastboot_tx_write_str("FAILnot implemented");
|
|
#endif
|
|
} else {
|
|
fastboot_tx_write_str("FAILunknown oem command");
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_FASTBOOT_FLASH
|
|
static void cb_erase(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmd = req->buf;
|
|
char response[FASTBOOT_RESPONSE_LEN] = {0};
|
|
|
|
strsep(&cmd, ":");
|
|
if (!cmd) {
|
|
pr_err("missing partition name");
|
|
fastboot_tx_write_str("FAILmissing partition name");
|
|
return;
|
|
}
|
|
#ifdef CONFIG_ANDROID_AB
|
|
if ((strcmp(cmd, PART_USERDATA) == 0) || (strcmp(cmd, PART_METADATA) == 0)) {
|
|
if (should_prevent_userdata_wipe()) {
|
|
pr_err("virtual A/B merging, can not erase userdata or metadata!\n");
|
|
fastboot_tx_write_str("FAILvirtual A/B merging,abort erase!");
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
fastboot_fail("no flash device defined", response);
|
|
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
|
|
fb_mmc_erase(cmd, response);
|
|
#endif
|
|
#ifdef CONFIG_FASTBOOT_FLASH_NAND_DEV
|
|
fb_nand_erase(cmd, response);
|
|
#endif
|
|
fastboot_tx_write_str(response);
|
|
}
|
|
#endif
|
|
|
|
struct cmd_dispatch_info {
|
|
char *cmd;
|
|
void (*cb)(struct usb_ep *ep, struct usb_request *req);
|
|
};
|
|
|
|
static const struct cmd_dispatch_info cmd_dispatch_info[] = {
|
|
{
|
|
.cmd = "reboot",
|
|
.cb = cb_reboot,
|
|
}, {
|
|
.cmd = "getvar:",
|
|
.cb = cb_getvar,
|
|
}, {
|
|
.cmd = "download:",
|
|
.cb = cb_download,
|
|
}, {
|
|
.cmd = "upload",
|
|
.cb = cb_upload,
|
|
}, {
|
|
.cmd = "boot",
|
|
.cb = cb_boot,
|
|
}, {
|
|
.cmd = "continue",
|
|
.cb = cb_continue,
|
|
}, {
|
|
.cmd = "set_active",
|
|
.cb = cb_set_active,
|
|
},
|
|
#ifdef CONFIG_FASTBOOT_FLASH
|
|
{
|
|
.cmd = "flashing",
|
|
.cb = cb_flashing,
|
|
},
|
|
{
|
|
.cmd = "flash",
|
|
.cb = cb_flash,
|
|
}, {
|
|
.cmd = "erase",
|
|
.cb = cb_erase,
|
|
},
|
|
#endif
|
|
{
|
|
.cmd = "oem",
|
|
.cb = cb_oem,
|
|
},
|
|
};
|
|
|
|
static void rx_handler_command(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
char *cmdbuf = req->buf;
|
|
void (*func_cb)(struct usb_ep *ep, struct usb_request *req) = NULL;
|
|
int i;
|
|
|
|
if (req->status != 0 || req->length == 0)
|
|
return;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cmd_dispatch_info); i++) {
|
|
if (!strcmp_l1(cmd_dispatch_info[i].cmd, cmdbuf)) {
|
|
func_cb = cmd_dispatch_info[i].cb;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!func_cb) {
|
|
pr_err("unknown command: %.*s", req->actual, cmdbuf);
|
|
fastboot_tx_write_str("FAILunknown command");
|
|
} else {
|
|
if (req->actual < req->length) {
|
|
u8 *buf = (u8 *)req->buf;
|
|
buf[req->actual] = 0;
|
|
func_cb(ep, req);
|
|
} else {
|
|
pr_err("buffer overflow");
|
|
fastboot_tx_write_str("FAILbuffer overflow");
|
|
}
|
|
}
|
|
|
|
*cmdbuf = '\0';
|
|
req->actual = 0;
|
|
usb_ep_queue(ep, req, 0);
|
|
}
|