u-boot/net/fastboot.c
Roman Kovalivskyi 2b2a771b40 fastboot: Add support for 'reboot fastboot' command
Android 10 adds support for dynamic partitions and in order to support
this userspace fastboot must be used[1]. New tool fastbootd is
included into recovery.

Userspace fastboot works from recovery and is launched if:
1) - Dynamic partitioning is enabled
2) - Boot control block has 'boot-fastboot' value into command field
The bootloader is expected to load and boot into the recovery image
upon seeing boot-fastboot in the BCB command. Recovery then parses the
BCB message and switches to fastbootd mode[2].

Please note that boot script is expected to handle 'boot-fastboot'
command in BCB and load into recovery mode.

Bootloader must support 'reboot fastboot' command which should reboot
device into userspace fastboot to accomodate those changes[3].

Another command that bootloader must support[3] is 'reboot recovery'. This
command should simply reboot device into recovery mode.

[1] - https://source.android.com/devices/bootloader/fastbootd
[2] - https://source.android.com/devices/bootloader/fastbootd#unified_fastboot_and_recovery
[3] - https://source.android.com/devices/bootloader/fastbootd#modifications_to_the_bootloader

Signed-off-by: Roman Kovalivskyi <roman.kovalivskyi@globallogic.com>
Signed-off-by: Roman Stratiienko <r.stratiienko@gmail.com>
Change-Id: I9d2bdc9a6f6f31ea98572fe155e1cc8341e9af76
2020-09-01 14:47:43 +02:00

323 lines
8.2 KiB
C

// SPDX-License-Identifier: BSD-2-Clause
/*
* Copyright (C) 2016 The Android Open Source Project
*/
#include <common.h>
#include <command.h>
#include <fastboot.h>
#include <net.h>
#include <net/fastboot.h>
/* Fastboot port # defined in spec */
#define WELL_KNOWN_PORT 5554
enum {
FASTBOOT_ERROR = 0,
FASTBOOT_QUERY = 1,
FASTBOOT_INIT = 2,
FASTBOOT_FASTBOOT = 3,
};
struct __packed fastboot_header {
uchar id;
uchar flags;
unsigned short seq;
};
#define PACKET_SIZE 1024
#define DATA_SIZE (PACKET_SIZE - sizeof(struct fastboot_header))
/* Sequence number sent for every packet */
static unsigned short sequence_number = 1;
static const unsigned short packet_size = PACKET_SIZE;
static const unsigned short udp_version = 1;
/* Keep track of last packet for resubmission */
static uchar last_packet[PACKET_SIZE];
static unsigned int last_packet_len;
static struct in_addr fastboot_remote_ip;
/* The UDP port at their end */
static int fastboot_remote_port;
/* The UDP port at our end */
static int fastboot_our_port;
static void boot_downloaded_image(void);
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
/**
* fastboot_udp_send_info() - Send an INFO packet during long commands.
*
* @msg: String describing the reason for waiting
*/
static void fastboot_udp_send_info(const char *msg)
{
uchar *packet;
uchar *packet_base;
int len = 0;
char response[FASTBOOT_RESPONSE_LEN] = {0};
struct fastboot_header response_header = {
.id = FASTBOOT_FASTBOOT,
.flags = 0,
.seq = htons(sequence_number)
};
++sequence_number;
packet = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
packet_base = packet;
/* Write headers */
memcpy(packet, &response_header, sizeof(response_header));
packet += sizeof(response_header);
/* Write response */
fastboot_response("INFO", response, "%s", msg);
memcpy(packet, response, strlen(response));
packet += strlen(response);
len = packet - packet_base;
/* Save packet for retransmitting */
last_packet_len = len;
memcpy(last_packet, packet_base, last_packet_len);
net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
fastboot_remote_port, fastboot_our_port, len);
}
/**
* fastboot_timed_send_info() - Send INFO packet every 30 seconds
*
* @msg: String describing the reason for waiting
*
* Send an INFO packet during long commands based on timer. An INFO packet
* is sent if the time is 30 seconds after start. Else, noop.
*/
static void fastboot_timed_send_info(const char *msg)
{
static ulong start;
/* Initialize timer */
if (start == 0)
start = get_timer(0);
ulong time = get_timer(start);
/* Send INFO packet to host every 30 seconds */
if (time >= 30000) {
start = get_timer(0);
fastboot_udp_send_info(msg);
}
}
#endif
/**
* fastboot_send() - Sends a packet in response to received fastboot packet
*
* @header: Header for response packet
* @fastboot_data: Pointer to received fastboot data
* @fastboot_data_len: Length of received fastboot data
* @retransmit: Nonzero if sending last sent packet
*/
static void fastboot_send(struct fastboot_header header, char *fastboot_data,
unsigned int fastboot_data_len, uchar retransmit)
{
uchar *packet;
uchar *packet_base;
int len = 0;
const char *error_msg = "An error occurred.";
short tmp;
struct fastboot_header response_header = header;
static char command[FASTBOOT_COMMAND_LEN];
static int cmd = -1;
static bool pending_command;
char response[FASTBOOT_RESPONSE_LEN] = {0};
/*
* We will always be sending some sort of packet, so
* cobble together the packet headers now.
*/
packet = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
packet_base = packet;
/* Resend last packet */
if (retransmit) {
memcpy(packet, last_packet, last_packet_len);
net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
fastboot_remote_port, fastboot_our_port,
last_packet_len);
return;
}
response_header.seq = htons(response_header.seq);
memcpy(packet, &response_header, sizeof(response_header));
packet += sizeof(response_header);
switch (header.id) {
case FASTBOOT_QUERY:
tmp = htons(sequence_number);
memcpy(packet, &tmp, sizeof(tmp));
packet += sizeof(tmp);
break;
case FASTBOOT_INIT:
tmp = htons(udp_version);
memcpy(packet, &tmp, sizeof(tmp));
packet += sizeof(tmp);
tmp = htons(packet_size);
memcpy(packet, &tmp, sizeof(tmp));
packet += sizeof(tmp);
break;
case FASTBOOT_ERROR:
memcpy(packet, error_msg, strlen(error_msg));
packet += strlen(error_msg);
break;
case FASTBOOT_FASTBOOT:
if (cmd == FASTBOOT_COMMAND_DOWNLOAD) {
if (!fastboot_data_len && !fastboot_data_remaining()) {
fastboot_data_complete(response);
} else {
fastboot_data_download(fastboot_data,
fastboot_data_len,
response);
}
} else if (!pending_command) {
strlcpy(command, fastboot_data,
min((size_t)fastboot_data_len + 1,
sizeof(command)));
pending_command = true;
} else {
cmd = fastboot_handle_command(command, response);
pending_command = false;
}
/*
* Sent some INFO packets, need to update sequence number in
* header
*/
if (header.seq != sequence_number) {
response_header.seq = htons(sequence_number);
memcpy(packet_base, &response_header,
sizeof(response_header));
}
/* Write response to packet */
memcpy(packet, response, strlen(response));
packet += strlen(response);
break;
default:
pr_err("ID %d not implemented.\n", header.id);
return;
}
len = packet - packet_base;
/* Save packet for retransmitting */
last_packet_len = len;
memcpy(last_packet, packet_base, last_packet_len);
net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
fastboot_remote_port, fastboot_our_port, len);
/* Continue boot process after sending response */
if (!strncmp("OKAY", response, 4)) {
switch (cmd) {
case FASTBOOT_COMMAND_BOOT:
boot_downloaded_image();
break;
case FASTBOOT_COMMAND_CONTINUE:
net_set_state(NETLOOP_SUCCESS);
break;
case FASTBOOT_COMMAND_REBOOT:
case FASTBOOT_COMMAND_REBOOT_BOOTLOADER:
case FASTBOOT_COMMAND_REBOOT_FASTBOOTD:
case FASTBOOT_COMMAND_REBOOT_RECOVERY:
do_reset(NULL, 0, 0, NULL);
break;
}
}
if (!strncmp("OKAY", response, 4) || !strncmp("FAIL", response, 4))
cmd = -1;
}
/**
* boot_downloaded_image() - Boots into downloaded image.
*/
static void boot_downloaded_image(void)
{
fastboot_boot();
net_set_state(NETLOOP_SUCCESS);
}
/**
* fastboot_handler() - Incoming UDP packet handler.
*
* @packet: Pointer to incoming UDP packet
* @dport: Destination UDP port
* @sip: Source IP address
* @sport: Source UDP port
* @len: Packet length
*/
static void fastboot_handler(uchar *packet, unsigned int dport,
struct in_addr sip, unsigned int sport,
unsigned int len)
{
struct fastboot_header header;
char fastboot_data[DATA_SIZE] = {0};
unsigned int fastboot_data_len = 0;
if (dport != fastboot_our_port)
return;
fastboot_remote_ip = sip;
fastboot_remote_port = sport;
if (len < sizeof(struct fastboot_header) || len > PACKET_SIZE)
return;
memcpy(&header, packet, sizeof(header));
header.flags = 0;
header.seq = ntohs(header.seq);
packet += sizeof(header);
len -= sizeof(header);
switch (header.id) {
case FASTBOOT_QUERY:
fastboot_send(header, fastboot_data, 0, 0);
break;
case FASTBOOT_INIT:
case FASTBOOT_FASTBOOT:
fastboot_data_len = len;
if (len > 0)
memcpy(fastboot_data, packet, len);
if (header.seq == sequence_number) {
fastboot_send(header, fastboot_data,
fastboot_data_len, 0);
sequence_number++;
} else if (header.seq == sequence_number - 1) {
/* Retransmit last sent packet */
fastboot_send(header, fastboot_data,
fastboot_data_len, 1);
}
break;
default:
pr_err("ID %d not implemented.\n", header.id);
header.id = FASTBOOT_ERROR;
fastboot_send(header, fastboot_data, 0, 0);
break;
}
}
void fastboot_start_server(void)
{
printf("Using %s device\n", eth_get_name());
printf("Listening for fastboot command on %pI4\n", &net_ip);
fastboot_our_port = WELL_KNOWN_PORT;
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
fastboot_set_progress_callback(fastboot_timed_send_info);
#endif
net_set_udp_handler(fastboot_handler);
/* zero out server ether in case the server ip has changed */
memset(net_server_ethaddr, 0, 6);
}