qiurui
/
rv1126-uboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Implement fastboot flash and erase. 

Add function to respond to fastboot flash and erase. Flash writes the
previously downloaded image to indicated partition. Erase clears the
indicated partition. fb_flash and fb_erase are essentially wrappers
for fb_mmc_flash_write and fb_mmc_erase, which are implemented in
common/fb_mmc.c.

Added common/fb_common.c, where fastboot_okay/fail are implemented.
common/fb_mmc.c assumes fasboot_okay() and fastboot_fail() are
implemented, but they were tied to the fastboot USB implementation.
This refactor adds the response string as a parameter to
fastboot_okay/fail, instead of modifying a global.

Bug: 31887729
Test: FLASH:
      - Create file "foo" containing 2048 chars = "-"
      - Start "fastboot udp" on device and run
        "fastboot -s udp:$RPI_IP flash misc foo" from host
      - From U-boot console, read into memory the first 4 blocks from
        misc partition, observe each byte is "-".

      ERASE
      - Start "fastboot udp" on device and run
        "fastboot -s udp:$RPI_IP erase misc" from host
	  - From U-boot console, read into memory many blocks from misc
        partition, observe each byte is 0x00

	  Configs that use fastboot USB implementation still build.

Change-Id: I5bd54868990bd9d5736d0969b3db240c2926eeec
This commit is contained in:
Jocelyn Bohr 2016-11-09 11:24:08 -08:00 committed by Kever Yang
parent 45930fc17b
commit 8b464fa913
11 changed files with 120 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
common/Makefile
View File

@ -120,6 +120,10 @@ obj-y += fb_nand.o
endif
endif
ifneq ($(or $(CONFIG_USB_FUNCTION_FASTBOOT),$(CONFIG_UDP_FUNCTION_FASTBOOT)),)
obj-y += fb_common.o
endif
ifdef CONFIG_CMD_EEPROM_LAYOUT
obj-y += eeprom/eeprom_field.o eeprom/eeprom_layout.o
endif

22
common/fb_common.c Normal file
View File

@ -0,0 +1,22 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <common.h>
#include <fastboot.h>
void fastboot_fail(const char *reason, char *response)
{
const char *fail_str = "FAIL";
strncpy(response, fail_str, FASTBOOT_RESPONSE_LEN);
strncat(response, reason, FASTBOOT_RESPONSE_LEN - strlen(fail_str) - 1);
}
void fastboot_okay(const char *reason, char *response)
{
const char *okay_str = "OKAY";
strncpy(response, okay_str, FASTBOOT_RESPONSE_LEN);
strncat(response, reason, FASTBOOT_RESPONSE_LEN - strlen(okay_str) - 1);
}

37
common/fb_mmc.c
View File

@ -74,7 +74,7 @@ static lbaint_t fb_mmc_sparse_reserve(struct sparse_storage *info,
static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
const char *part_name, void *buffer,
unsigned int download_bytes)
unsigned int download_bytes, char *response)
{
lbaint_t blkcnt;
lbaint_t blks;
@ -85,7 +85,7 @@ static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
if (blkcnt > info->size) {
error("too large for partition: '%s'\n", part_name);
fastboot_fail("too large for partition");
fastboot_fail("too large for partition", response);
return;
}
@ -94,13 +94,13 @@ static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
blks = blk_dwrite(dev_desc, info->start, blkcnt, buffer);
if (blks != blkcnt) {
error("failed writing to device %d\n", dev_desc->devnum);
fastboot_fail("failed writing to device");
fastboot_fail("failed writing to device", response);
return;
}
printf("........ wrote " LBAFU " bytes to '%s'\n", blkcnt * info->blksz,
part_name);
fastboot_okay("");
fastboot_okay("", response);
}
#ifdef CONFIG_ANDROID_BOOT_IMAGE
@ -261,7 +261,7 @@ static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
#endif
void fb_mmc_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes)
unsigned int download_bytes, char *response)
{
struct blk_desc *dev_desc;
disk_partition_t info;
@ -269,7 +269,7 @@ void fb_mmc_flash_write(const char *cmd, void *download_buffer,
dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
fastboot_fail("invalid mmc device", response);
return;
}
@ -280,16 +280,17 @@ void fb_mmc_flash_write(const char *cmd, void *download_buffer,
if (is_valid_gpt_buf(dev_desc, download_buffer)) {
printf("%s: invalid GPT - refusing to write to flash\n",
__func__);
fastboot_fail("invalid GPT partition");
fastboot_fail("invalid GPT partition", response);
return;
}
if (write_mbr_and_gpt_partitions(dev_desc, download_buffer)) {
printf("%s: writing GPT partitions failed\n", __func__);
fastboot_fail("writing GPT partitions failed");
fastboot_fail(
"writing GPT partitions failed", response);
return;
}
printf("........ success\n");
fastboot_okay("");
fastboot_okay("", response);
return;
}
#endif
@ -323,7 +324,7 @@ void fb_mmc_flash_write(const char *cmd, void *download_buffer,
if (part_get_info_by_name_or_alias(dev_desc, cmd, &info) < 0) {
error("cannot find partition: '%s'\n", cmd);
fastboot_fail("cannot find partition");
fastboot_fail("cannot find partition", response);
return;
}
@ -344,14 +345,14 @@ void fb_mmc_flash_write(const char *cmd, void *download_buffer,
sparse.priv = &sparse_priv;
write_sparse_image(&sparse, cmd, download_buffer,
download_bytes);
download_bytes, response);
} else {
write_raw_image(dev_desc, &info, cmd, download_buffer,
download_bytes);
download_bytes, response);
}
}
void fb_mmc_erase(const char *cmd)
void fb_mmc_erase(const char *cmd, char *response)
{
int ret;
struct blk_desc *dev_desc;
@ -361,21 +362,21 @@ void fb_mmc_erase(const char *cmd)
if (mmc == NULL) {
error("invalid mmc device");
fastboot_fail("invalid mmc device");
fastboot_fail("invalid mmc device", response);
return;
}
dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device");
fastboot_fail("invalid mmc device");
fastboot_fail("invalid mmc device", response);
return;
}
ret = part_get_info_by_name_or_alias(dev_desc, cmd, &info);
if (ret < 0) {
error("cannot find partition: '%s'", cmd);
fastboot_fail("cannot find partition");
fastboot_fail("cannot find partition", response);
return;
}
@ -394,11 +395,11 @@ void fb_mmc_erase(const char *cmd)
blks = blk_derase(dev_desc, blks_start, blks_size);
if (blks != blks_size) {
error("failed erasing from device %d", dev_desc->devnum);
fastboot_fail("failed erasing from device");
fastboot_fail("failed erasing from device", response);
return;
}
printf("........ erased " LBAFU " bytes from '%s'\n",
blks_size * info.blksz, cmd);
fastboot_okay("");
fastboot_okay("", response);
}

31
common/fb_nand.c
View File

@ -32,7 +32,8 @@ __weak int board_fastboot_write_partition_setup(char *name)
static int fb_nand_lookup(const char *partname,
struct mtd_info **mtd,
struct part_info **part)
struct part_info **part
char *response)
{
struct mtd_device *dev;
int ret;
@ -41,21 +42,21 @@ static int fb_nand_lookup(const char *partname,
ret = mtdparts_init();
if (ret) {
error("Cannot initialize MTD partitions\n");
fastboot_fail("cannot init mtdparts");
fastboot_fail("cannot init mtdparts", response);
return ret;
}
ret = find_dev_and_part(partname, &dev, &pnum, part);
if (ret) {
error("cannot find partition: '%s'", partname);
fastboot_fail("cannot find partition");
fastboot_fail("cannot find partition", response);
return ret;
}
if (dev->id->type != MTD_DEV_TYPE_NAND) {
error("partition '%s' is not stored on a NAND device",
partname);
fastboot_fail("not a NAND device");
fastboot_fail("not a NAND device", response);
return -EINVAL;
}
@ -146,16 +147,16 @@ static lbaint_t fb_nand_sparse_reserve(struct sparse_storage *info,
}
void fb_nand_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes)
unsigned int download_bytes, char *response)
{
struct part_info *part;
struct mtd_info *mtd = NULL;
int ret;
ret = fb_nand_lookup(cmd, &mtd, &part);
ret = fb_nand_lookup(cmd, &mtd, &part, response);
if (ret) {
error("invalid NAND device");
fastboot_fail("invalid NAND device");
fastboot_fail("invalid NAND device", response);
return;
}
@ -181,7 +182,7 @@ void fb_nand_flash_write(const char *cmd, void *download_buffer,
sparse.priv = &sparse_priv;
write_sparse_image(&sparse, cmd, download_buffer,
download_bytes);
download_bytes, response);
} else {
printf("Flashing raw image at offset 0x%llx\n",
part->offset);
@ -194,23 +195,23 @@ void fb_nand_flash_write(const char *cmd, void *download_buffer,
}
if (ret) {
fastboot_fail("error writing the image");
fastboot_fail("error writing the image", response);
return;
}
fastboot_okay("");
fastboot_okay("", response);
}
void fb_nand_erase(const char *cmd)
void fb_nand_erase(const char *cmd, char *response)
{
struct part_info *part;
struct mtd_info *mtd = NULL;
int ret;
ret = fb_nand_lookup(cmd, &mtd, &part);
ret = fb_nand_lookup(cmd, &mtd, &part, response);
if (ret) {
error("invalid NAND device");
fastboot_fail("invalid NAND device");
fastboot_fail("invalid NAND device", response);
return;
}
@ -221,9 +222,9 @@ void fb_nand_erase(const char *cmd)
ret = _fb_nand_erase(mtd, part);
if (ret) {
error("failed erasing from device %s", mtd->name);
fastboot_fail("failed erasing from device");
fastboot_fail("failed erasing from device", response);
return;
}
fastboot_okay("");
fastboot_okay("", response);
}

26
common/image-sparse.c
View File

@ -51,7 +51,7 @@
void write_sparse_image(
struct sparse_storage *info, const char *part_name,
void *data, unsigned sz)
void *data, unsigned sz, char *response)
{
lbaint_t blk;
lbaint_t blkcnt;
@ -101,7 +101,7 @@ void write_sparse_image(
if (offset) {
printf("%s: Sparse image block size issue [%u]\n",
__func__, sparse_header->blk_sz);
fastboot_fail("sparse image block size issue");
fastboot_fail("sparse image block size issue", response);
return;
}
@ -137,7 +137,7 @@ void write_sparse_image(
if (chunk_header->total_sz !=
(sparse_header->chunk_hdr_sz + chunk_data_sz)) {
fastboot_fail(
"Bogus chunk size for chunk type Raw");
"Bogus chunk size for chunk type Raw", response);
return;
}
@ -146,7 +146,7 @@ void write_sparse_image(
"%s: Request would exceed partition size!\n",
__func__);
fastboot_fail(
"Request would exceed partition size!");
"Request would exceed partition size!", response);
return;
}
@ -157,7 +157,7 @@ void write_sparse_image(
__func__, "Write failed, block #",
blk, blks);
fastboot_fail(
"flash write failure");
"flash write failure", response);
return;
}
blk += blks;
@ -170,7 +170,7 @@ void write_sparse_image(
if (chunk_header->total_sz !=
(sparse_header->chunk_hdr_sz + sizeof(uint32_t))) {
fastboot_fail(
"Bogus chunk size for chunk type FILL");
"Bogus chunk size for chunk type FILL", response);
return;
}
@ -181,7 +181,7 @@ void write_sparse_image(
ARCH_DMA_MINALIGN));
if (!fill_buf) {
fastboot_fail(
"Malloc failed for: CHUNK_TYPE_FILL");
"Malloc failed for: CHUNK_TYPE_FILL", response);
return;
}
@ -199,7 +199,7 @@ void write_sparse_image(
"%s: Request would exceed partition size!\n",
__func__);
fastboot_fail(
"Request would exceed partition size!");
"Request would exceed partition size!", response);
return;
}
@ -215,7 +215,7 @@ void write_sparse_image(
"Write failed, block #",
blk, j);
fastboot_fail(
"flash write failure");
"flash write failure", response);
free(fill_buf);
return;
}
@ -236,7 +236,7 @@ void write_sparse_image(
if (chunk_header->total_sz !=
sparse_header->chunk_hdr_sz) {
fastboot_fail(
"Bogus chunk size for chunk type Dont Care");
"Bogus chunk size for chunk type Dont Care", response);
return;
}
total_blocks += chunk_header->chunk_sz;
@ -246,7 +246,7 @@ void write_sparse_image(
default:
printf("%s: Unknown chunk type: %x\n", __func__,
chunk_header->chunk_type);
fastboot_fail("Unknown chunk type");
fastboot_fail("Unknown chunk type", response);
return;
}
}
@ -256,9 +256,9 @@ void write_sparse_image(
printf("........ wrote %u bytes to '%s'\n", bytes_written, part_name);
if (total_blocks != sparse_header->total_blks)
fastboot_fail("sparse image write failure");
fastboot_fail("sparse image write failure", response);
else
fastboot_okay("");
fastboot_okay("", response);
return;
}

36
drivers/usb/gadget/f_fastboot.c
View File

@ -150,21 +150,6 @@ static struct usb_gadget_strings *fastboot_strings[] = {
static void rx_handler_command(struct usb_ep *ep, struct usb_request *req);
static int strcmp_l1(const char *s1, const char *s2);
static char *fb_response_str;
void fastboot_fail(const char *reason)
{
strncpy(fb_response_str, "FAIL\0", 5);
strncat(fb_response_str, reason, FASTBOOT_RESPONSE_LEN - 4 - 1);
}
void fastboot_okay(const char *reason)
{
strncpy(fb_response_str, "OKAY\0", 5);
strncat(fb_response_str, reason, FASTBOOT_RESPONSE_LEN - 4 - 1);
}
static void fastboot_complete(struct usb_ep *ep, struct usb_request *req)
{
int status = req->status;
@ -598,18 +583,14 @@ static void cb_flash(struct usb_ep *ep, struct usb_request *req)
return;
}
/* initialize the response buffer */
fb_response_str = response;
fastboot_fail("no flash device defined");
fastboot_fail("no flash device defined", response);
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
fb_mmc_flash_write(cmd, (void *)CONFIG_FASTBOOT_BUF_ADDR,
download_bytes);
download_bytes, response);
#endif
#ifdef CONFIG_FASTBOOT_FLASH_NAND_DEV
fb_nand_flash_write(cmd,
(void *)CONFIG_FASTBOOT_BUF_ADDR,
download_bytes);
fb_nand_flash_write(cmd, (void *)CONFIG_FASTBOOT_BUF_ADDR,
download_bytes, response);
#endif
fastboot_tx_write_str(response);
}
@ -650,15 +631,12 @@ static void cb_erase(struct usb_ep *ep, struct usb_request *req)
return;
}
/* initialize the response buffer */
fb_response_str = response;
fastboot_fail("no flash device defined");
fastboot_fail("no flash device defined", response);
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
fb_mmc_erase(cmd);
fb_mmc_erase(cmd, response);
#endif
#ifdef CONFIG_FASTBOOT_FLASH_NAND_DEV
fb_nand_erase(cmd);
fb_nand_erase(cmd, response);
#endif
fastboot_tx_write_str(response);
}

6
include/fastboot.h
View File

@ -14,9 +14,9 @@
#define _FASTBOOT_H_
/* The 64 defined bytes plus \0 */
#define FASTBOOT_RESPONSE_LEN (64 + 1)
#define FASTBOOT_RESPONSE_LEN (64 + 1)
void fastboot_fail(const char *reason);
void fastboot_okay(const char *reason);
void fastboot_fail(const char *reason, char *response);
void fastboot_okay(const char *reason, char *response);
#endif /* _FASTBOOT_H_ */

4
include/fb_mmc.h
View File

@ -5,5 +5,5 @@
*/
void fb_mmc_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes);
void fb_mmc_erase(const char *cmd);
unsigned int download_bytes, char *response);
void fb_mmc_erase(const char *cmd, char *response);

4
include/fb_nand.h
View File

@ -6,5 +6,5 @@
*/
void fb_nand_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes);
void fb_nand_erase(const char *cmd);
unsigned int download_bytes, char *response);
void fb_nand_erase(const char *cmd, char *response);

2
include/image-sparse.h
View File

@ -37,4 +37,4 @@ static inline int is_sparse_image(void *buf)
}
void write_sparse_image(struct sparse_storage *info, const char *part_name,
void *data, unsigned sz);
void *data, unsigned sz, char *response);

32
net/fastboot.c
View File

@ -5,6 +5,8 @@
*/
#include <common.h>
#include <fastboot.h>
#include <fb_mmc.h>
#include <net.h>
#include <net/fastboot.h>
#include <stdlib.h>
@ -29,7 +31,6 @@ struct __attribute__((packed)) fastboot_header {
#define PACKET_SIZE 1024
#define FASTBOOT_HEADER_SIZE sizeof(struct fastboot_header)
#define DATA_SIZE (PACKET_SIZE - FASTBOOT_HEADER_SIZE)
#define FASTBOOT_RESPONSE_LEN (64 + 1)
#define FASTBOOT_VERSION "0.4"
/* Sequence number sent for every packet */
@ -58,6 +59,8 @@ static int fastboot_our_port;
static void fb_getvar(char*);
static void fb_download(char*, unsigned int, char*);
static void fb_flash(char*);
static void fb_erase(char*);
static void cleanup_command_data(void);
static void write_fb_response(const char*, const char*, char*);
@ -129,6 +132,10 @@ static void fastboot_send(struct fastboot_header fb_header, char *fastboot_data,
fb_getvar(response);
} else if (!strcmp("download", cmd_string)) {
fb_download(fastboot_data, fastboot_data_len, response);
} else if (!strcmp("flash", cmd_string)) {
fb_flash(response);
} else if (!strcmp("erase", cmd_string)) {
fb_erase(response);
} else {
error("command %s not implemented.\n", cmd_string);
write_fb_response("FAIL", "unrecognized command", response);
@ -243,6 +250,29 @@ static void fb_download(char *fastboot_data, unsigned int fastboot_data_len,
}
}
/**
* Writes the previously downloaded image to the partition indicated by
* cmd_parameter. Writes to response.
*
* @param repsonse Pointer to fastboot response buffer
*/
static void fb_flash(char *response)
{
fb_mmc_flash_write(cmd_parameter, (void*)CONFIG_FASTBOOT_BUF_ADDR,
image_size, response);
}
/**
* Erases the partition indicated by cmd_parameter (clear to 0x00s). Writes
* to response.
*
* @param repsonse Pointer to fastboot response buffer
*/
static void fb_erase(char *response)
{
fb_mmc_erase(cmd_parameter, response);
}
/**
* Writes a response to response buffer of the form "$tag$reason".
*