Eric Lee / smarc-uboot | Embedian Git Server

Commit 8cb9cd7e436a395ea772763c56788cb19e8c0b83

Authored by Haoran.Wang 2020-02-26 08:45:13 +0800

Committed by Ji Luo 2020-05-18 09:45:08 +0800

Exists in smarc_8mq-imx_v2020.04_5.4.24_2.1.0 and in 1 other branch

MA-16457-2 support reboot-fastboot command in u-boot

Android implement the userspace fastboot in Android Recovery.
Follow Google's spec, added below 2 fastboot command support:
  * fastboot getvar is-userspace
  * fastboot reboot fastboot

TEST: fastboot commands.

Change-Id: Ib6047413be0a45b3c00626cdb8594809eb8a2b6b
Signed-off-by: Haoran.Wang <elven.wang@nxp.com>
(cherry picked from commit 314bded076dfc3e544cc7094ce3f6c4c330be4dd)

Showing 7 changed files with 94 additions and 2 deletions Inline Diff

drivers/fastboot/fb_fsl/bcb.h
drivers/fastboot/fb_fsl/command.c
drivers/fastboot/fb_fsl/fb_fsl_command.c
drivers/fastboot/fb_fsl/fb_fsl_getvar.c
drivers/usb/gadget/f_fastboot.c
include/fastboot.h
net/fastboot.c

drivers/fastboot/fb_fsl/bcb.h

Diff comments View file @ 8cb9cd7

 // SPDX-License-Identifier:     GPL-2.0+
 /*
  * Copyright (C) 2015-2016 Freescale Semiconductor, Inc.
  */
 #ifndef BCB_H
 #define BCB_H
 #include <linux/types.h>
 #include <linux/stat.h>
 #define FASTBOOT_BCB_CMD "bootonce-bootloader"
 #ifdef CONFIG_ANDROID_RECOVERY
 #define RECOVERY_BCB_CMD "boot-recovery"
+#define RECOVERY_FASTBOOT_ARG "recovery\n--fastboot"
 #endif
 /* keep same as bootable/recovery/bootloader.h */
 struct 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];
 };
 struct bootloader_message_ab {
 	struct bootloader_message message;
 	char slot_suffix[32];
 	/* Round up the entire struct to 4096-byte. */
 	char reserved[2016];
 };
 /* start from bootloader_message_ab.slot_suffix[BOOTCTRL_IDX] */
 #define BOOTCTRL_IDX                            0
 #define MISC_COMMAND_IDX                        0
 #define BOOTCTRL_OFFSET         \
 	(u32)(&(((struct bootloader_message_ab *)0)->slot_suffix[BOOTCTRL_IDX]))
 #define MISC_COMMAND \
 	(u32)(uintptr_t)(&(((struct bootloader_message *)0)->command[MISC_COMMAND_IDX]))
+#ifdef CONFIG_ANDROID_RECOVERY
+#define RECOVERY_OPTIONS\
+	(u32)(uintptr_t)(&(((struct bootloader_message *)0)->recovery[0]))
+#endif
 int bcb_rw_block(bool bread, char **ppblock,
 		uint *pblksize, char *pblock_write, uint offset, uint size);
 int bcb_write_command(char *bcb_command);
 int bcb_read_command(char *command);
+#ifdef CONFIG_ANDROID_RECOVERY
+int bcb_write_recovery_opt(char *opts);
+#endif
 #endif

drivers/fastboot/fb_fsl/command.c

Diff comments View file @ 8cb9cd7

 // SPDX-License-Identifier:     GPL-2.0+
 /*
  * Copyright (C) 2015-2016 Freescale Semiconductor, Inc.
  */
 #include <common.h>
 #include <g_dnl.h>
 #include "bcb.h"
 int bcb_read_command(char *command)
 {
 	int ret = 0;
 	char *p_block = NULL;
 	uint offset_in_block = 0;
 	uint blk_size = 0;
 	if (command == NULL)
 		return -1;
 	ret = bcb_rw_block(true, &p_block, &blk_size, NULL, MISC_COMMAND, 32);
 	if (ret) {
 		printf("read_bootctl, bcb_rw_block read failed\n");
 		return -1;
 	}
 	offset_in_block = MISC_COMMAND%blk_size;
 	memcpy(command, p_block + offset_in_block, 32);
 	free(p_block);
 	return 0;
 }
 int bcb_write_command(char *bcb_command)
 {
 	int ret = 0;
 	char *p_block = NULL;
 	uint offset_in_block = 0;
 	uint blk_size = 0;
 	if (bcb_command == NULL)
 		return -1;
 	ret = bcb_rw_block(true, &p_block, &blk_size, NULL,  MISC_COMMAND, 32);
 	if (ret) {
 		printf("write_bootctl, bcb_rw_block read failed\n");
 		return -1;
 	}
 	offset_in_block = MISC_COMMAND%blk_size;
 	memcpy(p_block + offset_in_block, bcb_command, 32);
 	ret = bcb_rw_block(false, NULL, NULL, p_block, MISC_COMMAND, 32);
 	if (ret) {
 		free(p_block);
 		printf("write_bootctl, bcb_rw_block write failed\n");
 		return -1;
 	}
 	free(p_block);
 	return 0;
 }
+#ifdef CONFIG_ANDROID_RECOVERY
+int bcb_write_recovery_opt(char *opts)
+{
+	int ret = 0;
+	char *p_block = NULL;
+	uint offset_in_block = 0;
+	uint blk_size = 0;
+	if (opts == NULL)
+		return -1;
+	ret = bcb_rw_block(true, &p_block, &blk_size, NULL, RECOVERY_OPTIONS, 32);
+	if (ret) {
+		printf("write_bootctl, bcb_rw_block read failed\n");
+		return -1;
+	}
+	offset_in_block = RECOVERY_OPTIONS%blk_size;
+	memcpy(p_block + offset_in_block, opts, 32);
+	ret = bcb_rw_block(false, NULL, NULL, p_block, RECOVERY_OPTIONS, 32);
+	if (ret) {
+		free(p_block);
+		printf("write_bootctl, bcb_rw_block write failed\n");
+		return -1;
+	}
+	free(p_block);
+	return 0;
+}
+#endif

drivers/fastboot/fb_fsl/fb_fsl_command.c

Diff comments View file @ 8cb9cd7

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright 2019 NXP
  */
 #include <asm/mach-imx/sys_proto.h>
 #include <fb_fsl.h>
 #include <fastboot.h>
 #include <fastboot-internal.h>
 #include <mmc.h>
 #include <android_image.h>
 #include <asm/bootm.h>
 #include <nand.h>
 #include <part.h>
 #include <sparse_format.h>
 #include <image-sparse.h>
 #include <image.h>
 #include <asm/mach-imx/boot_mode.h>
 #include <asm/arch/sys_proto.h>
 #include <asm/setup.h>
 #include <env.h>
 #ifdef CONFIG_ANDROID_RECOVERY
 #include <recovery.h>
 #endif
 #ifdef CONFIG_BCB_SUPPORT
 #include "bcb.h"
 #endif
 #ifdef CONFIG_AVB_SUPPORT
 #include <dt_table.h>
 #include <fsl_avb.h>
 #endif
 #ifdef CONFIG_ANDROID_THINGS_SUPPORT
 #include <asm-generic/gpio.h>
 #include <asm/mach-imx/gpio.h>
 #include "../lib/avb/fsl/fsl_avbkey.h"
 #include "../arch/arm/include/asm/mach-imx/hab.h"
 #endif
 #if defined(CONFIG_FASTBOOT_LOCK)
 #include "fastboot_lock_unlock.h"
 #endif
 #ifdef CONFIG_IMX_TRUSTY_OS
 #include "u-boot/sha256.h"
 #include <trusty/libtipc.h>
 #endif
 #include "fb_fsl_common.h"
 #define EP_BUFFER_SIZE			4096
 /**
  * fastboot_bytes_received - number of bytes received in the current download
  */
 static u32 fastboot_bytes_received;
 /**
  * fastboot_bytes_expected - number of bytes expected in the current download
  */
 static u32 fastboot_bytes_expected;
 /* Write the bcb with fastboot bootloader commands */
 static void enable_fastboot_command(void)
 {
 #ifdef CONFIG_BCB_SUPPORT
 	char fastboot_command[32] = {0};
 	strncpy(fastboot_command, FASTBOOT_BCB_CMD, 31);
 	bcb_write_command(fastboot_command);
 #endif
 }
+#ifdef CONFIG_ANDROID_RECOVERY
+/* Write the recovery options with fastboot bootloader commands */
+static void enable_recovery_fastboot(void)
+{
+#ifdef CONFIG_BCB_SUPPORT
+	char msg[32] = {0};
+	strncpy(msg, RECOVERY_BCB_CMD, 31);
+	bcb_write_command(msg);
+	strncpy(msg, RECOVERY_FASTBOOT_ARG, 31);
+	bcb_write_recovery_opt(msg);
+#endif
+}
+#endif
 /* Get the Boot mode from BCB cmd or Key pressed */
 static FbBootMode fastboot_get_bootmode(void)
 {
 	int boot_mode = BOOTMODE_NORMAL;
 #ifdef CONFIG_ANDROID_RECOVERY
 	if(is_recovery_key_pressing()) {
 		boot_mode = BOOTMODE_RECOVERY_KEY_PRESSED;
 		return boot_mode;
 	}
 #endif
 #ifdef CONFIG_BCB_SUPPORT
 	int ret = 0;
 	char command[32];
 	ret = bcb_read_command(command);
 	if (ret < 0) {
 		printf("read command failed\n");
 		return boot_mode;
 	}
 	if (!strcmp(command, FASTBOOT_BCB_CMD)) {
 		boot_mode = BOOTMODE_FASTBOOT_BCB_CMD;
 	}
 #ifdef CONFIG_ANDROID_RECOVERY
 	else if (!strcmp(command, RECOVERY_BCB_CMD)) {
 		boot_mode = BOOTMODE_RECOVERY_BCB_CMD;
 	}
 #endif
 	/* Clean the mode once its read out,
 	   no matter what in the mode string */
 	memset(command, 0, 32);
 	bcb_write_command(command);
 #endif
 	return boot_mode;
 }
 /* export to lib_arm/board.c */
 void fastboot_run_bootmode(void)
 {
 	FbBootMode boot_mode = fastboot_get_bootmode();
 	switch(boot_mode){
 	case BOOTMODE_FASTBOOT_BCB_CMD:
 		/* Make the boot into fastboot mode*/
 		puts("Fastboot: Got bootloader commands!\n");
 		run_command("fastboot 0", 0);
 		break;
 #ifdef CONFIG_ANDROID_RECOVERY
 	case BOOTMODE_RECOVERY_BCB_CMD:
 	case BOOTMODE_RECOVERY_KEY_PRESSED:
 		/* Make the boot into recovery mode */
 		puts("Fastboot: Got Recovery key pressing or recovery commands!\n");
 		board_recovery_setup();
 		break;
 #endif
 	default:
 		/* skip special mode boot*/
 		puts("Fastboot: Normal\n");
 		break;
 	}
 }
 /**
  * okay() - Send bare OKAY response
  *
  * @cmd_parameter: Pointer to command parameter
  * @response: Pointer to fastboot response buffer
  *
  * Send a bare OKAY fastboot response. This is used where the command is
  * valid, but all the work is done after the response has been sent (e.g.
  * boot, reboot etc.)
  */
 static void okay(char *cmd_parameter, char *response)
 {
 	fastboot_okay(NULL, response);
 }
 /**
  * getvar() - Read a config/version variable
  *
  * @cmd_parameter: Pointer to command parameter
  * @response: Pointer to fastboot response buffer
  */
 static void getvar(char *cmd_parameter, char *response)
 {
 	fastboot_getvar(cmd_parameter, response);
 }
 /**
  * reboot_bootloader() - Sets reboot bootloader flag.
  *
  * @cmd_parameter: Pointer to command parameter
  * @response: Pointer to fastboot response buffer
  */
 static void reboot_bootloader(char *cmd_parameter, char *response)
 {
 	enable_fastboot_command();
 	if (fastboot_set_reboot_flag())
 		fastboot_fail("Cannot set reboot flag", response);
 	else
 		fastboot_okay(NULL, response);
 }
+#ifdef CONFIG_ANDROID_RECOVERY
+/**
+ * reboot_fastboot() - Sets reboot fastboot flag.
+ *
+ * @cmd_parameter: Pointer to command parameter
+ * @response: Pointer to fastboot response buffer
+ */
+static void reboot_fastboot(char *cmd_parameter, char *response)
+{
+	enable_recovery_fastboot();
+	if (fastboot_set_reboot_flag())
+		fastboot_fail("Cannot set reboot flag", response);
+	else
+		fastboot_okay(NULL, response);
+}
+#endif
 static void upload(char *cmd_parameter, char *response)
 {
 	if (!fastboot_bytes_received || fastboot_bytes_received > (EP_BUFFER_SIZE * 32)) {
 		fastboot_fail("", response);
 		return;
 	}
 	printf("Will upload %d bytes.\n", fastboot_bytes_received);
 	snprintf(response, FASTBOOT_RESPONSE_LEN, "DATA%08x", fastboot_bytes_received);
 	fastboot_tx_write_more(response);
 	fastboot_tx_write((const char *)(fastboot_buf_addr), fastboot_bytes_received);
 	snprintf(response,FASTBOOT_RESPONSE_LEN, "OKAY");
 	fastboot_tx_write_more(response);
 	fastboot_none_resp(response);
 }
 /**
  * fastboot_download() - Start a download transfer from the client
  *
  * @cmd_parameter: Pointer to command parameter
  * @response: Pointer to fastboot response buffer
  */
 static void download(char *cmd_parameter, char *response)
 {
 	char *tmp;
 	if (!cmd_parameter) {
 		fastboot_fail("Expected command parameter", response);
 		return;
 	}
 	fastboot_bytes_received = 0;
 	fastboot_bytes_expected = simple_strtoul(cmd_parameter, &tmp, 16);
 	if (fastboot_bytes_expected == 0) {
 		fastboot_fail("Expected nonzero image size", response);
 		return;
 	}
 	/*
 	 * Nothing to download yet. Response is of the form:
 	 * [DATA|FAIL]$cmd_parameter
 	 *
 	 * where cmd_parameter is an 8 digit hexadecimal number
 	 */
 	if (fastboot_bytes_expected > fastboot_buf_size) {
 		fastboot_fail(cmd_parameter, response);
 	} else {
 		printf("Starting download of %d bytes\n",
 		       fastboot_bytes_expected);
 		fastboot_response("DATA", response, "%s", cmd_parameter);
 	}
 }
 /**
  * fastboot_data_remaining() - return bytes remaining in current transfer
  *
  * Return: Number of bytes left in the current download
  */
 u32 fastboot_data_remaining(void)
 {
 	if (fastboot_bytes_received >= fastboot_bytes_expected)
 		return 0;
 	return fastboot_bytes_expected - fastboot_bytes_received;
 }
 /**
  * fastboot_data_download() - Copy image data to fastboot_buf_addr.
  *
  * @fastboot_data: Pointer to received fastboot data
  * @fastboot_data_len: Length of received fastboot data
  * @response: Pointer to fastboot response buffer
  *
  * Copies image data from fastboot_data to fastboot_buf_addr. Writes to
  * response. fastboot_bytes_received is updated to indicate the number
  * of bytes that have been transferred.
  *
  * On completion sets image_size and ${filesize} to the total size of the
  * downloaded image.
  */
 void fastboot_data_download(const void *fastboot_data,
 			    unsigned int fastboot_data_len,
 			    char *response)
 {
 #define BYTES_PER_DOT	0x20000
 	u32 pre_dot_num, now_dot_num;
 	if (fastboot_data_len == 0 ||
 	    (fastboot_bytes_received + fastboot_data_len) >
 	    fastboot_bytes_expected) {
 		fastboot_fail("Received invalid data length",
 			      response);
 		return;
 	}
 	/* Download data to fastboot_buf_addr */
 	memcpy(fastboot_buf_addr + fastboot_bytes_received,
 	       fastboot_data, fastboot_data_len);
 	pre_dot_num = fastboot_bytes_received / BYTES_PER_DOT;
 	fastboot_bytes_received += fastboot_data_len;
 	now_dot_num = fastboot_bytes_received / BYTES_PER_DOT;
 	if (pre_dot_num != now_dot_num) {
 		putc('.');
 		if (!(now_dot_num % 74))
 			putc('\n');
 	}
 	*response = '\0';
 }
 /**
  * fastboot_data_complete() - Mark current transfer complete
  *
  * @response: Pointer to fastboot response buffer
  *
  * Set image_size and ${filesize} to the total size of the downloaded image.
  */
 void fastboot_data_complete(char *response)
 {
 	/* Download complete. Respond with "OKAY" */
 	fastboot_okay(NULL, response);
 	printf("\ndownloading of %d bytes finished\n", fastboot_bytes_received);
 	env_set_hex("filesize", fastboot_bytes_received);
 	env_set_hex("fastboot_bytes", fastboot_bytes_received);
 	fastboot_bytes_expected = 0;
 }
 #if defined(CONFIG_FASTBOOT_LOCK)
 static int partition_table_valid(void)
 {
 	int status, mmc_no;
 	struct blk_desc *dev_desc;
 #if defined(CONFIG_IMX_TRUSTY_OS) && !defined(CONFIG_ARM64)
 	/* Prevent other partition accessing when no TOS flashed. */
 	if (!tos_flashed)
 		return 0;
 #endif
 	disk_partition_t info;
 	mmc_no = fastboot_devinfo.dev_id;
 	dev_desc = blk_get_dev("mmc", mmc_no);
 	if (dev_desc)
 		status = part_get_info(dev_desc, 1, &info);
 	else
 		status = -1;
 	return (status == 0);
 }
 static void wipe_all_userdata(void)
 {
 	char response[FASTBOOT_RESPONSE_LEN];
 	/* Erase all user data */
 	printf("Start userdata wipe process....\n");
 	/* Erase /data partition */
 	fastboot_wipe_data_partition();
 #if defined (CONFIG_ANDROID_SUPPORT) || defined (CONFIG_ANDROID_AUTO_SUPPORT)
 	/* Erase the misc partition. */
 	process_erase_mmc(FASTBOOT_PARTITION_MISC, response);
 #endif
 #ifndef CONFIG_ANDROID_AB_SUPPORT
 	/* Erase the cache partition for legacy imx6/7 */
 	process_erase_mmc(FASTBOOT_PARTITION_CACHE, response);
 #endif
 #if defined(AVB_RPMB) && !defined(CONFIG_IMX_TRUSTY_OS)
 	printf("Start stored_rollback_index wipe process....\n");
 	rbkidx_erase();
 	printf("Wipe stored_rollback_index completed.\n");
 #endif
 	printf("Wipe userdata completed.\n");
 }
 static FbLockState do_fastboot_unlock(bool force)
 {
 	int status;
 	if (fastboot_get_lock_stat() == FASTBOOT_UNLOCK) {
 		printf("The device is already unlocked\n");
 		return FASTBOOT_UNLOCK;
 	}
 	if ((fastboot_lock_enable() == FASTBOOT_UL_ENABLE) || force) {
 		printf("It is able to unlock device. %d\n",fastboot_lock_enable());
 #if defined(CONFIG_SECURE_UNLOCK) && defined(CONFIG_IMX_TRUSTY_OS)
 		if ((fastboot_bytes_received == 0) || !hab_is_enabled()) {
 			printf("No unlock credential found or hab is not closed!\n");
 			return FASTBOOT_LOCK_ERROR;
 		} else {
 			char *serial = get_serial();
 			status = trusty_verify_secure_unlock(fastboot_buf_addr,
 								fastboot_bytes_received,
 								serial, 16);
 			if (status < 0) {
 				printf("verify secure unlock credential fail due Trusty return %d\n", status);
 				return FASTBOOT_LOCK_ERROR;
 			}
 		}
 #endif
 		wipe_all_userdata();
 		status = fastboot_set_lock_stat(FASTBOOT_UNLOCK);
 		if (status < 0)
 			return FASTBOOT_LOCK_ERROR;
 	} else {
 		printf("It is not able to unlock device.");
 		return FASTBOOT_LOCK_ERROR;
 	}
 	return FASTBOOT_UNLOCK;
 }
 static FbLockState do_fastboot_lock(void)
 {
 	int status;
 	if (fastboot_get_lock_stat() == FASTBOOT_LOCK) {
 		printf("The device is already locked\n");
 		return FASTBOOT_LOCK;
 	}
 	wipe_all_userdata();
 	status = fastboot_set_lock_stat(FASTBOOT_LOCK);
 	if (status < 0)
 		return FASTBOOT_LOCK_ERROR;
 	return FASTBOOT_LOCK;
 }
 static bool endswith(char* s, char* subs) {
 	if (!s || !subs)
 		return false;
 	uint32_t len = strlen(s);
 	uint32_t sublen = strlen(subs);
 	if (len < sublen) {
 		return false;
 	}
 	if (strncmp(s + len - sublen, subs, sublen)) {
 		return false;
 	}
 	return true;
 }
 static void flashing(char *cmd, char *response)
 {
 	FbLockState status;
 	FbLockEnableResult result;
 	if (endswith(cmd, "lock_critical")) {
 		strcpy(response, "OKAY");
 	}
 #ifdef CONFIG_AVB_ATX
 	else if (endswith(cmd, FASTBOOT_AVB_AT_PERM_ATTR)) {
 		if (avb_atx_fuse_perm_attr(fastboot_buf_addr, fastboot_bytes_received))
 			strcpy(response, "FAILInternal error!");
 		else
 			strcpy(response, "OKAY");
 	} else if (endswith(cmd, FASTBOOT_AT_GET_UNLOCK_CHALLENGE)) {
 		if (avb_atx_get_unlock_challenge(fsl_avb_ops.atx_ops,
 						fastboot_buf_addr, &fastboot_bytes_received))
 			strcpy(response, "FAILInternal error!");
 		else
 			strcpy(response, "OKAY");
 	} else if (endswith(cmd, FASTBOOT_AT_UNLOCK_VBOOT)) {
 		if (at_unlock_vboot_is_disabled()) {
 			printf("unlock vboot already disabled, can't unlock the device!\n");
 			strcpy(response, "FAILunlock vboot already disabled!.");
 		} else {
 #ifdef CONFIG_AT_AUTHENTICATE_UNLOCK
 			if (avb_atx_verify_unlock_credential(fsl_avb_ops.atx_ops,
 								fastboot_buf_addr))
 				strcpy(response, "FAILIncorrect unlock credential!");
 			else {
 #endif
 				status = do_fastboot_unlock(true);
 				if (status != FASTBOOT_LOCK_ERROR)
 					strcpy(response, "OKAY");
 				else
 					strcpy(response, "FAILunlock device failed.");
 #ifdef CONFIG_AT_AUTHENTICATE_UNLOCK
 			}
 #endif
 		}
 	} else if (endswith(cmd, FASTBOOT_AT_LOCK_VBOOT)) {
 		if (perm_attr_are_fused()) {
 			status = do_fastboot_lock();
 			if (status != FASTBOOT_LOCK_ERROR)
 				strcpy(response, "OKAY");
 			else
 				strcpy(response, "FAILlock device failed.");
 		} else
 			strcpy(response, "FAILpermanent attributes not fused!");
 	} else if (endswith(cmd, FASTBOOT_AT_DISABLE_UNLOCK_VBOOT)) {
 		/* This command can only be called after 'oem at-lock-vboot' */
 		status = fastboot_get_lock_stat();
 		if (status == FASTBOOT_LOCK) {
 			if (at_unlock_vboot_is_disabled()) {
 				printf("unlock vboot already disabled!\n");
 				strcpy(response, "OKAY");
 			}
 			else {
 				if (!at_disable_vboot_unlock())
 					strcpy(response, "OKAY");
 				else
 					strcpy(response, "FAILdisable unlock vboot fail!");
 			}
 		} else
 			strcpy(response, "FAILplease lock the device first!");
 	}
 #endif /* CONFIG_AVB_ATX */
 #ifdef CONFIG_ANDROID_THINGS_SUPPORT
 	else if (endswith(cmd, FASTBOOT_BOOTLOADER_VBOOT_KEY)) {
 		strcpy(response, "OKAY");
 	}
 #endif /* CONFIG_ANDROID_THINGS_SUPPORT */
 #ifdef CONFIG_IMX_TRUSTY_OS
 	else if (endswith(cmd, FASTBOOT_GET_CA_REQ)) {
 		uint8_t *ca_output;
 		uint32_t ca_length, cp_length;
 		if (trusty_atap_get_ca_request(fastboot_buf_addr, fastboot_bytes_received,
 						&(ca_output), &ca_length)) {
 			printf("ERROR get_ca_request failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			cp_length = min((uint32_t)CONFIG_FASTBOOT_BUF_SIZE, ca_length);
 			memcpy(fastboot_buf_addr, ca_output, cp_length);
 			fastboot_bytes_received = ca_length;
 			strcpy(response, "OKAY");
 		}
 	} else if (endswith(cmd, FASTBOOT_SET_CA_RESP)) {
 		if (trusty_atap_set_ca_response(fastboot_buf_addr, fastboot_bytes_received)) {
 			printf("ERROR set_ca_response failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else
 			strcpy(response, "OKAY");
 	} else if (endswith(cmd, FASTBOOT_SET_RSA_ATTESTATION_KEY_ENC)) {
 		if (trusty_set_attestation_key_enc(fastboot_buf_addr,
 							fastboot_bytes_received,
 							KM_ALGORITHM_RSA)) {
 			printf("ERROR set rsa attestation key failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Set rsa attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	} else if (endswith(cmd, FASTBOOT_SET_EC_ATTESTATION_KEY_ENC)) {
 		if (trusty_set_attestation_key_enc(fastboot_buf_addr,
 							fastboot_bytes_received,
 							KM_ALGORITHM_EC)) {
 			printf("ERROR set ec attestation key failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Set ec attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	} else if (endswith(cmd, FASTBOOT_APPEND_RSA_ATTESTATION_CERT_ENC)) {
 		if (trusty_append_attestation_cert_chain_enc(fastboot_buf_addr,
 								fastboot_bytes_received,
 								KM_ALGORITHM_RSA)) {
 			printf("ERROR append rsa attestation cert chain failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Append rsa attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	}  else if (endswith(cmd, FASTBOOT_APPEND_EC_ATTESTATION_CERT_ENC)) {
 		if (trusty_append_attestation_cert_chain_enc(fastboot_buf_addr,
 								fastboot_bytes_received,
 								KM_ALGORITHM_EC)) {
 			printf("ERROR append ec attestation cert chain failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Append ec attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	} else if (endswith(cmd, FASTBOOT_SET_RSA_ATTESTATION_KEY)) {
 		if (trusty_set_attestation_key(fastboot_buf_addr,
 						fastboot_bytes_received,
 						KM_ALGORITHM_RSA)) {
 			printf("ERROR set rsa attestation key failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Set rsa attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	} else if (endswith(cmd, FASTBOOT_SET_EC_ATTESTATION_KEY)) {
 		if (trusty_set_attestation_key(fastboot_buf_addr,
 						fastboot_bytes_received,
 						KM_ALGORITHM_EC)) {
 			printf("ERROR set ec attestation key failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Set ec attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	} else if (endswith(cmd, FASTBOOT_APPEND_RSA_ATTESTATION_CERT)) {
 		if (trusty_append_attestation_cert_chain(fastboot_buf_addr,
 							fastboot_bytes_received,
 							KM_ALGORITHM_RSA)) {
 			printf("ERROR append rsa attestation cert chain failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Append rsa attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	}  else if (endswith(cmd, FASTBOOT_APPEND_EC_ATTESTATION_CERT)) {
 		if (trusty_append_attestation_cert_chain(fastboot_buf_addr,
 							fastboot_bytes_received,
 							KM_ALGORITHM_EC)) {
 			printf("ERROR append ec attestation cert chain failed!\n");
 			strcpy(response, "FAILInternal error!");
 		} else {
 			printf("Append ec attestation key successfully!\n");
 			strcpy(response, "OKAY");
 		}
 	}  else if (endswith(cmd, FASTBOOT_GET_MPPUBK)) {
 		if (fastboot_get_mppubk(fastboot_buf_addr, &fastboot_bytes_received)) {
 			printf("ERROR Generate mppubk failed!\n");
 			strcpy(response, "FAILGenerate mppubk failed!");
 		} else {
 			printf("mppubk generated!\n");
 			strcpy(response, "OKAY");
 		}
 	}  else if (endswith(cmd, FASTBOOT_GET_SERIAL_NUMBER)) {
 		char *serial = get_serial();
 		if (!serial)
 			strcpy(response, "FAILSerial number not support!");
 		else {
 			/* Serial number will not exceed 16 bytes.*/
 			strncpy(fastboot_buf_addr, serial, 16);
 			fastboot_bytes_received = 16;
 			printf("Serial number generated!\n");
 			strcpy(response, "OKAY");
 		}
 	}
 #ifndef CONFIG_AVB_ATX
 	else if (endswith(cmd, FASTBOOT_SET_RPMB_KEY)) {
 		if (fastboot_set_rpmb_key(fastboot_buf_addr, fastboot_bytes_received)) {
 			printf("ERROR set rpmb key failed!\n");
 			strcpy(response, "FAILset rpmb key failed!");
 		} else
 			strcpy(response, "OKAY");
 	} else if (endswith(cmd, FASTBOOT_SET_RPMB_RANDOM_KEY)) {
 		if (fastboot_set_rpmb_random_key()) {
 			printf("ERROR set rpmb random key failed!\n");
 			strcpy(response, "FAILset rpmb random key failed!");
 		} else
 			strcpy(response, "OKAY");
 	} else if (endswith(cmd, FASTBOOT_SET_VBMETA_PUBLIC_KEY)) {
 		if (avb_set_public_key(fastboot_buf_addr,
 					fastboot_bytes_received))
 			strcpy(response, "FAILcan't set public key!");
 		else
 			strcpy(response, "OKAY");
 	}
 #endif /* !CONFIG_AVB_ATX */
 #endif /* CONFIG_IMX_TRUSTY_OS */
 	else if (endswith(cmd, "unlock_critical")) {
 		strcpy(response, "OKAY");
 	} else if (endswith(cmd, "unlock")) {
 		printf("flashing unlock.\n");
 #ifdef CONFIG_AVB_ATX
 		/* We should do nothing here For Android Things which
 		 * enables the authenticated unlock feature.
 		 */
 		strcpy(response, "OKAY");
 #else
 		status = do_fastboot_unlock(false);
 		if (status != FASTBOOT_LOCK_ERROR)
 			strcpy(response, "OKAY");
 		else
 			strcpy(response, "FAILunlock device failed.");
 #endif
 	} else if (endswith(cmd, "lock")) {
 #ifdef CONFIG_AVB_ATX
 		/* We should do nothing here For Android Things which
 		 * enables the at-lock-vboot feature.
 		 */
 		strcpy(response, "OKAY");
 #else
 		printf("flashing lock.\n");
 		status = do_fastboot_lock();
 		if (status != FASTBOOT_LOCK_ERROR)
 			strcpy(response, "OKAY");
 		else
 			strcpy(response, "FAILlock device failed.");
 #endif
 	} else if (endswith(cmd, "get_unlock_ability")) {
 		result = fastboot_lock_enable();
 		if (result == FASTBOOT_UL_ENABLE) {
 			fastboot_tx_write_more("INFO1");
 			strcpy(response, "OKAY");
 		} else if (result == FASTBOOT_UL_DISABLE) {
 			fastboot_tx_write_more("INFO0");
 			strcpy(response, "OKAY");
 		} else {
 			printf("flashing get_unlock_ability fail!\n");
 			strcpy(response, "FAILget unlock ability failed.");
 		}
 	} else {
 		printf("Unknown flashing command:%s\n", cmd);
 		strcpy(response, "FAILcommand not defined");
 	}
 	fastboot_tx_write_more(response);
 	/* Must call fastboot_none_resp before returning from the dispatch function
 	 *  which uses fastboot_tx_write_more
 	 */
 	fastboot_none_resp(response);
 }
 #endif /* CONFIG_FASTBOOT_LOCK */
 #ifdef CONFIG_AVB_SUPPORT
 static void set_active_avb(char *cmd, char *response)
 {
 	AvbIOResult ret;
 	int slot = 0;
 	if (!cmd) {
 		pr_err("missing slot suffix\n");
 		fastboot_fail("missing slot suffix", response);
 		return;
 	}
 	slot = slotidx_from_suffix(cmd);
 	if (slot < 0) {
 		fastboot_fail("err slot suffix", response);
 		return;
 	}
 	ret = avb_ab_mark_slot_active(&fsl_avb_ab_ops, slot);
 	if (ret != AVB_IO_RESULT_OK)
 		fastboot_fail("avb IO error", response);
 	else
 		fastboot_okay(NULL, response);
 	return;
 }
 #endif /*CONFIG_AVB_SUPPORT*/
 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
 static void flash(char *cmd, char *response)
 {
 	if (!cmd) {
 		pr_err("missing partition name");
 		fastboot_fail("missing partition name", response);
 		return;
 	}
 	/* Always enable image flash for Android Things. */
 #if defined(CONFIG_FASTBOOT_LOCK) && !defined(CONFIG_AVB_ATX)
 	int status;
 	status = fastboot_get_lock_stat();
 	if (status == FASTBOOT_LOCK) {
 		pr_err("device is LOCKed!\n");
 		fastboot_fail("device is locked.", response);
 		return;
 	} else if (status == FASTBOOT_LOCK_ERROR) {
 		pr_err("write lock status into device!\n");
 		fastboot_set_lock_stat(FASTBOOT_LOCK);
 		fastboot_fail("device is locked.", response);
 		return;
 	}
 #endif
 	fastboot_process_flash(cmd, fastboot_buf_addr,
 		fastboot_bytes_received, response);
 #if defined(CONFIG_FASTBOOT_LOCK)
 	if (strncmp(cmd, "gpt", 3) == 0) {
 		int gpt_valid = 0;
 		gpt_valid = partition_table_valid();
 		/* If gpt is valid, load partitons table into memory.
 		   So if the next command is "fastboot reboot bootloader",
 		   it can find the "misc" partition to r/w. */
 		if(gpt_valid) {
 			fastboot_load_partitions();
 			/* Unlock device if the gpt is valid */
 			do_fastboot_unlock(true);
 		}
 	}
 #endif
 }
 static void erase(char *cmd, char *response)
 {
 	if (!cmd) {
 		pr_err("missing partition name");
 		fastboot_fail("missing partition name", response);
 		return;
 	}
 #if defined(CONFIG_FASTBOOT_LOCK) && !defined(CONFIG_AVB_ATX)
 	FbLockState status;
 	status = fastboot_get_lock_stat();
 	if (status == FASTBOOT_LOCK) {
 		pr_err("device is LOCKed!\n");
 		fastboot_fail("device is locked.", response);
 		return;
 	} else if (status == FASTBOOT_LOCK_ERROR) {
 		pr_err("write lock status into device!\n");
 		fastboot_set_lock_stat(FASTBOOT_LOCK);
 		fastboot_fail("device is locked.", response);
 		return;
 	}
 #endif
 	fastboot_process_erase(cmd, response);
 }
 #endif
 /**
  * fastboot_set_reboot_flag() - Set flag to indicate reboot-bootloader
  *
  * This is a redefinition, since BSP dose not need the function of
  * "reboot into bootloader", and with BCB support, the flag can be
  * set with another way. Redefine this function to override the weak
  * definition to avoid error return value.
  */
 int fastboot_set_reboot_flag(void)
 {
 	return 0;
 }
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 /**
  * run_ucmd() - Execute the UCmd command
  *
  * @cmd_parameter: Pointer to command parameter
  * @response: Pointer to fastboot response buffer
  */
 static void run_ucmd(char *cmd_parameter, char *response)
 {
 	if (!cmd_parameter) {
 		pr_err("missing slot suffix\n");
 		fastboot_fail("missing command", response);
 		return;
 	}
 	if(run_command(cmd_parameter, 0)) {
 		fastboot_fail("", response);
 	} else {
 		fastboot_okay(NULL, response);
 		/* cmd may impact fastboot related environment*/
 		fastboot_setup();
 	}
 }
 static char g_a_cmd_buff[64];
 void fastboot_acmd_complete(void)
 {
 	run_command(g_a_cmd_buff, 0);
 }
 /**
  * run_acmd() - Execute the ACmd command
  *
  * @cmd_parameter: Pointer to command parameter
  * @response: Pointer to fastboot response buffer
  */
 static void run_acmd(char *cmd_parameter, char *response)
 {
         if (!cmd_parameter) {
                 pr_err("missing slot suffix\n");
                 fastboot_fail("missing command", response);
                 return;
         }
 	strcpy(g_a_cmd_buff, cmd_parameter);
 	fastboot_okay(NULL, response);
 }
 #endif
 static const struct {
 	const char *command;
 	void (*dispatch)(char *cmd_parameter, char *response);
 } commands[FASTBOOT_COMMAND_COUNT] = {
 		[FASTBOOT_COMMAND_REBOOT_BOOTLOADER] = {
 			.command = "reboot-bootloader",
 			.dispatch = reboot_bootloader,
 		},
 		[FASTBOOT_COMMAND_UPLOAD] = {
 			.command = "upload",
 			.dispatch = upload,
 		},
 		[FASTBOOT_COMMAND_GETSTAGED] = {
 			.command = "get_staged",
 			.dispatch = upload,
 		},
 #if defined(CONFIG_FASTBOOT_LOCK)
 		[FASTBOOT_COMMAND_FLASHING] = {
 			.command = "flashing",
 			.dispatch = flashing,
 		},
 		[FASTBOOT_COMMAND_OEM] = {
 			.command = "oem",
 			.dispatch = flashing,
 		},
 #endif
 #ifdef CONFIG_AVB_SUPPORT
 		[FASTBOOT_COMMAND_SETACTIVE] = {
 			.command = "set_active",
 			.dispatch = set_active_avb,
 		},
 #endif
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 		[FASTBOOT_COMMAND_UCMD] = {
 			.command = "UCmd",
 			.dispatch = run_ucmd,
 		},
 		[FASTBOOT_COMMAND_ACMD] = {
 			.command ="ACmd",
 			.dispatch = run_acmd,
 		},
 #endif
 		[FASTBOOT_COMMAND_REBOOT] = {
 			.command = "reboot",
 			.dispatch = okay,
 		},
 		[FASTBOOT_COMMAND_GETVAR] = {
 			.command = "getvar",
 			.dispatch = getvar,
 		},
 		[FASTBOOT_COMMAND_DOWNLOAD] = {
 			.command = "download",
 			.dispatch = download,
 		},
 		[FASTBOOT_COMMAND_BOOT] = {
 			.command = "boot",
 			.dispatch = okay,
 		},
 		[FASTBOOT_COMMAND_CONTINUE] = {
 			.command = "continue",
 			.dispatch = okay,
 		},
 #ifdef CONFIG_FASTBOOT_FLASH
 		[FASTBOOT_COMMAND_FLASH] = {
 			.command = "flash",
 			.dispatch = flash,
 		},
 		[FASTBOOT_COMMAND_ERASE] = {
 			.command = "erase",
 			.dispatch = erase,
 		},
 #endif
 #ifdef CONFIG_AVB_ATX
 		[FASTBOOT_COMMAND_STAGE] = {
 			.command = "stage",
 			.dispatch = download,
+		},
+#endif
+#ifdef CONFIG_ANDROID_RECOVERY
+		[FASTBOOT_COMMAND_RECOVERY_FASTBOOT] = {
+			.command = "reboot-fastboot",
+			.dispatch = reboot_fastboot,
 		},
 #endif
 };
 /**
  * fastboot_handle_command - Handle fastboot command
  *
  * @cmd_string: Pointer to command string
  * @response: Pointer to fastboot response buffer
  *
  * Return: Executed command, or -1 if not recognized
  */
 int fastboot_handle_command(char *cmd_string, char *response)
 {
 	int i;
 	char *cmd_parameter;
 	cmd_parameter = cmd_string;
 	strsep(&cmd_parameter, ":");
 	/* separate cmdstring for "fastboot oem/flashing" with a blank */
 	if(cmd_parameter == NULL)
 	{
 		cmd_parameter = cmd_string;
 		strsep(&cmd_parameter, " ");
 	}
 	for (i = 0; i < ARRAY_SIZE(commands); i++) {
 		if (commands[i].command != NULL &&
 			!strcmp(commands[i].command, cmd_string)) {
 			if (commands[i].dispatch) {
 				commands[i].dispatch(cmd_parameter,
 							response);
 				return i;
 			} else {
 				break;
 			}
 		}
 	}
 	pr_err("command %s not recognized.\n", cmd_string);
 	fastboot_fail("unrecognized command", response);
 	return -1;
 }

drivers/fastboot/fb_fsl/fb_fsl_getvar.c

Diff comments View file @ 8cb9cd7

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright 2019 NXP
  */
 #include <common.h>
 #include <asm/mach-imx/sys_proto.h>
 #include <fb_fsl.h>
 #include <fastboot.h>
 #include <mmc.h>
 #include <android_image.h>
 #include <asm/bootm.h>
 #include <nand.h>
 #include <part.h>
 #include <sparse_format.h>
 #include <image-sparse.h>
 #include <image.h>
 #include <asm/mach-imx/boot_mode.h>
 #include <asm/arch/sys_proto.h>
 #include <asm/setup.h>
 #include <env.h>
 #include <version.h>
 #ifdef CONFIG_AVB_SUPPORT
 #include <dt_table.h>
 #include <fsl_avb.h>
 #endif
 #ifdef CONFIG_ANDROID_THINGS_SUPPORT
 #include <asm-generic/gpio.h>
 #include <asm/mach-imx/gpio.h>
 #include "../lib/avb/fsl/fsl_avbkey.h"
 #include "../arch/arm/include/asm/mach-imx/hab.h"
 #endif
 #if defined(CONFIG_FASTBOOT_LOCK)
 #include "fastboot_lock_unlock.h"
 #endif
 #include "fb_fsl_common.h"
 #ifdef CONFIG_IMX_TRUSTY_OS
 #include "u-boot/sha256.h"
 #include <trusty/libtipc.h>
 #define ATAP_UUID_SIZE 32
 #define ATAP_UUID_STR_SIZE ((ATAP_UUID_SIZE*2) + 1)
 #endif
 #if defined(CONFIG_ANDROID_THINGS_SUPPORT) && defined(CONFIG_ARCH_IMX8M)
-#define FASTBOOT_COMMON_VAR_NUM 14
+#define FASTBOOT_COMMON_VAR_NUM 15
 #else
-#define FASTBOOT_COMMON_VAR_NUM 13
+#define FASTBOOT_COMMON_VAR_NUM 14
 #endif
 #define FASTBOOT_VAR_YES    "yes"
 #define FASTBOOT_VAR_NO     "no"
 /* common variables of fastboot getvar command */
 char *fastboot_common_var[FASTBOOT_COMMON_VAR_NUM] = {
 	"version",
 	"version-bootloader",
 	"version-baseband",
 	"product",
 	"secure",
 	"max-download-size",
 	"erase-block-size",
 	"logical-block-size",
 	"unlocked",
 	"off-mode-charge",
 	"battery-voltage",
 	"variant",
 	"battery-soc-ok",
+	"is-userspace",
 #if defined(CONFIG_ANDROID_THINGS_SUPPORT) && defined(CONFIG_ARCH_IMX8M)
 	"baseboard_id"
 #endif
 };
 /* at-vboot-state variable list */
 #ifdef CONFIG_AVB_ATX
 #define AT_VBOOT_STATE_VAR_NUM 6
 extern struct imx_sec_config_fuse_t const imx_sec_config_fuse;
 extern int fuse_read(u32 bank, u32 word, u32 *val);
 char *fastboot_at_vboot_state_var[AT_VBOOT_STATE_VAR_NUM] = {
 	"bootloader-locked",
 	"bootloader-min-versions",
 	"avb-perm-attr-set",
 	"avb-locked",
 	"avb-unlock-disabled",
 	"avb-min-versions"
 };
 #endif
 static int strcmp_l1(const char *s1, const char *s2)
 {
 	if (!s1 || !s2)
 		return -1;
 	return strncmp(s1, s2, strlen(s1));
 }
 static bool is_slotvar(char *cmd)
 {
 	assert(cmd != NULL);
 	if (!strcmp_l1("has-slot:", cmd) ||
 		!strcmp_l1("slot-successful:", cmd) ||
 		!strcmp_l1("slot-count", cmd) ||
 		!strcmp_l1("slot-suffixes", cmd) ||
 		!strcmp_l1("current-slot", cmd) ||
 		!strcmp_l1("slot-unbootable:", cmd) ||
 		!strcmp_l1("slot-retry-count:", cmd))
 			return true;
 	return false;
 }
 static char serial[IMX_SERIAL_LEN];
 char *get_serial(void)
 {
 #ifdef CONFIG_SERIAL_TAG
 	struct tag_serialnr serialnr;
 	memset(serial, 0, IMX_SERIAL_LEN);
 	get_board_serial(&serialnr);
 	sprintf(serial, "%08x%08x", serialnr.high, serialnr.low);
 	return serial;
 #else
 	return NULL;
 #endif
 }
 #if !defined(PRODUCT_NAME)
 #define PRODUCT_NAME "NXP i.MX"
 #endif
 #if !defined(VARIANT_NAME)
 #define VARIANT_NAME "NXP i.MX"
 #endif
 #ifdef CONFIG_IMX_TRUSTY_OS
 static void uuid_hex2string(uint8_t *uuid, char* buf, uint32_t uuid_len, uint32_t uuid_strlen) {
 	uint32_t i;
 	if (!uuid || !buf)
 		return;
 	char *cp = buf;
 	char *buf_end = buf + uuid_strlen;
 	for (i = 0; i < uuid_len; i++) {
 		cp += snprintf(cp, buf_end - cp, "%02x", uuid[i]);
 	}
 }
 #endif
 #if defined(CONFIG_ANDROID_THINGS_SUPPORT) && defined(CONFIG_ARCH_IMX8M)
 int get_imx8m_baseboard_id(void);
 #endif
 static int get_single_var(char *cmd, char *response)
 {
 	char *str = cmd;
 	int chars_left;
 	const char *s;
 	struct mmc *mmc;
 	int mmc_dev_no;
 	int blksz;
 	chars_left = FASTBOOT_RESPONSE_LEN - strlen(response) - 1;
 	if ((str = strstr(cmd, "partition-size:"))) {
 		str +=strlen("partition-size:");
 		struct fastboot_ptentry* fb_part;
 		fb_part = fastboot_flash_find_ptn(str);
 		if (!fb_part) {
 			strncat(response, "Wrong partition name.", chars_left);
 			fastboot_flash_dump_ptn();
 			return -1;
 		} else {
 			snprintf(response + strlen(response), chars_left,
 				 "0x%llx",
 				 (uint64_t)fb_part->length * get_block_size());
 		}
 	} else if ((str = strstr(cmd, "partition-type:"))) {
 		str +=strlen("partition-type:");
 		struct fastboot_ptentry* fb_part;
 		fb_part = fastboot_flash_find_ptn(str);
 		if (!fb_part) {
 			strncat(response, "Wrong partition name.", chars_left);
 			fastboot_flash_dump_ptn();
 			return -1;
 		} else {
 			strncat(response, fb_part->fstype, chars_left);
 		}
 	} else if ((str = strstr(cmd, "is-logical:"))) {
 		str +=strlen("is-logical:");
 		struct fastboot_ptentry* fb_part;
 		fb_part = fastboot_flash_find_ptn(str);
 		if (!fb_part) {
 			return -1;
 		} else {
 			snprintf(response + strlen(response), chars_left, "no");
 		}
 	} else if (!strcmp_l1("version-baseband", cmd)) {
 		strncat(response, "N/A", chars_left);
 	} else if (!strcmp_l1("version-bootloader", cmd) ||
 		!strcmp_l1("bootloader-version", cmd)) {
 		strncat(response, U_BOOT_VERSION, chars_left);
 	} else if (!strcmp_l1("version", cmd)) {
 		strncat(response, FASTBOOT_VERSION, chars_left);
 	} else if (!strcmp_l1("battery-voltage", cmd)) {
 		strncat(response, "0mV", chars_left);
 	} else if (!strcmp_l1("battery-soc-ok", cmd)) {
 		strncat(response, "yes", chars_left);
 	} else if (!strcmp_l1("variant", cmd)) {
 		strncat(response, VARIANT_NAME, chars_left);
 	} else if (!strcmp_l1("off-mode-charge", cmd)) {
 		strncat(response, "1", chars_left);
+	} else if (!strcmp_l1("is-userspace", cmd)) {
+		strncat(response, FASTBOOT_VAR_NO, chars_left);
 	} else if (!strcmp_l1("downloadsize", cmd) ||
 		!strcmp_l1("max-download-size", cmd)) {
 		snprintf(response + strlen(response), chars_left, "0x%x", CONFIG_FASTBOOT_BUF_SIZE);
 	} else if (!strcmp_l1("erase-block-size", cmd)) {
 		mmc_dev_no = mmc_get_env_dev();
 		mmc = find_mmc_device(mmc_dev_no);
 		blksz = get_block_size();
 		snprintf(response + strlen(response), chars_left, "0x%x",
 				(blksz * mmc->erase_grp_size));
 	} else if (!strcmp_l1("logical-block-size", cmd)) {
 		blksz = get_block_size();
 		snprintf(response + strlen(response), chars_left, "0x%x", blksz);
 	} else if (!strcmp_l1("serialno", cmd)) {
 		s = get_serial();
 		if (s)
 			strncat(response, s, chars_left);
 		else {
 			strncat(response, "FAILValue not set", chars_left);
 			return -1;
 		}
 	} else if (!strcmp_l1("product", cmd)) {
 		strncat(response, PRODUCT_NAME, chars_left);
 	}
 #ifdef CONFIG_IMX_TRUSTY_OS
         else if(!strcmp_l1("at-attest-uuid", cmd)) {
 		char *uuid;
 		char uuid_str[ATAP_UUID_STR_SIZE];
 		if (trusty_atap_read_uuid_str(&uuid)) {
 			printf("ERROR read uuid failed!\n");
 			strncat(response, "FAILCannot get uuid!", chars_left);
 			return -1;
 		} else {
 			uuid_hex2string((uint8_t*)uuid, uuid_str,ATAP_UUID_SIZE, ATAP_UUID_STR_SIZE);
 			strncat(response, uuid_str, chars_left);
 			trusty_free(uuid);
 		}
 	}
 	else if(!strcmp_l1("at-attest-dh", cmd)) {
 		strncat(response, "1:P256,2:curve25519", chars_left);
 	}
 #endif
 #if defined(CONFIG_FASTBOOT_LOCK)
 	else if (!strcmp_l1("secure", cmd)) {
 		strncat(response, FASTBOOT_VAR_YES, chars_left);
 	} else if (!strcmp_l1("unlocked",cmd)){
 		int status = fastboot_get_lock_stat();
 		if (status == FASTBOOT_UNLOCK) {
 			strncat(response, FASTBOOT_VAR_YES, chars_left);
 		} else {
 			strncat(response, FASTBOOT_VAR_NO, chars_left);
 		}
 	}
 #else
 	else if (!strcmp_l1("secure", cmd)) {
 		strncat(response, FASTBOOT_VAR_NO, chars_left);
 	} else if (!strcmp_l1("unlocked",cmd)) {
 		strncat(response, FASTBOOT_VAR_NO, chars_left);
 	}
 #endif
 	else if (is_slotvar(cmd)) {
 #ifdef CONFIG_AVB_SUPPORT
 		if (get_slotvar_avb(&fsl_avb_ab_ops, cmd,
 				response + strlen(response), chars_left + 1) < 0)
 			return -1;
 #else
 		strncat(response, FASTBOOT_VAR_NO, chars_left);
 #endif
 	}
 #if defined(CONFIG_ANDROID_THINGS_SUPPORT) && defined(CONFIG_ARCH_IMX8M)
 	else if (!strcmp_l1("baseboard_id", cmd)) {
 		int baseboard_id;
 		baseboard_id = get_imx8m_baseboard_id();
 		if (baseboard_id < 0) {
 			printf("Get baseboard id failed!\n");
 			strncat(response, "Get baseboard id failed!", chars_left);
 			return -1;
 		} else
 			snprintf(response + strlen(response), chars_left, "0x%x", baseboard_id);
 	}
 #endif
 #ifdef CONFIG_AVB_ATX
 	else if (!strcmp_l1("bootloader-locked", cmd)) {
 		/* Below is basically copied from is_hab_enabled() */
 		struct imx_sec_config_fuse_t *fuse =
 			(struct imx_sec_config_fuse_t *)&imx_sec_config_fuse;
 		uint32_t reg;
 		int ret;
 		/* Read the secure boot status from fuse. */
 		ret = fuse_read(fuse->bank, fuse->word, &reg);
 		if (ret) {
 			printf("\nSecure boot fuse read error!\n");
 			strncat(response, "Secure boot fuse read error!", chars_left);
 			return -1;
 		}
 		/* Check if the secure boot bit is enabled */
 		if ((reg & 0x2000000) == 0x2000000)
 			strncat(response, "1", chars_left);
 		else
 			strncat(response, "0", chars_left);
 	} else if (!strcmp_l1("bootloader-min-versions", cmd)) {
 #ifndef CONFIG_ARM64
 		/* We don't support bootloader rbindex protection for
 		 * ARM32(like imx7d) and the format is: "bootloader,tee". */
 		strncat(response, "-1,-1", chars_left);
 #elif defined(CONFIG_DUAL_BOOTLOADER)
 		/* Rbindex protection for bootloader is supported only when the
 		 * 'dual bootloader' feature is enabled. U-boot will get the rbindx
 		 * from RAM which is passed by spl because we can only get the rbindex
 		 * at spl stage. The format in this case is: "spl,atf,tee,u-boot".
 		 */
 		struct bl_rbindex_package *bl_rbindex;
 		uint32_t rbindex;
 		bl_rbindex = (struct bl_rbindex_package *)BL_RBINDEX_LOAD_ADDR;
 		if (!strncmp(bl_rbindex->magic, BL_RBINDEX_MAGIC,
 				BL_RBINDEX_MAGIC_LEN)) {
 			rbindex = bl_rbindex->rbindex;
 			snprintf(response + strlen(response), chars_left,
 					"-1,%d,%d,%d",rbindex, rbindex, rbindex);
 		} else {
 			printf("Error bootloader rbindex magic!\n");
 			strncat(response, "Get bootloader rbindex fail!", chars_left);
 			return -1;
 		}
 #else
 		/* Return -1 for all partition if 'dual bootloader' feature
 		 * is not enabled */
 		strncat(response, "-1,-1,-1,-1", chars_left);
 #endif
 	} else if (!strcmp_l1("avb-perm-attr-set", cmd)) {
 		if (perm_attr_are_fused())
 			strncat(response, "1", chars_left);
 		else
 			strncat(response, "0", chars_left);
 	} else if (!strcmp_l1("avb-locked", cmd)) {
 		FbLockState status;
 		status = fastboot_get_lock_stat();
 		if (status == FASTBOOT_LOCK)
 			strncat(response, "1", chars_left);
 		else if (status == FASTBOOT_UNLOCK)
 			strncat(response, "0", chars_left);
 		else {
 			printf("Get lock state error!\n");
 			strncat(response, "Get lock state failed!", chars_left);
 			return -1;
 		}
 	} else if (!strcmp_l1("avb-unlock-disabled", cmd)) {
 		if (at_unlock_vboot_is_disabled())
 			strncat(response, "1", chars_left);
 		else
 			strncat(response, "0", chars_left);
 	} else if (!strcmp_l1("avb-min-versions", cmd)) {
 		int i = 0;
 		/* rbindex location/value can be very large
 		 * number so we reserve enough space here.
 		 */
 		char buffer[35];
 		uint32_t rbindex_location[AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS + 2];
 		uint32_t location;
 		uint64_t rbindex;
 		memset(buffer, '\0', sizeof(buffer));
 		/* Set rbindex locations. */
 		for (i = 0; i < AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS; i++)
 			rbindex_location[i] = i;
 		/* Set Android Things key version rbindex locations */
 		rbindex_location[AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS]
 						= AVB_ATX_PIK_VERSION_LOCATION;
 		rbindex_location[AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS + 1]
 						= AVB_ATX_PSK_VERSION_LOCATION;
 		/* Read rollback index and set the reponse*/
 		for (i = 0; i < AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS + 2; i++) {
 			location = rbindex_location[i];
 			if (fsl_avb_ops.read_rollback_index(&fsl_avb_ops,
 								location, &rbindex)
 								!= AVB_IO_RESULT_OK) {
 				printf("Read rollback index error!\n");
 				snprintf(response, FASTBOOT_RESPONSE_LEN,
 					"INFOread rollback index error when get avb-min-versions");
 				return -1;
 			}
 			/* Generate the "location:value" pair */
 			snprintf(buffer, sizeof(buffer), "%d:%lld", location, rbindex);
 			if (i != AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS + 1)
 				strncat(buffer, ",", strlen(","));
 			if ((chars_left - (int)strlen(buffer)) >= 0) {
 				strncat(response, buffer, strlen(buffer));
 				chars_left -= strlen(buffer);
 			} else {
 				strncat(response, buffer, chars_left);
 				/* reponse buffer is full, send it first */
 				fastboot_tx_write_more(response);
 				/* reset the reponse buffer for next round */
 				memset(response, '\0', FASTBOOT_RESPONSE_LEN);
 				strncpy(response, "INFO", 5);
 				/* Copy left strings from 'buffer' to 'response' */
 				strncat(response, buffer + chars_left, strlen(buffer));
 				chars_left = FASTBOOT_RESPONSE_LEN -
 						strlen(response) - 1;
 			}
 		}
 	}
 #endif
 	else {
 		char envstr[32];
 		snprintf(envstr, sizeof(envstr) - 1, "fastboot.%s", cmd);
 		s = env_get(envstr);
 		if (s) {
 			strncat(response, s, chars_left);
 		} else {
 			snprintf(response, chars_left, "FAILunknown variable:%s",cmd);
 			printf("WARNING: unknown variable: %s\n", cmd);
 			return -1;
 		}
 	}
 	return 0;
 }
 void fastboot_getvar(char *cmd, char *response)
 {
 	int n = 0;
 	int status = 0;
 	int count = 0;
 	char var_name[FASTBOOT_RESPONSE_LEN];
 	char partition_base_name[MAX_PTN][16];
 	char slot_suffix[2][5] = {"a","b"};
 	if (!cmd) {
 		pr_err("missing variable");
 		fastboot_fail("missing var", response);
 		return;
 	}
 	if (!strcmp_l1("all", cmd)) {
 		memset(response, '\0', FASTBOOT_RESPONSE_LEN);
 		/* get common variables */
 		for (n = 0; n < FASTBOOT_COMMON_VAR_NUM; n++) {
 			snprintf(response, FASTBOOT_RESPONSE_LEN, "INFO%s:", fastboot_common_var[n]);
 			get_single_var(fastboot_common_var[n], response);
 			fastboot_tx_write_more(response);
 		}
 		/* get at-vboot-state variables */
 #ifdef CONFIG_AVB_ATX
 		for (n = 0; n < AT_VBOOT_STATE_VAR_NUM; n++) {
 			snprintf(response, FASTBOOT_RESPONSE_LEN, "INFO%s:", fastboot_at_vboot_state_var[n]);
 			get_single_var(fastboot_at_vboot_state_var[n], response);
 			fastboot_tx_write_more(response);
 		}
 #endif
 		/* get partition type */
 		for (n = 0; n < g_pcount; n++) {
 			snprintf(response, FASTBOOT_RESPONSE_LEN, "INFOpartition-type:%s:", g_ptable[n].name);
 			snprintf(var_name, sizeof(var_name), "partition-type:%s", g_ptable[n].name);
 			get_single_var(var_name, response);
 			fastboot_tx_write_more(response);
 		}
 		/* get partition size */
 		for (n = 0; n < g_pcount; n++) {
 			snprintf(response, FASTBOOT_RESPONSE_LEN, "INFOpartition-size:%s:", g_ptable[n].name);
 			snprintf(var_name, sizeof(var_name), "partition-size:%s", g_ptable[n].name);
 			get_single_var(var_name,response);
 			fastboot_tx_write_more(response);
 		}
 		/* slot related variables */
 		if (fastboot_parts_is_slot()) {
 			/* get has-slot variables */
 			count = fastboot_parts_get_name(partition_base_name);
 			for (n = 0; n < count; n++) {
 				snprintf(response, FASTBOOT_RESPONSE_LEN, "INFOhas-slot:%s:", partition_base_name[n]);
 				snprintf(var_name, sizeof(var_name), "has-slot:%s", partition_base_name[n]);
 				get_single_var(var_name,response);
 				fastboot_tx_write_more(response);
 			}
 			/* get current slot */
 			strncpy(response, "INFOcurrent-slot:", FASTBOOT_RESPONSE_LEN);
 			get_single_var("current-slot", response);
 			fastboot_tx_write_more(response);
 			/* get slot count */
 			strncpy(response, "INFOslot-count:", FASTBOOT_RESPONSE_LEN);
 			get_single_var("slot-count", response);
 			fastboot_tx_write_more(response);
 			/* get slot-successful variable */
 			for (n = 0; n < 2; n++) {
 				snprintf(response, FASTBOOT_RESPONSE_LEN, "INFOslot-successful:%s:", slot_suffix[n]);
 				snprintf(var_name, sizeof(var_name), "slot-successful:%s", slot_suffix[n]);
 				get_single_var(var_name, response);
 				fastboot_tx_write_more(response);
 			}
 			/*get slot-unbootable variable*/
 			for (n = 0; n < 2; n++) {
 				snprintf(response, FASTBOOT_RESPONSE_LEN, "INFOslot-unbootable:%s:", slot_suffix[n]);
 				snprintf(var_name, sizeof(var_name), "slot-unbootable:%s", slot_suffix[n]);
 				get_single_var(var_name, response);
 				fastboot_tx_write_more(response);
 			}
 			/*get slot-retry-count variable*/
 			for (n = 0; n < 2; n++) {
 				snprintf(response, FASTBOOT_RESPONSE_LEN, "INFOslot-retry-count:%s:", slot_suffix[n]);
 				snprintf(var_name, sizeof(var_name), "slot-retry-count:%s", slot_suffix[n]);
 				get_single_var(var_name, response);
 				fastboot_tx_write_more(response);
 			}
 		}
 		strncpy(response, "OKAYDone!", 10);
 		fastboot_tx_write_more(response);
 		fastboot_none_resp(response);
 		return;
 	}
 #ifdef CONFIG_AVB_ATX
 	else if (!strcmp_l1("at-vboot-state", cmd)) {
 			/* get at-vboot-state variables */
 		for (n = 0; n < AT_VBOOT_STATE_VAR_NUM; n++) {
 			snprintf(response, FASTBOOT_RESPONSE_LEN, "INFO%s:", fastboot_at_vboot_state_var[n]);
 			get_single_var(fastboot_at_vboot_state_var[n], response);
 			fastboot_tx_write_more(response);
 		}
 		strncpy(response, "OKAY", 5);
 		fastboot_tx_write_more(response);
 		fastboot_none_resp(response);
 		return;
 	} else if ((!strcmp_l1("bootloader-locked", cmd)) ||
 			(!strcmp_l1("bootloader-min-versions", cmd)) ||
 			(!strcmp_l1("avb-perm-attr-set", cmd)) ||
 			(!strcmp_l1("avb-locked", cmd)) ||
 			(!strcmp_l1("avb-unlock-disabled", cmd)) ||
 			(!strcmp_l1("avb-min-versions", cmd))) {
 		printf("Can't get this variable alone, get 'at-vboot-state' instead!\n");
 		fastboot_fail("Can't get this variable alone, get 'at-vboot-state' instead.", response);
 		return;
 	}
 #endif
 	else {
 		char reason[FASTBOOT_RESPONSE_LEN];
 		memset(reason, '\0', FASTBOOT_RESPONSE_LEN);
 		status = get_single_var(cmd, reason);
 		if (status != 0)
 			fastboot_fail(reason, response);
 		else
 			fastboot_okay(reason, response);
 		return;
 	}
 }

drivers/usb/gadget/f_fastboot.c

Diff comments View file @ 8cb9cd7

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * (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>
  */
 #include <config.h>
 #include <common.h>
 #include <env.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 <g_dnl.h>
 #include <serial.h>
 #include <stdio_dev.h>
 #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
 /*
  * 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.
  */
 typedef struct usb_req usb_req;
 struct usb_req {
 	struct usb_request *in_req;
 	usb_req *next;
 };
 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;
 	usb_req *front, *rear;
 };
 static char fb_ext_prop_name[] = "DeviceInterfaceGUID";
 static char fb_ext_prop_data[] = "{4866319A-F4D6-4374-93B9-DC2DEB361BA9}";
 static struct usb_os_desc_ext_prop fb_ext_prop = {
 	.type = 1,		/* NUL-terminated Unicode String (REG_SZ) */
 	.name = fb_ext_prop_name,
 	.data = fb_ext_prop_data,
 };
 /* 16 bytes of "Compatible ID" and "Subcompatible ID" */
 static char fb_cid[16] = {'W', 'I', 'N', 'U', 'S', 'B'};
 static struct usb_os_desc fb_os_desc = {
 	.ext_compat_id = fb_cid,
 };
 static struct usb_os_desc_table fb_os_desc_table = {
 	.os_desc = &fb_os_desc,
 };
 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 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_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,
 };
 /* Super speed */
 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_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 fb_ss_bulk_comp_desc = {
 	.bLength =		sizeof(fb_ss_bulk_comp_desc),
 	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
 };
 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 *)&fb_ss_bulk_comp_desc,
 	(struct usb_descriptor_header *)&ss_ep_out,
 	(struct usb_descriptor_header *)&fb_ss_bulk_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)
 {
 	if (gadget_is_superspeed(g) && g->speed >= USB_SPEED_SUPER)
 		return ss;
 	if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
 		return hs;
 	return fs;
 }
 /*
  * 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,
 };
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 extern struct stdio_dev g_fastboot_stdio;
 #endif
 static void rx_handler_command(struct usb_ep *ep, struct usb_request *req);
 static void fastboot_fifo_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	int status = req->status;
 	usb_req *request;
 	if (!status) {
 		if (fastboot_func->front != NULL) {
 			request = fastboot_func->front;
 			fastboot_func->front = fastboot_func->front->next;
 			usb_ep_free_request(ep, request->in_req);
 			free(request);
 		} else {
 			printf("fail free request\n");
 		}
 		return;
 	}
 }
 static void fastboot_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	int status = req->status;
 	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;
 	/* Enable OS and Extended Properties Feature Descriptor */
 	c->cdev->use_os_string = 1;
 	f->os_desc_table = &fb_os_desc_table;
 	f->os_desc_n = 1;
 	f->os_desc_table->if_id = id;
 	INIT_LIST_HEAD(&fb_os_desc.ext_prop);
 	fb_ext_prop.name_len = strlen(fb_ext_prop.name) * 2 + 2;
 	fb_os_desc.ext_prop_len = 10 + fb_ext_prop.name_len;
 	fb_os_desc.ext_prop_count = 1;
 	fb_ext_prop.data_len = strlen(fb_ext_prop.data) * 2 + 2;
 	fb_os_desc.ext_prop_len += fb_ext_prop.data_len + 4;
 	list_add_tail(&fb_ext_prop.entry, &fb_os_desc.ext_prop);
 	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)) {
 		ss_ep_in.bEndpointAddress = fs_ep_in.bEndpointAddress;
 		ss_ep_out.bEndpointAddress = fs_ep_out.bEndpointAddress;
 		f->ss_descriptors = fb_ss_function;
 	}
 	s = env_get("serial#");
 	if (s)
 		g_dnl_set_serialnumber((char *)s);
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 	stdio_register(&g_fastboot_stdio);
 #endif
 	return 0;
 }
 static void fastboot_unbind(struct usb_configuration *c, struct usb_function *f)
 {
 	f->os_desc_table = NULL;
 	list_del(&fb_os_desc.ext_prop);
 	memset(fastboot_func, 0, sizeof(*fastboot_func));
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT) && CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
 	stdio_deregister("fastboot", 1);
 #endif
 }
 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);
 	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);
 	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);
 int fastboot_tx_write_more(const char *buffer)
 {
 	int ret = 0;
 	/* alloc usb request FIFO node */
 	usb_req *req = (usb_req *)malloc(sizeof(usb_req));
 	if (!req) {
 		printf("failed alloc usb req!\n");
 		return -ENOMEM;
 	}
 	/* usb request node FIFO enquene */
 	if ((fastboot_func->front == NULL) && (fastboot_func->rear == NULL)) {
 		fastboot_func->front = fastboot_func->rear = req;
 		req->next = NULL;
 	} else {
 		fastboot_func->rear->next = req;
 		fastboot_func->rear = req;
 		req->next = NULL;
 	}
 	/* alloc in request for current node */
 	req->in_req = fastboot_start_ep(fastboot_func->in_ep);
 	if (!req->in_req) {
 		printf("failed alloc req in\n");
 		fastboot_disable(&(fastboot_func->usb_function));
 		return  -EINVAL;
 	}
 	req->in_req->complete = fastboot_fifo_complete;
 	memcpy(req->in_req->buf, buffer, strlen(buffer));
 	req->in_req->length = strlen(buffer);
 	ret = usb_ep_queue(fastboot_func->in_ep, req->in_req, 0);
 	if (ret) {
 		printf("Error %d on queue\n", ret);
 		return -EINVAL;
 	}
 	ret = 0;
 	return ret;
 }
 int fastboot_tx_write(const char *buffer, unsigned int buffer_size)
 {
 	struct usb_request *in_req = fastboot_func->in_req;
 	int ret;
 	if (!buffer_size)
 		return 0;
 	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)
 {
 	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);
 }
 static unsigned int rx_bytes_expected(struct usb_ep *ep)
 {
 	int rx_remain = fastboot_data_remaining();
 	unsigned int rem;
 	unsigned int maxpacket = usb_endpoint_maxp(ep->desc);
 	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;
 }
 static void rx_handler_dl_image(struct usb_ep *ep, struct usb_request *req)
 {
 	char response[FASTBOOT_RESPONSE_LEN] = {0};
 	unsigned int transfer_size = fastboot_data_remaining();
 	const unsigned char *buffer = req->buf;
 	unsigned int buffer_size = req->actual;
 	if (req->status != 0) {
 		printf("Bad status: %d\n", req->status);
 		return;
 	}
 	if (buffer_size < transfer_size)
 		transfer_size = buffer_size;
 	fastboot_data_download(buffer, transfer_size, response);
 	if (response[0]) {
 		fastboot_tx_write_str(response);
 	} else if (!fastboot_data_remaining()) {
 		fastboot_data_complete(response);
 		/*
 		 * Reset global transfer variable
 		 */
 		req->complete = rx_handler_command;
 		req->length = EP_BUFFER_SIZE;
 		fastboot_tx_write_str(response);
 	} else {
 		req->length = rx_bytes_expected(ep);
 	}
 	req->actual = 0;
 	usb_ep_queue(ep, req, 0);
 }
 static void do_exit_on_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	g_dnl_trigger_detach();
 }
 static void do_bootm_on_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	fastboot_boot();
 	do_exit_on_complete(ep, req);
 }
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 static void do_acmd_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	/* When usb dequeue complete will be called
 	 *  Need status value before call run_command.
 	 * otherwise, host can't get last message.
 	 */
 	if(req->status == 0)
 		fastboot_acmd_complete();
 }
 #endif
 static void rx_handler_command(struct usb_ep *ep, struct usb_request *req)
 {
 	char *cmdbuf = req->buf;
 	char response[FASTBOOT_RESPONSE_LEN] = {0};
 	int cmd = -1;
 	/* init in request FIFO pointer */
 	fastboot_func->front = NULL;
 	fastboot_func->rear  = NULL;
 	if (req->status != 0 || req->length == 0)
 		return;
 	if (req->actual < req->length) {
 		cmdbuf[req->actual] = '\0';
 		cmd = fastboot_handle_command(cmdbuf, response);
 	} else {
 		pr_err("buffer overflow");
 		fastboot_fail("buffer overflow", response);
 	}
 	if (!strncmp("DATA", response, 4)) {
 		req->complete = rx_handler_dl_image;
 		req->length = rx_bytes_expected(ep);
 	}
 	fastboot_tx_write_str(response);
 	if (!strncmp("OKAY", response, 4)) {
 		switch (cmd) {
 		case FASTBOOT_COMMAND_BOOT:
 			fastboot_func->in_req->complete = do_bootm_on_complete;
 			break;
 		case FASTBOOT_COMMAND_CONTINUE:
 			fastboot_func->in_req->complete = do_exit_on_complete;
 			break;
 		case FASTBOOT_COMMAND_REBOOT:
 		case FASTBOOT_COMMAND_REBOOT_BOOTLOADER:
+#ifdef CONFIG_ANDROID_RECOVERY
+		case FASTBOOT_COMMAND_RECOVERY_FASTBOOT:
+#endif
 			fastboot_func->in_req->complete = compl_do_reset;
 			break;
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 		case FASTBOOT_COMMAND_ACMD:
 			fastboot_func->in_req->complete = do_acmd_complete;
 			break;
 #endif
 		}
 	}
 	*cmdbuf = '\0';
 	req->actual = 0;
 	usb_ep_queue(ep, req, 0);
 }

include/fastboot.h

Diff comments View file @ 8cb9cd7

 /* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * (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>
  */
 #ifndef _FASTBOOT_H_
 #define _FASTBOOT_H_
 #define FASTBOOT_VERSION	"0.4"
 /* The 64 defined bytes plus \0 */
 #define FASTBOOT_COMMAND_LEN	(64 + 1)
 #define FASTBOOT_RESPONSE_LEN	(64 + 1)
 /**
  * All known commands to fastboot
  */
 enum {
 	FASTBOOT_COMMAND_GETVAR = 0,
 	FASTBOOT_COMMAND_DOWNLOAD,
 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
 	FASTBOOT_COMMAND_FLASH,
 	FASTBOOT_COMMAND_ERASE,
 #endif
 	FASTBOOT_COMMAND_BOOT,
 	FASTBOOT_COMMAND_CONTINUE,
 	FASTBOOT_COMMAND_REBOOT,
 	FASTBOOT_COMMAND_REBOOT_BOOTLOADER,
 	FASTBOOT_COMMAND_SET_ACTIVE,
 #if CONFIG_IS_ENABLED(FASTBOOT_CMD_OEM_FORMAT)
 	FASTBOOT_COMMAND_OEM_FORMAT,
 #endif
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 	FASTBOOT_COMMAND_ACMD,
 	FASTBOOT_COMMAND_UCMD,
 #endif
 #ifdef CONFIG_FSL_FASTBOOT
 	FASTBOOT_COMMAND_UPLOAD,
 	FASTBOOT_COMMAND_GETSTAGED,
 #ifdef CONFIG_FASTBOOT_LOCK
 	FASTBOOT_COMMAND_FLASHING,
 	FASTBOOT_COMMAND_OEM,
 #endif
 #ifdef CONFIG_AVB_SUPPORT
 	FASTBOOT_COMMAND_SETACTIVE,
 #endif
 #ifdef CONFIG_AVB_ATX
 	FASTBOOT_COMMAND_STAGE,
 #endif
 #endif
+#ifdef CONFIG_ANDROID_RECOVERY
+	FASTBOOT_COMMAND_RECOVERY_FASTBOOT,
+#endif
 	FASTBOOT_COMMAND_COUNT
 };
 /**
  * fastboot_response() - Writes a response of the form "$tag$reason".
  *
  * @tag: The first part of the response
  * @response: Pointer to fastboot response buffer
  * @format: printf style format string
  */
 void fastboot_response(const char *tag, char *response,
 		       const char *format, ...)
 	__attribute__ ((format (__printf__, 3, 4)));
 /**
  * fastboot_fail() - Write a FAIL response of the form "FAIL$reason".
  *
  * @reason: Pointer to returned reason string
  * @response: Pointer to fastboot response buffer
  */
 void fastboot_fail(const char *reason, char *response);
 /**
  * fastboot_okay() - Write an OKAY response of the form "OKAY$reason".
  *
  * @reason: Pointer to returned reason string, or NULL to send a bare "OKAY"
  * @response: Pointer to fastboot response buffer
  */
 void fastboot_okay(const char *reason, char *response);
 /**
  * fastboot_set_reboot_flag() - Set flag to indicate reboot-bootloader
  *
  * Set flag which indicates that we should reboot into the bootloader
  * following the reboot that fastboot executes after this function.
  *
  * This function should be overridden in your board file with one
  * which sets whatever flag your board specific Android bootloader flow
  * requires in order to re-enter the bootloader.
  */
 int fastboot_set_reboot_flag(void);
 /**
  * fastboot_set_progress_callback() - set progress callback
  *
  * @progress: Pointer to progress callback
  *
  * Set a callback which is invoked periodically during long running operations
  * (flash and erase). This can be used (for example) by the UDP transport to
  * send INFO responses to keep the client alive whilst those commands are
  * executing.
  */
 void fastboot_set_progress_callback(void (*progress)(const char *msg));
 /*
  * fastboot_init() - initialise new fastboot protocol session
  *
  * @buf_addr: Pointer to download buffer, or NULL for default
  * @buf_size: Size of download buffer, or zero for default
  */
 void fastboot_init(void *buf_addr, u32 buf_size);
 /**
  * fastboot_boot() - Execute fastboot boot command
  *
  * If ${fastboot_bootcmd} is set, run that command to execute the boot
  * process, if that returns, then exit the fastboot server and return
  * control to the caller.
  *
  * Otherwise execute "bootm <fastboot_buf_addr>", if that fails, reset
  * the board.
  */
 void fastboot_boot(void);
 /**
  * fastboot_handle_command() - Handle fastboot command
  *
  * @cmd_string: Pointer to command string
  * @response: Pointer to fastboot response buffer
  *
  * Return: Executed command, or -1 if not recognized
  */
 int fastboot_handle_command(char *cmd_string, char *response);
 /**
  * fastboot_data_remaining() - return bytes remaining in current transfer
  *
  * Return: Number of bytes left in the current download
  */
 u32 fastboot_data_remaining(void);
 /**
  * fastboot_data_download() - Copy image data to fastboot_buf_addr.
  *
  * @fastboot_data: Pointer to received fastboot data
  * @fastboot_data_len: Length of received fastboot data
  * @response: Pointer to fastboot response buffer
  *
  * Copies image data from fastboot_data to fastboot_buf_addr. Writes to
  * response. fastboot_bytes_received is updated to indicate the number
  * of bytes that have been transferred.
  */
 void fastboot_data_download(const void *fastboot_data,
 			    unsigned int fastboot_data_len, char *response);
 /**
  * fastboot_data_complete() - Mark current transfer complete
  *
  * @response: Pointer to fastboot response buffer
  *
  * Set image_size and ${filesize} to the total size of the downloaded image.
  */
 void fastboot_data_complete(char *response);
 #if CONFIG_IS_ENABLED(FASTBOOT_UUU_SUPPORT)
 void fastboot_acmd_complete(void);
 #endif
 int fastboot_tx_write_more(const char *buffer);
 int fastboot_tx_write(const char *buffer, unsigned int buffer_size);
 #endif /* _FASTBOOT_H_ */

net/fastboot.c

Diff comments View file @ 8cb9cd7

 // SPDX-License-Identifier: BSD-2-Clause
 /*
  * Copyright (C) 2016 The Android Open Source Project
  */
 #include <common.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:
+#ifdef CONFIG_ANDROID_RECOVERY
+		case FASTBOOT_COMMAND_RECOVERY_FASTBOOT:
+#endif
 			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);
 }