omap4: add support for booting cpu from usb
Signed-off-by: Vicente <vicencb@gmail.com> Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
This commit is contained in:
parent
7b8a200154
commit
6b4dc4d4f1
|
@ -0,0 +1,27 @@
|
||||||
|
-------------- omap4_usb_booting --------------
|
||||||
|
|
||||||
|
omap4 processors have support for booting from the usb port. To be able to fully
|
||||||
|
use this feature you will need to enable the following:
|
||||||
|
OMAP4_USBBOOT
|
||||||
|
This CONFIG_ option adds the required infrastructure.
|
||||||
|
DRIVER_SERIAL_OMAP4_USBBOOT
|
||||||
|
This adds console support over the same usb port used for booting.
|
||||||
|
FS_OMAP4_USBBOOT
|
||||||
|
This adds filesystem support over the same usb port used for booting.
|
||||||
|
|
||||||
|
To send the bootloader to the processor, execute the utility omap4_usbboot which
|
||||||
|
can be found in the scripts subdirectory.
|
||||||
|
omap4_usbboot takes two parameters:
|
||||||
|
the bootloader image
|
||||||
|
a directory name which will be the root for the guest system
|
||||||
|
Once omap4_usbboot is running it will wait for enumeration of the omap4 cpu on
|
||||||
|
the host usb subsystem. Then power on or reset the cpu with the correct sys_boot
|
||||||
|
or SAR memory configuration.
|
||||||
|
|
||||||
|
If everything works, barebox's first stage will boot and afterwards it will load
|
||||||
|
the second stage found at "/barebox.bin".
|
||||||
|
Barebox's second stage will still have access to the usb filesystem, so an
|
||||||
|
initrd and a zImage can be loaded.
|
||||||
|
|
||||||
|
Overall this procedure frees the developer of continously be changing the SD
|
||||||
|
card or other boot media from host to target.
|
|
@ -82,6 +82,15 @@ config ARCH_TEXT_BASE
|
||||||
default 0x80e80000 if MACH_OMAP343xSDP
|
default 0x80e80000 if MACH_OMAP343xSDP
|
||||||
default 0x80e80000 if MACH_BEAGLE
|
default 0x80e80000 if MACH_BEAGLE
|
||||||
|
|
||||||
|
config OMAP4_USBBOOT
|
||||||
|
bool "enable booting from USB"
|
||||||
|
default n
|
||||||
|
depends on ARCH_OMAP4 && !MMU
|
||||||
|
help
|
||||||
|
Say Y here if you want to be able to boot an OMAP4 cpu from USB.
|
||||||
|
You need the utility program omap4_usbboot to boot from USB.
|
||||||
|
Please read oamp4_usb_booting.txt for more information.
|
||||||
|
|
||||||
config BOARDINFO
|
config BOARDINFO
|
||||||
default "Texas Instrument's SDP343x" if MACH_OMAP343xSDP
|
default "Texas Instrument's SDP343x" if MACH_OMAP343xSDP
|
||||||
default "Texas Instrument's Beagle" if MACH_BEAGLE
|
default "Texas Instrument's Beagle" if MACH_BEAGLE
|
||||||
|
|
|
@ -27,4 +27,5 @@ pbl-$(CONFIG_OMAP3_CLOCK_CONFIG) += omap3_clock.o
|
||||||
obj-$(CONFIG_OMAP_GPMC) += gpmc.o devices-gpmc-nand.o
|
obj-$(CONFIG_OMAP_GPMC) += gpmc.o devices-gpmc-nand.o
|
||||||
obj-$(CONFIG_SHELL_NONE) += xload.o
|
obj-$(CONFIG_SHELL_NONE) += xload.o
|
||||||
obj-$(CONFIG_I2C_TWL6030) += omap4_twl6030_mmc.o
|
obj-$(CONFIG_I2C_TWL6030) += omap4_twl6030_mmc.o
|
||||||
|
obj-$(CONFIG_OMAP4_USBBOOT) += omap4_rom_usb.o
|
||||||
obj-y += gpio.o
|
obj-y += gpio.o
|
||||||
|
|
|
@ -0,0 +1,141 @@
|
||||||
|
/*
|
||||||
|
* 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;
|
||||||
|
};
|
||||||
|
|
||||||
|
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
|
|
@ -8,6 +8,7 @@
|
||||||
#include <mach/xload.h>
|
#include <mach/xload.h>
|
||||||
#include <mach/gpmc.h>
|
#include <mach/gpmc.h>
|
||||||
#include <mach/gpio.h>
|
#include <mach/gpio.h>
|
||||||
|
#include <mach/omap4_rom_usb.h>
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* The following several lines are taken from U-Boot to support
|
* The following several lines are taken from U-Boot to support
|
||||||
|
@ -459,13 +460,21 @@ late_initcall(watchdog_init);
|
||||||
|
|
||||||
static int omap_vector_init(void)
|
static int omap_vector_init(void)
|
||||||
{
|
{
|
||||||
__asm__ __volatile__ (
|
/*
|
||||||
"mov r0, #0;"
|
* omap4 usbboot interfaces with the omap4 ROM to reuse the USB port
|
||||||
"mcr p15, #0, r0, c12, c0, #0;"
|
* used for booting.
|
||||||
:
|
* The ROM code uses interrupts for the transfers, so do not modify the
|
||||||
:
|
* interrupt vectors in this case.
|
||||||
: "r0"
|
*/
|
||||||
);
|
if (omap4_bootsrc() != OMAP_BOOTSRC_USB1) {
|
||||||
|
__asm__ __volatile__ (
|
||||||
|
"mov r0, #0;"
|
||||||
|
"mcr p15, #0, r0, c12, c0, #0;"
|
||||||
|
:
|
||||||
|
:
|
||||||
|
: "r0"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -0,0 +1,198 @@
|
||||||
|
/*
|
||||||
|
* 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 <common.h>
|
||||||
|
#include <mach/omap4-silicon.h>
|
||||||
|
#include <mach/omap4_rom_usb.h>
|
||||||
|
#include <mach/xload.h>
|
||||||
|
#include <init.h>
|
||||||
|
|
||||||
|
static struct omap4_usbboot omap4_usbboot_pdata;
|
||||||
|
|
||||||
|
static 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;
|
||||||
|
|
||||||
|
memset(&omap4_usbboot_pdata, 0, sizeof(omap4_usbboot_pdata));
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int omap4_usbboot_init(void)
|
||||||
|
{
|
||||||
|
if (omap4_bootsrc() == OMAP_BOOTSRC_USB1) {
|
||||||
|
omap4_usbboot_open();
|
||||||
|
omap4_usbboot_puts("USB communications initialized\n");
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
core_initcall(omap4_usbboot_init);
|
|
@ -6,3 +6,4 @@ mk-am35xx-spi-image
|
||||||
mkimage
|
mkimage
|
||||||
mkublheader
|
mkublheader
|
||||||
omap_signGP
|
omap_signGP
|
||||||
|
omap4_usbboot
|
||||||
|
|
|
@ -13,6 +13,10 @@ hostprogs-$(CONFIG_ARCH_OMAP) += omap_signGP mk-am35xx-spi-image
|
||||||
hostprogs-$(CONFIG_ARCH_S5PCxx) += s5p_cksum
|
hostprogs-$(CONFIG_ARCH_S5PCxx) += s5p_cksum
|
||||||
hostprogs-$(CONFIG_ARCH_DAVINCI) += mkublheader
|
hostprogs-$(CONFIG_ARCH_DAVINCI) += mkublheader
|
||||||
|
|
||||||
|
HOSTLOADLIBES_omap4_usbboot = -lpthread
|
||||||
|
omap4_usbboot-objs := usb_linux.o omap4_usbboot.o
|
||||||
|
hostprogs-$(CONFIG_OMAP4_USBBOOT)+= omap4_usbboot
|
||||||
|
|
||||||
always := $(hostprogs-y) $(hostprogs-m)
|
always := $(hostprogs-y) $(hostprogs-m)
|
||||||
|
|
||||||
subdir-y += mod
|
subdir-y += mod
|
||||||
|
|
|
@ -0,0 +1,415 @@
|
||||||
|
/*
|
||||||
|
* 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 <unistd.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <sys/mman.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
#include <termios.h>
|
||||||
|
|
||||||
|
#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 128
|
||||||
|
|
||||||
|
#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, \
|
||||||
|
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\n", c);
|
||||||
|
tcsetattr(STDIN_FILENO, TCSANOW, &vars->to);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
struct file_data {
|
||||||
|
size_t size;
|
||||||
|
void *data;
|
||||||
|
};
|
||||||
|
|
||||||
|
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 fname[256];
|
||||||
|
|
||||||
|
if (usb_read(usb, &i, 4) != 4) {
|
||||||
|
host_print("USB error\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
ret = 0;
|
||||||
|
switch (i) {
|
||||||
|
case USBBOOT_FS_CMD_OPEN:
|
||||||
|
for (j = 0; rootfs[j]; j++)
|
||||||
|
fname[j] = rootfs[j];
|
||||||
|
for (;; j++) {
|
||||||
|
if (usb_read(usb, &i, 4) != 4) {
|
||||||
|
host_print("USB error\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
if (i == USBBOOT_FS_CMD_END) {
|
||||||
|
fname[j] = 0;
|
||||||
|
break;
|
||||||
|
} else if (i > 0xFF) {
|
||||||
|
host_print("Error in filename\n");
|
||||||
|
ret++;
|
||||||
|
fname[j] = 0;
|
||||||
|
break;
|
||||||
|
} else
|
||||||
|
fname[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\n");
|
||||||
|
ret++;
|
||||||
|
goto open_error_1;
|
||||||
|
}
|
||||||
|
fd = open(fname, O_RDONLY);
|
||||||
|
if (fd < 0) {
|
||||||
|
host_print("cannot open '%s'\n", fname);
|
||||||
|
ret++;
|
||||||
|
goto open_error_1;
|
||||||
|
}
|
||||||
|
if (fstat(fd, &s)) {
|
||||||
|
host_print("cannot stat '%s'\n", fname);
|
||||||
|
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'\n", fname);
|
||||||
|
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_vector[i].data = NULL;
|
||||||
|
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\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case USBBOOT_FS_CMD_CLOSE:
|
||||||
|
if (usb_read(usb, &i, 4) != 4) {
|
||||||
|
host_print("USB error\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
if (i >= MAX_OPEN_FILES || !fd_vector[i].data) {
|
||||||
|
host_print("invalid close index\n");
|
||||||
|
ret++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (usb_read(usb, &j, 4) != 4) {
|
||||||
|
host_print("USB error\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
if (j != USBBOOT_FS_CMD_END) {
|
||||||
|
host_print("invalid close\n");
|
||||||
|
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\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
if (i >= MAX_OPEN_FILES || !fd_vector[i].data) {
|
||||||
|
host_print("invalid read index\n");
|
||||||
|
ret++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (usb_read(usb, &pos, 4) != 4) {
|
||||||
|
host_print("USB error\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
if (pos >= fd_vector[i].size) {
|
||||||
|
host_print("invalid read pos\n");
|
||||||
|
ret++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (usb_read(usb, &size, 4) != 4) {
|
||||||
|
host_print("USB error\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
if (pos+size > fd_vector[i].size) {
|
||||||
|
host_print("invalid read size\n");
|
||||||
|
ret++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (usb_read(usb, &j, 4) != 4) {
|
||||||
|
host_print("USB error\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
if (j != USBBOOT_FS_CMD_END) {
|
||||||
|
host_print("invalid read\n");
|
||||||
|
ret++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (usb_write(usb, fd_vector[i].data+pos, size) != size) {
|
||||||
|
host_print("could not send file to target\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case USBBOOT_FS_CMD_END:
|
||||||
|
default:
|
||||||
|
host_print("Unknown filesystem command\n");
|
||||||
|
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\n");
|
||||||
|
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 <xloader> <rootfs>\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;
|
||||||
|
}
|
|
@ -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
|
|
@ -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 <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include <sys/ioctl.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <dirent.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
#include <linux/usbdevice_fs.h>
|
||||||
|
#include <linux/usbdevice_fs.h>
|
||||||
|
#include <linux/version.h>
|
||||||
|
#include <linux/usb/ch9.h>
|
||||||
|
#include <asm/byteorder.h>
|
||||||
|
|
||||||
|
#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);
|
||||||
|
}
|
Loading…
Reference in New Issue