summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorSascha Hauer <s.hauer@pengutronix.de>2015-06-24 14:25:10 +0200
committerSascha Hauer <s.hauer@pengutronix.de>2015-07-02 08:20:48 +0200
commit1d7c8ec1431aec1c75c79dc17ecad0ab80435311 (patch)
treef5a1363e1227fcfcfe014194e04414e639147616
parent302076b017f386a1cc51fcd405cdd6edcae9cd86 (diff)
downloadbarebox-1d7c8ec1431aec1c75c79dc17ecad0ab80435311.tar.gz
barebox-1d7c8ec1431aec1c75c79dc17ecad0ab80435311.tar.xz
ARM: OMAP: Add omap3 USB loader tool
The OMAP3 supports uploading the first stage bootloader via USB. The ROM leaves the MUSB controller enabled and it can then be used to upload a 2nd stage image. This patch adds the omap3-usb-loader tool and the necessary barebox support to upload the 2nd stage image. The omap usb loader tool is downloaded from https://github.com/grant-h/omap_loader and changed to also accept CHSETTINGS images. Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
-rw-r--r--arch/arm/mach-omap/Kconfig15
-rw-r--r--arch/arm/mach-omap/Makefile2
-rw-r--r--arch/arm/mach-omap/include/mach/omap3-generic.h2
-rw-r--r--arch/arm/mach-omap/omap3_xload_usb.c185
-rw-r--r--arch/arm/mach-omap/xload.c8
-rw-r--r--scripts/Makefile3
-rw-r--r--scripts/omap3-usb-loader.c921
7 files changed, 1134 insertions, 2 deletions
diff --git a/arch/arm/mach-omap/Kconfig b/arch/arm/mach-omap/Kconfig
index c86542370d..abf204a63d 100644
--- a/arch/arm/mach-omap/Kconfig
+++ b/arch/arm/mach-omap/Kconfig
@@ -120,6 +120,21 @@ config OMAP4_USBBOOT
You need the utility program omap4_usbboot to boot from USB.
Please read omap4_usb_booting.txt for more information.
+config OMAP3_USBBOOT
+ bool "enable booting from USB"
+ depends on ARCH_OMAP3
+ help
+ Say Y here if you want to be able to boot the 2nd stage via USB. This
+ works by transferring the 2nd stage image using the MUSB controller
+ which is already initialized by the ROM code. Use the omap3-usb-loader
+ tool selectable below to upload images.
+
+config OMAP3_USB_LOADER
+ bool "enable omap3 USB loader host tool"
+ depends on ARCH_OMAP3
+ help
+ Say Y here to build the omap3 usb loader tool.
+
config OMAP_SERIALBOOT
bool "enable booting from serial"
select XYMODEM
diff --git a/arch/arm/mach-omap/Makefile b/arch/arm/mach-omap/Makefile
index fcc2727713..65072b91e4 100644
--- a/arch/arm/mach-omap/Makefile
+++ b/arch/arm/mach-omap/Makefile
@@ -31,6 +31,8 @@ obj-$(CONFIG_OMAP_GPMC) += gpmc.o devices-gpmc-nand.o
obj-$(CONFIG_SHELL_NONE) += xload.o
obj-$(CONFIG_MFD_TWL6030) += omap4_twl6030_mmc.o
obj-$(CONFIG_OMAP4_USBBOOT) += omap4_rom_usb.o
+obj-$(CONFIG_OMAP3_USBBOOT) += omap3_xload_usb.o
+pbl-$(CONFIG_OMAP3_USBBOOT) += omap3_xload_usb.o
obj-$(CONFIG_CMD_BOOT_ORDER) += boot_order.o
obj-$(CONFIG_BAREBOX_UPDATE_AM33XX_SPI_NOR_MLO) += am33xx_bbu_spi_mlo.o
obj-$(CONFIG_BAREBOX_UPDATE_AM33XX_NAND) += am33xx_bbu_nand.o
diff --git a/arch/arm/mach-omap/include/mach/omap3-generic.h b/arch/arm/mach-omap/include/mach/omap3-generic.h
index 7db0838a5f..ab53b98971 100644
--- a/arch/arm/mach-omap/include/mach/omap3-generic.h
+++ b/arch/arm/mach-omap/include/mach/omap3-generic.h
@@ -29,4 +29,6 @@ void __noreturn omap3_reset_cpu(unsigned long addr);
int omap3_init(void);
int omap3_devices_init(void);
+void *omap3_xload_boot_usb(void);
+
#endif /* __MACH_OMAP3_GENERIC_H */
diff --git a/arch/arm/mach-omap/omap3_xload_usb.c b/arch/arm/mach-omap/omap3_xload_usb.c
new file mode 100644
index 0000000000..e7dc21e4a7
--- /dev/null
+++ b/arch/arm/mach-omap/omap3_xload_usb.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2015 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
+ *
+ * Based on a patch by:
+ *
+ * Copyright (C) 2011 Rick Bronson
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <common.h>
+#include <io.h>
+#include <malloc.h>
+#include <mach/omap3-silicon.h>
+#include <mach/omap3-generic.h>
+
+static void __iomem *omap3_usb_base = (void __iomem *)OMAP3_MUSB0_BASE;
+
+#define OMAP34XX_USB_EP(n) (omap3_usb_base + 0x100 + 0x10 * (n))
+
+#define MUSB_RXCSR 0x06
+#define MUSB_RXCOUNT 0x08
+#define MUSB_TXCSR 0x02
+#define MUSB_FIFOSIZE 0x0F
+#define OMAP34XX_USB_RXCSR(n) (OMAP34XX_USB_EP(n) + MUSB_RXCSR)
+#define OMAP34XX_USB_RXCOUNT(n) (OMAP34XX_USB_EP(n) + MUSB_RXCOUNT)
+#define OMAP34XX_USB_TXCSR(n) (OMAP34XX_USB_EP(n) + MUSB_TXCSR)
+#define OMAP34XX_USB_FIFOSIZE(n) (OMAP34XX_USB_EP(n) + MUSB_FIFOSIZE)
+#define OMAP34XX_USB_FIFO(n) (omap3_usb_base + 0x20 + ((n) * 4))
+
+/* memory mapped registers */
+#define BULK_ENDPOINT 1
+#define MUSB_RXCSR_RXPKTRDY 0x0001
+#define MUSB_TXCSR_TXPKTRDY 0x0001
+
+#define PACK4(a,b,c,d) (((d) << 24) | ((c) << 16) | ((b) << 8) | (a))
+#define USBLOAD_CMD_FILE PACK4('U', 'S', 'B', 's') /* send file size */
+#define USBLOAD_CMD_JUMP PACK4('U', 'S', 'B', 'j') /* go where I tell you */
+#define USBLOAD_CMD_FILE_REQ PACK4('U', 'S', 'B', 'f') /* file request */
+#define USBLOAD_CMD_ECHO_SZ PACK4('U', 'S', 'B', 'n') /* echo file size */
+#define USBLOAD_CMD_REPORT_SZ PACK4('U', 'S', 'B', 'o') /* report file size */
+#define USBLOAD_CMD_MESSAGE PACK4('U', 'S', 'B', 'm') /* message for debug */
+
+static int usb_send(unsigned char *buffer, unsigned int buffer_size)
+{
+ unsigned int cntr;
+ u16 txcsr;
+ void __iomem *reg = (void *)OMAP34XX_USB_TXCSR(BULK_ENDPOINT);
+ void __iomem *bulk_fifo = (void *)OMAP34XX_USB_FIFO(BULK_ENDPOINT);
+
+ txcsr = readw(reg);
+
+ if (txcsr & MUSB_TXCSR_TXPKTRDY)
+ return 0;
+
+ for (cntr = 0; cntr < buffer_size; cntr++)
+ writeb(buffer[cntr], bulk_fifo);
+
+ txcsr = readw(reg);
+ txcsr |= MUSB_TXCSR_TXPKTRDY;
+ writew(txcsr, reg);
+
+ return buffer_size;
+}
+
+static int usb_recv(u8 *buffer)
+{
+ int cntr;
+ u16 count = 0;
+ u16 rxcsr;
+ void __iomem *reg = (void *)OMAP34XX_USB_RXCSR(BULK_ENDPOINT);
+ void __iomem *bulk_fifo = (void *)OMAP34XX_USB_FIFO(BULK_ENDPOINT);
+
+ rxcsr = readw(reg);
+
+ if (!(rxcsr & MUSB_RXCSR_RXPKTRDY))
+ return 0;
+
+ count = readw((void *)OMAP34XX_USB_RXCOUNT(BULK_ENDPOINT));
+ for (cntr = 0; cntr < count; cntr++)
+ *buffer++ = readb(bulk_fifo);
+
+ /* Clear the RXPKTRDY bit */
+ rxcsr = readw(reg);
+ rxcsr &= ~MUSB_RXCSR_RXPKTRDY;
+ writew(rxcsr, reg);
+
+ return count;
+}
+
+static unsigned char usb_outbuffer[64];
+
+static void usb_msg(unsigned int cmd, const char *msg)
+{
+ unsigned char *p_char = usb_outbuffer;
+
+ *(int *)p_char = cmd;
+
+ p_char += sizeof(cmd);
+
+ if (msg) {
+ while (*msg)
+ *p_char++= *msg++;
+ *p_char++= 0;
+ }
+
+ usb_send(usb_outbuffer, p_char - usb_outbuffer);
+}
+
+static void usb_code(unsigned int cmd, u32 code)
+{
+ unsigned int *p_int = (unsigned int *)usb_outbuffer;
+
+ *p_int++ = cmd;
+ *p_int++ = code;
+ usb_send (usb_outbuffer, ((unsigned char *) p_int) - usb_outbuffer);
+}
+
+void *omap3_xload_boot_usb(void)
+{
+ int res;
+ void *buf;
+ u32 *buf32;
+ u32 total;
+ void *addr;
+ u32 bytes;
+ int size;
+ int cntr;
+ void *fn;
+ u8 __buf[512];
+
+ buf32 = buf = __buf;
+
+ usb_msg (USBLOAD_CMD_FILE_REQ, "file req");
+ for (cntr = 0; cntr < 10000000; cntr++) {
+ size = usb_recv(buf);
+ if (!size)
+ continue;
+
+ switch (buf32[0]) {
+ case USBLOAD_CMD_FILE:
+ pr_debug ("USBLOAD_CMD_FILE total = %d size = 0x%x addr = 0x%x\n",
+ res, buf32[1], buf32[2]);
+ total = buf32[1]; /* get size and address */
+ addr = (void *)buf32[2];
+ usb_code(USBLOAD_CMD_ECHO_SZ, total);
+
+ bytes = 0;
+
+ while (bytes < total) {
+ size = usb_recv(buf);
+ memcpy(addr, buf, size);
+ addr += size;
+ bytes += size;
+ }
+
+ usb_code(USBLOAD_CMD_REPORT_SZ, total); /* tell him we got this many bytes */
+ usb_msg (USBLOAD_CMD_FILE_REQ, "file req"); /* see if they have another file for us */
+ break;
+ case USBLOAD_CMD_JUMP:
+ pr_debug("USBLOAD_CMD_JUMP total = %d addr = 0x%x val = 0x%x\n",
+ res, buf32[0], buf32[1]);
+ fn = (void *)buf32[1];
+ goto out;
+ default:
+ break;
+ }
+ }
+
+ fn = NULL;
+out:
+
+ return fn;
+}
diff --git a/arch/arm/mach-omap/xload.c b/arch/arm/mach-omap/xload.c
index 85c9120ccf..4a0714ed93 100644
--- a/arch/arm/mach-omap/xload.c
+++ b/arch/arm/mach-omap/xload.c
@@ -14,6 +14,7 @@
#include <xymodem.h>
#include <mach/generic.h>
#include <mach/am33xx-generic.h>
+#include <mach/omap3-generic.h>
#include <net.h>
#include <environment.h>
#include <dhcp.h>
@@ -284,13 +285,16 @@ static __noreturn int omap_xload(void)
func = omap_xload_boot_mmc();
break;
case BOOTSOURCE_USB:
- if (IS_ENABLED(CONFIG_FS_OMAP4_USBBOOT)) {
+ if (IS_ENABLED(CONFIG_OMAP3_USBBOOT) && cpu_is_omap3()) {
+ printf("booting from USB\n");
+ func = omap3_xload_boot_usb();
+ } else if (IS_ENABLED(CONFIG_FS_OMAP4_USBBOOT)) {
printf("booting from USB\n");
func = omap4_xload_boot_usb();
- break;
} else {
printf("booting from USB not enabled\n");
}
+ break;
case BOOTSOURCE_NAND:
printf("booting from NAND\n");
func = omap_xload_boot_nand(barebox_part->nand_offset,
diff --git a/scripts/Makefile b/scripts/Makefile
index 74c22136db..a3f6222d08 100644
--- a/scripts/Makefile
+++ b/scripts/Makefile
@@ -24,6 +24,9 @@ HOSTLOADLIBES_mxsimage = `pkg-config --libs openssl`
HOSTCFLAGS_mxs-usb-loader.o = `pkg-config --cflags libusb-1.0`
HOSTLOADLIBES_mxs-usb-loader = `pkg-config --libs libusb-1.0`
hostprogs-$(CONFIG_ARCH_MXS_USBLOADER) += mxs-usb-loader
+HOSTCFLAGS_omap3-usb-loader.o = `pkg-config --cflags libusb-1.0`
+HOSTLOADLIBES_omap3-usb-loader = `pkg-config --libs libusb-1.0`
+hostprogs-$(CONFIG_OMAP3_USB_LOADER) += omap3-usb-loader
subdir-y += mod
subdir-$(CONFIG_OMAP4_USBBOOT) += omap4_usbboot
diff --git a/scripts/omap3-usb-loader.c b/scripts/omap3-usb-loader.c
new file mode 100644
index 0000000000..edf6043edf
--- /dev/null
+++ b/scripts/omap3-usb-loader.c
@@ -0,0 +1,921 @@
+/*
+ * OMAP Loader, a USB uploader application targeted at OMAP3 processors
+ * Copyright (C) 2008 Martin Mueller <martinmm@pfump.org>
+ * Copyright (C) 2014 Grant Hernandez <grant.h.hernandez@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdbool.h>
+
+/*
+ * Reasons for the name change: this is a complete rewrite of
+ * the unversioned omap3_usbload so to lower ambiguity the name was changed.
+ * The GPLv2 license specifies rewrites as derived work.
+ */
+#define PROG_NAME "OMAP Loader"
+#define VERSION "1.0.0"
+
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define OMAP_IS_BIG_ENDIAN
+#endif
+
+#ifdef OMAP_IS_BIG_ENDIAN
+#include <arpa/inet.h>
+#endif
+
+#include <unistd.h> /* for usleep and friends */
+#include <getopt.h>
+#include <errno.h>
+#include <libgen.h> /* for basename */
+
+#include <libusb-1.0/libusb.h> /* the main event */
+
+/* Device specific defines (OMAP)
+ * Primary source: http://www.ti.com/lit/pdf/sprugn4
+ * Section 26.4.5 "Peripheral Booting"
+ */
+#define OMAP_BASE_ADDRESS 0x40200000
+#define OMAP_PERIPH_BOOT 0xF0030002
+#define OMAP_VENDOR_ID 0x0451
+#define OMAP_PRODUCT_ID 0xD00E
+/* TODO: dynamically discover these endpoints */
+#define OMAP_USB_BULK_IN 0x81
+#define OMAP_USB_BULK_OUT 0x01
+#define OMAP_ASIC_ID_LEN 69
+
+#ifdef OMAP_IS_BIG_ENDIAN
+#define cpu_to_le32(v) (((v & 0xff) << 24) | ((v & 0xff00) << 8) | \
+ ((v & 0xff0000) >> 8) | ((v & 0xff000000) >> 24))
+#define le32_to_cpu(v) cpu_to_le32(v)
+#else
+#define cpu_to_le32(v) (v)
+#define le32_to_cpu(v) (v)
+#endif
+
+/*
+ * taken from x-loader/drivers/usb/usb.c
+ * All credit to Martin Mueller
+ */
+#define PACK4(a,b,c,d) (((d)<<24) | ((c)<<16) | ((b)<<8) | (a))
+#define USBLOAD_CMD_FILE PACK4('U','S','B','s') /* file size request */
+#define USBLOAD_CMD_FILE_REQ PACK4('U','S','B','f') /* file size resp */
+#define USBLOAD_CMD_JUMP PACK4('U','S','B','j') /* execute code here */
+#define USBLOAD_CMD_ECHO_SZ PACK4('U','S','B','n') /* file size confirm to */
+#define USBLOAD_CMD_REPORT_SZ PACK4('U','S','B','o') /* confirm full file */
+#define USBLOAD_CMD_MESSAGE PACK4('U','S','B','m') /* debug message */
+
+/* USB transfer characteristics */
+#define USB_MAX_WAIT 5000
+#define USB_TIMEOUT 1000
+#define USB_MAX_TIMEOUTS (USB_MAX_WAIT/USB_TIMEOUT)
+
+/* stores the data and attributes of a file to upload in to memory */
+struct file_upload {
+ size_t size;
+ void *data;
+ uint32_t addr;
+ char *path;
+ char *basename;
+};
+
+/* stores all of the arguments read in by getopt in main() */
+struct arg_state {
+ struct file_upload **files;
+ int numfiles;
+ uint32_t jumptarget;
+ uint16_t vendor, product;
+};
+
+static int g_verbose = 0;
+
+static void log_error(char *fmt, ...)
+{
+ va_list va;
+
+ va_start(va, fmt);
+ fprintf(stdout, "[-] ");
+ vfprintf(stdout, fmt, va);
+ va_end(va);
+}
+
+static void log_info(char *fmt, ...)
+{
+ va_list va;
+
+ va_start(va, fmt);
+ fprintf(stdout, "[+] ");
+ vfprintf(stdout, fmt, va);
+ va_end(va);
+}
+
+static bool omap_usb_read(libusb_device_handle *handle, unsigned char *data,
+ int length, int *actuallength)
+{
+ int ret = 0;
+ int iter = 0;
+ int sizeleft = length;
+
+ if (!actuallength)
+ return false;
+
+ while (sizeleft > 0) {
+ int actualread = 0;
+ int readamt = sizeleft;
+
+ ret = libusb_bulk_transfer(handle, OMAP_USB_BULK_IN, data + iter,
+ readamt, &actualread, USB_TIMEOUT);
+
+ if (ret == LIBUSB_ERROR_TIMEOUT) {
+ sizeleft -= actualread;
+ iter += actualread;
+
+ /* we got some data, lets cut our losses and stop here */
+ if (iter > 0)
+ break;
+
+ log_error("device timed out while transfering in %d bytes (got %d)\n",
+ length, iter);
+
+ return false;
+ } else if (ret == LIBUSB_SUCCESS) {
+ /* we cant trust actualRead on anything but a timeout or success */
+ sizeleft -= actualread;
+ iter += actualread;
+
+ /* stop at the first sign of data */
+ if (iter > 0)
+ break;
+ } else {
+ log_error("fatal transfer error (BULK_IN) for %d bytes (got %d): %s\n",
+ length, iter, libusb_error_name(ret));
+ return false;
+ }
+ }
+
+ *actuallength = iter;
+
+ return true;
+}
+
+static bool omap_usb_write(libusb_device_handle *handle, void *data, int length)
+{
+ int ret = 0;
+ int numtimeouts = 0;
+ int iter = 0;
+ int sizeleft = length;
+
+ while (sizeleft > 0) {
+ int actualwrite = 0;
+ int writeamt = sizeleft > 512 ? 512 : sizeleft;
+
+ ret = libusb_bulk_transfer(handle, OMAP_USB_BULK_OUT, data + iter,
+ writeamt, &actualwrite, USB_TIMEOUT);
+
+ if (ret == LIBUSB_ERROR_TIMEOUT) {
+ numtimeouts++;
+ sizeleft -= actualwrite;
+ iter += actualwrite;
+
+ /* build in some reliablity */
+ if (numtimeouts > USB_MAX_TIMEOUTS) {
+ log_error("device timed out while transfering out %d bytes (%d made it)\n",
+ length, iter);
+ return false;
+ }
+ } else if (ret == LIBUSB_SUCCESS) {
+ /* we cant trust actualWrite on anything but a timeout or success */
+ sizeleft -= actualwrite;
+ iter += actualwrite;
+ } else {
+ log_error("fatal transfer error (BULK_OUT) for %d bytes (%d made it): %s\n",
+ length, iter, libusb_error_name(ret));
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static unsigned char *omap_usb_get_string(libusb_device_handle *handle, uint8_t idx)
+{
+ unsigned char *data = NULL;
+ int len = 0;
+ int ret = 0;
+
+ if (!handle)
+ return NULL;
+
+ while (true) {
+ if (!len || ret < 0) {
+ len += 256;
+ data = realloc(data, len);
+
+ if (!data)
+ return NULL;
+ }
+
+ ret = libusb_get_string_descriptor_ascii(handle, idx, data, len);
+
+ /* we can still recover... */
+ if (ret < 0) {
+ if (ret == LIBUSB_ERROR_INVALID_PARAM)
+ continue; /* try again with an increased size */
+
+ log_error("failed to lookup string index %hhu: %s\n",
+ idx, libusb_error_name(ret));
+
+ /* unrecoverable */
+ free(data);
+ return NULL;
+ } else {
+ /* we got something! */
+ break;
+ }
+ }
+
+ return data;
+}
+
+uint16_t omap_products[] = {
+ 0xd009,
+ 0xd00f,
+};
+
+static libusb_device_handle *omap_usb_open(libusb_context *ctx, uint16_t vendor, uint16_t product)
+{
+ libusb_device **devlist;
+ libusb_device_handle *handle;
+ struct libusb_device_descriptor desc;
+ ssize_t count, i;
+ int ret;
+
+ log_info("scanning for USB device matching %04hx:%04hx...\n",
+ vendor, product);
+
+ while (1) {
+ if ((count = libusb_get_device_list(ctx, &devlist)) < 0) {
+ log_error("failed to gather USB device list: %s\n",
+ libusb_error_name(count));
+ return NULL;
+ }
+
+ for (i = 0; i < count; i++) {
+ ret = libusb_get_device_descriptor(devlist[i], &desc);
+ if (ret < 0) {
+ log_error("failed to get USB device descriptor: %s\n",
+ libusb_error_name(ret));
+ libusb_free_device_list(devlist, 1);
+ return NULL;
+ }
+
+ if (desc.idVendor != vendor)
+ continue;
+
+ if (product) {
+ if (desc.idProduct != product)
+ continue;
+ goto found;
+ }
+
+ for (i = 0; i < sizeof(omap_products) / sizeof(uint16_t); i++)
+ if (desc.idProduct == omap_products[i]) {
+ product = desc.idProduct;
+ goto found;
+ }
+ }
+
+ libusb_free_device_list(devlist, 1);
+
+ /* nothing found yet. have a 10ms nap */
+ usleep(10000);
+ }
+found:
+ ret = libusb_open(devlist[i], &handle);
+ if (ret < 0) {
+ log_error("failed to open USB device %04hx:%04hx: %s\n",
+ vendor, product, libusb_error_name(ret));
+ libusb_free_device_list(devlist, 1);
+ return NULL;
+ }
+
+ ret = libusb_claim_interface(handle, 0);
+ if (ret) {
+ printf("Claim failed\n");
+ return NULL;
+ }
+
+ /* grab the manufacturer and product strings for printing */
+ unsigned char *mfgstr = omap_usb_get_string(handle, desc.iManufacturer);
+ unsigned char *prodstr = omap_usb_get_string(handle, desc.iProduct);
+
+ log_info("successfully opened %04hx:%04hx (", vendor, product);
+
+ if (mfgstr) {
+ fprintf(stdout, prodstr ? "%s " : "%s", mfgstr);
+ free(mfgstr);
+ }
+
+ if (prodstr) {
+ fprintf(stdout, "%s", prodstr);
+ free(prodstr);
+ }
+
+ fprintf(stdout, ")\n");
+
+ return handle;
+}
+
+static unsigned char *read_file(char *path, size_t *readamt)
+{
+ FILE *fp = fopen(path, "rb");
+
+ if (!fp) {
+ log_error("failed to open file \'%s\': %s\n", path,
+ strerror(errno));
+ return NULL;
+ }
+
+ unsigned char *data = NULL;
+ size_t allocsize = 0;
+ size_t iter = 0;
+
+ while (1) {
+ if (iter >= iter) {
+ allocsize += 1024;
+ data = realloc(data, allocsize);
+ if (!data)
+ return NULL;
+ }
+
+ size_t readsize = allocsize - iter;
+ size_t ret = fread(data + iter, sizeof (unsigned char), readsize, fp);
+
+ iter += ret;
+
+ if (ret != readsize) {
+ if (feof(fp)) {
+ break;
+ } else if (ferror(fp)) {
+ log_error("error file reading file \'%s\': %s\n",
+ path, strerror(errno));
+ free(data);
+ return NULL;
+ }
+ }
+ }
+
+ /* trim the allocation down to size */
+ data = realloc(data, iter);
+ *readamt = iter;
+
+ return data;
+}
+
+static int transfer_first_stage(libusb_device_handle * handle, struct arg_state *args)
+{
+ unsigned char *buffer = NULL;
+ uint32_t cmd = 0;
+ uint32_t filelen = 0;
+ int bufsize = 0x200;
+ int transLen = 0;
+ int i;
+ void *data;
+ uint32_t *dbuf;
+
+ struct file_upload *file = args->files[0];
+
+ /* TODO determine buffer size based on endpoint */
+ buffer = calloc(bufsize, sizeof (unsigned char));
+ filelen = cpu_to_le32(file->size);
+
+ data = file->data;
+ dbuf = data;
+
+ if (le32toh(dbuf[5]) == 0x45534843) {
+ int chsettingssize = 512 + 2 * sizeof(uint32_t);
+
+ log_info("CHSETTINGS image detected. Skipping header\n");
+
+ data += chsettingssize;
+ filelen -= chsettingssize;
+ }
+
+ /* read the ASIC ID */
+ if (!omap_usb_read(handle, buffer, bufsize, &transLen)) {
+ log_error("failed to read ASIC ID from USB connection. "
+ "Check your USB device!\n");
+ goto fail;
+ }
+
+ if (transLen != OMAP_ASIC_ID_LEN) {
+ log_error("got some ASIC ID, but it's not the right length, %d "
+ "(expected %d)\n", transLen, OMAP_ASIC_ID_LEN);
+ goto fail;
+ }
+
+ /* optionally, print some ASIC ID info */
+ if (g_verbose) {
+ char *fields[] =
+ { "Num Subblocks", "Device ID Info", "Reserved",
+ "Ident Data", "Reserved", "CRC (4 bytes)"
+ };
+ int fieldLen[] = { 1, 7, 4, 23, 23, 11 };
+ int field = 0;
+ int nextSep = 0;
+
+ log_info("got ASIC ID - ");
+
+ for (i = 0; i < transLen; i++) {
+ if (i == nextSep) {
+ fprintf(stdout, "%s%s ",
+ (field > 0) ? ", " : "", fields[field]);
+ nextSep += fieldLen[field];
+ field++;
+
+ fprintf(stdout, "[");
+ }
+
+ fprintf(stdout, "%02x", buffer[i]);
+
+ if (i + 1 == nextSep)
+ fprintf(stdout, "]");
+ }
+
+ fprintf(stdout, "\n");
+ }
+
+ /* send the peripheral boot command */
+ cmd = cpu_to_le32(OMAP_PERIPH_BOOT);
+
+ if (!omap_usb_write(handle, (unsigned char *) &cmd, sizeof (cmd))) {
+ log_error("failed to send the peripheral boot command 0x%08x\n",
+ OMAP_PERIPH_BOOT);
+ goto fail;
+ }
+
+ /* send the length of the first file (little endian) */
+ if (!omap_usb_write
+ (handle, (unsigned char *) &filelen, sizeof (filelen))) {
+ log_error("failed to length specifier of %u to OMAP BootROM\n",
+ filelen);
+ goto fail;
+ }
+
+ /* send the file! */
+ if (!omap_usb_write(handle, data, filelen)) {
+ log_error("failed to send file \'%s\' (size %u)\n",
+ file->basename, filelen);
+ goto fail;
+ }
+
+ free(buffer);
+ return 1;
+
+ fail:
+ free(buffer);
+ return 0;
+}
+
+static int transfer_other_files(libusb_device_handle *handle, struct arg_state *args)
+{
+ uint32_t *buffer = NULL;
+ int bufsize = 128 * sizeof (*buffer);
+ int numfailures = 0; /* build in some reliablity */
+ int maxfailures = 3;
+ int transLen = 0;
+ int curfile = 1; /* skip the first file */
+ size_t len;
+
+ buffer = calloc(bufsize, sizeof(unsigned char));
+
+ /* handle the state machine for the X-Loader */
+ while (curfile < args->numfiles) {
+ uint32_t opcode = 0;
+ uint8_t *extra = NULL;
+ struct file_upload *f = args->files[curfile];
+
+ /* read the opcode from xloader ID */
+ if (!omap_usb_read
+ (handle, (unsigned char *) buffer, bufsize, &transLen)) {
+ numfailures++;
+
+ if (numfailures >= maxfailures) {
+ log_error("failed to read command from X-Loader\n");
+ goto fail;
+ }
+
+ /* sleep a bit */
+ usleep(2000 * 1000); /* 2s */
+ continue; /* try the opcode read again */
+ }
+
+ if (transLen < 8) {
+ log_error("failed to recieve enough data for the opcode\n");
+ goto fail;
+ }
+
+ /* extract the opcode and extra data pointer */
+ opcode = le32_to_cpu(buffer[0]);
+ extra = (uint8_t *)buffer;
+
+ switch (opcode) {
+ case USBLOAD_CMD_FILE_REQ:
+ /* X-loader is requesting a file to be sent */
+ /* send the opcode, size, and addr */
+ buffer[0] = cpu_to_le32(USBLOAD_CMD_FILE);
+ buffer[1] = cpu_to_le32(f->size);
+ buffer[2] = cpu_to_le32(f->addr);
+
+ if (!omap_usb_write(handle, (unsigned char *)buffer, sizeof(*buffer) * 3)) {
+ log_error("failed to send load file command to the X-loader\n");
+ goto fail;
+ }
+
+ if (g_verbose) {
+ log_info("uploading \'%s\' (size %zu) to 0x%08x\n",
+ f->basename, f->size, f->addr);
+ }
+
+ break;
+ case USBLOAD_CMD_ECHO_SZ:
+ /* X-loader confirms the size to recieve */
+ if (buffer[1] != f->size) {
+ log_error
+ ("X-loader failed to recieve the right file size for "
+ "file \'%s\' (got %u, expected %zu)\n",
+ f->basename, buffer[1], f->size);
+ goto fail;
+ }
+
+ /* upload the raw file data */
+ if (!omap_usb_write(handle, f->data, f->size)) {
+ log_error
+ ("failed to send file \'%s\' to the X-loader\n",
+ f->basename);
+ goto fail;
+ }
+
+ break;
+ case USBLOAD_CMD_REPORT_SZ:
+ /* X-loader confirms the amount of data it recieved */
+ if (buffer[1] != f->size) {
+ log_error
+ ("X-loader failed to recieve the right amount of data for "
+ "file \'%s\' (got %u, expected %zu)\n",
+ f->basename, buffer[1], f->size);
+ goto fail;
+ }
+
+ curfile++; /* move on to the next file */
+ break;
+ case USBLOAD_CMD_MESSAGE:
+ /* X-loader debug message */
+ len = strlen((char *)extra);
+
+ if (len > (bufsize - sizeof (opcode) - 1))
+ log_error("X-loader debug message not NUL terminated (size %zu)\n",
+ len);
+ else
+ fprintf(stdout, "X-loader Debug: %s\n", extra);
+ break;
+ default:
+ log_error("unknown X-Loader opcode 0x%08X (%c%c%c%c)\n",
+ opcode, extra[0], extra[1], extra[2],
+ extra[3]);
+ goto fail;
+ }
+ }
+
+ /* we're done uploading files to X-loader send the jump command */
+ buffer[0] = cpu_to_le32(USBLOAD_CMD_JUMP);
+ buffer[1] = cpu_to_le32(args->jumptarget);
+
+ if (!omap_usb_write
+ (handle, (unsigned char *) buffer, sizeof (*buffer) * 2)) {
+ log_error
+ ("failed to send the final jump command to the X-loader. "
+ "Target was 0x%08x\n", args->jumptarget);
+ goto fail;
+ }
+
+ if (g_verbose)
+ log_info("jumping to address 0x%08x\n", args->jumptarget);
+
+ free(buffer);
+ return 1;
+
+ fail:
+ free(buffer);
+ return 0;
+}
+
+static int process_args(struct arg_state *args)
+{
+ int i;
+
+ /* For each file, load it in to memory
+ * TODO: defer this until transfer time (save memory and pipeline IO)
+ */
+
+ for (i = 0; i < args->numfiles; i++) {
+ struct file_upload *f = args->files[i];
+
+ f->data = read_file(f->path, &f->size);
+
+ if (!f->data) {
+ return 1;
+ }
+ }
+
+ if (g_verbose > 0) {
+ for (i = 0; i < args->numfiles; i++) {
+ struct file_upload *f = args->files[i];
+
+ printf("File \'%s\' at 0x%08x, size %zu\n",
+ f->basename, f->addr, f->size);
+ }
+ }
+
+ libusb_context *ctx;
+ libusb_device_handle *dev;
+ int ret;
+
+ if ((ret = libusb_init(&ctx)) < 0) {
+ log_error("failed to initialize libusb context: %s\n",
+ libusb_error_name(ret));
+ return ret;
+ }
+
+ dev = omap_usb_open(ctx, args->vendor, args->product);
+
+ if (!dev) {
+ libusb_exit(ctx);
+ return 1;
+ }
+
+ /* Communicate with the TI BootROM directly
+ * - retrieve ASIC ID
+ * - start peripheral boot
+ * - upload first file
+ * - execute first file
+ */
+ if (!transfer_first_stage(dev, args)) {
+ log_error("failed to transfer the first stage file \'%s\'\n",
+ args->files[0]->basename);
+ goto fail;
+ }
+
+ /* Note: this is a race between the target's processor getting X-loader
+ * running and our processor. If we fail to communicate with the X-loader,
+ * it's possible that it hasn't been fully initialized. I'm not going to put
+ * some stupid, arbitrary sleep value here. The transfer_other_files function
+ * should be robust enough to handle some errors.
+ */
+
+ /* If we are passed one file, assume that the user just wants to
+ * upload some initial code with no X-loader chaining
+ */
+ if (args->numfiles > 1) {
+ if (!transfer_other_files(dev, args)) {
+ log_error
+ ("failed to transfer the additional files in to memory\n");
+ goto fail;
+ }
+ }
+
+ log_info("successfully transfered %d %s\n", args->numfiles,
+ (args->numfiles > 1) ? "files" : "file");
+
+ /* safely close our USB handle and context */
+ libusb_close(dev);
+ libusb_exit(ctx);
+ return 0;
+
+fail:
+ libusb_close(dev);
+ libusb_exit(ctx);
+
+ return 1;
+}
+
+/* getopt configuration */
+static int do_version = 0;
+static const char *const short_opt = "f:a:j:i:p:vh";
+static const struct option long_opt[] = {
+ {"file", 1, NULL, 'f'},
+ {"addr", 1, NULL, 'a'},
+ {"jump", 1, NULL, 'j'},
+ {"vendor", 1, NULL, 'i'},
+ {"product", 1, NULL, 'p'},
+ {"verbose", 0, NULL, 'v'},
+ {"help", 0, NULL, 'h'},
+ {"version", 0, &do_version, 1},
+ {NULL, 0, NULL, 0}
+};
+
+static void usage(char *exe)
+{
+ printf(
+"Usage: %s [options] -f first-stage [-f file -a addr]...\n"
+"Options:\n"
+" -f, --file Provide the filename of a binary file to be\n"
+" uploaded. The first file specified is uploaded to\n"
+" the fixed address 0x%08x as defined by the manual.\n"
+" Additional files must be followed by an address\n"
+" argument (-a).\n"
+" -a, --addr The address to load the prior file at.\n"
+" -j, --jump Specify the address to jump to after loading all\n"
+" of the files in to memory.\n"
+" -i, --vendor Override the default vendor ID to poll for\n"
+" (default 0x%04x).\n"
+" -p, --product Poll for specific product id. Default: All known OMAP chips\n"
+" -h, --help Display this message.\n"
+" -v, --verbose Enable verbose output.\n"
+"\n"
+"Description:\n"
+" %s's basic usage is to upload an arbitrary file in to the memory\n"
+" of a TI OMAP3 compatible processor. This program directly\n"
+" communicates with the TI BootROM in order to upload a first stage\n"
+" payload, in most cases, TI's X-Loader. Using a compatible X-Loader\n"
+" will enable the upload of any file to any part in device memory.\n"
+"\n"
+"Examples:\n"
+" Uploading a compatible X-Loader, U-Boot, Kernel, and RAMDisk, then jumping\n"
+" to the U-Boot image for further bootloading:\n"
+" %s -f x-load.bin -f u-boot.bin -a 0x80200000 -f uImage -a 0x80800000 \\\n"
+" -f uRamdisk -a 0x81000000 -j 0x80200000\n"
+" Uploading arbitrary code to be executed (doesn't have to be X-loader):\n"
+" %s -f exec_me.bin\n"
+" Trying to debug an upload issue using verbose output:\n"
+" %s -v -f exec_me.bin -f file1.bin -a 0xdeadbeef -j 0xabad1dea\n"
+"\n"
+"Authors:\n"
+" Grant Hernandez <grant.h.hernandez@gmail.com> - rewrite of omap3_usbload to\n"
+" use the newer libusb 1.0\n"
+" Martin Mueller <martinmm@pfump.org> - initial code (omap3_usbload)\n"
+" and X-Loader patch\n",
+ exe, OMAP_BASE_ADDRESS, OMAP_VENDOR_ID, PROG_NAME, exe, exe, exe
+ );
+}
+
+static void license(void)
+{
+ printf(
+"Copyright (C) 2008 Martin Mueller <martinmm@pfump.org>\n"
+"Copyright (C) 2014 Grant Hernandez <grant.h.hernandez@gmail.com>\n"
+"License GPLv2: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>.\n"
+"This is free software: you are free to change and redistribute it.\n"
+"There is NO WARRANTY, to the extent permitted by law.\n"
+ );
+}
+
+int main(int argc, char *argv[])
+{
+ int opt;
+ bool gotfile = false;
+ bool gotjump = false;
+ int filecount = 0;
+ char *exe = NULL;
+
+ /* temporary local file object */
+ struct file_upload file;
+ /* total arg state */
+ struct arg_state *args = calloc(1, sizeof (*args));
+
+ if (argc < 1) {
+ log_error("invalid arguments (no argv[0])\n");
+ return 1;
+ }
+
+ exe = argv[0];
+
+ fprintf(stdout, "%s %s\n", PROG_NAME, VERSION);
+
+ /* set the default vendor and product */
+ args->vendor = OMAP_VENDOR_ID;
+ args->product = 0;
+
+ while ((opt = getopt_long(argc, argv, short_opt, long_opt, NULL)) != -1) {
+ switch (opt) {
+ case 0:
+ if (do_version) {
+ license();
+ return 0;
+ }
+ break;
+ case 'f':
+ if (gotfile) {
+ log_error("missing address argument (-a) for file \'%s\'\n",
+ file.path);
+ usage(exe);
+ return 1;
+ }
+
+ file.path = strdup(optarg);
+
+ /* necessary to be sure that we own all the memory
+ and that the path input can be modified */
+ char *tmpPath = strdup(file.path);
+ file.basename = strdup(basename(tmpPath));
+ free(tmpPath);
+
+ filecount++;
+
+ /* the first file gets uploaded to a fixed address
+ as specified by the technical reference manual */
+ if (filecount == 1) {
+ file.addr = OMAP_BASE_ADDRESS;
+
+ /* commit the file object with the processor specified base address */
+ args->files = realloc(args->files, filecount);
+ args->numfiles = filecount;
+ args->files[filecount - 1] = malloc(sizeof (file));
+ memcpy(args->files[filecount - 1], &file, sizeof (file));
+ } else {
+ /* commit only after an address is specified */
+ gotfile = true;
+ }
+ break;
+ case 'a':
+ if (!gotfile) {
+ log_error
+ ("missing file argument (-f) before address \'%s\'\n",
+ optarg);
+ usage(exe);
+ return 1;
+ }
+
+ /* passing 0 to strtoul enables detection of the 0x prefix with
+ base-10 fallback if missing */
+ file.addr = strtoul(optarg, NULL, 0);
+
+ /* commit the file object */
+ args->files = realloc(args->files, filecount);
+ args->numfiles = filecount;
+ args->files[filecount - 1] = malloc(sizeof(file));
+ memcpy(args->files[filecount - 1], &file, sizeof(file));
+
+ gotfile = false;
+ break;
+ case 'j':
+ args->jumptarget = strtoul(optarg, NULL, 0);
+ gotjump = true;
+ break;
+ case 'i':
+ args->vendor = (uint16_t)strtoul(optarg, NULL, 0);
+ break;
+ case 'p':
+ args->product = (uint16_t)strtoul(optarg, NULL, 0);
+ break;
+ case 'v':
+ g_verbose++;
+ break;
+ case 'h':
+ usage(exe);
+ return 0;
+ default:
+ usage(exe);
+ return 1;
+ }
+ }
+
+ if (gotfile) {
+ log_error("got file \'%s\', but no address!\n", file.path);
+ usage(exe);
+ return 1;
+ }
+
+ if (args->numfiles <= 0) {
+ log_error("at least one file needs to be specified\n");
+ usage(exe);
+ return 1;
+ }
+
+ if (args->numfiles == 1 && gotjump) {
+ log_info
+ ("WARNING: jump target 0x%08x specified, but will never be taken "
+ "(more than one file required)\n", args->jumptarget);
+ } else if (args->numfiles > 1 && !gotjump) {
+ log_info
+ ("WARNING: no jump target specified. Defaulting to the first "
+ "file's (\'%s\') address 0x%08x\n",
+ args->files[1]->basename, args->files[1]->addr);
+ args->jumptarget = args->files[1]->addr;
+ }
+
+ return process_args(args);
+}