From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from 16.mo3.mail-out.ovh.net ([188.165.56.217] helo=mo3.mail-out.ovh.net) by merlin.infradead.org with esmtp (Exim 4.76 #1 (Red Hat Linux)) id 1TIKDj-0002HI-Pw for barebox@lists.infradead.org; Sun, 30 Sep 2012 14:10:14 +0000 Received: from mail181.ha.ovh.net (b7.ovh.net [213.186.33.57]) by mo3.mail-out.ovh.net (Postfix) with SMTP id 179FFFFB1E5 for ; Sun, 30 Sep 2012 16:18:52 +0200 (CEST) Date: Sun, 30 Sep 2012 16:07:43 +0200 From: Jean-Christophe PLAGNIOL-VILLARD Message-ID: <20120930140743.GS26553@game.jcrosoft.org> References: <1348973437-31132-1-git-send-email-vicencb@gmail.com> <1348973437-31132-7-git-send-email-vicencb@gmail.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <1348973437-31132-7-git-send-email-vicencb@gmail.com> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: barebox-bounces@lists.infradead.org Errors-To: barebox-bounces+u.kleine-koenig=pengutronix.de@lists.infradead.org Subject: Re: [PATCH 6/9] omap4: add usb boot support To: vj Cc: barebox@lists.infradead.org On 04:50 Sun 30 Sep , vj wrote: > --- > arch/arm/cpu/cpu.c | 1 + > arch/arm/mach-omap/Kconfig | 7 + > arch/arm/mach-omap/Makefile | 1 + > arch/arm/mach-omap/include/mach/omap4_rom_usb.h | 142 ++++++++ > arch/arm/mach-omap/omap4_generic.c | 13 + > arch/arm/mach-omap/omap4_rom_usb.c | 186 +++++++++++ > scripts/.gitignore | 1 + > scripts/Makefile | 4 + > scripts/omap4_usbboot.c | 416 ++++++++++++++++++++++++ > scripts/usb.h | 61 ++++ > scripts/usb_linux.c | 397 ++++++++++++++++++++++ > 11 files changed, 1229 insertions(+) > create mode 100644 arch/arm/mach-omap/include/mach/omap4_rom_usb.h > create mode 100644 arch/arm/mach-omap/omap4_rom_usb.c > create mode 100644 scripts/omap4_usbboot.c > create mode 100644 scripts/usb.h > create mode 100644 scripts/usb_linux.c > > diff --git a/arch/arm/cpu/cpu.c b/arch/arm/cpu/cpu.c > index 71ef8c0..05343de 100644 > --- a/arch/arm/cpu/cpu.c > +++ b/arch/arm/cpu/cpu.c > @@ -89,6 +89,7 @@ void arch_shutdown(void) > : "r0", "r1", "r2", "r3", "r6", "r10", "r12", "lr", "cc", "memory" > ); > #endif > + __asm__ __volatile__ ("cpsid i\n"); > } > > #ifdef CONFIG_THUMB2_BAREBOX > diff --git a/arch/arm/mach-omap/Kconfig b/arch/arm/mach-omap/Kconfig > index d735284..16583cb 100644 > --- a/arch/arm/mach-omap/Kconfig > +++ b/arch/arm/mach-omap/Kconfig > @@ -96,6 +96,13 @@ config ARCH_TEXT_BASE > default 0x80e80000 if MACH_OMAP343xSDP > default 0x80e80000 if MACH_BEAGLE > > +config OMAP4_USBBOOT > + bool "enable booting from USB" > + default n > + depends on ARCH_OMAP4 && !MMU > + help > + Enable this to enable USB booting > + > config BOARDINFO > default "Texas Instrument's SDP343x" if MACH_OMAP343xSDP > default "Texas Instrument's Beagle" if MACH_BEAGLE > diff --git a/arch/arm/mach-omap/Makefile b/arch/arm/mach-omap/Makefile > index f087f4b..e89f6ed 100644 > --- a/arch/arm/mach-omap/Makefile > +++ b/arch/arm/mach-omap/Makefile > @@ -30,4 +30,5 @@ obj-$(CONFIG_OMAP3_CLOCK_CONFIG) += omap3_clock.o > obj-$(CONFIG_OMAP_GPMC) += gpmc.o devices-gpmc-nand.o > obj-$(CONFIG_SHELL_NONE) += xload.o > obj-$(CONFIG_I2C_TWL6030) += omap4_twl6030_mmc.o > +obj-$(CONFIG_OMAP4_USBBOOT) += omap4_rom_usb.o > obj-y += gpio.o > diff --git a/arch/arm/mach-omap/include/mach/omap4_rom_usb.h b/arch/arm/mach-omap/include/mach/omap4_rom_usb.h > new file mode 100644 > index 0000000..b7818df > --- /dev/null > +++ b/arch/arm/mach-omap/include/mach/omap4_rom_usb.h > @@ -0,0 +1,142 @@ > +/* > + * Copyright (C) 2010 The Android Open Source Project > + * All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * * Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * * Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in > + * the documentation and/or other materials provided with the > + * distribution. > + * > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS > + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE > + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, > + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, > + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS > + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED > + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, > + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT > + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF > + * SUCH DAMAGE. > + */ > + > +#ifndef _OMAP4_ROM_USB_H_ > +#define _OMAP4_ROM_USB_H_ > + > +/* public api */ > +#define PUBLIC_API_BASE_4430 (0x28400) > +#define PUBLIC_API_BASE_4460 (0x30400) > + > +#define PUBLIC_GET_DRIVER_MEM_OFFSET (0x04) > +#define PUBLIC_GET_DRIVER_PER_OFFSET (0x08) > +#define PUBLIC_GET_DEVICE_MEM_OFFSET (0x80) > +#define PUBLIC_GET_DEVICE_PER_OFFSET (0x84) > + > +#define DEVICE_NULL 0x40 > +#define DEVICE_UART1 0x41 > +#define DEVICE_UART2 0x42 > +#define DEVICE_UART3 0x43 > +#define DEVICE_UART4 0x44 > +#define DEVICE_USB 0x45 > +#define DEVICE_USBEXT 0x46 > + > +#define XFER_MODE_CPU 0 > +#define XFER_MODE_DMA 1 > + > +#define STATUS_OKAY 0 > +#define STATUS_FAILED 1 > +#define STATUS_TIMEOUT 2 > +#define STATUS_BAD_PARAM 3 > +#define STATUS_WAITING 4 > +#define STATUS_NO_MEMORY 5 > +#define STATUS_INVALID_PTR 6 > + > +/* Memory ROM interface */ > +struct read_desc { > + u32 sector_start; > + u32 sector_count; > + void *destination; > +}; > + > +struct mem_device { > + u32 initialized; > + u8 device_type; > + u8 trials_count; > + u32 xip_device; > + u16 search_size; > + u32 base_address; > + u16 hs_toc_mask; > + u16 gp_toc_mask; > + void *device_data; > + u16 *boot_options; > +}; > + > +struct mem_driver { > + int (*init)(struct mem_device *md); > + int (*read)(struct mem_device *md, struct read_desc *rd); > + int (*configure)(struct mem_device *md, void *config); > +}; > + > + > +/* Peripheral ROM interface */ > +struct per_handle { > + void *set_to_null; > + void (*callback)(struct per_handle *rh); > + void *data; > + u32 length; > + u16 *options; > + u32 xfer_mode; > + u32 device_type; > + u32 status; > + u16 hs_toc_mask; > + u16 gp_toc_mask; > + u32 config_timeout; > +}; > + > +struct per_driver { > + int (*init)(struct per_handle *rh); > + int (*read)(struct per_handle *rh); > + int (*write)(struct per_handle *rh); > + int (*close)(struct per_handle *rh); > + int (*config)(struct per_handle *rh, void *x); > +}; > + > +#define USB_SETCONFIGDESC_ATTRIBUTES (0) > +#define USB_SETCONFIGDESC_MAXPOWER (1) > +#define USB_SETSUSPEND_CALLBACK (2) > +struct per_usb_config { > + u32 configid; > + u32 value; > +}; > + > +#define API(n) ((void *) (*((u32 *) (n)))) > +/* ROM API End */ > + > +struct omap4_usbboot { > + struct per_handle dread; > + struct per_handle dwrite; > + struct per_driver *io; > +}; > + > +int omap4_usbboot_open(void); > +void omap4_usbboot_close(void); > + > +void omap4_usbboot_queue_read(void *data, unsigned len); > +int omap4_usbboot_wait_read(void); > +int omap4_usbboot_is_read_waiting(void); > +int omap4_usbboot_is_read_ok(void); > + > +void omap4_usbboot_queue_write(void *data, unsigned len); > +int omap4_usbboot_wait_write(void); > + > +int omap4_usbboot_read(void *data, unsigned len); > +int omap4_usbboot_write(void *data, unsigned len); > +void omap4_usbboot_puts(const char *s); > + > +#endif > diff --git a/arch/arm/mach-omap/omap4_generic.c b/arch/arm/mach-omap/omap4_generic.c > index 6562268..ee62cf2 100644 > --- a/arch/arm/mach-omap/omap4_generic.c > +++ b/arch/arm/mach-omap/omap4_generic.c > @@ -8,6 +8,9 @@ > #include > #include > #include > +#ifdef CONFIG_OMAP4_USBBOOT > +#include > +#endif > > /* > * The following several lines are taken from U-Boot to support > @@ -457,6 +460,15 @@ static int watchdog_init(void) > } > late_initcall(watchdog_init); > > +#ifdef CONFIG_OMAP4_USBBOOT > +static int omap4_usbboot_init(void) > +{ > + omap4_usbboot_open(); > + omap4_usbboot_puts("USB communications initialized\n"); > + return 0; > +} > +postcore_initcall(omap4_usbboot_init); > +#else > static int omap_vector_init(void) > { > __asm__ __volatile__ ( > @@ -470,6 +482,7 @@ static int omap_vector_init(void) > return 0; > } > core_initcall(omap_vector_init); > +#endif need more explanation here > > #define OMAP4_TRACING_VECTOR3 0x4030d048 > > diff --git a/arch/arm/mach-omap/omap4_rom_usb.c b/arch/arm/mach-omap/omap4_rom_usb.c > new file mode 100644 > index 0000000..741f2b7 > --- /dev/null > +++ b/arch/arm/mach-omap/omap4_rom_usb.c > @@ -0,0 +1,186 @@ > +/* > + * This code is based on: > + * git://github.com/swetland/omap4boot.git > + */ > +/* > + * Copyright (C) 2010 The Android Open Source Project > + * All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * * Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * * Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in > + * the documentation and/or other materials provided with the > + * distribution. > + * > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS > + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE > + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, > + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, > + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS > + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED > + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, > + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT > + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF > + * SUCH DAMAGE. > + */ > + > +#include > +#include > +#include > + > +struct omap4_usbboot *omap4_usbboot_pdata; > + > +int omap4_usbboot_open(void) > +{ > + int (*rom_get_per_driver)(struct per_driver **io, u32 device_type); > + int (*rom_get_per_device)(struct per_handle **rh); > + struct per_handle *boot; > + int n; > + u32 base; > + > + if (omap4_revision() >= OMAP4460_ES1_0) > + base = PUBLIC_API_BASE_4460; > + else > + base = PUBLIC_API_BASE_4430; > + > + rom_get_per_driver = API(base + PUBLIC_GET_DRIVER_PER_OFFSET); > + rom_get_per_device = API(base + PUBLIC_GET_DEVICE_PER_OFFSET); > + > + n = rom_get_per_device(&boot); > + if (n) > + return n; > + > + if ((boot->device_type != DEVICE_USB) && > + (boot->device_type != DEVICE_USBEXT)) > + return -1; > + > + omap4_usbboot_pdata = xzalloc(sizeof(struct omap4_usbboot)); > + n = rom_get_per_driver(&omap4_usbboot_pdata->io, boot->device_type); > + if (n) > + return n; > + > + omap4_usbboot_pdata->dread.status = -1; > + omap4_usbboot_pdata->dread.xfer_mode = boot->xfer_mode; > + omap4_usbboot_pdata->dread.options = boot->options; > + omap4_usbboot_pdata->dread.device_type = boot->device_type; > + > + omap4_usbboot_pdata->dwrite.status = -1; > + omap4_usbboot_pdata->dwrite.xfer_mode = boot->xfer_mode; > + omap4_usbboot_pdata->dwrite.options = boot->options; > + omap4_usbboot_pdata->dwrite.device_type = boot->device_type; > + __asm__ __volatile__ ("cpsie i\n"); > + return 0; > +} > + > + > +static void rom_read_callback(struct per_handle *rh) > +{ > + omap4_usbboot_pdata->dread.status = rh->status; > + return; > +} > + > +void omap4_usbboot_queue_read(void *data, unsigned len) > +{ > + int n; > + omap4_usbboot_pdata->dread.data = data; > + omap4_usbboot_pdata->dread.length = len; > + omap4_usbboot_pdata->dread.status = STATUS_WAITING; > + omap4_usbboot_pdata->dread.xfer_mode = 1; > + omap4_usbboot_pdata->dread.callback = rom_read_callback; > + n = omap4_usbboot_pdata->io->read(&omap4_usbboot_pdata->dread); > + if (n) > + omap4_usbboot_pdata->dread.status = n; > +} > + > +int omap4_usbboot_wait_read(void) > +{ > + int ret; > + while (omap4_usbboot_pdata->dread.status == STATUS_WAITING) > + /* cpu_relax(); */ > + barrier(); > + ret = omap4_usbboot_pdata->dread.status; > + omap4_usbboot_pdata->dread.status = -1; > + return ret; > +} > +int omap4_usbboot_is_read_waiting(void) > +{ > + barrier(); > + return omap4_usbboot_pdata->dread.status == STATUS_WAITING; > +} > +int omap4_usbboot_is_read_ok(void) > +{ > + barrier(); > + return omap4_usbboot_pdata->dread.status == STATUS_OKAY; > +} > + > +static void rom_write_callback(struct per_handle *rh) > +{ > + omap4_usbboot_pdata->dwrite.status = rh->status; > + return; > +} > + > +void omap4_usbboot_queue_write(void *data, unsigned len) > +{ > + int n; > + omap4_usbboot_pdata->dwrite.data = data; > + omap4_usbboot_pdata->dwrite.length = len; > + omap4_usbboot_pdata->dwrite.status = STATUS_WAITING; > + omap4_usbboot_pdata->dwrite.xfer_mode = 1; > + omap4_usbboot_pdata->dwrite.callback = rom_write_callback; > + n = omap4_usbboot_pdata->io->write(&omap4_usbboot_pdata->dwrite); > + if (n) > + omap4_usbboot_pdata->dwrite.status = n; > +} > + > +int omap4_usbboot_wait_write(void) > +{ > + int ret; > + while (omap4_usbboot_pdata->dwrite.status == STATUS_WAITING) > + /* cpu_relax(); */ > + barrier(); > + ret = omap4_usbboot_pdata->dwrite.status; > + omap4_usbboot_pdata->dwrite.status = -1; > + return ret; > +} > + > +#define USB_MAX_IO 65536 > +int omap4_usbboot_read(void *data, unsigned len) > +{ > + unsigned xfer; > + unsigned char *x = data; > + int n; > + while (len > 0) { > + xfer = (len > USB_MAX_IO) ? USB_MAX_IO : len; > + omap4_usbboot_queue_read(x, xfer); > + n = omap4_usbboot_wait_read(); > + if (n) > + return n; > + x += xfer; > + len -= xfer; > + } > + return 0; > +} > + > +int omap4_usbboot_write(void *data, unsigned len) > +{ > + omap4_usbboot_queue_write(data, len); > + return omap4_usbboot_wait_write(); > +} > + > +void omap4_usbboot_close(void) > +{ > + omap4_usbboot_pdata->io->close(&omap4_usbboot_pdata->dread); > +} > + > +void omap4_usbboot_puts(const char *s) > +{ > + u32 c; > + while ((c = *s++)) > + omap4_usbboot_write(&c, 4); > +} can you put a device driver for this > diff --git a/scripts/.gitignore b/scripts/.gitignore > index 6e63f85..4fb5a1f 100644 > --- a/scripts/.gitignore > +++ b/scripts/.gitignore > @@ -5,3 +5,4 @@ kallsyms > mkimage > mkublheader > omap_signGP > +omap4_usbboot > diff --git a/scripts/Makefile b/scripts/Makefile > index 7ca5e29..6c1b113 100644 > --- a/scripts/Makefile > +++ b/scripts/Makefile > @@ -4,6 +4,8 @@ > # --------------------------------------------------------------------------- > # kallsyms: Find all symbols in barebox > > +HOSTLDFLAGS += -lpthread > + no the -lpthread is for omap4_usbboot target olny is HOSTLOADLIBES_omap4_usbboot and HOSTCFLAGS_omap4_usbboot.o for specifc header and lib > hostprogs-$(CONFIG_KALLSYMS) += kallsyms > hostprogs-y += bin2c > hostprogs-y += mkimage > @@ -12,6 +14,8 @@ hostprogs-$(CONFIG_ARCH_NETX) += gen_netx_image > hostprogs-$(CONFIG_ARCH_OMAP) += omap_signGP > hostprogs-$(CONFIG_ARCH_S5PCxx) += s5p_cksum > hostprogs-$(CONFIG_ARCH_DAVINCI) += mkublheader > +hostprogs-$(CONFIG_OMAP4_USBBOOT)+= omap4_usbboot > +omap4_usbboot-objs := usb_linux.o omap4_usbboot.o > > always := $(hostprogs-y) $(hostprogs-m) > > diff --git a/scripts/omap4_usbboot.c b/scripts/omap4_usbboot.c > new file mode 100644 > index 0000000..aa11759 > --- /dev/null > +++ b/scripts/omap4_usbboot.c > @@ -0,0 +1,416 @@ > +/* > + * 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. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, > + * MA 02111-1307 USA > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "usb.h" > + > +#define USBBOOT_FS_MAGIC 0x5562464D > +#define USBBOOT_FS_CMD_OPEN 0x46530000 > +#define USBBOOT_FS_CMD_CLOSE 0x46530001 > +#define USBBOOT_FS_CMD_READ 0x46530002 > +#define USBBOOT_FS_CMD_END 0x4653FFFF > +#define MAX_OPEN_FILES 1000 > + > +#define RESET 0 > +#define BRIGHT 1 > +#define WHITE 8 > +#define RED 1 > +#define BLACK 0 > +#define FORMAT "%c[%d;%d;%dm" > +#define TARGET_FORMAT 0x1B, BRIGHT, RED+30, BLACK+40 > +#define HOST_FORMAT 0x1B, RESET, WHITE+30, BLACK+40 > +#define host_print(fmt, arg...) printf(FORMAT fmt FORMAT"\n", \ > + HOST_FORMAT, ##arg, TARGET_FORMAT) > + > +struct thread_vars { > + struct usb_handle *usb; > + int hide; > + struct termios to; > +}; > +void *listenerTask(void *argument) > +{ > + struct thread_vars *vars = argument; > + int c; > + for (;;) { > + c = getchar(); > + if (c == EOF) > + return NULL; > + while (vars->hide) > + usleep(10000); > + if (usb_write(vars->usb, &c, 4) != 4) { > + host_print("could not send '%c' to target", c); > + tcsetattr(STDIN_FILENO, TCSANOW, &vars->to); > + exit(1); > + } > + } > + return NULL; > +} > +struct file_data { > + size_t size; > + void *data; > +}; > + > +int read_asic_id(struct usb_handle *usb) > +{ > +#define LINEWIDTH 16 > + const uint32_t msg_getid = 0xF0030003; > + int i, j, k, ret; > + uint8_t id[81]; > + char line[LINEWIDTH*3+8]; > + > + printf("reading ASIC ID\n"); > + memset(id , 0xee, sizeof(id)); > + if (usb_write(usb, &msg_getid, sizeof(msg_getid)) != > + sizeof(msg_getid) > + ) { > + printf("Could not send msg_getid request\n"); > + return -1; > + } > + if (usb_read(usb, id, sizeof(id)) != sizeof(id)) { > + printf("Could not read msg_getid answer\n"); > + return -1; > + } > + for (i = 0; i < sizeof(id); i += LINEWIDTH) { > + sprintf(line, "%02X: ", i); > + for (j = 0; j < LINEWIDTH && j < sizeof(id)-i; j++) > + sprintf(line+4+j*3, "%02X ", id[i+j]); > + line[4+j*3+0] = '\n'; > + line[4+j*3+1] = 0; > + printf(line); > + } > + ret = 0; > + for (i = 1, j = 0; i < sizeof(id) && j < id[0]; i += 2+id[i+1], j++) { > + if (i+2+id[i+1] > sizeof(id)) { > + printf("Truncated subblock\n"); > + ret++; > + continue; > + } > + switch (id[i]) { > + case 0x01: /* ID subblock */ > + if (id[i+1] != 0x05) { > + printf("Unexpected ID subblock size\n"); > + ret++; > + continue; > + } > + if (id[i+2] != 0x01) > + printf("Unexpected fixed value\n"); > + k = (id[i+3]<<8) | id[i+4]; > + switch (k) { > + case 0x4440: > + printf("OMAP 4460 Device\n"); > + break; > + default: > + printf("Unknown Device\n"); > + break; > + } > + switch (id[i+5]) { > + case 0x07: > + printf("CH enabled (read from eFuse)\n"); > + break; > + case 0x17: > + printf("CH disabled (read from eFuse)\n"); > + break; > + default: > + printf("Unknown CH setting\n"); > + break; > + } > + printf("Rom version: %hhu\n", id[i+6]); > + break; > + case 0x15: /* Checksum subblock */ > + if (id[i+1] != 0x09) { > + printf("Unexpected Checksum subblock size\n"); > + ret++; > + continue; > + } > + if (id[i+2] != 0x01) > + printf("Unexpected fixed value\n"); > + k = (id[i+3]<<24) | (id[i+4]<<16) | > + (id[i+5]<<8) | id[i+6]; > + printf("Rom CRC: 0x%08X\n", k); > + k = (id[i+7]<<24) | (id[i+8]<<16) | > + (id[i+9]<<8) | id[i+10]; > + switch (k) { > + case 0: > + printf("A GP device\n"); > + break; > + default: > + printf("Unknown device\n"); > + break; > + } > + break; > + } > + } > + if (i != sizeof(id) || j != id[0]) { > + printf("Unexpected ASIC ID structure size.\n"); > + ret++; > + } > + return ret; > +} > + > +int process_file( > + struct usb_handle *usb, const char *rootfs, struct file_data *fd_vector) > +{ > + uint32_t i, j, pos, size; > + struct stat s; > + int fd, ret; > + char line[256]; > + > + if (usb_read(usb, &i, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + ret = 0; > + switch (i) { > + case USBBOOT_FS_CMD_OPEN: > + for (j = 0; rootfs[j]; j++) > + line[j] = rootfs[j]; > + for (;; j++) { > + if (usb_read(usb, &i, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + if (i == USBBOOT_FS_CMD_END) { > + line[j] = 0; > + break; > + } else if (i > 0xFF) { > + host_print("Error in filename"); > + ret++; > + line[j] = 0; > + break; > + } else > + line[j] = i; > + } > + for (i = 0; i < MAX_OPEN_FILES && fd_vector[i].data; i++) > + ; > + if (i >= MAX_OPEN_FILES) { > + host_print("MAX_OPEN_FILES exceeded"); > + ret++; > + goto open_error_1; > + } > + fd = open(line, O_RDONLY); > + if (fd < 0) { > + host_print("cannot open '%s'", line); > + ret++; > + goto open_error_1; > + } > + if (fstat(fd, &s)) { > + host_print("cannot stat '%s'", line); > + ret++; > + goto open_error_2; > + } > + fd_vector[i].data = mmap(NULL, s.st_size, PROT_READ, > + MAP_PRIVATE, fd, 0); > + if (fd_vector[i].data == MAP_FAILED) { > + host_print("cannot mmap '%s'", line); > + ret++; > + goto open_error_2; > + } > + close(fd); > + fd_vector[i].size = size = s.st_size; > + fd = i; > + goto open_ok; > + > +open_error_2: > + close(fd); > +open_error_1: > + fd_vector[i].size = size = 0; > + fd = -1; > +open_ok: > + if (usb_write(usb, &fd, 4) != 4 || > + usb_write(usb, &size, 4) != 4 > + ) { > + host_print("could not send file size to target"); > + exit(1); > + } > + break; > + case USBBOOT_FS_CMD_CLOSE: > + if (usb_read(usb, &i, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + if (i >= MAX_OPEN_FILES || !fd_vector[i].data) { > + host_print("invalid close index"); > + ret++; > + break; > + } > + if (usb_read(usb, &j, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + if (j != USBBOOT_FS_CMD_END) { > + host_print("invalid close"); > + ret++; > + break; > + } > + munmap(fd_vector[i].data, fd_vector[i].size); > + fd_vector[i].data = NULL; > + break; > + case USBBOOT_FS_CMD_READ: > + if (usb_read(usb, &i, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + if (i >= MAX_OPEN_FILES || !fd_vector[i].data) { > + host_print("invalid read index"); > + ret++; > + break; > + } > + if (usb_read(usb, &pos, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + if (pos >= fd_vector[i].size) { > + host_print("invalid read pos"); > + ret++; > + break; > + } > + if (usb_read(usb, &size, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + if (pos+size > fd_vector[i].size) { > + host_print("invalid read size"); > + ret++; > + break; > + } > + if (usb_read(usb, &j, 4) != 4) { > + host_print("USB error"); > + exit(1); > + } > + if (j != USBBOOT_FS_CMD_END) { > + host_print("invalid read"); > + ret++; > + break; > + } > + if (usb_write(usb, fd_vector[i].data+pos, size) != size) { > + host_print("could not send file to target"); > + exit(1); > + } > + break; > + case USBBOOT_FS_CMD_END: > + default: > + host_print("Unknown filesystem command"); > + ret++; > + break; > + } > + return ret; > +} > + > +int usb_boot( > + struct usb_handle *usb, void *data, unsigned sz, const char *rootfs) > +{ > + const uint32_t msg_boot = 0xF0030002; > + uint32_t msg_size = sz; > + int i; > + pthread_t thread; > + struct thread_vars vars; > + struct termios tn; > + struct file_data fd_vector[MAX_OPEN_FILES]; > + > + read_asic_id(usb); > + > + printf("sending xload to target...\n"); > + usb_write(usb, &msg_boot, sizeof(msg_boot)); > + usb_write(usb, &msg_size, sizeof(msg_size)); > + usb_write(usb, data, sz); > + munmap(data, msg_size); > + for (i = 0; i < MAX_OPEN_FILES; i++) > + fd_vector[i].data = NULL; > + > + vars.usb = usb; > + vars.hide = 0; > + tcgetattr(STDIN_FILENO, &vars.to); > + tn = vars.to; > + tn.c_lflag &= ~(ICANON | ECHO); > + printf(FORMAT, TARGET_FORMAT); > + tcsetattr(STDIN_FILENO, TCSANOW, &tn); > + if (pthread_create(&thread, NULL, listenerTask, &vars)) > + host_print("listenerTask failed"); > + for (;;) { > + if (usb_read(usb, &i, 4) != 4) > + break; > + if (i == USBBOOT_FS_MAGIC) { > + vars.hide = 1; > + process_file(usb, rootfs, fd_vector); > + vars.hide = 0; > + continue; > + } > + printf("%c", i); > + fflush(stdout); > + } > + tcsetattr(STDIN_FILENO, TCSANOW, &vars.to); > + return 0; > +} > + > +int match_omap4_bootloader(struct usb_ifc_info *ifc) > +{ > + if (ifc->dev_vendor != 0x0451) > + return -1; > + if ((ifc->dev_product != 0xD010) && (ifc->dev_product != 0xD00F)) > + return -1; > + return 0; > +} > + > +int main(int argc, char **argv) > +{ > + void *data; > + unsigned sz; > + struct stat s; > + int fd; > + struct usb_handle *usb; > + int once; > + > + if (argc != 3) { > + printf("usage: %s \n", argv[0]); > + return 0; > + } > + argv++; > + fd = open(argv[0], O_RDONLY); > + if (fd < 0 || fstat(fd, &s)) { > + printf("cannot open '%s'\n", argv[0]); > + return -1; > + } > + data = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0); > + if (data == MAP_FAILED) { > + printf("cannot mmap '%s'\n", argv[0]); > + return -1; > + } > + sz = s.st_size; > + close(fd); > + argv++; > + printf(FORMAT, HOST_FORMAT); > + for (once = 1;;) { > + usb = usb_open(match_omap4_bootloader); > + if (usb) > + return usb_boot(usb, data, sz, argv[0]); > + if (once) { > + once = 0; > + printf("waiting for OMAP44xx device...\n"); > + } > + usleep(250000); > + } > + return -1; > +} > diff --git a/scripts/usb.h b/scripts/usb.h > new file mode 100644 > index 0000000..d50aa6a > --- /dev/null > +++ b/scripts/usb.h > @@ -0,0 +1,61 @@ > +/* > + * Copyright (C) 2008 The Android Open Source Project > + * All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * * Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * * Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in > + * the documentation and/or other materials provided with the > + * distribution. > + * > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS > + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE > + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, > + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, > + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS > + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED > + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, > + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT > + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF > + * SUCH DAMAGE. > + */ > + > +#ifndef _USB_H_ > +#define _USB_H_ > + > +struct usb_ifc_info { > + /* from device descriptor */ > + unsigned short dev_vendor; > + unsigned short dev_product; > + > + unsigned char dev_class; > + unsigned char dev_subclass; > + unsigned char dev_protocol; > + > + unsigned char ifc_class; > + unsigned char ifc_subclass; > + unsigned char ifc_protocol; > + > + unsigned char has_bulk_in; > + unsigned char has_bulk_out; > + > + unsigned char writable; > + > + char serial_number[256]; > +}; > + > +typedef int (*ifc_match_func)(struct usb_ifc_info *ifc); > + > +struct usb_handle *usb_open(ifc_match_func callback); > +int usb_close(struct usb_handle *h); > +int usb_read(struct usb_handle *h, void *_data, int len); > +int usb_write(struct usb_handle *h, const void *_data, int len); > + > + > +#endif > diff --git a/scripts/usb_linux.c b/scripts/usb_linux.c > new file mode 100644 > index 0000000..43529aa > --- /dev/null > +++ b/scripts/usb_linux.c > @@ -0,0 +1,397 @@ > +/* > + * Copyright (C) 2008 The Android Open Source Project > + * All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * * Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * * Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in > + * the documentation and/or other materials provided with the > + * distribution. > + * > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS > + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE > + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, > + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, > + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS > + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED > + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, > + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT > + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF > + * SUCH DAMAGE. > + */ > + > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > + > +#include "usb.h" > + > +#define MAX_RETRIES 5 > + > +#ifdef TRACE_USB > +#define DBG1(x...) fprintf(stderr, x) > +#define DBG(x...) fprintf(stderr, x) > +#else > +#define DBG(x...) > +#define DBG1(x...) > +#endif > + > +struct usb_handle { > + char fname[64]; > + int desc; > + unsigned char ep_in; > + unsigned char ep_out; > +}; > + > +static inline int badname(const char *name) > +{ > + while (*name) { > + if (!isdigit(*name++)) > + return 1; > + } > + return 0; > +} > + > +static int check(void *_desc, int len, unsigned type, int size) > +{ > + unsigned char *desc = _desc; > + > + if (len < size) > + return -1; > + if (desc[0] < size) > + return -1; > + if (desc[0] > len) > + return -1; > + if (desc[1] != type) > + return -1; > + > + return 0; > +} > + > +static int filter_usb_device(int fd, char *ptr, int len, int writable, > + ifc_match_func callback, int *ept_in_id, int *ept_out_id, int *ifc_id) > +{ > + struct usb_device_descriptor *dev; > + struct usb_config_descriptor *cfg; > + struct usb_interface_descriptor *ifc; > + struct usb_endpoint_descriptor *ept; > + struct usb_ifc_info info; > + > + int in, out; > + unsigned i; > + unsigned e; > + > + if (check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE)) > + return -1; > + dev = (void *) ptr; > + len -= dev->bLength; > + ptr += dev->bLength; > + > + if (check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE)) > + return -1; > + cfg = (void *) ptr; > + len -= cfg->bLength; > + ptr += cfg->bLength; > + > + info.dev_vendor = dev->idVendor; > + info.dev_product = dev->idProduct; > + info.dev_class = dev->bDeviceClass; > + info.dev_subclass = dev->bDeviceSubClass; > + info.dev_protocol = dev->bDeviceProtocol; > + info.writable = writable; > + > + /* read device serial number (if there is one) */ > + info.serial_number[0] = 0; > + if (dev->iSerialNumber) { > + struct usbdevfs_ctrltransfer ctrl; > + __u16 buffer[128]; > + int result; > + > + memset(buffer, 0, sizeof(buffer)); > + > + ctrl.bRequestType = USB_DIR_IN| > + USB_TYPE_STANDARD|USB_RECIP_DEVICE; > + ctrl.bRequest = USB_REQ_GET_DESCRIPTOR; > + ctrl.wValue = (USB_DT_STRING << 8) | dev->iSerialNumber; > + ctrl.wIndex = 0; > + ctrl.wLength = sizeof(buffer); > + ctrl.data = buffer; > + ctrl.timeout = 50; > + > + result = ioctl(fd, USBDEVFS_CONTROL, &ctrl); > + if (result > 0) { > + int i; > + /* skip first word, and copy the rest to the serial > + string, changing shorts to bytes. */ > + result /= 2; > + for (i = 1; i < result; i++) > + info.serial_number[i - 1] = buffer[i]; > + info.serial_number[i - 1] = 0; > + } > + } > + > + for (i = 0; i < cfg->bNumInterfaces; i++) { > + if (check(ptr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE)) > + return -1; > + ifc = (void *) ptr; > + len -= ifc->bLength; > + ptr += ifc->bLength; > + > + in = -1; > + out = -1; > + info.ifc_class = ifc->bInterfaceClass; > + info.ifc_subclass = ifc->bInterfaceSubClass; > + info.ifc_protocol = ifc->bInterfaceProtocol; > + > + for (e = 0; e < ifc->bNumEndpoints; e++) { > + if (check(ptr, len, USB_DT_ENDPOINT, > + USB_DT_ENDPOINT_SIZE) > + ) > + return -1; > + ept = (void *) ptr; > + len -= ept->bLength; > + ptr += ept->bLength; > + > + if ((ept->bmAttributes & 0x03) != 0x02) > + continue; > + > + if (ept->bEndpointAddress & 0x80) > + in = ept->bEndpointAddress; > + else > + out = ept->bEndpointAddress; > + } > + > + info.has_bulk_in = (in != -1); > + info.has_bulk_out = (out != -1); > + > + if (callback(&info) == 0) { > + *ept_in_id = in; > + *ept_out_id = out; > + *ifc_id = ifc->bInterfaceNumber; > + return 0; > + } > + } > + > + return -1; > +} > + > +static struct usb_handle *find_usb_device( > + const char *base, ifc_match_func callback) > +{ > + struct usb_handle *usb = 0; > + char busname[64], devname[64]; > + char desc[1024]; > + int n, in, out, ifc; > + > + DIR *busdir, *devdir; > + struct dirent *de; > + int fd; > + int writable; > + > + busdir = opendir(base); > + if (busdir == 0) > + return 0; > + > + while ((de = readdir(busdir)) && (usb == 0)) { > + if (badname(de->d_name)) > + continue; > + > + sprintf(busname, "%s/%s", base, de->d_name); > + devdir = opendir(busname); > + if (devdir == 0) > + continue; > + > + /* DBG("[ scanning %s ]\n", busname); */ > + while ((de = readdir(devdir)) && (usb == 0)) { > + > + if (badname(de->d_name)) > + continue; > + sprintf(devname, "%s/%s", busname, de->d_name); > + > + /* DBG("[ scanning %s ]\n", devname); */ > + writable = 1; > + fd = open(devname, O_RDWR); > + if (fd < 0) { > + /* Check if we have read-only access, > + so we can give a helpful diagnostic > + like "adb devices" does. */ > + writable = 0; > + fd = open(devname, O_RDONLY); > + if (fd < 0) > + continue; > + } > + > + n = read(fd, desc, sizeof(desc)); > + > + if (filter_usb_device(fd, desc, n, writable, > + callback, &in, &out, &ifc) == 0 > + ) { > + usb = calloc(1, sizeof(struct usb_handle)); > + strcpy(usb->fname, devname); > + usb->ep_in = in; > + usb->ep_out = out; > + usb->desc = fd; > + > + n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc); > + if (n != 0) { > + close(fd); > + free(usb); > + usb = 0; > + continue; > + } > + } else > + close(fd); > + } > + closedir(devdir); > + } > + closedir(busdir); > + > + return usb; > +} > + > +int usb_write(struct usb_handle *h, const void *_data, int len) > +{ > + unsigned char *data = (unsigned char *) _data; > + unsigned count = 0; > + struct usbdevfs_bulktransfer bulk; > + int n; > + > + if (h->ep_out == 0) > + return -1; > + > + if (len == 0) { > + bulk.ep = h->ep_out; > + bulk.len = 0; > + bulk.data = data; > + bulk.timeout = 0; > + > + n = ioctl(h->desc, USBDEVFS_BULK, &bulk); > + if (n != 0) { > + fprintf(stderr, "ERROR: n = %d, errno = %d (%s)\n", > + n, errno, strerror(errno)); > + return -1; > + } > + return 0; > + } > + > + while (len > 0) { > + int xfer; > + xfer = (len > 4096) ? 4096 : len; > + > + bulk.ep = h->ep_out; > + bulk.len = xfer; > + bulk.data = data; > + bulk.timeout = 0; > + > + n = ioctl(h->desc, USBDEVFS_BULK, &bulk); > + if (n != xfer) { > + DBG("ERROR: n = %d, errno = %d (%s)\n", > + n, errno, strerror(errno)); > + return -1; > + } > + > + count += xfer; > + len -= xfer; > + data += xfer; > + } > + > + return count; > +} > + > +int usb_read(struct usb_handle *h, void *_data, int len) > +{ > + unsigned char *data = (unsigned char *) _data; > + unsigned count = 0; > + struct usbdevfs_bulktransfer bulk; > + int n, retry; > + > + if (h->ep_in == 0) > + return -1; > + > + while (len > 0) { > + int xfer = (len > 4096) ? 4096 : len; > + > + bulk.ep = h->ep_in; > + bulk.len = xfer; > + bulk.data = data; > + bulk.timeout = 0; > + retry = 0; > + > + do { > + DBG("[ usb read %d fd = %d], fname=%s\n", > + xfer, h->desc, h->fname); > + n = ioctl(h->desc, USBDEVFS_BULK, &bulk); > + DBG("[ usb read %d ] = %d, fname=%s, Retry %d\n", > + xfer, n, h->fname, retry); > + > + if (n < 0) { > + DBG1("ERROR: n = %d, errno = %d (%s)\n", > + n, errno, strerror(errno)); > + if (++retry > MAX_RETRIES) > + return -1; > + sleep(1); > + } > + } while (n < 0); > + > + count += n; > + len -= n; > + data += n; > + > + if (n < xfer) > + break; > + } > + > + return count; > +} > + > +void usb_kick(struct usb_handle *h) > +{ > + int fd; > + > + fd = h->desc; > + h->desc = -1; > + if (fd >= 0) { > + close(fd); > + DBG("[ usb closed %d ]\n", fd); > + } > +} > + > +int usb_close(struct usb_handle *h) > +{ > + int fd; > + > + fd = h->desc; > + h->desc = -1; > + if (fd >= 0) { > + close(fd); > + DBG("[ usb closed %d ]\n", fd); > + } > + > + return 0; > +} > + > +struct usb_handle *usb_open(ifc_match_func callback) > +{ > + return find_usb_device("/dev/bus/usb", callback); > +} > -- > 1.7.12.1 > > > _______________________________________________ > barebox mailing list > barebox@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/barebox _______________________________________________ barebox mailing list barebox@lists.infradead.org http://lists.infradead.org/mailman/listinfo/barebox