summaryrefslogtreecommitdiff
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/fastboot/fastboot.c1127
-rw-r--r--drivers/usb/gadget/ci_udc.c2
-rw-r--r--drivers/usb/gadget/f_fastboot.c1746
3 files changed, 1746 insertions, 1129 deletions
diff --git a/drivers/fastboot/fastboot.c b/drivers/fastboot/fastboot.c
deleted file mode 100644
index 0b5bebb..0000000
--- a/drivers/fastboot/fastboot.c
+++ /dev/null
@@ -1,1127 +0,0 @@
-/*
- * Copyright (C) 2010-2014 Freescale Semiconductor, Inc. All Rights Reserved.
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-#include <common.h>
-#include <config.h>
-#include <malloc.h>
-#include <fastboot.h>
-#include <usb/imx_udc.h>
-#include <asm/io.h>
-#include <usbdevice.h>
-#include <mmc.h>
-#include <sata.h>
-#ifdef CONFIG_ANDROID_RECOVERY
-#include <recovery.h>
-#endif
-
-/*
- * Defines
- */
-#define NUM_ENDPOINTS 2
-
-#define CONFIG_USBD_OUT_PKTSIZE 0x200
-#define CONFIG_USBD_IN_PKTSIZE 0x200
-#define MAX_BUFFER_SIZE 0x200
-
-/*
- * imx family android layout
- * mbr - 0 ~ 0x3FF byte
- * bootloader - 0x400 ~ 0xFFFFF byte
- * kernel - 0x100000 ~ 5FFFFF byte
- * uramedisk - 0x600000 ~ 0x6FFFFF supposing 1M temporarily
- * SYSTEM partition - /dev/mmcblk0p2 or /dev/sda2
- * RECOVERY parittion - dev/mmcblk0p4 or /dev/sda4
- */
-#define ANDROID_MBR_OFFSET 0
-#define ANDROID_MBR_SIZE 0x200
-#define ANDROID_BOOTLOADER_OFFSET 0x400
-#define ANDROID_BOOTLOADER_SIZE 0xFFC00
-#define ANDROID_KERNEL_OFFSET 0x100000
-#define ANDROID_KERNEL_SIZE 0x500000
-#define ANDROID_URAMDISK_OFFSET 0x600000
-#define ANDROID_URAMDISK_SIZE 0x100000
-
-#define STR_LANG_INDEX 0x00
-#define STR_MANUFACTURER_INDEX 0x01
-#define STR_PRODUCT_INDEX 0x02
-#define STR_SERIAL_INDEX 0x03
-#define STR_CONFIG_INDEX 0x04
-#define STR_DATA_INTERFACE_INDEX 0x05
-#define STR_CTRL_INTERFACE_INDEX 0x06
-#define STR_COUNT 0x07
-
-#define FASTBOOT_FBPARTS_ENV_MAX_LEN 1024
-/* To support the Android-style naming of flash */
-#define MAX_PTN 16
-
-
-/*pentry index internally*/
-enum {
- PTN_MBR_INDEX = 0,
- PTN_BOOTLOADER_INDEX,
- PTN_KERNEL_INDEX,
- PTN_URAMDISK_INDEX,
- PTN_SYSTEM_INDEX,
- PTN_RECOVERY_INDEX
-};
-
-struct fastboot_device_info fastboot_devinfo;
-
-/* defined and used by gadget/ep0.c */
-extern struct usb_string_descriptor **usb_strings;
-
-static struct usb_device_instance device_instance[1];
-static struct usb_bus_instance bus_instance[1];
-static struct usb_configuration_instance config_instance[1];
-static struct usb_interface_instance interface_instance[1];
-static struct usb_alternate_instance alternate_instance[1];
-/* one extra for control endpoint */
-static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1];
-
-static struct cmd_fastboot_interface *fastboot_interface;
-static int fastboot_configured_flag;
-static int usb_disconnected;
-
-/* Indicies, References */
-static u8 rx_endpoint;
-static u8 tx_endpoint;
-static struct usb_string_descriptor *fastboot_string_table[STR_COUNT];
-
-/* USB Descriptor Strings */
-static u8 wstrLang[4] = {4, USB_DT_STRING, 0x9, 0x4};
-static u8 wstrManufacturer[2 * (sizeof(CONFIG_FASTBOOT_MANUFACTURER_STR))];
-static u8 wstrProduct[2 * (sizeof(CONFIG_FASTBOOT_PRODUCT_NAME_STR))];
-static u8 wstrSerial[2*(sizeof(CONFIG_FASTBOOT_SERIAL_NUM))];
-static u8 wstrConfiguration[2 * (sizeof(CONFIG_FASTBOOT_CONFIGURATION_STR))];
-static u8 wstrDataInterface[2 * (sizeof(CONFIG_FASTBOOT_INTERFACE_STR))];
-
-/* Standard USB Data Structures */
-static struct usb_interface_descriptor interface_descriptors[1];
-static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS];
-static struct usb_configuration_descriptor *configuration_descriptor;
-static struct usb_device_descriptor device_descriptor = {
- .bLength = sizeof(struct usb_device_descriptor),
- .bDescriptorType = USB_DT_DEVICE,
- .bcdUSB = cpu_to_le16(USB_BCD_VERSION),
- .bDeviceClass = 0xff,
- .bDeviceSubClass = 0xff,
- .bDeviceProtocol = 0xff,
- .bMaxPacketSize0 = 0x40,
- .idVendor = cpu_to_le16(CONFIG_FASTBOOT_VENDOR_ID),
- .idProduct = cpu_to_le16(CONFIG_FASTBOOT_PRODUCT_ID),
- .bcdDevice = cpu_to_le16(CONFIG_FASTBOOT_BCD_DEVICE),
- .iManufacturer = STR_MANUFACTURER_INDEX,
- .iProduct = STR_PRODUCT_INDEX,
- .iSerialNumber = STR_SERIAL_INDEX,
- .bNumConfigurations = 1
-};
-
-/*
- * Static Generic Serial specific data
- */
-
-struct fastboot_config_desc {
- struct usb_configuration_descriptor configuration_desc;
- struct usb_interface_descriptor interface_desc[1];
- struct usb_endpoint_descriptor data_endpoints[NUM_ENDPOINTS];
-};
-
-static struct fastboot_config_desc
-fastboot_configuration_descriptors[1] = {
- {
- .configuration_desc = {
- .bLength = sizeof(struct usb_configuration_descriptor),
- .bDescriptorType = USB_DT_CONFIG,
- .wTotalLength =
- cpu_to_le16(sizeof(struct fastboot_config_desc)),
- .bNumInterfaces = 1,
- .bConfigurationValue = 1,
- .iConfiguration = STR_CONFIG_INDEX,
- .bmAttributes =
- BMATTRIBUTE_SELF_POWERED|BMATTRIBUTE_RESERVED,
- .bMaxPower = 0x32
- },
- .interface_desc = {
- {
- .bLength =
- sizeof(struct usb_interface_descriptor),
- .bDescriptorType = USB_DT_INTERFACE,
- .bInterfaceNumber = 0,
- .bAlternateSetting = 0,
- .bNumEndpoints = NUM_ENDPOINTS,
- .bInterfaceClass =
- FASTBOOT_INTERFACE_CLASS,
- .bInterfaceSubClass =
- FASTBOOT_INTERFACE_SUB_CLASS,
- .bInterfaceProtocol =
- FASTBOOT_INTERFACE_PROTOCOL,
- .iInterface = STR_DATA_INTERFACE_INDEX
- },
- },
- .data_endpoints = {
- {
- .bLength =
- sizeof(struct usb_endpoint_descriptor),
- .bDescriptorType = USB_DT_ENDPOINT,
- .bEndpointAddress = UDC_OUT_ENDPOINT |
- USB_DIR_OUT,
- .bmAttributes = USB_ENDPOINT_XFER_BULK,
- .wMaxPacketSize =
- cpu_to_le16(CONFIG_USBD_OUT_PKTSIZE),
- .bInterval = 0x00,
- },
- {
- .bLength =
- sizeof(struct usb_endpoint_descriptor),
- .bDescriptorType = USB_DT_ENDPOINT,
- .bEndpointAddress = UDC_IN_ENDPOINT |
- USB_DIR_IN,
- .bmAttributes = USB_ENDPOINT_XFER_BULK,
- .wMaxPacketSize =
- cpu_to_le16(CONFIG_USBD_IN_PKTSIZE),
- .bInterval = 0x00,
- },
- },
- },
-};
-
-
-
-static struct fastboot_ptentry ptable[MAX_PTN];
-static unsigned int pcount;
-
-
-/* Static Function Prototypes */
-static void _fastboot_init_strings(void);
-static void _fastboot_init_instances(void);
-static void _fastboot_init_endpoints(void);
-static void _fastboot_event_handler(struct usb_device_instance *device,
- usb_device_event_t event, int data);
-static int _fastboot_cdc_setup(struct usb_device_request *request,
- struct urb *urb);
-static int _fastboot_usb_configured(void);
-#if defined(CONFIG_FASTBOOT_STORAGE_SATA) \
- || defined(CONFIG_FASTBOOT_STORAGE_MMC)
-static int _fastboot_parts_load_from_ptable(void);
-#endif
-#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
-static int _fastboot_parts_load_from_env(void);
-#endif
-static int _fastboot_setup_dev(void);
-static void _fastboot_load_partitions(void);
-
-/* utility function for converting char* to wide string used by USB */
-static void str2wide(char *str, u16 * wide)
-{
- int i;
- for (i = 0; i < strlen(str) && str[i]; i++) {
- #if defined(__LITTLE_ENDIAN)
- wide[i] = (u16) str[i];
- #elif defined(__BIG_ENDIAN)
- wide[i] = ((u16)(str[i])<<8);
- #else
- #error "__LITTLE_ENDIAN or __BIG_ENDIAN undefined"
- #endif
- }
-}
-
-/*
- Get mmc control number from passed string, eg, "mmc1" mean device 1. Only
- support "mmc0" to "mmc9" currently. It will be treated as device 0 for
- other string.
-*/
-static int _fastboot_get_mmc_no(char *env_str)
-{
- int digit = 0;
- unsigned char a;
-
- if (env_str && (strlen(env_str) >= 4) &&
- !strncmp(env_str, "mmc", 3)) {
- a = env_str[3];
- if (a >= '0' && a <= '9')
- digit = a - '0';
- }
-
- return digit;
-}
-
-static int _fastboot_setup_dev(void)
-{
- char *fastboot_env;
- fastboot_env = getenv("fastboot_dev");
-
- if (fastboot_env) {
- if (!strcmp(fastboot_env, "sata")) {
- fastboot_devinfo.type = DEV_SATA;
- fastboot_devinfo.dev_id = 0;
- } else if (!strcmp(fastboot_env, "nand")) {
- fastboot_devinfo.type = DEV_NAND;
- fastboot_devinfo.dev_id = 0;
- } else if (!strncmp(fastboot_env, "mmc", 3)) {
- fastboot_devinfo.type = DEV_MMC;
- fastboot_devinfo.dev_id = _fastboot_get_mmc_no(fastboot_env);
- }
- } else {
- return 1;
- }
-
- return 0;
-}
-
-
-/*
- * Initialize fastboot
- */
-int fastboot_init(struct cmd_fastboot_interface *interface)
-{
- printf("fastboot is in init......");
-
- fastboot_interface = interface;
- fastboot_interface->product_name = CONFIG_FASTBOOT_PRODUCT_NAME_STR;
- fastboot_interface->serial_no = CONFIG_FASTBOOT_SERIAL_NUM;
- fastboot_interface->nand_block_size = 4096;
- fastboot_interface->transfer_buffer =
- (unsigned char *)CONFIG_FASTBOOT_TRANSFER_BUF;
- fastboot_interface->transfer_buffer_size =
- CONFIG_FASTBOOT_TRANSFER_BUF_SIZE;
-
- _fastboot_init_strings();
- /* Basic USB initialization */
- udc_init();
-
- _fastboot_init_instances();
-
- udc_startup_events(device_instance);
- udc_connect(); /* Enable pullup for host detection */
-
- return 0;
-}
-
-static void _fastboot_init_strings(void)
-{
- struct usb_string_descriptor *string;
-
- fastboot_string_table[STR_LANG_INDEX] =
- (struct usb_string_descriptor *)wstrLang;
-
- string = (struct usb_string_descriptor *)wstrManufacturer;
- string->bLength = sizeof(wstrManufacturer);
- string->bDescriptorType = USB_DT_STRING;
- str2wide(CONFIG_FASTBOOT_MANUFACTURER_STR, string->wData);
- fastboot_string_table[STR_MANUFACTURER_INDEX] = string;
-
- string = (struct usb_string_descriptor *)wstrProduct;
- string->bLength = sizeof(wstrProduct);
- string->bDescriptorType = USB_DT_STRING;
- str2wide(CONFIG_FASTBOOT_PRODUCT_NAME_STR, string->wData);
- fastboot_string_table[STR_PRODUCT_INDEX] = string;
-
- string = (struct usb_string_descriptor *)wstrSerial;
- string->bLength = sizeof(wstrSerial);
- string->bDescriptorType = USB_DT_STRING;
- str2wide(CONFIG_FASTBOOT_SERIAL_NUM, string->wData);
- fastboot_string_table[STR_SERIAL_INDEX] = string;
-
- string = (struct usb_string_descriptor *)wstrConfiguration;
- string->bLength = sizeof(wstrConfiguration);
- string->bDescriptorType = USB_DT_STRING;
- str2wide(CONFIG_FASTBOOT_CONFIGURATION_STR, string->wData);
- fastboot_string_table[STR_CONFIG_INDEX] = string;
-
- string = (struct usb_string_descriptor *) wstrDataInterface;
- string->bLength = sizeof(wstrDataInterface);
- string->bDescriptorType = USB_DT_STRING;
- str2wide(CONFIG_FASTBOOT_INTERFACE_STR, string->wData);
- fastboot_string_table[STR_DATA_INTERFACE_INDEX] = string;
-
- /* Now, initialize the string table for ep0 handling */
- usb_strings = fastboot_string_table;
-}
-
-static void _fastboot_init_instances(void)
-{
- int i;
- u16 temp;
-
- /* Assign endpoint descriptors */
- ep_descriptor_ptrs[0] =
- &fastboot_configuration_descriptors[0].data_endpoints[0];
- ep_descriptor_ptrs[1] =
- &fastboot_configuration_descriptors[0].data_endpoints[1];
-
- /* Configuration Descriptor */
- configuration_descriptor =
- (struct usb_configuration_descriptor *)
- &fastboot_configuration_descriptors;
-
- fastboot_configured_flag = 0;
-
- /* initialize device instance */
- memset(device_instance, 0, sizeof(struct usb_device_instance));
- device_instance->device_state = STATE_INIT;
- device_instance->device_descriptor = &device_descriptor;
- device_instance->event = _fastboot_event_handler;
- device_instance->cdc_recv_setup = _fastboot_cdc_setup;
- device_instance->bus = bus_instance;
- device_instance->configurations = 1;
- device_instance->configuration_instance_array = config_instance;
-
- /* initialize bus instance */
- memset(bus_instance, 0, sizeof(struct usb_bus_instance));
- bus_instance->device = device_instance;
- bus_instance->endpoint_array = endpoint_instance;
- bus_instance->max_endpoints = NUM_ENDPOINTS + 1;
- bus_instance->maxpacketsize = 0xFF;
- bus_instance->serial_number_str = CONFIG_FASTBOOT_SERIAL_NUM;
-
- /* configuration instance */
- memset(config_instance, 0,
- sizeof(struct usb_configuration_instance));
- config_instance->interfaces = 1;
- config_instance->configuration_descriptor = configuration_descriptor;
- config_instance->interface_instance_array = interface_instance;
-
- /* interface instance */
- memset(interface_instance, 0,
- sizeof(struct usb_interface_instance));
- interface_instance->alternates = 1;
- interface_instance->alternates_instance_array = alternate_instance;
-
- /* alternates instance */
- memset(alternate_instance, 0,
- sizeof(struct usb_alternate_instance));
- alternate_instance->interface_descriptor = interface_descriptors;
- alternate_instance->endpoints = NUM_ENDPOINTS;
- alternate_instance->endpoints_descriptor_array = ep_descriptor_ptrs;
-
- /* endpoint instances */
- memset(&endpoint_instance[0], 0,
- sizeof(struct usb_endpoint_instance));
- endpoint_instance[0].endpoint_address = 0;
- endpoint_instance[0].rcv_packetSize = EP0_MAX_PACKET_SIZE;
- endpoint_instance[0].rcv_attributes = USB_ENDPOINT_XFER_CONTROL;
- endpoint_instance[0].tx_packetSize = EP0_MAX_PACKET_SIZE;
- endpoint_instance[0].tx_attributes = USB_ENDPOINT_XFER_CONTROL;
- udc_setup_ep(device_instance, 0, &endpoint_instance[0]);
-
- for (i = 1; i <= NUM_ENDPOINTS; i++) {
- memset(&endpoint_instance[i], 0,
- sizeof(struct usb_endpoint_instance));
-
- endpoint_instance[i].endpoint_address =
- ep_descriptor_ptrs[i - 1]->bEndpointAddress;
-
- endpoint_instance[i].rcv_attributes =
- ep_descriptor_ptrs[i - 1]->bmAttributes;
-
- /*fix the abort caused by unalignment*/
- temp = *(u8 *)&ep_descriptor_ptrs[i - 1]->wMaxPacketSize;
- temp |=
- (*(((u8 *)&ep_descriptor_ptrs[i - 1]->wMaxPacketSize) + 1) << 8);
-
- endpoint_instance[i].rcv_packetSize =
- le16_to_cpu(temp);
-
- endpoint_instance[i].tx_attributes =
- ep_descriptor_ptrs[i - 1]->bmAttributes;
-
- endpoint_instance[i].tx_packetSize =
- le16_to_cpu(temp);
-
- endpoint_instance[i].tx_attributes =
- ep_descriptor_ptrs[i - 1]->bmAttributes;
-
- urb_link_init(&endpoint_instance[i].rcv);
- urb_link_init(&endpoint_instance[i].rdy);
- urb_link_init(&endpoint_instance[i].tx);
- urb_link_init(&endpoint_instance[i].done);
-
- if (endpoint_instance[i].endpoint_address & USB_DIR_IN) {
- tx_endpoint = i;
- endpoint_instance[i].tx_urb =
- usbd_alloc_urb(device_instance,
- &endpoint_instance[i]);
- } else {
- rx_endpoint = i;
- endpoint_instance[i].rcv_urb =
- usbd_alloc_urb(device_instance,
- &endpoint_instance[i]);
- }
- }
-}
-
-static void _fastboot_init_endpoints(void)
-{
- int i;
-
- bus_instance->max_endpoints = NUM_ENDPOINTS + 1;
- for (i = 1; i <= NUM_ENDPOINTS; i++)
- udc_setup_ep(device_instance, i, &endpoint_instance[i]);
-}
-
-static void _fastboot_destroy_endpoints(void)
-{
- int i;
- struct urb *tx_urb;
-
- for (i = 1; i <= NUM_ENDPOINTS; i++) {
- /*dealloc urb*/
- if (endpoint_instance[i].endpoint_address & USB_DIR_IN) {
- if (endpoint_instance[i].tx_urb)
- usbd_dealloc_urb(endpoint_instance[i].tx_urb);
-
- while (endpoint_instance[i].tx_queue) {
- tx_urb = first_urb_detached(&endpoint_instance[i].tx);
- if (tx_urb) {
- usbd_dealloc_urb(tx_urb);
- endpoint_instance[i].tx_queue--;
- } else {
- break;
- }
- }
- endpoint_instance[i].tx_queue = 0;
-
- do {
- tx_urb = first_urb_detached(&endpoint_instance[i].done);
- if (tx_urb)
- usbd_dealloc_urb(tx_urb);
- } while (tx_urb);
-
- } else {
- if (endpoint_instance[i].rcv_urb)
- usbd_dealloc_urb(endpoint_instance[i].rcv_urb);
- }
-
- udc_destroy_ep(device_instance, &endpoint_instance[i]);
- }
-}
-
-
-static int _fill_buffer(u8 *buf)
-{
- struct usb_endpoint_instance *endpoint =
- &endpoint_instance[rx_endpoint];
-
- if (endpoint->rcv_urb && endpoint->rcv_urb->actual_length) {
- unsigned int nb = 0;
- char *src = (char *)endpoint->rcv_urb->buffer;
- unsigned int rx_avail = MAX_BUFFER_SIZE;
-
- if (rx_avail >= endpoint->rcv_urb->actual_length) {
- nb = endpoint->rcv_urb->actual_length;
- memcpy(buf, src, nb);
- endpoint->rcv_urb->actual_length = 0;
- }
- return nb;
- }
- return 0;
-}
-
-static struct urb *_next_urb(struct usb_device_instance *device,
- struct usb_endpoint_instance *endpoint)
-{
- struct urb *current_urb = NULL;
- int space;
-
- /* If there's a queue, then we should add to the last urb */
- if (!endpoint->tx_queue)
- current_urb = endpoint->tx_urb;
- else
- /* Last urb from tx chain */
- current_urb =
- p2surround(struct urb, link, endpoint->tx.prev);
-
- /* Make sure this one has enough room */
- space = current_urb->buffer_length - current_urb->actual_length;
- if (space > 0)
- return current_urb;
- else { /* No space here */
- /* First look at done list */
- current_urb = first_urb_detached(&endpoint->done);
- if (!current_urb)
- current_urb = usbd_alloc_urb(device, endpoint);
-
- urb_append(&endpoint->tx, current_urb);
- endpoint->tx_queue++;
- }
- return current_urb;
-}
-
-static int _fastboot_usb_configured(void)
-{
- return fastboot_configured_flag;
-}
-
-static void _fastboot_event_handler(struct usb_device_instance *device,
- usb_device_event_t event, int data)
-{
- switch (event) {
- case DEVICE_RESET:
- case DEVICE_BUS_INACTIVE:
- fastboot_configured_flag = 0;
- break;
- case DEVICE_CONFIGURED:
- fastboot_configured_flag = 1;
- _fastboot_init_endpoints();
- break;
- case DEVICE_ADDRESS_ASSIGNED:
- default:
- break;
- }
-}
-
-static int _fastboot_cdc_setup(struct usb_device_request *request,
- struct urb *urb)
-{
- return 0;
-}
-
-
-/*!
- * Function to receive data from host through channel
- *
- * @buf buffer to fill in
- * @count read data size
- *
- * @return 0
- */
-int fastboot_usb_recv(u8 *buf, int count)
-{
- int len = 0;
-
- while (!_fastboot_usb_configured())
- udc_irq();
-
- /* update rxqueue to wait new data */
- mxc_udc_rxqueue_update(2, count);
-
- while (!len) {
- if (is_usb_disconnected()) {
- /*it will not unconfigure when disconnect
- from host, so here needs manual unconfigure
- anyway, it's just a workaround*/
- fastboot_configured_flag = 0;
- usb_disconnected = 1;
- return 0;
- }
- udc_irq();
- if (_fastboot_usb_configured())
- len = _fill_buffer(buf);
- }
- return len;
-}
-
-int fastboot_getvar(const char *rx_buffer, char *tx_buffer)
-{
- /* Place board specific variables here */
- return 0;
-}
-
-int fastboot_poll()
-{
- u8 buffer[MAX_BUFFER_SIZE];
- int length = 0;
-
- memset(buffer, 0, MAX_BUFFER_SIZE);
-
- length = fastboot_usb_recv(buffer, MAX_BUFFER_SIZE);
-
- /* If usb disconnected, blocked here to wait */
- if (usb_disconnected) {
- udc_disconnect();
- udc_connect();
- /*the udc_connect will be blocked until connect to host
- so, the usb_disconnect should be 0 after udc_connect,
- and should be set manually. Anyway, it's just a workaround*/
- usb_disconnected = 0;
- }
-
- if (!length)
- return FASTBOOT_INACTIVE;
-
- /* Pass this up to the interface's handler */
- if (fastboot_interface && fastboot_interface->rx_handler) {
- if (!fastboot_interface->rx_handler(buffer, length))
- return FASTBOOT_OK;
- }
- return FASTBOOT_OK;
-}
-
-int fastboot_tx(unsigned char *buffer, unsigned int buffer_size)
-{
- /* Not realized yet */
- return 0;
-}
-
-static int _fastboot_write_buffer(const char *buffer,
- unsigned int buffer_size)
-{
- struct usb_endpoint_instance *endpoint =
- (struct usb_endpoint_instance *)&endpoint_instance[tx_endpoint];
- struct urb *current_urb = NULL;
-
- if (!_fastboot_usb_configured())
- return 0;
-
- current_urb = _next_urb(device_instance, endpoint);
- if (buffer_size) {
- char *dest;
- int space_avail, popnum, count, total = 0;
-
- /* Break buffer into urb sized pieces,
- * and link each to the endpoint
- */
- count = buffer_size;
- while (count > 0) {
- if (!current_urb) {
- printf("current_urb is NULL, buffer_size %d\n",
- buffer_size);
- return total;
- }
-
- dest = (char *)current_urb->buffer +
- current_urb->actual_length;
-
- space_avail = current_urb->buffer_length -
- current_urb->actual_length;
- popnum = min(space_avail, count);
- if (popnum == 0)
- break;
-
- memcpy(dest, buffer + total, popnum);
- printf("send: %s\n", (char *)buffer);
-
- current_urb->actual_length += popnum;
- total += popnum;
-
- if (udc_endpoint_write(endpoint))
- /* Write pre-empted by RX */
- return 0;
- count -= popnum;
- } /* end while */
- return total;
- }
- return 0;
-}
-
-int fastboot_tx_status(const char *buffer, unsigned int buffer_size)
-{
- int len = 0;
-
- while (buffer_size > 0) {
- len = _fastboot_write_buffer(buffer + len, buffer_size);
- buffer_size -= len;
-
- udc_irq();
- }
- udc_irq();
-
- return 0;
-}
-
-void fastboot_shutdown(void)
-{
- usb_shutdown();
-
- /* Reset interface*/
- if (fastboot_interface &&
- fastboot_interface->reset_handler) {
- fastboot_interface->reset_handler();
- }
-
- /* Reset some globals */
- _fastboot_destroy_endpoints();
- fastboot_interface = NULL;
- fastboot_configured_flag = 0;
- usb_disconnected = 0;
-
- /*free memory*/
- udc_destroy();
-}
-
-/*
- * CPU and board-specific fastboot initializations. Aliased function
- * signals caller to move on
- */
-static void __def_fastboot_setup(void)
-{
- /*do nothing here*/
-}
-void board_fastboot_setup(void) \
- __attribute__((weak, alias("__def_fastboot_setup")));
-
-
-void fastboot_setup(void)
-{
- /*execute board relevant initilizations for preparing fastboot */
- board_fastboot_setup();
-
- /*get the fastboot dev*/
- _fastboot_setup_dev();
-
- /*check if we need to setup recovery*/
-#ifdef CONFIG_ANDROID_RECOVERY
- check_recovery_mode();
-#endif
-
- /*load partitions information for the fastboot dev*/
- _fastboot_load_partitions();
-}
-
-/* export to lib_arm/board.c */
-void check_fastboot(void)
-{
- if (fastboot_check_and_clean_flag())
- do_fastboot(NULL, 0, 0, 0);
-}
-
-#if defined(CONFIG_FASTBOOT_STORAGE_SATA) \
- || defined(CONFIG_FASTBOOT_STORAGE_MMC)
-/**
- @mmc_dos_partition_index: the partition index in mbr.
- @mmc_partition_index: the boot partition or user partition index,
- not related to the partition table.
- */
-static int _fastboot_parts_add_ptable_entry(int ptable_index,
- int mmc_dos_partition_index,
- int mmc_partition_index,
- const char *name,
- block_dev_desc_t *dev_desc,
- struct fastboot_ptentry *ptable)
-{
- disk_partition_t info;
- strcpy(ptable[ptable_index].name, name);
-
- if (get_partition_info(dev_desc,
- mmc_dos_partition_index, &info)) {
- printf("Bad partition index:%d for partition:%s\n",
- mmc_dos_partition_index, name);
- return -1;
- } else {
- ptable[ptable_index].start = info.start;
- ptable[ptable_index].length = info.size;
- ptable[ptable_index].partition_id = mmc_partition_index;
- }
- return 0;
-}
-
-static int _fastboot_parts_load_from_ptable(void)
-{
- int i;
-#ifdef CONFIG_CMD_SATA
- int sata_device_no;
-#endif
-
- /* mmc boot partition: -1 means no partition, 0 user part., 1 boot part.
- * default is no partition, for emmc default user part, except emmc*/
- int boot_partition = FASTBOOT_MMC_NONE_PARTITION_ID;
- int user_partition = FASTBOOT_MMC_NONE_PARTITION_ID;
-
- struct mmc *mmc;
- block_dev_desc_t *dev_desc;
- struct fastboot_ptentry ptable[PTN_RECOVERY_INDEX + 1];
-
- /* sata case in env */
- if (fastboot_devinfo.type == DEV_SATA) {
-#ifdef CONFIG_CMD_SATA
- puts("flash target is SATA\n");
- if (sata_initialize())
- return -1;
- sata_device_no = CONFIG_FASTBOOT_SATA_NO;
- if (sata_device_no >= CONFIG_SYS_SATA_MAX_DEVICE) {
- printf("Unknown SATA(%d) device for fastboot\n",
- sata_device_no);
- return -1;
- }
- dev_desc = sata_get_dev(sata_device_no);
-#else /*! CONFIG_CMD_SATA*/
- puts("SATA isn't buildin\n");
- return -1;
-#endif /*! CONFIG_CMD_SATA*/
- } else if (fastboot_devinfo.type == DEV_MMC) {
- int mmc_no = 0;
- mmc_no = fastboot_devinfo.dev_id;
-
- printf("flash target is MMC:%d\n", mmc_no);
- mmc = find_mmc_device(mmc_no);
- if (mmc && mmc_init(mmc))
- printf("MMC card init failed!\n");
-
- dev_desc = get_dev("mmc", mmc_no);
- if (NULL == dev_desc) {
- printf("** Block device MMC %d not supported\n",
- mmc_no);
- return -1;
- }
-
- /* multiple boot paritions for eMMC 4.3 later */
- if (mmc->part_config != MMCPART_NOAVAILABLE) {
- boot_partition = FASTBOOT_MMC_BOOT_PARTITION_ID;
- user_partition = FASTBOOT_MMC_USER_PARTITION_ID;
- }
- } else {
- printf("Can't setup partition table on this device %d\n",
- fastboot_devinfo.type);
- return -1;
- }
-
- memset((char *)ptable, 0,
- sizeof(struct fastboot_ptentry) * (PTN_RECOVERY_INDEX + 1));
- /* MBR */
- strcpy(ptable[PTN_MBR_INDEX].name, "mbr");
- ptable[PTN_MBR_INDEX].start = ANDROID_MBR_OFFSET / dev_desc->blksz;
- ptable[PTN_MBR_INDEX].length = ANDROID_MBR_SIZE / dev_desc->blksz;
- ptable[PTN_MBR_INDEX].partition_id = user_partition;
- /* Bootloader */
- strcpy(ptable[PTN_BOOTLOADER_INDEX].name, "bootloader");
- ptable[PTN_BOOTLOADER_INDEX].start =
- ANDROID_BOOTLOADER_OFFSET / dev_desc->blksz;
- ptable[PTN_BOOTLOADER_INDEX].length =
- ANDROID_BOOTLOADER_SIZE / dev_desc->blksz;
- ptable[PTN_BOOTLOADER_INDEX].partition_id = boot_partition;
-
- _fastboot_parts_add_ptable_entry(PTN_KERNEL_INDEX,
- CONFIG_ANDROID_BOOT_PARTITION_MMC,
- user_partition, "boot", dev_desc, ptable);
- _fastboot_parts_add_ptable_entry(PTN_RECOVERY_INDEX,
- CONFIG_ANDROID_RECOVERY_PARTITION_MMC,
- user_partition,
- "recovery", dev_desc, ptable);
- _fastboot_parts_add_ptable_entry(PTN_SYSTEM_INDEX,
- CONFIG_ANDROID_SYSTEM_PARTITION_MMC,
- user_partition,
- "system", dev_desc, ptable);
-
- for (i = 0; i <= PTN_RECOVERY_INDEX; i++)
- fastboot_flash_add_ptn(&ptable[i]);
-
- return 0;
-}
-#endif /*CONFIG_FASTBOOT_STORAGE_SATA || CONFIG_FASTBOOT_STORAGE_MMC*/
-
-#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
-static unsigned long long _memparse(char *ptr, char **retptr)
-{
- char *endptr; /* local pointer to end of parsed string */
-
- unsigned long ret = simple_strtoul(ptr, &endptr, 0);
-
- switch (*endptr) {
- case 'M':
- case 'm':
- ret <<= 10;
- case 'K':
- case 'k':
- ret <<= 10;
- endptr++;
- default:
- break;
- }
-
- if (retptr)
- *retptr = endptr;
-
- return ret;
-}
-
-static int _fastboot_parts_add_env_entry(char *s, char **retptr)
-{
- unsigned long size;
- unsigned long offset = 0;
- char *name;
- int name_len;
- int delim;
- unsigned int flags;
- struct fastboot_ptentry part;
-
- size = _memparse(s, &s);
- if (0 == size) {
- printf("Error:FASTBOOT size of parition is 0\n");
- return 1;
- }
-
- /* fetch partition name and flags */
- flags = 0; /* this is going to be a regular partition */
- delim = 0;
- /* check for offset */
- if (*s == '@') {
- s++;
- offset = _memparse(s, &s);
- } else {
- printf("Error:FASTBOOT offset of parition is not given\n");
- return 1;
- }
-
- /* now look for name */
- if (*s == '(')
- delim = ')';
-
- if (delim) {
- char *p;
-
- name = ++s;
- p = strchr((const char *)name, delim);
- if (!p) {
- printf("Error:FASTBOOT no closing %c found in partition name\n",
- delim);
- return 1;
- }
- name_len = p - name;
- s = p + 1;
- } else {
- printf("Error:FASTBOOT no partition name for \'%s\'\n", s);
- return 1;
- }
-
- /* check for options */
- while (1) {
- if (strncmp(s, "i", 1) == 0) {
- flags |= FASTBOOT_PTENTRY_FLAGS_WRITE_I;
- s += 1;
- } else if (strncmp(s, "ubifs", 5) == 0) {
- /* ubifs */
- flags |= FASTBOOT_PTENTRY_FLAGS_WRITE_TRIMFFS;
- s += 5;
- } else {
- break;
- }
- if (strncmp(s, "|", 1) == 0)
- s += 1;
- }
-
- /* enter this partition (offset will be calculated later if it is zero at this point) */
- part.length = size;
- part.start = offset;
- part.flags = flags;
-
- if (name) {
- if (name_len >= sizeof(part.name)) {
- printf("Error:FASTBOOT partition name is too long\n");
- return 1;
- }
- strncpy(&part.name[0], name, name_len);
- /* name is not null terminated */
- part.name[name_len] = '\0';
- } else {
- printf("Error:FASTBOOT no name\n");
- return 1;
- }
-
- fastboot_flash_add_ptn(&part);
-
- /*if the nand partitions envs are not initialized, try to init them*/
- if (check_parts_values(&part))
- save_parts_values(&part, part.start, part.length);
-
- /* return (updated) pointer command line string */
- *retptr = s;
-
- /* return partition table */
- return 0;
-}
-
-static int _fastboot_parts_load_from_env(void)
-{
- char fbparts[FASTBOOT_FBPARTS_ENV_MAX_LEN], *env;
-
- env = getenv("fbparts");
- if (env) {
- unsigned int len;
- len = strlen(env);
- if (len && len < FASTBOOT_FBPARTS_ENV_MAX_LEN) {
- char *s, *e;
-
- memcpy(&fbparts[0], env, len + 1);
- printf("Fastboot: Adding partitions from environment\n");
- s = &fbparts[0];
- e = s + len;
- while (s < e) {
- if (_fastboot_parts_add_env_entry(s, &s)) {
- printf("Error:Fastboot: Abort adding partitions\n");
- pcount = 0;
- return 1;
- }
- /* Skip a bunch of delimiters */
- while (s < e) {
- if ((' ' == *s) ||
- ('\t' == *s) ||
- ('\n' == *s) ||
- ('\r' == *s) ||
- (',' == *s)) {
- s++;
- } else {
- break;
- }
- }
- }
- }
- }
-
- return 0;
-}
-#endif /*CONFIG_FASTBOOT_STORAGE_NAND*/
-
-static void _fastboot_load_partitions(void)
-{
- pcount = 0;
-#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
- _fastboot_parts_load_from_env();
-#elif defined(CONFIG_FASTBOOT_STORAGE_SATA) \
- || defined(CONFIG_FASTBOOT_STORAGE_MMC)
- _fastboot_parts_load_from_ptable();
-#endif
-}
-
-/*
- * Android style flash utilties */
-void fastboot_flash_add_ptn(struct fastboot_ptentry *ptn)
-{
- if (pcount < MAX_PTN) {
- memcpy(ptable + pcount, ptn, sizeof(struct fastboot_ptentry));
- pcount++;
- }
-}
-
-void fastboot_flash_dump_ptn(void)
-{
- unsigned int n;
- for (n = 0; n < pcount; n++) {
- struct fastboot_ptentry *ptn = ptable + n;
- printf("ptn %d name='%s' start=%d len=%d\n",
- n, ptn->name, ptn->start, ptn->length);
- }
-}
-
-
-struct fastboot_ptentry *fastboot_flash_find_ptn(const char *name)
-{
- unsigned int n;
-
- for (n = 0; n < pcount; n++) {
- /* Make sure a substring is not accepted */
- if (strlen(name) == strlen(ptable[n].name)) {
- if (0 == strcmp(ptable[n].name, name))
- return ptable + n;
- }
- }
-
- printf("can't find partition: %s, dump the partition table\n", name);
- fastboot_flash_dump_ptn();
- return 0;
-}
-
-struct fastboot_ptentry *fastboot_flash_get_ptn(unsigned int n)
-{
- if (n < pcount)
- return ptable + n;
- else
- return 0;
-}
-
-unsigned int fastboot_flash_get_ptn_count(void)
-{
- return pcount;
-}
diff --git a/drivers/usb/gadget/ci_udc.c b/drivers/usb/gadget/ci_udc.c
index b0ef35e..1dd8b11 100644
--- a/drivers/usb/gadget/ci_udc.c
+++ b/drivers/usb/gadget/ci_udc.c
@@ -888,7 +888,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
return ret;
ret = ci_udc_probe();
-#if defined(CONFIG_USB_EHCI_MX6) || defined(CONFIG_USB_EHCI_MXS)
+#if defined(CONFIG_USB_EHCI_MX6) || defined(CONFIG_USB_EHCI_MXS) || defined(CONFIG_USB_EHCI_MX7)
/*
* FIXME: usb_lowlevel_init()->ehci_hcd_init() should be doing all
* HW-specific initialization, e.g. ULPI-vs-UTMI PHY selection
diff --git a/drivers/usb/gadget/f_fastboot.c b/drivers/usb/gadget/f_fastboot.c
index 751ec9e..cbe4236 100644
--- a/drivers/usb/gadget/f_fastboot.c
+++ b/drivers/usb/gadget/f_fastboot.c
@@ -24,6 +24,18 @@
#include <fb_mmc.h>
#endif
+#ifdef CONFIG_FSL_FASTBOOT
+#include <fsl_fastboot.h>
+#include <mmc.h>
+#include <android_image.h>
+#include <asm/bootm.h>
+#include <nand.h>
+#include <aboot.h>
+#ifdef CONFIG_ANDROID_RECOVERY
+#include <recovery.h>
+#endif
+#endif
+
#define FASTBOOT_VERSION "0.4"
#define FASTBOOT_INTERFACE_CLASS 0xff
@@ -122,6 +134,1691 @@ static struct usb_gadget_strings *fastboot_strings[] = {
NULL,
};
+#ifdef CONFIG_FSL_FASTBOOT
+
+#define ANDROID_MBR_OFFSET 0
+#define ANDROID_MBR_SIZE 0x200
+#define ANDROID_BOOTLOADER_OFFSET 0x400
+#define ANDROID_BOOTLOADER_SIZE 0xFFC00
+#define ANDROID_KERNEL_OFFSET 0x100000
+#define ANDROID_KERNEL_SIZE 0x500000
+#define ANDROID_URAMDISK_OFFSET 0x600000
+#define ANDROID_URAMDISK_SIZE 0x100000
+
+
+
+#define MMC_SATA_BLOCK_SIZE 512
+#define FASTBOOT_FBPARTS_ENV_MAX_LEN 1024
+/* To support the Android-style naming of flash */
+#define MAX_PTN 16
+
+
+/*pentry index internally*/
+enum {
+ PTN_MBR_INDEX = 0,
+ PTN_BOOTLOADER_INDEX,
+ PTN_KERNEL_INDEX,
+ PTN_URAMDISK_INDEX,
+ PTN_SYSTEM_INDEX,
+ PTN_RECOVERY_INDEX
+};
+
+static unsigned int download_bytes_unpadded;
+
+static struct cmd_fastboot_interface interface = {
+ .rx_handler = NULL,
+ .reset_handler = NULL,
+ .product_name = NULL,
+ .serial_no = NULL,
+ .nand_block_size = 0,
+ .transfer_buffer = (unsigned char *)0xffffffff,
+ .transfer_buffer_size = 0,
+};
+
+
+#ifdef CONFIG_FASTBOOT_STORAGE_NAND
+static void save_env(struct fastboot_ptentry *ptn,
+ char *var, char *val)
+{
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ char lock[128], unlock[128];
+#endif
+
+ setenv(var, val);
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ sprintf(lock, "nand lock 0x%x 0x%x", ptn->start, ptn->length);
+ sprintf(unlock, "nand unlock 0x%x 0x%x", ptn->start, ptn->length);
+
+ /* This could be a problem is there is an outstanding lock */
+ run_command(unlock, 0);
+#endif
+ saveenv();
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ run_command(lock, 0);
+#endif
+}
+
+void save_parts_values(struct fastboot_ptentry *ptn,
+ unsigned int offset,
+ unsigned int size)
+{
+ char var[64], val[32];
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ char lock[128], unlock[128];
+ struct fastboot_ptentry *env_ptn;
+#endif
+
+ printf("saving it..\n");
+
+
+ sprintf(var, "%s_nand_offset", ptn->name);
+ sprintf(val, "0x%x", offset);
+
+ printf("setenv %s %s\n", var, val);
+
+ setenv(var, val);
+
+ sprintf(var, "%s_nand_size", ptn->name);
+ sprintf(val, "0x%x", size);
+
+ printf("setenv %s %s\n", var, val);
+
+ setenv(var, val);
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ /* Warning :
+ The environment is assumed to be in a partition named 'enviroment'.
+ It is very possible that your board stores the enviroment
+ someplace else. */
+ env_ptn = fastboot_flash_find_ptn("environment");
+
+ if (env_ptn) {
+ sprintf(lock, "nand lock 0x%x 0x%x",
+ env_ptn->start, env_ptn->length);
+ sprintf(unlock, "nand unlock 0x%x 0x%x",
+ env_ptn->start, env_ptn->length);
+
+ run_command(unlock, 0);
+ }
+#endif
+ saveenv();
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ if (env_ptn)
+ run_command(lock, 0);
+#endif
+}
+
+int check_parts_values(struct fastboot_ptentry *ptn)
+{
+ char var[64];
+
+ sprintf(var, "%s_nand_offset", ptn->name);
+ if (!getenv(var))
+ return 1;
+
+ sprintf(var, "%s_nand_size", ptn->name);
+ if (!getenv(var))
+ return 1;
+
+ return 0;
+}
+
+static int write_to_ptn(struct fastboot_ptentry *ptn)
+{
+ int ret = 1;
+ char length[32];
+ char write_type[32];
+ int repeat, repeat_max;
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ char lock[128];
+ char unlock[128];
+#endif
+ char write[128];
+ char erase[128];
+
+ printf("flashing '%s'\n", ptn->name);
+
+ /* Which flavor of write to use */
+ if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_I)
+ sprintf(write_type, "write.i");
+#ifdef CONFIG_CMD_NAND_TRIMFFS
+ else if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_TRIMFFS)
+ sprintf(write_type, "write.trimffs");
+#endif
+ else
+ sprintf(write_type, "write");
+
+ /* Some flashing requires writing the same data in multiple,
+ consecutive flash partitions */
+ repeat_max = 1;
+ if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_REPEAT_MASK) {
+ if (ptn->flags &
+ FASTBOOT_PTENTRY_FLAGS_WRITE_CONTIGUOUS_BLOCK) {
+ printf("Warning can not do both 'contiguous block' "
+ "and 'repeat' writes for for partition '%s'\n", ptn->name);
+ printf("Ignoring repeat flag\n");
+ } else {
+ repeat_max = ptn->flags &
+ FASTBOOT_PTENTRY_FLAGS_REPEAT_MASK;
+ }
+ }
+
+ /* Unlock the whole partition instead of trying to
+ manage special cases */
+ sprintf(length, "0x%x", ptn->length * repeat_max);
+
+ for (repeat = 0; repeat < repeat_max; repeat++) {
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ sprintf(lock, "nand lock 0x%x %s",
+ ptn->start + (repeat * ptn->length), length);
+ sprintf(unlock, "nand unlock 0x%x %s",
+ ptn->start + (repeat * ptn->length), length);
+#endif
+ sprintf(erase, "nand erase 0x%x %s",
+ ptn->start + (repeat * ptn->length), length);
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ run_command(unlock, 0);
+#endif
+ run_command(erase, 0);
+
+ if ((ptn->flags &
+ FASTBOOT_PTENTRY_FLAGS_WRITE_NEXT_GOOD_BLOCK) &&
+ (ptn->flags &
+ FASTBOOT_PTENTRY_FLAGS_WRITE_CONTIGUOUS_BLOCK)) {
+ /* Both can not be true */
+ printf("Warning can not do 'next good block' and \
+ 'contiguous block' for partition '%s'\n",
+ ptn->name);
+ printf("Ignoring these flags\n");
+ } else if (ptn->flags &
+ FASTBOOT_PTENTRY_FLAGS_WRITE_NEXT_GOOD_BLOCK) {
+ /* Keep writing until you get a good block
+ transfer_buffer should already be aligned */
+ if (interface.nand_block_size) {
+ unsigned int blocks = download_bytes /
+ interface.nand_block_size;
+ unsigned int i = 0;
+ unsigned int offset = 0;
+
+ while (i < blocks) {
+ /* Check for overflow */
+ if (offset >= ptn->length)
+ break;
+
+ /* download's address only advance
+ if last write was successful */
+
+ /* nand's address always advances */
+ sprintf(write, "nand %s 0x%p 0x%x 0x%x", write_type,
+ interface.transfer_buffer +
+ (i * interface.nand_block_size),
+ ptn->start + (repeat * ptn->length) + offset,
+ interface.nand_block_size);
+
+ ret = run_command(write, 0);
+ if (ret)
+ break;
+ else
+ i++;
+
+ /* Go to next nand block */
+ offset += interface.nand_block_size;
+ }
+ } else {
+ printf("Warning nand block size can not be 0 \
+ when using 'next good block' for \
+ partition '%s'\n", ptn->name);
+ printf("Ignoring write request\n");
+ }
+ } else if (ptn->flags &
+ FASTBOOT_PTENTRY_FLAGS_WRITE_CONTIGUOUS_BLOCK) {
+ /* Keep writing until you get a good block
+ transfer_buffer should already be aligned */
+ if (interface.nand_block_size) {
+ if (0 == nand_curr_device) {
+ nand_info_t *nand;
+ unsigned long off;
+ unsigned int ok_start;
+
+ nand = &nand_info[nand_curr_device];
+
+ printf("\nDevice %d bad blocks:\n",
+ nand_curr_device);
+
+ /* Initialize the ok_start to the
+ start of the partition
+ Then try to find a block large
+ enough for the download */
+ ok_start = ptn->start;
+
+ /* It is assumed that the start and
+ length are multiples of block size */
+ for (off = ptn->start;
+ off < ptn->start + ptn->length;
+ off += nand->erasesize) {
+ if (nand_block_isbad(nand, off)) {
+ /* Reset the ok_start
+ to the next block */
+ ok_start = off +
+ nand->erasesize;
+ }
+
+ /* Check if we have enough
+ blocks */
+ if ((ok_start - off) >=
+ download_bytes)
+ break;
+ }
+
+ /* Check if there is enough space */
+ if (ok_start + download_bytes <=
+ ptn->start + ptn->length) {
+
+ sprintf(write, "nand %s 0x%p 0x%x 0x%x", write_type,
+ interface.transfer_buffer,
+ ok_start,
+ download_bytes);
+
+ ret = run_command(write, 0);
+
+ /* Save the results into an
+ environment variable on the
+ format
+ ptn_name + 'offset'
+ ptn_name + 'size' */
+ if (ret) {
+ /* failed */
+ save_parts_values(ptn, ptn->start, 0);
+ } else {
+ /* success */
+ save_parts_values(ptn, ok_start, download_bytes);
+ }
+ } else {
+ printf("Error could not find enough contiguous space "
+ "in partition '%s'\n", ptn->name);
+ printf("Ignoring write request\n");
+ }
+ } else {
+ /* TBD : Generalize flash handling */
+ printf("Error only handling 1 NAND per board");
+ printf("Ignoring write request\n");
+ }
+ } else {
+ printf("Warning nand block size can not be 0 \
+ when using 'continuous block' for \
+ partition '%s'\n", ptn->name);
+ printf("Ignoring write request\n");
+ }
+ } else {
+ /* Normal case */
+ sprintf(write, "nand %s 0x%p 0x%x 0x%x", write_type,
+ interface.transfer_buffer,
+ ptn->start + (repeat * ptn->length),
+ download_bytes);
+#ifdef CONFIG_CMD_NAND_TRIMFFS
+ if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_TRIMFFS) {
+ sprintf(write, "nand %s 0x%p 0x%x 0x%x", write_type,
+ interface.transfer_buffer,
+ ptn->start + (repeat * ptn->length),
+ download_bytes_unpadded);
+ }
+#endif
+
+ ret = run_command(write, 0);
+
+ if (0 == repeat) {
+ if (ret) /* failed */
+ save_parts_values(ptn, ptn->start, 0);
+ else /* success */
+ save_parts_values(ptn, ptn->start,
+ download_bytes);
+ }
+ }
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ run_command(lock, 0);
+#endif
+
+ if (ret)
+ break;
+ }
+
+ return ret;
+}
+#else
+static void save_env(struct fastboot_ptentry *ptn,
+ char *var, char *val)
+{
+ setenv(var, val);
+ saveenv();
+}
+#endif
+
+/* When save = 0, just parse. The input is unchanged
+ When save = 1, parse and do the save. The input is changed */
+static int parse_env(void *ptn, char *err_string, int save, int debug)
+{
+ int ret = 1;
+ unsigned int sets = 0;
+ unsigned int comment_start = 0;
+ char *var = NULL;
+ char *var_end = NULL;
+ char *val = NULL;
+ char *val_end = NULL;
+ unsigned int i;
+
+ char *buff = (char *)interface.transfer_buffer;
+ unsigned int size = download_bytes_unpadded;
+
+ /* The input does not have to be null terminated.
+ This will cause a problem in the corner case
+ where the last line does not have a new line.
+ Put a null after the end of the input.
+
+ WARNING : Input buffer is assumed to be bigger
+ than the size of the input */
+ if (save)
+ buff[size] = 0;
+
+ for (i = 0; i < size; i++) {
+
+ if (NULL == var) {
+
+ /*
+ * Check for comments, comment ok only on
+ * mostly empty lines
+ */
+ if (buff[i] == '#')
+ comment_start = 1;
+
+ if (comment_start) {
+ if ((buff[i] == '\r') ||
+ (buff[i] == '\n')) {
+ comment_start = 0;
+ }
+ } else {
+ if (!((buff[i] == ' ') ||
+ (buff[i] == '\t') ||
+ (buff[i] == '\r') ||
+ (buff[i] == '\n'))) {
+ /*
+ * Normal whitespace before the
+ * variable
+ */
+ var = &buff[i];
+ }
+ }
+
+ } else if (((NULL == var_end) || (NULL == val)) &&
+ ((buff[i] == '\r') || (buff[i] == '\n'))) {
+
+ /* This is the case when a variable
+ is unset. */
+
+ if (save) {
+ /* Set the var end to null so the
+ normal string routines will work
+
+ WARNING : This changes the input */
+ buff[i] = '\0';
+
+ save_env(ptn, var, val);
+
+ if (debug)
+ printf("Unsetting %s\n", var);
+ }
+
+ /* Clear the variable so state is parse is back
+ to initial. */
+ var = NULL;
+ var_end = NULL;
+ sets++;
+ } else if (NULL == var_end) {
+ if ((buff[i] == ' ') ||
+ (buff[i] == '\t'))
+ var_end = &buff[i];
+ } else if (NULL == val) {
+ if (!((buff[i] == ' ') ||
+ (buff[i] == '\t')))
+ val = &buff[i];
+ } else if (NULL == val_end) {
+ if ((buff[i] == '\r') ||
+ (buff[i] == '\n')) {
+ /* look for escaped cr or ln */
+ if ('\\' == buff[i - 1]) {
+ /* check for dos */
+ if ((buff[i] == '\r') &&
+ (buff[i+1] == '\n'))
+ buff[i + 1] = ' ';
+ buff[i - 1] = buff[i] = ' ';
+ } else {
+ val_end = &buff[i];
+ }
+ }
+ } else {
+ sprintf(err_string, "Internal Error");
+
+ if (debug)
+ printf("Internal error at %s %d\n",
+ __FILE__, __LINE__);
+ return 1;
+ }
+ /* Check if a var / val pair is ready */
+ if (NULL != val_end) {
+ if (save) {
+ /* Set the end's with nulls so
+ normal string routines will
+ work.
+
+ WARNING : This changes the input */
+ *var_end = '\0';
+ *val_end = '\0';
+
+ save_env(ptn, var, val);
+
+ if (debug)
+ printf("Setting %s %s\n", var, val);
+ }
+
+ /* Clear the variable so state is parse is back
+ to initial. */
+ var = NULL;
+ var_end = NULL;
+ val = NULL;
+ val_end = NULL;
+
+ sets++;
+ }
+ }
+
+ /* Corner case
+ Check for the case that no newline at end of the input */
+ if ((NULL != var) &&
+ (NULL == val_end)) {
+ if (save) {
+ /* case of val / val pair */
+ if (var_end)
+ *var_end = '\0';
+ /* else case handled by setting 0 past
+ the end of buffer.
+ Similar for val_end being null */
+ save_env(ptn, var, val);
+
+ if (debug) {
+ if (var_end)
+ printf("Trailing Setting %s %s\n", var, val);
+ else
+ printf("Trailing Unsetting %s\n", var);
+ }
+ }
+ sets++;
+ }
+ /* Did we set anything ? */
+ if (0 == sets)
+ sprintf(err_string, "No variables set");
+ else
+ ret = 0;
+
+ return ret;
+}
+
+static int saveenv_to_ptn(struct fastboot_ptentry *ptn, char *err_string)
+{
+ int ret = 1;
+ int save = 0;
+ int debug = 0;
+
+ /* err_string is only 32 bytes
+ Initialize with a generic error message. */
+ sprintf(err_string, "%s", "Unknown Error");
+
+ /* Parse the input twice.
+ Only save to the enviroment if the entire input if correct */
+ save = 0;
+ if (0 == parse_env(ptn, err_string, save, debug)) {
+ save = 1;
+ ret = parse_env(ptn, err_string, save, debug);
+ }
+ return ret;
+}
+
+static char result_str[RESPONSE_LEN];
+
+void fastboot_fail(const char *s)
+{
+ strncpy(result_str, "FAIL\0", 5);
+ strncat(result_str, s, RESPONSE_LEN - 4 - 1);
+}
+
+void fastboot_okay(const char *s)
+{
+ strncpy(result_str, "OKAY\0", 5);
+ strncat(result_str, s, RESPONSE_LEN - 4 - 1);
+}
+
+#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+
+static void process_flash_nand(const char *cmdbuf, char *response)
+{
+ if (download_bytes) {
+ struct fastboot_ptentry *ptn;
+
+ ptn = fastboot_flash_find_ptn(cmdbuf);
+ if (ptn == 0) {
+ sprintf(response, "FAILpartition does not exist");
+ } else if ((download_bytes > ptn->length) &&
+ !(ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_ENV)) {
+ sprintf(response, "FAILimage too large for partition");
+ /* TODO : Improve check for yaffs write */
+ } else {
+ /* Check if this is not really a flash write
+ but rather a saveenv */
+ if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_ENV) {
+ /* Since the response can only be 64 bytes,
+ there is no point in having a large error message. */
+ char err_string[32];
+ if (saveenv_to_ptn(ptn, &err_string[0])) {
+ printf("savenv '%s' failed : %s\n",
+ ptn->name, err_string);
+ sprintf(response, "FAIL%s", err_string);
+ } else {
+ printf("partition '%s' saveenv-ed\n", ptn->name);
+ sprintf(response, "OKAY");
+ }
+ } else {
+ /* Normal case */
+ if (write_to_ptn(ptn)) {
+ printf("flashing '%s' failed\n", ptn->name);
+ sprintf(response, "FAILfailed to flash partition");
+ } else {
+ printf("partition '%s' flashed\n", ptn->name);
+ sprintf(response, "OKAY");
+ }
+ }
+ }
+ } else {
+ sprintf(response, "FAILno image downloaded");
+ }
+
+}
+#endif
+
+#if defined(CONFIG_FASTBOOT_STORAGE_SATA)
+static void process_flash_sata(const char *cmdbuf, char *response)
+{
+ if (download_bytes) {
+ struct fastboot_ptentry *ptn;
+
+ /* Next is the partition name */
+ ptn = fastboot_flash_find_ptn(cmdbuf);
+ if (ptn == 0) {
+ printf("Partition:'%s' does not exist\n", ptn->name);
+ sprintf(response, "FAILpartition does not exist");
+ } else if ((download_bytes >
+ ptn->length * MMC_SATA_BLOCK_SIZE) &&
+ !(ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_ENV)) {
+ printf("Image too large for the partition\n");
+ sprintf(response, "FAILimage too large for partition");
+ } else if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_ENV) {
+ /* Since the response can only be 64 bytes,
+ there is no point in having a large error message. */
+ char err_string[32];
+ if (saveenv_to_ptn(ptn, &err_string[0])) {
+ printf("savenv '%s' failed : %s\n", ptn->name, err_string);
+ sprintf(response, "FAIL%s", err_string);
+ } else {
+ printf("partition '%s' saveenv-ed\n", ptn->name);
+ sprintf(response, "OKAY");
+ }
+ } else {
+ unsigned int temp;
+ char sata_write[128];
+
+ /* block count */
+ temp = (download_bytes +
+ MMC_SATA_BLOCK_SIZE - 1) /
+ MMC_SATA_BLOCK_SIZE;
+
+ sprintf(sata_write, "sata write 0x%x 0x%x 0x%x",
+ (unsigned int)interface.transfer_buffer,
+ ptn->start,
+ temp)
+
+ if (run_command(sata_write, 0)) {
+ printf("Writing '%s' FAILED!\n",
+ ptn->name);
+ sprintf(response,
+ "FAIL: Write partition");
+ } else {
+ printf("Writing '%s' DONE!\n",
+ ptn->name);
+ sprintf(response, "OKAY");
+ }
+ }
+ } else {
+ sprintf(response, "FAILno image downloaded");
+ }
+
+}
+#endif
+
+#if defined(CONFIG_FASTBOOT_STORAGE_MMC)
+static int is_sparse_partition(struct fastboot_ptentry *ptn)
+{
+ if (ptn && !strncmp(ptn->name,
+ FASTBOOT_PARTITION_SYSTEM, strlen(FASTBOOT_PARTITION_SYSTEM))) {
+ printf("support sparse flash partition for %s\n", ptn->name);
+ return 1;
+ } else
+ return 0;
+}
+
+static void process_flash_mmc(const char *cmdbuf, char *response)
+{
+ if (download_bytes) {
+ struct fastboot_ptentry *ptn;
+
+ /* Next is the partition name */
+ ptn = fastboot_flash_find_ptn(cmdbuf);
+ if (ptn == 0) {
+ printf("Partition:'%s' does not exist\n", ptn->name);
+ sprintf(response, "FAILpartition does not exist");
+ } else if ((download_bytes >
+ ptn->length * MMC_SATA_BLOCK_SIZE) &&
+ !(ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_ENV)) {
+ printf("Image too large for the partition\n");
+ sprintf(response, "FAILimage too large for partition");
+ } else if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_ENV) {
+ /* Since the response can only be 64 bytes,
+ there is no point in having a large error message. */
+ char err_string[32];
+ if (saveenv_to_ptn(ptn, &err_string[0])) {
+ printf("savenv '%s' failed : %s\n", ptn->name, err_string);
+ sprintf(response, "FAIL%s", err_string);
+ } else {
+ printf("partition '%s' saveenv-ed\n", ptn->name);
+ sprintf(response, "OKAY");
+ }
+ } else {
+ unsigned int temp;
+
+ char mmc_dev[128];
+ char mmc_write[128];
+ int mmcret;
+
+ printf("writing to partition '%s'\n", ptn->name);
+
+ if (ptn->partition_id != FASTBOOT_MMC_NONE_PARTITION_ID)
+ sprintf(mmc_dev, "mmc dev %x %x",
+ fastboot_devinfo.dev_id, /*slot no*/
+ ptn->partition_id /*part no*/);
+ else
+ sprintf(mmc_dev, "mmc dev %x",
+ fastboot_devinfo.dev_id /*slot no*/);
+
+ if (is_sparse_partition(ptn) &&
+ is_sparse_image(interface.transfer_buffer)) {
+ int mmc_no = 0;
+ struct mmc *mmc;
+ block_dev_desc_t *dev_desc;
+ disk_partition_t info;
+ mmc_no = fastboot_devinfo.dev_id;
+
+ printf("sparse flash target is MMC:%d\n", mmc_no);
+ mmc = find_mmc_device(mmc_no);
+ if (mmc && mmc_init(mmc))
+ printf("MMC card init failed!\n");
+
+ dev_desc = get_dev("mmc", mmc_no);
+ if (NULL == dev_desc) {
+ printf("** Block device MMC %d not supported\n",
+ mmc_no);
+ return;
+ }
+
+ if (get_partition_info(dev_desc,
+ ptn->partition_index, &info)) {
+ printf("Bad partition index:%d for partition:%s\n",
+ ptn->partition_index, ptn->name);
+ return;
+ }
+
+ printf("writing to partition '%s' for sparse, buffer size %d\n",
+ ptn->name, download_bytes);
+ write_sparse_image(dev_desc, &info, ptn->name,
+ interface.transfer_buffer, download_bytes);
+ strcpy(response, result_str);
+ } else {
+ /* block count */
+ temp = (download_bytes +
+ MMC_SATA_BLOCK_SIZE - 1) /
+ MMC_SATA_BLOCK_SIZE;
+
+ sprintf(mmc_write, "mmc write 0x%x 0x%x 0x%x",
+ (unsigned int)interface.transfer_buffer, /*source*/
+ ptn->start, /*dest*/
+ temp /*length*/);
+
+ printf("Initializing '%s'\n", ptn->name);
+
+ mmcret = run_command(mmc_dev, 0);
+ if (mmcret)
+ sprintf(response, "FAIL:Init of MMC card");
+ else
+ sprintf(response, "OKAY");
+
+ printf("Writing '%s'\n", ptn->name);
+ if (run_command(mmc_write, 0)) {
+ printf("Writing '%s' FAILED!\n", ptn->name);
+ sprintf(response, "FAIL: Write partition");
+ } else {
+ printf("Writing '%s' DONE!\n", ptn->name);
+ sprintf(response, "OKAY");
+ }
+ }
+ }
+ } else {
+ sprintf(response, "FAILno image downloaded");
+ }
+}
+
+#endif
+
+
+static int rx_process_erase(const char *cmdbuf, char *response)
+{
+#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+ struct fastboot_ptentry *ptn;
+
+ ptn = fastboot_flash_find_ptn(cmdbuf);
+ if (ptn == 0) {
+ sprintf(response, "FAILpartition does not exist");
+ } else {
+ int status, repeat, repeat_max;
+
+ printf("erasing '%s'\n", ptn->name);
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ char lock[128];
+ char unlock[128];
+#endif
+ char erase[128];
+
+ repeat_max = 1;
+ if (ptn->flags & FASTBOOT_PTENTRY_FLAGS_REPEAT_MASK)
+ repeat_max = ptn->flags & FASTBOOT_PTENTRY_FLAGS_REPEAT_MASK;
+
+ for (repeat = 0; repeat < repeat_max;
+ repeat++) {
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ sprintf(lock, "nand lock 0x%x 0x%x",
+ ptn->start + (repeat * ptn->length),
+ ptn->length);
+ sprintf(unlock, "nand unlock 0x%x 0x%x",
+ ptn->start + (repeat * ptn->length),
+ ptn->length);
+#endif
+ sprintf(erase, "nand erase 0x%x 0x%x",
+ ptn->start + (repeat * ptn->length),
+ ptn->length);
+
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ run_command(unlock, 0);
+#endif
+ status = run_command(erase, 0);
+#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
+ run_command(lock, 0);
+#endif
+
+ if (status)
+ break;
+ }
+
+ if (status) {
+ sprintf(response,
+ "FAILfailed to erase partition");
+ } else {
+ printf("partition '%s' erased\n", ptn->name);
+ sprintf(response, "OKAY");
+ }
+ }
+ return 0;
+#else
+ printf("Not support erase command for EMMC\n");
+ return -1;
+#endif
+
+}
+
+static void rx_process_flash(const char *cmdbuf, char *response)
+{
+ switch (fastboot_devinfo.type) {
+#if defined(CONFIG_FASTBOOT_STORAGE_SATA)
+ case DEV_SATA:
+ process_flash_sata(cmdbuf, response);
+ break;
+#endif
+#if defined(CONFIG_FASTBOOT_STORAGE_MMC)
+ case DEV_MMC:
+ process_flash_mmc(cmdbuf, response);
+ break;
+#endif
+#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+ case DEV_NAND:
+ process_flash_nand(cmdbuf, response);
+ break;
+#endif
+ default:
+ printf("Not support flash command for current device %d\n",
+ fastboot_devinfo.type);
+ sprintf(response,
+ "FAILfailed to flash device");
+ break;
+ }
+}
+
+
+static void parameters_setup(void)
+{
+ interface.nand_block_size = 0;
+#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+ nand_info_t *nand = &nand_info[0];
+ if (nand)
+ interface.nand_block_size = nand->writesize;
+#endif
+ interface.transfer_buffer =
+ (unsigned char *)CONFIG_USB_FASTBOOT_BUF_ADDR;
+ interface.transfer_buffer_size =
+ CONFIG_USB_FASTBOOT_BUF_SIZE;
+}
+
+static struct fastboot_ptentry ptable[MAX_PTN];
+static unsigned int pcount;
+struct fastboot_device_info fastboot_devinfo;
+
+/*
+ Get mmc control number from passed string, eg, "mmc1" mean device 1. Only
+ support "mmc0" to "mmc9" currently. It will be treated as device 0 for
+ other string.
+*/
+static int _fastboot_get_mmc_no(char *env_str)
+{
+ int digit = 0;
+ unsigned char a;
+
+ if (env_str && (strlen(env_str) >= 4) &&
+ !strncmp(env_str, "mmc", 3)) {
+ a = env_str[3];
+ if (a >= '0' && a <= '9')
+ digit = a - '0';
+ }
+
+ return digit;
+}
+static int _fastboot_setup_dev(void)
+{
+ char *fastboot_env;
+ fastboot_env = getenv("fastboot_dev");
+
+ if (fastboot_env) {
+ if (!strcmp(fastboot_env, "sata")) {
+ fastboot_devinfo.type = DEV_SATA;
+ fastboot_devinfo.dev_id = 0;
+ } else if (!strcmp(fastboot_env, "nand")) {
+ fastboot_devinfo.type = DEV_NAND;
+ fastboot_devinfo.dev_id = 0;
+ } else if (!strncmp(fastboot_env, "mmc", 3)) {
+ fastboot_devinfo.type = DEV_MMC;
+ fastboot_devinfo.dev_id = _fastboot_get_mmc_no(fastboot_env);
+ }
+ } else {
+ return 1;
+ }
+
+ return 0;
+}
+
+#if defined(CONFIG_FASTBOOT_STORAGE_SATA) \
+ || defined(CONFIG_FASTBOOT_STORAGE_MMC)
+/**
+ @mmc_dos_partition_index: the partition index in mbr.
+ @mmc_partition_index: the boot partition or user partition index,
+ not related to the partition table.
+ */
+static int _fastboot_parts_add_ptable_entry(int ptable_index,
+ int mmc_dos_partition_index,
+ int mmc_partition_index,
+ const char *name,
+ block_dev_desc_t *dev_desc,
+ struct fastboot_ptentry *ptable)
+{
+ disk_partition_t info;
+ strcpy(ptable[ptable_index].name, name);
+
+ if (get_partition_info(dev_desc,
+ mmc_dos_partition_index, &info)) {
+ printf("Bad partition index:%d for partition:%s\n",
+ mmc_dos_partition_index, name);
+ return -1;
+ } else {
+ ptable[ptable_index].start = info.start;
+ ptable[ptable_index].length = info.size;
+ ptable[ptable_index].partition_id = mmc_partition_index;
+ ptable[ptable_index].partition_index = mmc_dos_partition_index;
+ }
+ return 0;
+}
+
+static int _fastboot_parts_load_from_ptable(void)
+{
+ int i;
+#ifdef CONFIG_CMD_SATA
+ int sata_device_no;
+#endif
+
+ /* mmc boot partition: -1 means no partition, 0 user part., 1 boot part.
+ * default is no partition, for emmc default user part, except emmc*/
+ int boot_partition = FASTBOOT_MMC_NONE_PARTITION_ID;
+ int user_partition = FASTBOOT_MMC_NONE_PARTITION_ID;
+
+ struct mmc *mmc;
+ block_dev_desc_t *dev_desc;
+ struct fastboot_ptentry ptable[PTN_RECOVERY_INDEX + 1];
+
+ /* sata case in env */
+ if (fastboot_devinfo.type == DEV_SATA) {
+#ifdef CONFIG_CMD_SATA
+ puts("flash target is SATA\n");
+ if (sata_initialize())
+ return -1;
+ sata_device_no = CONFIG_FASTBOOT_SATA_NO;
+ if (sata_device_no >= CONFIG_SYS_SATA_MAX_DEVICE) {
+ printf("Unknown SATA(%d) device for fastboot\n",
+ sata_device_no);
+ return -1;
+ }
+ dev_desc = sata_get_dev(sata_device_no);
+#else /*! CONFIG_CMD_SATA*/
+ puts("SATA isn't buildin\n");
+ return -1;
+#endif /*! CONFIG_CMD_SATA*/
+ } else if (fastboot_devinfo.type == DEV_MMC) {
+ int mmc_no = 0;
+ mmc_no = fastboot_devinfo.dev_id;
+
+ printf("flash target is MMC:%d\n", mmc_no);
+ mmc = find_mmc_device(mmc_no);
+ if (mmc && mmc_init(mmc))
+ printf("MMC card init failed!\n");
+
+ dev_desc = get_dev("mmc", mmc_no);
+ if (NULL == dev_desc) {
+ printf("** Block device MMC %d not supported\n",
+ mmc_no);
+ return -1;
+ }
+
+ /* multiple boot paritions for eMMC 4.3 later */
+ if (mmc->part_config != MMCPART_NOAVAILABLE) {
+ boot_partition = FASTBOOT_MMC_BOOT_PARTITION_ID;
+ user_partition = FASTBOOT_MMC_USER_PARTITION_ID;
+ }
+ } else {
+ printf("Can't setup partition table on this device %d\n",
+ fastboot_devinfo.type);
+ return -1;
+ }
+
+ memset((char *)ptable, 0,
+ sizeof(struct fastboot_ptentry) * (PTN_RECOVERY_INDEX + 1));
+ /* MBR */
+ strcpy(ptable[PTN_MBR_INDEX].name, "mbr");
+ ptable[PTN_MBR_INDEX].start = ANDROID_MBR_OFFSET / dev_desc->blksz;
+ ptable[PTN_MBR_INDEX].length = ANDROID_MBR_SIZE / dev_desc->blksz;
+ ptable[PTN_MBR_INDEX].partition_id = user_partition;
+ /* Bootloader */
+ strcpy(ptable[PTN_BOOTLOADER_INDEX].name, FASTBOOT_PARTITION_BOOTLOADER);
+ ptable[PTN_BOOTLOADER_INDEX].start =
+ ANDROID_BOOTLOADER_OFFSET / dev_desc->blksz;
+ ptable[PTN_BOOTLOADER_INDEX].length =
+ ANDROID_BOOTLOADER_SIZE / dev_desc->blksz;
+ ptable[PTN_BOOTLOADER_INDEX].partition_id = boot_partition;
+
+ _fastboot_parts_add_ptable_entry(PTN_KERNEL_INDEX,
+ CONFIG_ANDROID_BOOT_PARTITION_MMC,
+ user_partition,
+ FASTBOOT_PARTITION_BOOT , dev_desc, ptable);
+ _fastboot_parts_add_ptable_entry(PTN_RECOVERY_INDEX,
+ CONFIG_ANDROID_RECOVERY_PARTITION_MMC,
+ user_partition,
+ FASTBOOT_PARTITION_RECOVERY, dev_desc, ptable);
+ _fastboot_parts_add_ptable_entry(PTN_SYSTEM_INDEX,
+ CONFIG_ANDROID_SYSTEM_PARTITION_MMC,
+ user_partition,
+ FASTBOOT_PARTITION_SYSTEM, dev_desc, ptable);
+
+ for (i = 0; i <= PTN_RECOVERY_INDEX; i++)
+ fastboot_flash_add_ptn(&ptable[i]);
+
+ return 0;
+}
+#endif /*CONFIG_FASTBOOT_STORAGE_SATA || CONFIG_FASTBOOT_STORAGE_MMC*/
+
+#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+static unsigned long long _memparse(char *ptr, char **retptr)
+{
+ char *endptr; /* local pointer to end of parsed string */
+
+ unsigned long ret = simple_strtoul(ptr, &endptr, 0);
+
+ switch (*endptr) {
+ case 'M':
+ case 'm':
+ ret <<= 10;
+ case 'K':
+ case 'k':
+ ret <<= 10;
+ endptr++;
+ default:
+ break;
+ }
+
+ if (retptr)
+ *retptr = endptr;
+
+ return ret;
+}
+
+static int _fastboot_parts_add_env_entry(char *s, char **retptr)
+{
+ unsigned long size;
+ unsigned long offset = 0;
+ char *name;
+ int name_len;
+ int delim;
+ unsigned int flags;
+ struct fastboot_ptentry part;
+
+ size = _memparse(s, &s);
+ if (0 == size) {
+ printf("Error:FASTBOOT size of parition is 0\n");
+ return 1;
+ }
+
+ /* fetch partition name and flags */
+ flags = 0; /* this is going to be a regular partition */
+ delim = 0;
+ /* check for offset */
+ if (*s == '@') {
+ s++;
+ offset = _memparse(s, &s);
+ } else {
+ printf("Error:FASTBOOT offset of parition is not given\n");
+ return 1;
+ }
+
+ /* now look for name */
+ if (*s == '(')
+ delim = ')';
+
+ if (delim) {
+ char *p;
+
+ name = ++s;
+ p = strchr((const char *)name, delim);
+ if (!p) {
+ printf("Error:FASTBOOT no closing %c found in partition name\n",
+ delim);
+ return 1;
+ }
+ name_len = p - name;
+ s = p + 1;
+ } else {
+ printf("Error:FASTBOOT no partition name for \'%s\'\n", s);
+ return 1;
+ }
+
+ /* check for options */
+ while (1) {
+ if (strncmp(s, "i", 1) == 0) {
+ flags |= FASTBOOT_PTENTRY_FLAGS_WRITE_I;
+ s += 1;
+ } else if (strncmp(s, "ubifs", 5) == 0) {
+ /* ubifs */
+ flags |= FASTBOOT_PTENTRY_FLAGS_WRITE_TRIMFFS;
+ s += 5;
+ } else {
+ break;
+ }
+ if (strncmp(s, "|", 1) == 0)
+ s += 1;
+ }
+
+ /* enter this partition (offset will be calculated later if it is zero at this point) */
+ part.length = size;
+ part.start = offset;
+ part.flags = flags;
+
+ if (name) {
+ if (name_len >= sizeof(part.name)) {
+ printf("Error:FASTBOOT partition name is too long\n");
+ return 1;
+ }
+ strncpy(&part.name[0], name, name_len);
+ /* name is not null terminated */
+ part.name[name_len] = '\0';
+ } else {
+ printf("Error:FASTBOOT no name\n");
+ return 1;
+ }
+
+ fastboot_flash_add_ptn(&part);
+
+ /*if the nand partitions envs are not initialized, try to init them*/
+ if (check_parts_values(&part))
+ save_parts_values(&part, part.start, part.length);
+
+ /* return (updated) pointer command line string */
+ *retptr = s;
+
+ /* return partition table */
+ return 0;
+}
+
+static int _fastboot_parts_load_from_env(void)
+{
+ char fbparts[FASTBOOT_FBPARTS_ENV_MAX_LEN], *env;
+
+ env = getenv("fbparts");
+ if (env) {
+ unsigned int len;
+ len = strlen(env);
+ if (len && len < FASTBOOT_FBPARTS_ENV_MAX_LEN) {
+ char *s, *e;
+
+ memcpy(&fbparts[0], env, len + 1);
+ printf("Fastboot: Adding partitions from environment\n");
+ s = &fbparts[0];
+ e = s + len;
+ while (s < e) {
+ if (_fastboot_parts_add_env_entry(s, &s)) {
+ printf("Error:Fastboot: Abort adding partitions\n");
+ pcount = 0;
+ return 1;
+ }
+ /* Skip a bunch of delimiters */
+ while (s < e) {
+ if ((' ' == *s) ||
+ ('\t' == *s) ||
+ ('\n' == *s) ||
+ ('\r' == *s) ||
+ (',' == *s)) {
+ s++;
+ } else {
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+#endif /*CONFIG_FASTBOOT_STORAGE_NAND*/
+
+static void _fastboot_load_partitions(void)
+{
+ pcount = 0;
+#if defined(CONFIG_FASTBOOT_STORAGE_NAND)
+ _fastboot_parts_load_from_env();
+#elif defined(CONFIG_FASTBOOT_STORAGE_SATA) \
+ || defined(CONFIG_FASTBOOT_STORAGE_MMC)
+ _fastboot_parts_load_from_ptable();
+#endif
+}
+
+/*
+ * Android style flash utilties */
+void fastboot_flash_add_ptn(struct fastboot_ptentry *ptn)
+{
+ if (pcount < MAX_PTN) {
+ memcpy(ptable + pcount, ptn, sizeof(struct fastboot_ptentry));
+ pcount++;
+ }
+}
+
+void fastboot_flash_dump_ptn(void)
+{
+ unsigned int n;
+ for (n = 0; n < pcount; n++) {
+ struct fastboot_ptentry *ptn = ptable + n;
+ printf("ptn %d name='%s' start=%d len=%d\n",
+ n, ptn->name, ptn->start, ptn->length);
+ }
+}
+
+
+struct fastboot_ptentry *fastboot_flash_find_ptn(const char *name)
+{
+ unsigned int n;
+
+ for (n = 0; n < pcount; n++) {
+ /* Make sure a substring is not accepted */
+ if (strlen(name) == strlen(ptable[n].name)) {
+ if (0 == strcmp(ptable[n].name, name))
+ return ptable + n;
+ }
+ }
+
+ printf("can't find partition: %s, dump the partition table\n", name);
+ fastboot_flash_dump_ptn();
+ return 0;
+}
+
+struct fastboot_ptentry *fastboot_flash_get_ptn(unsigned int n)
+{
+ if (n < pcount)
+ return ptable + n;
+ else
+ return 0;
+}
+
+unsigned int fastboot_flash_get_ptn_count(void)
+{
+ return pcount;
+}
+
+/*
+ * CPU and board-specific fastboot initializations. Aliased function
+ * signals caller to move on
+ */
+static void __def_fastboot_setup(void)
+{
+ /*do nothing here*/
+}
+void board_fastboot_setup(void) \
+ __attribute__((weak, alias("__def_fastboot_setup")));
+
+
+void fastboot_setup(void)
+{
+ struct tag_serialnr serialnr;
+ char serial[17];
+
+ get_board_serial(&serialnr);
+ sprintf(serial, "%u%u", serialnr.high, serialnr.low);
+ g_dnl_set_serialnumber(serial);
+
+ /*execute board relevant initilizations for preparing fastboot */
+ board_fastboot_setup();
+
+ /*get the fastboot dev*/
+ _fastboot_setup_dev();
+
+ /*check if we need to setup recovery*/
+#ifdef CONFIG_ANDROID_RECOVERY
+ check_recovery_mode();
+#endif
+
+ /*load partitions information for the fastboot dev*/
+ _fastboot_load_partitions();
+
+ parameters_setup();
+}
+
+/* export to lib_arm/board.c */
+void check_fastboot(void)
+{
+ if (fastboot_check_and_clean_flag())
+ run_command("fastboot", 0);
+}
+
+#ifdef CONFIG_CMD_BOOTA
+ /* Section for Android bootimage format support
+ * Refer:
+ * http://android.git.kernel.org/?p=platform/system/core.git;a=blob;
+ * f=mkbootimg/bootimg.h
+ */
+
+void
+bootimg_print_image_hdr(struct andr_img_hdr *hdr)
+{
+#ifdef DEBUG
+ int i;
+ printf(" Image magic: %s\n", hdr->magic);
+
+ printf(" kernel_size: 0x%x\n", hdr->kernel_size);
+ printf(" kernel_addr: 0x%x\n", hdr->kernel_addr);
+
+ printf(" rdisk_size: 0x%x\n", hdr->ramdisk_size);
+ printf(" rdisk_addr: 0x%x\n", hdr->ramdisk_addr);
+
+ printf(" second_size: 0x%x\n", hdr->second_size);
+ printf(" second_addr: 0x%x\n", hdr->second_addr);
+
+ printf(" tags_addr: 0x%x\n", hdr->tags_addr);
+ printf(" page_size: 0x%x\n", hdr->page_size);
+
+ printf(" name: %s\n", hdr->name);
+ printf(" cmdline: %s%x\n", hdr->cmdline);
+
+ for (i = 0; i < 8; i++)
+ printf(" id[%d]: 0x%x\n", i, hdr->id[i]);
+#endif
+}
+
+static struct andr_img_hdr boothdr __aligned(ARCH_DMA_MINALIGN);
+
+/* boota <addr> [ mmc0 | mmc1 [ <partition> ] ] */
+int do_boota(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+ ulong addr = 0;
+ char *ptn = "boot";
+ int mmcc = -1;
+ struct andr_img_hdr *hdr = &boothdr;
+ ulong image_size;
+#ifdef CONFIG_SECURE_BOOT
+#define IVT_SIZE 0x20
+#define CSF_PAD_SIZE CONFIG_CSF_SIZE
+/* Max of bootimage size to be 16MB */
+#define MAX_ANDROID_BOOT_AUTH_SIZE 0x1000000
+/* Size appended to boot.img with boot_signer */
+#define BOOTIMAGE_SIGNATURE_SIZE 0x100
+#endif
+ int i = 0;
+
+ for (i = 0; i < argc; i++)
+ printf("%s ", argv[i]);
+ printf("\n");
+
+ if (argc < 2)
+ return -1;
+
+ if (!strncmp(argv[1], "mmc", 3))
+ mmcc = simple_strtoul(argv[1]+3, NULL, 10);
+ else
+ addr = simple_strtoul(argv[1], NULL, 16);
+
+ if (argc > 2)
+ ptn = argv[2];
+
+ if (mmcc != -1) {
+#ifdef CONFIG_MMC
+ struct fastboot_ptentry *pte;
+ struct mmc *mmc;
+ disk_partition_t info;
+ block_dev_desc_t *dev_desc = NULL;
+ unsigned sector;
+ unsigned bootimg_sectors;
+
+ memset((void *)&info, 0 , sizeof(disk_partition_t));
+ /* i.MX use MBR as partition table, so this will have
+ to find the start block and length for the
+ partition name and register the fastboot pte we
+ define the partition number of each partition in
+ config file
+ */
+ mmc = find_mmc_device(mmcc);
+ if (!mmc) {
+ printf("boota: cannot find '%d' mmc device\n", mmcc);
+ goto fail;
+ }
+ dev_desc = get_dev("mmc", mmcc);
+ if (NULL == dev_desc) {
+ printf("** Block device MMC %d not supported\n", mmcc);
+ goto fail;
+ }
+
+ /* below was i.MX mmc operation code */
+ if (mmc_init(mmc)) {
+ printf("mmc%d init failed\n", mmcc);
+ goto fail;
+ }
+
+ pte = fastboot_flash_find_ptn(ptn);
+ if (!pte) {
+ printf("boota: cannot find '%s' partition\n", ptn);
+ goto fail;
+ }
+
+ if (mmc->block_dev.block_read(mmcc, pte->start,
+ 1, (void *)hdr) < 0) {
+ printf("boota: mmc failed to read bootimg header\n");
+ goto fail;
+ }
+
+ if (android_image_check_header(hdr)) {
+ printf("boota: bad boot image magic\n");
+ goto fail;
+ }
+
+ image_size = android_image_get_end(hdr) - (ulong)hdr;
+ bootimg_sectors = image_size/512;
+
+#ifdef CONFIG_SECURE_BOOT
+ /* Default boot.img should be padded to 0x1000
+ before appended with IVT&CSF data. Set the threshold of
+ boot image for athendication as 16MB
+ */
+ image_size += BOOTIMAGE_SIGNATURE_SIZE;
+ image_size = ALIGN(image_size, 0x1000);
+ if (image_size > MAX_ANDROID_BOOT_AUTH_SIZE) {
+ printf("The image size is too large for athenticated boot!\n");
+ return 1;
+ }
+ /* Make sure all data boot.img + IVT + CSF been read to memory */
+ bootimg_sectors = image_size/512 +
+ ALIGN(IVT_SIZE + CSF_PAD_SIZE, 512)/512;
+#endif
+
+ if (mmc->block_dev.block_read(mmcc, pte->start,
+ bootimg_sectors,
+ (void *)load_addr) < 0) {
+ printf("boota: mmc failed to read kernel\n");
+ goto fail;
+ }
+ /* flush cache after read */
+ flush_cache((ulong)load_addr, bootimg_sectors * 512); /* FIXME */
+
+ addr = load_addr;
+
+#ifdef CONFIG_SECURE_BOOT
+ extern uint32_t authenticate_image(uint32_t ddr_start,
+ uint32_t image_size);
+
+ if (authenticate_image(load_addr, image_size)) {
+ printf("Authenticate OK\n");
+ } else {
+ printf("Authenticate image Fail, Please check\n\n");
+ return 1;
+ }
+#endif /*CONFIG_SECURE_BOOT*/
+
+ sector = pte->start + (hdr->page_size / 512);
+ sector += ALIGN(hdr->kernel_size, hdr->page_size) / 512;
+ if (mmc->block_dev.block_read(mmcc, sector,
+ (hdr->ramdisk_size / 512) + 1,
+ (void *)hdr->ramdisk_addr) < 0) {
+ printf("boota: mmc failed to read ramdisk\n");
+ goto fail;
+ }
+ /* flush cache after read */
+ flush_cache((ulong)hdr->ramdisk_addr, hdr->ramdisk_size); /* FIXME */
+
+#ifdef CONFIG_OF_LIBFDT
+ /* load the dtb file */
+ if (hdr->second_size && hdr->second_addr) {
+ sector += ALIGN(hdr->ramdisk_size, hdr->page_size) / 512;
+ if (mmc->block_dev.block_read(mmcc, sector,
+ (hdr->second_size / 512) + 1,
+ (void *)hdr->second_addr) < 0) {
+ printf("boota: mmc failed to dtb\n");
+ goto fail;
+ }
+ /* flush cache after read */
+ flush_cache((ulong)hdr->second_addr, hdr->second_size); /* FIXME */
+ }
+#endif /*CONFIG_OF_LIBFDT*/
+
+#else /*! CONFIG_MMC*/
+ return -1;
+#endif /*! CONFIG_MMC*/
+ } else {
+ unsigned raddr, end;
+#ifdef CONFIG_OF_LIBFDT
+ unsigned fdtaddr = 0;
+#endif
+
+ /* set this aside somewhere safe */
+ memcpy(hdr, (void *)addr, sizeof(*hdr));
+
+ if (android_image_check_header(hdr)) {
+ printf("boota: bad boot image magic\n");
+ return 1;
+ }
+
+ bootimg_print_image_hdr(hdr);
+
+ image_size = hdr->page_size +
+ ALIGN(hdr->kernel_size, hdr->page_size) +
+ ALIGN(hdr->ramdisk_size, hdr->page_size) +
+ ALIGN(hdr->second_size, hdr->page_size);
+
+#ifdef CONFIG_SECURE_BOOT
+ image_size = image_size + BOOTIMAGE_SIGNATURE_SIZE;
+ if (image_size > MAX_ANDROID_BOOT_AUTH_SIZE) {
+ printf("The image size is too large for athenticated boot!\n");
+ return 1;
+ }
+#endif /*CONFIG_SECURE_BOOT*/
+
+#ifdef CONFIG_SECURE_BOOT
+ extern uint32_t authenticate_image(uint32_t ddr_start,
+ uint32_t image_size);
+
+ if (authenticate_image(addr, image_size)) {
+ printf("Authenticate OK\n");
+ } else {
+ printf("Authenticate image Fail, Please check\n\n");
+ return 1;
+ }
+#endif
+
+ raddr = addr + hdr->page_size;
+ raddr += ALIGN(hdr->kernel_size, hdr->page_size);
+ end = raddr + hdr->ramdisk_size;
+#ifdef CONFIG_OF_LIBFDT
+ if (hdr->second_size) {
+ fdtaddr = raddr + ALIGN(hdr->ramdisk_size, hdr->page_size);
+ end = fdtaddr + hdr->second_size;
+ }
+#endif /*CONFIG_OF_LIBFDT*/
+
+ if (raddr != hdr->ramdisk_addr) {
+ /*check overlap*/
+ if (((hdr->ramdisk_addr >= addr) &&
+ (hdr->ramdisk_addr <= end)) ||
+ ((addr >= hdr->ramdisk_addr) &&
+ (addr <= hdr->ramdisk_addr + hdr->ramdisk_size))) {
+ printf("Fail: boota address overlap with ramdisk address\n");
+ return 1;
+ }
+ memmove((void *) hdr->ramdisk_addr,
+ (void *)raddr, hdr->ramdisk_size);
+ }
+
+#ifdef CONFIG_OF_LIBFDT
+ if (hdr->second_size && fdtaddr != hdr->second_addr) {
+ /*check overlap*/
+ if (((hdr->second_addr >= addr) &&
+ (hdr->second_addr <= end)) ||
+ ((addr >= hdr->second_addr) &&
+ (addr <= hdr->second_addr + hdr->second_size))) {
+ printf("Fail: boota address overlap with FDT address\n");
+ return 1;
+ }
+ memmove((void *) hdr->second_addr,
+ (void *)fdtaddr, hdr->second_size);
+ }
+#endif /*CONFIG_OF_LIBFDT*/
+ }
+
+ printf("kernel @ %08x (%d)\n", hdr->kernel_addr, hdr->kernel_size);
+ printf("ramdisk @ %08x (%d)\n", hdr->ramdisk_addr, hdr->ramdisk_size);
+#ifdef CONFIG_OF_LIBFDT
+ if (hdr->second_size)
+ printf("fdt @ %08x (%d)\n", hdr->second_addr, hdr->second_size);
+#endif /*CONFIG_OF_LIBFDT*/
+
+#ifdef CONFIG_SERIAL_TAG
+ struct tag_serialnr serialnr;
+ char bootargs[ANDR_BOOT_ARGS_SIZE];
+ char *commandline = getenv("bootargs");
+ get_board_serial(&serialnr);
+
+ if (commandline) {
+ sprintf(bootargs,
+ "%s androidboot.serialno=%08x%08x",
+ commandline,
+ serialnr.high,
+ serialnr.low);
+ } else {
+ sprintf(bootargs,
+ "androidboot.serialno=%08x%08x",
+ serialnr.high,
+ serialnr.low);
+ }
+ setenv("bootargs", bootargs);
+#endif
+
+ char boot_addr_start[12];
+ char ramdisk_addr[25];
+ char fdt_addr[12];
+
+ char *bootm_args[] = { "bootm", boot_addr_start, ramdisk_addr, fdt_addr};
+
+ sprintf(boot_addr_start, "0x%lx", addr);
+ sprintf(ramdisk_addr, "0x%x:0x%x", hdr->ramdisk_addr, hdr->ramdisk_size);
+ sprintf(fdt_addr, "0x%x", hdr->second_addr);
+
+ do_bootm(NULL, 0, 4, bootm_args);
+
+ /* This only happens if image is somehow faulty so we start over */
+ do_reset(NULL, 0, 0, NULL);
+
+ return 1;
+
+fail:
+#ifdef CONFIG_FSL_FASTBOOT
+ return run_command("fastboot", 0);
+#else /*! CONFIG_FSL_FASTBOOT*/
+ return -1;
+#endif /*! CONFIG_FSL_FASTBOOT*/
+}
+
+U_BOOT_CMD(
+ boota, 3, 1, do_boota,
+ "boota - boot android bootimg from memory\n",
+ "[<addr> | mmc0 | mmc1 | mmc2 | mmcX] [<partition>]\n "
+ "- boot application image stored in memory or mmc\n"
+ "\t'addr' should be the address of boot image "
+ "which is zImage+ramdisk.img\n"
+ "\t'mmcX' is the mmc device you store your boot.img, "
+ "which will read the boot.img from 1M offset('/boot' partition)\n"
+ "\t 'partition' (optional) is the partition id of your device, "
+ "if no partition give, will going to 'boot' partition\n"
+);
+#endif /* CONFIG_CMD_BOOTA */
+
+
+#endif
+
+
static void rx_handler_command(struct usb_ep *ep, struct usb_request *req);
static void fastboot_complete(struct usb_ep *ep, struct usb_request *req)
@@ -441,6 +2138,40 @@ static void rx_handler_dl_image(struct usb_ep *ep, struct usb_request *req)
fastboot_tx_write_str(response);
printf("\ndownloading of %d bytes finished\n", download_bytes);
+
+#ifdef CONFIG_FSL_FASTBOOT
+#ifdef CONFIG_FASTBOOT_STORAGE_NAND
+ /* Pad to block length
+ In most cases, padding the download to be
+ block aligned is correct. The exception is
+ when the following flash writes to the oob
+ area. This happens when the image is a
+ YAFFS image. Since we do not know what
+ the download is until it is flashed,
+ go ahead and pad it, but save the true
+ size in case if should have
+ been unpadded */
+ download_bytes_unpadded = download_bytes;
+ if (interface.nand_block_size) {
+ if (download_bytes %
+ interface.nand_block_size) {
+ unsigned int pad =
+ interface.nand_block_size -
+ (download_bytes % interface.nand_block_size);
+ unsigned int i;
+
+ for (i = 0; i < pad; i++) {
+ if (download_bytes >=
+ interface.transfer_buffer_size)
+ break;
+
+ interface.transfer_buffer[download_bytes] = 0;
+ download_bytes++;
+ }
+ }
+ }
+#endif
+#endif
} else {
max = is_high_speed ? hs_ep_out.wMaxPacketSize :
fs_ep_out.wMaxPacketSize;
@@ -485,7 +2216,11 @@ static void cb_download(struct usb_ep *ep, struct usb_request *req)
static void do_bootm_on_complete(struct usb_ep *ep, struct usb_request *req)
{
char boot_addr_start[12];
+#ifdef CONFIG_FSL_FASTBOOT
+ char *bootm_args[] = { "boota", boot_addr_start, NULL };
+#else
char *bootm_args[] = { "bootm", boot_addr_start, NULL };
+#endif
puts("Booting kernel..\n");
@@ -527,10 +2262,15 @@ static void cb_flash(struct usb_ep *ep, struct usb_request *req)
}
strcpy(response, "FAILno flash device defined");
+
+#ifdef CONFIG_FSL_FASTBOOT
+ rx_process_flash(cmd, response);
+#else
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
fb_mmc_flash_write(cmd, (void *)CONFIG_USB_FASTBOOT_BUF_ADDR,
download_bytes, response);
#endif
+#endif
fastboot_tx_write_str(response);
}
#endif
@@ -538,7 +2278,7 @@ static void cb_flash(struct usb_ep *ep, struct usb_request *req)
static void cb_oem(struct usb_ep *ep, struct usb_request *req)
{
char *cmd = req->buf;
-#ifdef CONFIG_FASTBOOT_FLASH
+#if defined(CONFIG_FASTBOOT_FLASH) && defined(CONFIG_FASTBOOT_FLASH_MMC_DEV)
if (strncmp("format", cmd + 4, 6) == 0) {
char cmdbuf[32];
sprintf(cmdbuf, "gpt write mmc %x $partitions",
@@ -572,9 +2312,13 @@ static void cb_erase(struct usb_ep *ep, struct usb_request *req)
strcpy(response, "FAILno flash device defined");
+#ifdef CONFIG_FSL_FASTBOOT
+ rx_process_erase(cmd, response);
+#else
#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
fb_mmc_erase(cmd, response);
#endif
+#endif
fastboot_tx_write_str(response);
}
#endif
generated by cgit v1.1 at 2024-07-02 23:01:30 +0000