add support for USB-based console (enable with "setenv stdout usbtty; setenv stdin usbtty")master
parent
79d696fc55
commit
232c150a25
@ -0,0 +1,47 @@ |
||||
#
|
||||
# (C) Copyright 2004
|
||||
# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||||
#
|
||||
# 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 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.
|
||||
#
|
||||
# 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 $(TOPDIR)/config.mk |
||||
|
||||
LIB = lib$(BOARD).a
|
||||
|
||||
OBJS := sx1.o flash.o
|
||||
SOBJS := platform.o
|
||||
|
||||
$(LIB): $(OBJS) $(SOBJS) |
||||
$(AR) crv $@ $^
|
||||
|
||||
clean: |
||||
rm -f $(SOBJS) $(OBJS)
|
||||
|
||||
distclean: clean |
||||
rm -f $(LIB) core *.bak .depend
|
||||
|
||||
#########################################################################
|
||||
|
||||
.depend: Makefile $(SOBJS:.o=.S) $(OBJS:.o=.c) |
||||
$(CC) -M $(CPPFLAGS) $(SOBJS:.o=.S) $(OBJS:.o=.c) > $@
|
||||
|
||||
-include .depend |
||||
|
||||
#########################################################################
|
@ -0,0 +1,19 @@ |
||||
#
|
||||
# (C) Copyright 2004
|
||||
# Wolfgang Denk, DENX Software Engineering, <wd@denx.de>
|
||||
#
|
||||
# SX1 board with OMAP1510 (ARM925T) cpu
|
||||
# see http://www.ti.com/ for more information on Texas Insturments
|
||||
#
|
||||
# SX1 has 1 bank of 256 MB SDRAM
|
||||
# Physical Address:
|
||||
# 1000'0000 to 2000'0000
|
||||
#
|
||||
#
|
||||
# Linux-Kernel is expected to be at 1000'8000, entry 1000'8000 (mem base + reserved)
|
||||
#
|
||||
# we load ourself to 1108'0000
|
||||
#
|
||||
#
|
||||
|
||||
TEXT_BASE = 0x11080000
|
@ -0,0 +1,436 @@ |
||||
/*
|
||||
* (C) Copyright 2001 |
||||
* Kyle Harris, Nexus Technologies, Inc. kharris@nexus-tech.net |
||||
* |
||||
* (C) Copyright 2004 |
||||
* Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
||||
* |
||||
* 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 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. |
||||
* |
||||
* 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 <common.h> |
||||
#include <linux/byteorder/swab.h> |
||||
|
||||
#define PHYS_FLASH_SECT_SIZE 0x00020000 /* 256 KB sectors (x2) */ |
||||
flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* info for FLASH chips */ |
||||
|
||||
/* Board support for 1 or 2 flash devices */ |
||||
#undef FLASH_PORT_WIDTH32 |
||||
#define FLASH_PORT_WIDTH16 |
||||
|
||||
#ifdef FLASH_PORT_WIDTH16 |
||||
#define FLASH_PORT_WIDTH ushort |
||||
#define FLASH_PORT_WIDTHV vu_short |
||||
#define SWAP(x) __swab16(x) |
||||
#else |
||||
#define FLASH_PORT_WIDTH ulong |
||||
#define FLASH_PORT_WIDTHV vu_long |
||||
#define SWAP(x) __swab32(x) |
||||
#endif |
||||
|
||||
#define FPW FLASH_PORT_WIDTH |
||||
#define FPWV FLASH_PORT_WIDTHV |
||||
|
||||
#define mb() __asm__ __volatile__ ("" : : : "memory") |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Functions |
||||
*/ |
||||
static ulong flash_get_size (FPW * addr, flash_info_t * info); |
||||
static int write_data (flash_info_t * info, ulong dest, FPW data); |
||||
static void flash_get_offsets (ulong base, flash_info_t * info); |
||||
void inline spin_wheel (void); |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/ |
||||
|
||||
unsigned long flash_init (void) |
||||
{ |
||||
int i; |
||||
ulong size = 0; |
||||
|
||||
for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) { |
||||
switch (i) { |
||||
case 0: |
||||
flash_get_size ((FPW *) PHYS_FLASH_1, &flash_info[i]); |
||||
flash_get_offsets (PHYS_FLASH_1, &flash_info[i]); |
||||
break; |
||||
case 1: |
||||
flash_get_size ((FPW *) PHYS_FLASH_2, &flash_info[i]); |
||||
flash_get_offsets (PHYS_FLASH_2, &flash_info[i]); |
||||
break; |
||||
default: |
||||
panic ("configured too many flash banks!\n"); |
||||
break; |
||||
} |
||||
size += flash_info[i].size; |
||||
} |
||||
|
||||
/* Protect monitor and environment sectors
|
||||
*/ |
||||
flash_protect ( FLAG_PROTECT_SET, |
||||
CFG_FLASH_BASE, |
||||
CFG_FLASH_BASE + monitor_flash_len - 1, |
||||
&flash_info[0]); |
||||
|
||||
flash_protect ( FLAG_PROTECT_SET, |
||||
CFG_ENV_ADDR, |
||||
CFG_ENV_ADDR + CFG_ENV_SIZE - 1, |
||||
&flash_info[0]); |
||||
|
||||
return size; |
||||
} |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/ |
||||
static void flash_get_offsets (ulong base, flash_info_t * info) |
||||
{ |
||||
int i; |
||||
|
||||
if (info->flash_id == FLASH_UNKNOWN) { |
||||
return; |
||||
} |
||||
|
||||
if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL) { |
||||
for (i = 0; i < info->sector_count; i++) { |
||||
info->start[i] = base + (i * PHYS_FLASH_SECT_SIZE); |
||||
info->protect[i] = 0; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/ |
||||
void flash_print_info (flash_info_t * info) |
||||
{ |
||||
int i; |
||||
|
||||
if (info->flash_id == FLASH_UNKNOWN) { |
||||
printf ("missing or unknown FLASH type\n"); |
||||
return; |
||||
} |
||||
|
||||
switch (info->flash_id & FLASH_VENDMASK) { |
||||
case FLASH_MAN_INTEL: |
||||
printf ("INTEL "); |
||||
break; |
||||
default: |
||||
printf ("Unknown Vendor "); |
||||
break; |
||||
} |
||||
|
||||
switch (info->flash_id & FLASH_TYPEMASK) { |
||||
case FLASH_28F128J3A: |
||||
printf ("28F128J3A\n"); |
||||
break; |
||||
case FLASH_28F640J3A: |
||||
printf ("28F640J3A\n"); |
||||
break; |
||||
default: |
||||
printf ("Unknown Chip Type\n"); |
||||
break; |
||||
} |
||||
|
||||
printf (" Size: %ld MB in %d Sectors\n", |
||||
info->size >> 20, info->sector_count); |
||||
|
||||
printf (" Sector Start Addresses:"); |
||||
for (i = 0; i < info->sector_count; ++i) { |
||||
if ((i % 5) == 0) |
||||
printf ("\n "); |
||||
printf (" %08lX%s", |
||||
info->start[i], |
||||
info->protect[i] ? " (RO)" : " "); |
||||
} |
||||
printf ("\n"); |
||||
return; |
||||
} |
||||
|
||||
/*
|
||||
* The following code cannot be run from FLASH! |
||||
*/ |
||||
static ulong flash_get_size (FPW * addr, flash_info_t * info) |
||||
{ |
||||
volatile FPW value; |
||||
|
||||
/* Write auto select command: read Manufacturer ID */ |
||||
addr[0x5555] = (FPW) 0x00AA00AA; |
||||
addr[0x2AAA] = (FPW) 0x00550055; |
||||
addr[0x5555] = (FPW) 0x00900090; |
||||
|
||||
mb (); |
||||
value = addr[0]; |
||||
|
||||
switch (value) { |
||||
case (FPW) INTEL_MANUFACT: |
||||
info->flash_id = FLASH_MAN_INTEL; |
||||
break; |
||||
default: |
||||
info->flash_id = FLASH_UNKNOWN; |
||||
info->sector_count = 0; |
||||
info->size = 0; |
||||
addr[0] = (FPW) 0x00FF00FF; /* restore read mode */ |
||||
return (0); /* no or unknown flash */ |
||||
} |
||||
|
||||
mb (); |
||||
value = addr[1]; /* device ID */ |
||||
switch (value) { |
||||
case (FPW) INTEL_ID_28F128J3A: |
||||
info->flash_id += FLASH_28F128J3A; |
||||
info->sector_count = 128; |
||||
info->size = 0x01000000; |
||||
break; /* => 16 MB */ |
||||
case (FPW) INTEL_ID_28F640J3A: |
||||
info->flash_id += FLASH_28F640J3A; |
||||
info->sector_count = 64; |
||||
info->size = 0x00800000; |
||||
break; /* => 8 MB */ |
||||
default: |
||||
info->flash_id = FLASH_UNKNOWN; |
||||
break; |
||||
} |
||||
|
||||
if (info->sector_count > CFG_MAX_FLASH_SECT) { |
||||
printf ("** ERROR: sector count %d > max (%d) **\n", |
||||
info->sector_count, CFG_MAX_FLASH_SECT); |
||||
info->sector_count = CFG_MAX_FLASH_SECT; |
||||
} |
||||
|
||||
addr[0] = (FPW) 0x00FF00FF; /* restore read mode */ |
||||
|
||||
return (info->size); |
||||
} |
||||
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/ |
||||
|
||||
int flash_erase (flash_info_t * info, int s_first, int s_last) |
||||
{ |
||||
int flag, prot, sect; |
||||
ulong type, start, last; |
||||
int rcode = 0; |
||||
|
||||
if ((s_first < 0) || (s_first > s_last)) { |
||||
if (info->flash_id == FLASH_UNKNOWN) { |
||||
printf ("- missing\n"); |
||||
} else { |
||||
printf ("- no sectors to erase\n"); |
||||
} |
||||
return 1; |
||||
} |
||||
|
||||
type = (info->flash_id & FLASH_VENDMASK); |
||||
if ((type != FLASH_MAN_INTEL)) { |
||||
printf ("Can't erase unknown flash type %08lx - aborted\n", |
||||
info->flash_id); |
||||
return 1; |
||||
} |
||||
|
||||
prot = 0; |
||||
for (sect = s_first; sect <= s_last; ++sect) { |
||||
if (info->protect[sect]) { |
||||
prot++; |
||||
} |
||||
} |
||||
|
||||
if (prot) { |
||||
printf ("- Warning: %d protected sectors will not be erased!\n", |
||||
prot); |
||||
} else { |
||||
printf ("\n"); |
||||
} |
||||
|
||||
/*start = get_timer (0); */ |
||||
last = start; |
||||
|
||||
/* Disable interrupts which might cause a timeout here */ |
||||
flag = disable_interrupts (); |
||||
|
||||
/* Start erase on unprotected sectors */ |
||||
for (sect = s_first; sect <= s_last; sect++) { |
||||
if (info->protect[sect] == 0) { /* not protected */ |
||||
FPWV *addr = (FPWV *) (info->start[sect]); |
||||
FPW status; |
||||
|
||||
printf ("Erasing sector %2d ... ", sect); |
||||
|
||||
/* arm simple, non interrupt dependent timer */ |
||||
reset_timer_masked (); |
||||
|
||||
*addr = (FPW) 0x00500050; /* clear status register */ |
||||
*addr = (FPW) 0x00200020; /* erase setup */ |
||||
*addr = (FPW) 0x00D000D0; /* erase confirm */ |
||||
|
||||
while (((status = *addr) & (FPW) 0x00800080) != (FPW) 0x00800080) { |
||||
if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) { |
||||
printf ("Timeout\n"); |
||||
*addr = (FPW) 0x00B000B0; /* suspend erase */ |
||||
*addr = (FPW) 0x00FF00FF; /* reset to read mode */ |
||||
rcode = 1; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
*addr = (FPW) 0x00500050; /* clear status register cmd. */ |
||||
*addr = (FPW) 0x00FF00FF; /* resest to read mode */ |
||||
|
||||
printf (" done\n"); |
||||
} |
||||
} |
||||
return rcode; |
||||
} |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Copy memory to flash, returns: |
||||
* 0 - OK |
||||
* 1 - write timeout |
||||
* 2 - Flash not erased |
||||
* 4 - Flash not identified |
||||
*/ |
||||
|
||||
int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt) |
||||
{ |
||||
ulong cp, wp; |
||||
FPW data; |
||||
int count, i, l, rc, port_width; |
||||
|
||||
if (info->flash_id == FLASH_UNKNOWN) { |
||||
return 4; |
||||
} |
||||
/* get lower word aligned address */ |
||||
#ifdef FLASH_PORT_WIDTH16 |
||||
wp = (addr & ~1); |
||||
port_width = 2; |
||||
#else |
||||
wp = (addr & ~3); |
||||
port_width = 4; |
||||
#endif |
||||
|
||||
/*
|
||||
* handle unaligned start bytes |
||||
*/ |
||||
if ((l = addr - wp) != 0) { |
||||
data = 0; |
||||
for (i = 0, cp = wp; i < l; ++i, ++cp) { |
||||
data = (data << 8) | (*(uchar *) cp); |
||||
} |
||||
for (; i < port_width && cnt > 0; ++i) { |
||||
data = (data << 8) | *src++; |
||||
--cnt; |
||||
++cp; |
||||
} |
||||
for (; cnt == 0 && i < port_width; ++i, ++cp) { |
||||
data = (data << 8) | (*(uchar *) cp); |
||||
} |
||||
|
||||
if ((rc = write_data (info, wp, SWAP (data))) != 0) { |
||||
return (rc); |
||||
} |
||||
wp += port_width; |
||||
} |
||||
|
||||
/*
|
||||
* handle word aligned part |
||||
*/ |
||||
count = 0; |
||||
while (cnt >= port_width) { |
||||
data = 0; |
||||
for (i = 0; i < port_width; ++i) { |
||||
data = (data << 8) | *src++; |
||||
} |
||||
if ((rc = write_data (info, wp, SWAP (data))) != 0) { |
||||
return (rc); |
||||
} |
||||
wp += port_width; |
||||
cnt -= port_width; |
||||
if (count++ > 0x800) { |
||||
spin_wheel (); |
||||
count = 0; |
||||
} |
||||
} |
||||
|
||||
if (cnt == 0) { |
||||
return (0); |
||||
} |
||||
|
||||
/*
|
||||
* handle unaligned tail bytes |
||||
*/ |
||||
data = 0; |
||||
for (i = 0, cp = wp; i < port_width && cnt > 0; ++i, ++cp) { |
||||
data = (data << 8) | *src++; |
||||
--cnt; |
||||
} |
||||
for (; i < port_width; ++i, ++cp) { |
||||
data = (data << 8) | (*(uchar *) cp); |
||||
} |
||||
|
||||
return (write_data (info, wp, SWAP (data))); |
||||
} |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Write a word or halfword to Flash, returns: |
||||
* 0 - OK |
||||
* 1 - write timeout |
||||
* 2 - Flash not erased |
||||
*/ |
||||
static int write_data (flash_info_t * info, ulong dest, FPW data) |
||||
{ |
||||
FPWV *addr = (FPWV *) dest; |
||||
ulong status; |
||||
int flag; |
||||
|
||||
/* Check if Flash is (sufficiently) erased */ |
||||
if ((*addr & data) != data) { |
||||
printf ("not erased at %08lx (%x)\n", (ulong) addr, *addr); |
||||
return (2); |
||||
} |
||||
/* Disable interrupts which might cause a timeout here */ |
||||
flag = disable_interrupts (); |
||||
|
||||
*addr = (FPW) 0x00400040; /* write setup */ |
||||
*addr = data; |
||||
|
||||
/* arm simple, non interrupt dependent timer */ |
||||
reset_timer_masked (); |
||||
|
||||
/* wait while polling the status register */ |
||||
while (((status = *addr) & (FPW) 0x00800080) != (FPW) 0x00800080) { |
||||
|
||||
if (get_timer_masked () > CFG_FLASH_WRITE_TOUT) { |
||||
*addr = (FPW) 0x00FF00FF; /* restore read mode */ |
||||
return (1); |
||||
} |
||||
} |
||||
|
||||
*addr = (FPW) 0x00FF00FF; /* restore read mode */ |
||||
|
||||
return (0); |
||||
} |
||||
|
||||
void inline spin_wheel (void) |
||||
{ |
||||
static int p = 0; |
||||
static char w[] = "\\/-"; |
||||
|
||||
printf ("\010%c", w[p]); |
||||
(++p == 3) ? (p = 0) : 0; |
||||
} |
@ -0,0 +1,406 @@ |
||||
/* |
||||
* Board specific setup info |
||||
* |
||||
* (C) Copyright 2003 |
||||
* Texas Instruments, <www.ti.com> |
||||
* |
||||
* -- Some bits of code used from rrload's head_OMAP1510.s -- |
||||
* Copyright (C) 2002 RidgeRun, Inc. |
||||
* |
||||
* 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 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. |
||||
* |
||||
* 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 <config.h> |
||||
#include <version.h> |
||||
|
||||
#if defined(CONFIG_OMAP1510) |
||||
#include <./configs/omap1510.h> |
||||
#endif |
||||
|
||||
#define OMAP1510_CLKS ((1<<EN_XORPCK)|(1<<EN_PERCK)|(1<<EN_TIMCK)|(1<<EN_GPIOCK)) |
||||
|
||||
|
||||
_TEXT_BASE: |
||||
.word TEXT_BASE /* sdram load addr from config.mk */ |
||||
|
||||
.globl platformsetup
|
||||
platformsetup: |
||||
|
||||
/* |
||||
* Configure 1510 pins functions to match our board. |
||||
*/ |
||||
ldr r0, REG_PULL_DWN_CTRL_0 |
||||
ldr r1, VAL_PULL_DWN_CTRL_0 |
||||
str r1, [r0] |
||||
ldr r0, REG_PULL_DWN_CTRL_1 |
||||
ldr r1, VAL_PULL_DWN_CTRL_1 |
||||
str r1, [r0] |
||||
ldr r0, REG_PULL_DWN_CTRL_2 |
||||
ldr r1, VAL_PULL_DWN_CTRL_2 |
||||
str r1, [r0] |
||||
ldr r0, REG_PULL_DWN_CTRL_3 |
||||
ldr r1, VAL_PULL_DWN_CTRL_3 |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_4 |
||||
ldr r1, VAL_FUNC_MUX_CTRL_4 |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_5 |
||||
ldr r1, VAL_FUNC_MUX_CTRL_5 |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_6 |
||||
ldr r1, VAL_FUNC_MUX_CTRL_6 |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_7 |
||||
ldr r1, VAL_FUNC_MUX_CTRL_7 |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_8 |
||||
ldr r1, VAL_FUNC_MUX_CTRL_8 |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_9 |
||||
ldr r1, VAL_FUNC_MUX_CTRL_9 |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_A |
||||
ldr r1, VAL_FUNC_MUX_CTRL_A |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_B |
||||
ldr r1, VAL_FUNC_MUX_CTRL_B |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_C |
||||
ldr r1, VAL_FUNC_MUX_CTRL_C |
||||
str r1, [r0] |
||||
ldr r0, REG_FUNC_MUX_CTRL_D |
||||
ldr r1, VAL_FUNC_MUX_CTRL_D |
||||
str r1, [r0] |
||||
ldr r0, REG_VOLTAGE_CTRL_0 |
||||
ldr r1, VAL_VOLTAGE_CTRL_0 |
||||
str r1, [r0] |
||||
ldr r0, REG_TEST_DBG_CTRL_0 |
||||
ldr r1, VAL_TEST_DBG_CTRL_0 |
||||
str r1, [r0] |
||||
ldr r0, REG_MOD_CONF_CTRL_0 |
||||
ldr r1, VAL_MOD_CONF_CTRL_0 |
||||
str r1, [r0] |
||||
|
||||
/* Move to 1510 mode */ |
||||
ldr r0, REG_COMP_MODE_CTRL_0 |
||||
ldr r1, VAL_COMP_MODE_CTRL_0 |
||||
str r1, [r0] |
||||
|
||||
/* Set up Traffic Ctlr*/ |
||||
ldr r0, REG_TC_IMIF_PRIO |
||||
mov r1, #0x0 |
||||
str r1, [r0] |
||||
ldr r0, REG_TC_EMIFS_PRIO |
||||
str r1, [r0] |
||||
ldr r0, REG_TC_EMIFF_PRIO |
||||
str r1, [r0] |
||||
|
||||
ldr r0, REG_TC_EMIFS_CONFIG |
||||
ldr r1, [r0] |
||||
bic r1, r1, #0x08 /* clear the global power-down enable PDE bit */ |
||||
bic r1, r1, #0x01 /* write protect flash by clearing the WP bit */ |
||||
str r1, [r0] /* EMIFS GlB Configuration. (value 0x12 most likely) */ |
||||
|
||||
ldr r0, _GPIO_PIN_CONTROL_REG |
||||
ldrh r1,[r0] |
||||
orr r1, r1, #0x0001 /* M_PCM_SYNC */ |
||||
orr r1, r1, #0x4000 /* IPC_ACTIVE */ |
||||
orr r1, r1, #0x0002 /* A_IRDA_OFF */ |
||||
orr r1, r1, #0x0800 /* A_SWITCH */ |
||||
orr r1, r1, #0x8000 /* A_USB_ON */ |
||||
strh r1,[r0] |
||||
|
||||
ldr r0, _GPIO_DIR_CONTROL_REG |
||||
ldrh r1,[r0] |
||||
bic r1, r1, #0x0001 /* M_PCM_SYNC */ |
||||
bic r1, r1, #0x4000 /* IPC_ACTIVE */ |
||||
bic r1, r1, #0x0002 /* A_IRDA_OFF */ |
||||
bic r1, r1, #0x0800 /* A_SWITCH */ |
||||
bic r1, r1, #0x8000 /* A_USB_ON */ |
||||
strh r1,[r0] |
||||
|
||||
ldr r0, _GPIO_DATA_OUTPUT_REG |
||||
ldrh r1,[r0] |
||||
bic r1, r1, #0x0001 /* M_PCM_SYNC */ |
||||
orr r1, r1, #0x4000 /* IPC_ACTIVE */ |
||||
orr r1, r1, #0x0002 /* A_IRDA_OFF */ |
||||
bic r1, r1, #0x0800 /* A_SWITCH */ |
||||
bic r1, r1, #0x8000 /* A_USB_ON */ |
||||
strh r1,[r0] |
||||
|
||||
/* Setup some clock domains */ |
||||
ldr r1, =OMAP1510_CLKS |
||||
ldr r0, REG_ARM_IDLECT2 |
||||
strh r1, [r0] /* CLKM, Clock domain control. */ |
||||
|
||||
mov r1, #0x01 /* PER_EN bit */ |
||||
ldr r0, REG_ARM_RSTCT2 |
||||
strh r1, [r0] /* CLKM; Peripheral reset. */
|
||||
|
||||
/* Set CLKM to Sync-Scalable */ |
||||
/* I supposidly need to enable the dsp clock before switching */ |
||||
mov r1, #0x1000 |
||||
ldr r0, REG_ARM_SYSST |
||||
strh r1, [r0] |
||||
mov r0, #0x400 |
||||
1: |
||||
subs r0, r0, #0x1 /* wait for any bubbles to finish */ |
||||
bne 1b |
||||
|
||||
ldr r1, VAL_ARM_CKCTL /* use 12Mhz ref, PER must be <= 50Mhz so /2 */ |
||||
ldr r0, REG_ARM_CKCTL |
||||
strh r1, [r0] |
||||
|
||||
/* setup DPLL 1 */ |
||||
ldr r1, VAL_DPLL1_CTL |
||||
ldr r0, REG_DPLL1_CTL |
||||
strh r1, [r0] |
||||
ands r1, r1, #0x10 /* Check if PLL is enabled. */ |
||||
beq lock_end /* Do not look for lock if BYPASS selected */ |
||||
2: |
||||
ldrh r1, [r0] |
||||
ands r1, r1, #0x01 /* Check the LOCK bit. */ |
||||
beq 2b /* ...loop until bit goes hi. */ |
||||
lock_end: |
||||
|
||||
/* Set memory timings corresponding to the new clock speed */ |
||||
|
||||
/* Check execution location to determine current execution location |
||||
* and branch to appropriate initialization code. |
||||
*/ |
||||
mov r0, #0x10000000 /* Load physical SDRAM base. */ |
||||
mov r1, pc /* Get current execution location. */ |
||||
cmp r1, r0 /* Compare. */ |
||||
bge skip_sdram /* Skip over EMIF-fast initialization if running from SDRAM. */ |
||||
|
||||
/* |
||||
* Delay for SDRAM initialization. |
||||
*/ |
||||
mov r3, #0x1800 /* value should be checked */ |
||||
3: |
||||
subs r3, r3, #0x1 /* Decrement count */ |
||||
bne 3b |
||||
|
||||
/* |
||||
* Set SDRAM control values. Disable refresh before MRS command. |
||||
*/ |
||||
ldr r0, VAL_TC_EMIFF_SDRAM_CONFIG /* get good value */ |
||||
bic r3, r0, #0xC /* (BIT3|BIT2) ulConfig with auto-refresh disabled. */ |
||||
orr r3, r3, #0x8000000 /* (BIT27) Disable CLK when Power down or Self-Refresh */ |
||||
orr r3, r3, #0x4000000 /* BIT26 Power Down Enable */ |
||||
ldr r2, REG_TC_EMIFF_SDRAM_CONFIG /* Point to configuration register. */ |
||||
str r3, [r2] /* Store the passed value with AR disabled. */ |
||||
|
||||
ldr r1, VAL_TC_EMIFF_MRS /* get MRS value */ |
||||
ldr r2, REG_TC_EMIFF_MRS /* Point to MRS register. */ |
||||
str r1, [r2] /* Store the passed value.*/ |
||||
|
||||
ldr r2, REG_TC_EMIFF_SDRAM_CONFIG /* Point to configuration register. */ |
||||
str r0, [r2] /* Store the passed value. */ |
||||
|
||||
/* |
||||
* Delay for SDRAM initialization. |
||||
*/ |
||||
mov r3, #0x1800 |
||||
4: |
||||
subs r3, r3, #1 /* Decrement count. */ |
||||
bne 4b |
||||
|
||||
skip_sdram: |
||||
|
||||
/* slow interface */ |
||||
ldr r1, VAL_TC_EMIFS_CS0_CONFIG |
||||
ldr r0, REG_TC_EMIFS_CS0_CONFIG |
||||
str r1, [r0] /* Chip Select 0 */ |
||||
ldr r1, VAL_TC_EMIFS_CS1_CONFIG |
||||
ldr r0, REG_TC_EMIFS_CS1_CONFIG |
||||
str r1, [r0] /* Chip Select 1 */ |
||||
ldr r1, VAL_TC_EMIFS_CS2_CONFIG |
||||
ldr r0, REG_TC_EMIFS_CS2_CONFIG |
||||
str r1, [r0] /* Chip Select 2 */ |
||||
ldr r1, VAL_TC_EMIFS_CS3_CONFIG |
||||
ldr r0, REG_TC_EMIFS_CS3_CONFIG |
||||
str r1, [r0] /* Chip Select 3 */ |
||||
|
||||
/* back to arch calling code */ |
||||
mov pc, lr |
||||
|
||||
/* the literal pools origin */ |
||||
.ltorg |
||||
|
||||
/* OMAP configuration registers */ |
||||
REG_FUNC_MUX_CTRL_0: /* 32 bits */ |
||||
.word 0xfffe1000
|
||||
REG_FUNC_MUX_CTRL_1: /* 32 bits */ |
||||
.word 0xfffe1004
|
||||
REG_FUNC_MUX_CTRL_2: /* 32 bits */ |
||||
.word 0xfffe1008
|
||||
REG_COMP_MODE_CTRL_0: /* 32 bits */ |
||||
.word 0xfffe100c
|
||||
REG_FUNC_MUX_CTRL_3: /* 32 bits */ |
||||
.word 0xfffe1010
|
||||
REG_FUNC_MUX_CTRL_4: /* 32 bits */ |
||||
.word 0xfffe1014
|
||||
REG_FUNC_MUX_CTRL_5: /* 32 bits */ |
||||
.word 0xfffe1018
|
||||
REG_FUNC_MUX_CTRL_6: /* 32 bits */ |
||||
.word 0xfffe101c
|
||||
REG_FUNC_MUX_CTRL_7: /* 32 bits */ |
||||
.word 0xfffe1020
|
||||
REG_FUNC_MUX_CTRL_8: /* 32 bits */ |
||||
.word 0xfffe1024
|
||||
REG_FUNC_MUX_CTRL_9: /* 32 bits */ |
||||
.word 0xfffe1028
|
||||
REG_FUNC_MUX_CTRL_A: /* 32 bits */ |
||||
.word 0xfffe102C
|
||||
REG_FUNC_MUX_CTRL_B: /* 32 bits */ |
||||
.word 0xfffe1030
|
||||
REG_FUNC_MUX_CTRL_C: /* 32 bits */ |
||||
.word 0xfffe1034
|
||||
REG_FUNC_MUX_CTRL_D: /* 32 bits */ |
||||
.word 0xfffe1038
|
||||
REG_PULL_DWN_CTRL_0: /* 32 bits */ |
||||
.word 0xfffe1040
|
||||
REG_PULL_DWN_CTRL_1: /* 32 bits */ |
||||
.word 0xfffe1044
|
||||
REG_PULL_DWN_CTRL_2: /* 32 bits */ |
||||
.word 0xfffe1048
|
||||
REG_PULL_DWN_CTRL_3: /* 32 bits */ |
||||
.word 0xfffe104c
|
||||
REG_VOLTAGE_CTRL_0: /* 32 bits */ |
||||
.word 0xfffe1060
|
||||
REG_TEST_DBG_CTRL_0: /* 32 bits */ |
||||
.word 0xfffe1070
|
||||
REG_MOD_CONF_CTRL_0: /* 32 bits */ |
||||
.word 0xfffe1080
|
||||
REG_TC_IMIF_PRIO: /* 32 bits */ |
||||
.word 0xfffecc00
|
||||
REG_TC_EMIFS_PRIO: /* 32 bits */ |
||||
.word 0xfffecc04
|
||||
REG_TC_EMIFF_PRIO: /* 32 bits */ |
||||
.word 0xfffecc08
|
||||
REG_TC_EMIFS_CONFIG: /* 32 bits */ |
||||
.word 0xfffecc0c
|
||||
REG_TC_EMIFS_CS0_CONFIG: /* 32 bits */ |
||||
.word 0xfffecc10
|
||||
REG_TC_EMIFS_CS1_CONFIG: /* 32 bits */ |
||||
.word 0xfffecc14
|
||||
REG_TC_EMIFS_CS2_CONFIG: /* 32 bits */ |
||||
.word 0xfffecc18
|
||||
REG_TC_EMIFS_CS3_CONFIG: /* 32 bits */ |
||||
.word 0xfffecc1c
|
||||
REG_TC_EMIFF_SDRAM_CONFIG: /* 32 bits */ |
||||
.word 0xfffecc20
|
||||
REG_TC_EMIFF_MRS: /* 32 bits */ |
||||
.word 0xfffecc24
|
||||
/* MPU clock/reset/power mode control registers */ |
||||
REG_ARM_CKCTL: /* 16 bits */ |
||||
.word 0xfffece00
|
||||
REG_ARM_IDLECT2: /* 16 bits */ |
||||
.word 0xfffece08
|
||||
REG_ARM_RSTCT2: /* 16 bits */ |
||||
.word 0xfffece14
|
||||
REG_ARM_SYSST: /* 16 bits */ |
||||
.word 0xfffece18
|
||||
/* DPLL control registers */ |
||||
REG_DPLL1_CTL: /* 16 bits */ |
||||
.word 0xfffecf00
|
||||
/* identification code register */ |
||||
REG_IDCODE: /* 32 bits */ |
||||
.word 0xfffed404
|
||||
|
||||
/* SX1 specific */ |
||||
_GPIO_PIN_CONTROL_REG: |
||||
.word GPIO_PIN_CONTROL_REG
|
||||
_GPIO_DIR_CONTROL_REG: |
||||
.word GPIO_DIR_CONTROL_REG
|
||||
_GPIO_DATA_OUTPUT_REG: |
||||
.word GPIO_DATA_OUTPUT_REG
|
||||
|
||||
VAL_COMP_MODE_CTRL_0: |
||||
.word 0x0000eaef
|
||||
VAL_FUNC_MUX_CTRL_4: |
||||
.word 0x00000000
|
||||
VAL_FUNC_MUX_CTRL_5: |
||||
.word 0x00000000
|
||||
VAL_FUNC_MUX_CTRL_6: |
||||
.word 0x00000001
|
||||
VAL_FUNC_MUX_CTRL_7: |
||||
.word 0x00001000
|
||||
VAL_FUNC_MUX_CTRL_8: |
||||
.word 0x00001240 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
VAL_FUNC_MUX_CTRL_9: |
||||
.word 0x00201008
|
||||
VAL_FUNC_MUX_CTRL_A: |
||||
.word 0x00001000
|
||||
VAL_FUNC_MUX_CTRL_B: |
||||
.word 0x00000000
|
||||
VAL_FUNC_MUX_CTRL_C: |
||||
.word 0x09008001 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
VAL_FUNC_MUX_CTRL_D: |
||||
.word 0x00000000
|
||||
VAL_PULL_DWN_CTRL_0: |
||||
.word 0xfffeffff
|
||||
VAL_PULL_DWN_CTRL_1: |
||||
.word 0xd1ffffec
|
||||
VAL_PULL_DWN_CTRL_2: |
||||
.word 0xffa80c5b
|
||||
VAL_PULL_DWN_CTRL_3: |
||||
.word 0xffffc0fe
|
||||
VAL_VOLTAGE_CTRL_0: |
||||
.word 0x00000007
|
||||
VAL_TEST_DBG_CTRL_0: |
||||
/* The OMAP5910 TRM says this register must be 0, but HelenConfRegs |
||||
* says to write a 7. Don't know what the right thing is to do, so |
||||
* I'm leaving it at 7 since that's what was already here. |
||||
*/ |
||||
.word 0x00000007
|
||||
VAL_MOD_CONF_CTRL_0: |
||||
.word 0x0da20000 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
|
||||
VAL_ARM_CKCTL: |
||||
.word 0x010D
|
||||
|
||||
VAL_DPLL1_CTL: |
||||
.word 0x3A33 /*[Hertle] Value of Symbian Image*/ |
||||
|
||||
VAL_TC_EMIFS_CS1_CONFIG_PRELIM: |
||||
.word 0x00001149
|
||||
|
||||
VAL_TC_EMIFS_CS2_CONFIG_PRELIM: |
||||
.word 0x00004158
|
||||
|
||||
VAL_TC_EMIFS_CS0_CONFIG: |
||||
.word 0x00213090 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
|
||||
VAL_TC_EMIFS_CS1_CONFIG: |
||||
.word 0x00215070 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
|
||||
VAL_TC_EMIFS_CS2_CONFIG: |
||||
.word 0x00001139 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
|
||||
VAL_TC_EMIFS_CS3_CONFIG: |
||||
.word 0x00001139 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
|
||||
VAL_TC_EMIFF_SDRAM_CONFIG: |
||||
.word 0x0105f0b4 /*[Knoller] Value of Symbian Image Wing B2*/ |
||||
|
||||
|
||||
VAL_TC_EMIFF_MRS: |
||||
.word 0x00000027 /*[Knoller] Value of Symbian Image Wing B2*/ |
@ -0,0 +1,125 @@ |
||||
/*
|
||||
* (C) Copyright 2004 |
||||
* Wolfgang Denk, DENX Software Engineering, <wd@denx.de> |
||||
* |
||||
* (C) Copyright 2003 |
||||
* Texas Instruments, <www.ti.com> |
||||
* Kshitij Gupta <Kshitij@ti.com> |
||||
* |
||||
* 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 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. |
||||
* |
||||
* 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 <common.h> |
||||
|
||||
static void flash__init (void); |
||||
static void ether__init (void); |
||||
|
||||
static inline void delay (unsigned long loops) |
||||
{ |
||||
__asm__ volatile ("1:\n" |
||||
"subs %0, %1, #1\n" |
||||
"bne 1b":"=r" (loops):"0" (loops)); |
||||
} |
||||
|
||||
/*
|
||||
* Miscellaneous platform dependent initialisations |
||||
*/ |
||||
|
||||
int board_init (void) |
||||
{ |
||||
DECLARE_GLOBAL_DATA_PTR; |
||||
|
||||
/* arch number of SX1 Board */ |
||||
gd->bd->bi_arch_number = 241; |
||||
|
||||
/* adress of boot parameters */ |
||||
gd->bd->bi_boot_params = 0x10000100; |
||||
|
||||
/* kk - this speeds up your boot a quite a bit. However to make it
|
||||
* work, you need make sure your kernel startup flush bug is fixed. |
||||
* ... rkw ... |
||||
*/ |
||||
icache_enable (); |
||||
|
||||
flash__init (); |
||||
ether__init (); |
||||
return 0; |
||||
} |
||||
|
||||
|
||||
int misc_init_r (void) |
||||
{ |
||||
/* volatile ushort *gdir = (ushort *) (GPIO_DIR_CONTROL_REG); */ |
||||
/* volatile ushort *mdir = (ushort *) (MPUIO_DIR_CONTROL_REG); */ |
||||
|
||||
/* setup gpio direction to match board (no floats!) */ |
||||
/**gdir = 0xCFF9; */ |
||||
/**mdir = 0x103F; */ |
||||
|
||||
return (0); |
||||
} |
||||
|
||||
/******************************
|
||||
Routine: |
||||
Description: |
||||
******************************/ |
||||
static void flash__init (void) |
||||
{ |
||||
#define CS0_CHIP_SELECT_REG 0xfffecc10 |
||||
#define CS3_CHIP_SELECT_REG 0xfffecc1c |
||||
#define EMIFS_GlB_Config_REG 0xfffecc0c |
||||
|
||||
unsigned int regval; |
||||
|
||||
regval = *((volatile unsigned int *) EMIFS_GlB_Config_REG); |
||||
regval = regval | 0x0001; /* Turn off write protection for flash devices. */ |
||||
if (regval & 0x0002) { |
||||
regval = regval & 0xfffd; /* Swap CS0 and CS3 so that flash is visible at 0x0 and eeprom at 0x0c000000. */ |
||||
/* If, instead, you want to reference flash at 0x0c000000, then it seemed the following were necessary. */ |
||||
/* *((volatile unsigned int *)CS0_CHIP_SELECT_REG) = 0x202090; / * Overrides head.S setting of 0x212090 */ |
||||
/* *((volatile unsigned int *)CS3_CHIP_SELECT_REG) = 0x202090; / * Let's flash chips be fully functional. */ |
||||
} |
||||
*((volatile unsigned int *) EMIFS_GlB_Config_REG) = regval; |
||||
} |
||||
|
||||
|
||||
/******************************
|
||||
Routine: |
||||
Description: |
||||
******************************/ |
||||
static void ether__init (void) |
||||
{ |
||||
#define ETH_CONTROL_REG 0x0800000b |
||||
/* take the Ethernet controller out of reset and wait
|
||||
* for the EEPROM load to complete. |
||||
*/ |
||||
*((volatile unsigned char *) ETH_CONTROL_REG) &= ~0x01; |
||||
udelay (3); |
||||
} |
||||
|
||||
|
||||
int dram_init (void) |
||||
{ |
||||
DECLARE_GLOBAL_DATA_PTR; |
||||
|
||||
gd->bd->bi_dram[0].start = PHYS_SDRAM_1; |
||||
gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE; |
||||
|
||||
return 0; |
||||
} |
@ -0,0 +1,56 @@ |
||||
/* |
||||
* (C) Copyright 2004 |
||||
* Wolfgang Denk, DENX Software Engineering, <wg@denx.de> |
||||
* |
||||
* 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 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. |
||||
* |
||||
* 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 |
||||
*/ |
||||
|
||||
OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm") |
||||
/*OUTPUT_FORMAT("elf32-arm", "elf32-arm", "elf32-arm")*/ |
||||
OUTPUT_ARCH(arm) |
||||
ENTRY(_start) |
||||
SECTIONS |
||||
{ |
||||
. = 0x00000000; |
||||
|
||||
. = ALIGN(4); |
||||
.text : |
||||
{ |
||||
cpu/arm925t/start.o (.text) |
||||
*(.text) |
||||
} |
||||
|
||||
. = ALIGN(4); |
||||
.rodata : { *(.rodata) } |
||||
|
||||
. = ALIGN(4); |
||||
.data : { *(.data) } |
||||
|
||||
. = ALIGN(4); |
||||
.got : { *(.got) } |
||||
|
||||
__u_boot_cmd_start = .; |
||||
.u_boot_cmd : { *(.u_boot_cmd) } |
||||
__u_boot_cmd_end = .; |
||||
|
||||
. = ALIGN(4); |
||||
__bss_start = .; |
||||
.bss : { *(.bss) } |
||||
_end = .; |
||||
} |
@ -0,0 +1,110 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* 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. |
||||
* |
||||
* 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 <common.h> |
||||
#include <malloc.h> |
||||
|
||||
#include <circbuf.h> |
||||
|
||||
|
||||
int buf_init (circbuf_t * buf, unsigned int size) |
||||
{ |
||||
assert (buf != NULL); |
||||
|
||||
buf->size = 0; |
||||
buf->totalsize = size; |
||||
buf->data = (char *) malloc (sizeof (char) * size); |
||||
assert (buf->data != NULL); |
||||
|
||||
buf->top = buf->data; |
||||
buf->tail = buf->data; |
||||
buf->end = &(buf->data[size]); |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
int buf_free (circbuf_t * buf) |
||||
{ |
||||
assert (buf != NULL); |
||||
assert (buf->data != NULL); |
||||
|
||||
free (buf->data); |
||||
memset (buf, 0, sizeof (circbuf_t)); |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
int buf_pop (circbuf_t * buf, char *dest, unsigned int len) |
||||
{ |
||||
unsigned int i; |
||||
char *p = buf->top; |
||||
|
||||
assert (buf != NULL); |
||||
assert (dest != NULL); |
||||
|
||||
/* Cap to number of bytes in buffer */ |
||||
if (len > buf->size) |
||||
len = buf->size; |
||||
|
||||
for (i = 0; i < len; i++) { |
||||
dest[i] = *p++; |
||||
/* Bounds check. */ |
||||
if (p == buf->end) { |
||||
p = buf->data; |
||||
} |
||||
} |
||||
|
||||
/* Update 'top' pointer */ |
||||
buf->top = p; |
||||
buf->size -= len; |
||||
|
||||
return len; |
||||
} |
||||
|
||||
int buf_push (circbuf_t * buf, const char *src, unsigned int len) |
||||
{ |
||||
/* NOTE: this function allows push to overwrite old data. */ |
||||
unsigned int i; |
||||
char *p = buf->tail; |
||||
|
||||
assert (buf != NULL); |
||||
assert (src != NULL); |
||||
|
||||
for (i = 0; i < len; i++) { |
||||
*p++ = src[i]; |
||||
if (p == buf->end) { |
||||
p = buf->data; |
||||
} |
||||
/* Make sure pushing too much data just replaces old data */ |
||||
if (buf->size < buf->totalsize) { |
||||
buf->size++; |
||||
} else { |
||||
buf->top++; |
||||
if (buf->top == buf->end) { |
||||
buf->top = buf->data; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* Update 'tail' pointer */ |
||||
buf->tail = p; |
||||
|
||||
return len; |
||||
} |
@ -0,0 +1,281 @@ |
||||
/*
|
||||
* Basic I2C functions |
||||
* |
||||
* Copyright (c) 2003 Texas Instruments |
||||
* |
||||
* This package is free software; you can redistribute it and/or |
||||
* modify it under the terms of the license found in the file |
||||
* named COPYING that should have accompanied this file. |
||||
* |
||||
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR |
||||
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED |
||||
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
||||
* |
||||
* Author: Jian Zhang jzhang@ti.com, Texas Instruments |
||||
* |
||||
* Copyright (c) 2003 Wolfgang Denk, wd@denx.de |
||||
* Rewritten to fit into the current U-Boot framework |
||||
* |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
|
||||
#ifdef CONFIG_DRIVER_OMAP1510_I2C |
||||
|
||||
static void wait_for_bb (void); |
||||
static u16 wait_for_pin (void); |
||||
|
||||
void i2c_init (int speed, int slaveadd) |
||||
{ |
||||
u16 scl; |
||||
|
||||
if (inw (I2C_CON) & I2C_CON_EN) { |
||||
outw (0, I2C_CON); |
||||
udelay (5000); |
||||
} |
||||
|
||||
/* 12Mhz I2C module clock */ |
||||
outw (0, I2C_PSC); |
||||
outw (I2C_CON_EN, I2C_CON); |
||||
outw (0, I2C_SYSTEST); |
||||
/* have to enable intrrupts or OMAP i2c module doesn't work */ |
||||
outw (I2C_IE_XRDY_IE | I2C_IE_RRDY_IE | I2C_IE_ARDY_IE | |
||||
I2C_IE_NACK_IE | I2C_IE_AL_IE, I2C_IE); |
||||
scl = (12000000 / 2) / speed - 6; |
||||
outw (scl, I2C_SCLL); |
||||
outw (scl, I2C_SCLH); |
||||
/* own address */ |
||||
outw (slaveadd, I2C_OA); |
||||
outw (0, I2C_CNT); |
||||
udelay (1000); |
||||
} |
||||
|
||||
static int i2c_read_byte (u8 devaddr, u8 regoffset, u8 * value) |
||||
{ |
||||
int i2c_error = 0; |
||||
u16 status; |
||||
|
||||
/* wait until bus not busy */ |
||||
wait_for_bb (); |
||||
|
||||
/* one byte only */ |
||||
outw (1, I2C_CNT); |
||||
/* set slave address */ |
||||
outw (devaddr, I2C_SA); |
||||
/* no stop bit needed here */ |
||||
outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX, I2C_CON); |
||||
|
||||
status = wait_for_pin (); |
||||
|
||||
if (status & I2C_STAT_XRDY) { |
||||
/* Important: have to use byte access */ |
||||
*(volatile u8 *) (I2C_DATA) = regoffset; |
||||
udelay (20000); |
||||
if (inw (I2C_STAT) & I2C_STAT_NACK) { |
||||
i2c_error = 1; |
||||
} |
||||
} else { |
||||
i2c_error = 1; |
||||
} |
||||
|
||||
if (!i2c_error) { |
||||
/* free bus, otherwise we can't use a combined transction */ |
||||
outw (0, I2C_CON); |
||||
while (inw (I2C_STAT) || (inw (I2C_CON) & I2C_CON_MST)) { |
||||
udelay (10000); |
||||
/* Have to clear pending interrupt to clear I2C_STAT */ |
||||
inw (I2C_IV); |
||||
} |
||||
|
||||
wait_for_bb (); |
||||
/* set slave address */ |
||||
outw (devaddr, I2C_SA); |
||||
/* read one byte from slave */ |
||||
outw (1, I2C_CNT); |
||||
/* need stop bit here */ |
||||
outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP, |
||||
I2C_CON); |
||||
|
||||
status = wait_for_pin (); |
||||
if (status & I2C_STAT_RRDY) { |
||||
*value = inw (I2C_DATA); |
||||
udelay (20000); |
||||
} else { |
||||
i2c_error = 1; |
||||
} |
||||
|
||||
if (!i2c_error) { |
||||
outw (I2C_CON_EN, I2C_CON); |
||||
while (inw (I2C_STAT) |
||||
|| (inw (I2C_CON) & I2C_CON_MST)) { |
||||
udelay (10000); |
||||
inw (I2C_IV); |
||||
} |
||||
} |
||||
} |
||||
|
||||
return i2c_error; |
||||
} |
||||
|
||||
static int i2c_write_byte (u8 devaddr, u8 regoffset, u8 value) |
||||
{ |
||||
int i2c_error = 0; |
||||
u16 status; |
||||
|
||||
/* wait until bus not busy */ |
||||
wait_for_bb (); |
||||
|
||||
/* two bytes */ |
||||
outw (2, I2C_CNT); |
||||
/* set slave address */ |
||||
outw (devaddr, I2C_SA); |
||||
/* stop bit needed here */ |
||||
outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX | |
||||
I2C_CON_STP, I2C_CON); |
||||
|
||||
/* wait until state change */ |
||||
status = wait_for_pin (); |
||||
|
||||
if (status & I2C_STAT_XRDY) { |
||||
/* send out two bytes */ |
||||
outw ((value << 8) + regoffset, I2C_DATA); |
||||
/* must have enough delay to allow BB bit to go low */ |
||||
udelay (30000); |
||||
if (inw (I2C_STAT) & I2C_STAT_NACK) { |
||||
i2c_error = 1; |
||||
} |
||||
} else { |
||||
i2c_error = 1; |
||||
} |
||||
|
||||
if (!i2c_error) { |
||||
outw (I2C_CON_EN, I2C_CON); |
||||
while (inw (I2C_STAT) || (inw (I2C_CON) & I2C_CON_MST)) { |
||||
udelay (1000); |
||||
/* have to read to clear intrrupt */ |
||||
inw (I2C_IV); |
||||
} |
||||
} |
||||
|
||||
return i2c_error; |
||||
} |
||||
|
||||
int i2c_probe (uchar chip) |
||||
{ |
||||
int res = 1; |
||||
|
||||
if (chip == inw (I2C_OA)) { |
||||
return res; |
||||
} |
||||
|
||||
/* wait until bus not busy */ |
||||
wait_for_bb (); |
||||
|
||||
/* try to read one byte */ |
||||
outw (1, I2C_CNT); |
||||
/* set slave address */ |
||||
outw (chip, I2C_SA); |
||||
/* stop bit needed here */ |
||||
outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP, I2C_CON); |
||||
/* enough delay for the NACK bit set */ |
||||
udelay (2000); |
||||
if (!(inw (I2C_STAT) & I2C_STAT_NACK)) { |
||||
res = 0; |
||||
} else { |
||||
outw (inw (I2C_CON) | I2C_CON_STP, I2C_CON); |
||||
udelay (20); |
||||
wait_for_bb (); |
||||
} |
||||
|
||||
return res; |
||||
} |
||||
|
||||
int i2c_read (uchar chip, uint addr, int alen, uchar * buffer, int len) |
||||
{ |
||||
int i; |
||||
|
||||
if (alen > 1) { |
||||
printf ("I2C read: addr len %d not supported\n", alen); |
||||
return 1; |
||||
} |
||||
|
||||
if (addr + len > 256) { |
||||
printf ("I2C read: address out of range\n"); |
||||
return 1; |
||||
} |
||||
|
||||
for (i = 0; i < len; i++) { |
||||
if (i2c_read_byte (chip, addr + i, &buffer[i])) { |
||||
printf ("I2C read: I/O error\n"); |
||||
i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE); |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int i2c_write (uchar chip, uint addr, int alen, uchar * buffer, int len) |
||||
{ |
||||
int i; |
||||
|
||||
if (alen > 1) { |
||||
printf ("I2C read: addr len %d not supported\n", alen); |
||||
return 1; |
||||
} |
||||
|
||||
if (addr + len > 256) { |
||||
printf ("I2C read: address out of range\n"); |
||||
return 1; |
||||
} |
||||
|
||||
for (i = 0; i < len; i++) { |
||||
if (i2c_write_byte (chip, addr + i, buffer[i])) { |
||||
printf ("I2C read: I/O error\n"); |
||||
i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE); |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void wait_for_bb (void) |
||||
{ |
||||
int timeout = 10; |
||||
|
||||
while ((inw (I2C_STAT) & I2C_STAT_BB) && timeout--) { |
||||
inw (I2C_IV); |
||||
udelay (1000); |
||||
} |
||||
|
||||
if (timeout <= 0) { |
||||
printf ("timed out in wait_for_bb: I2C_STAT=%x\n", |
||||
inw (I2C_STAT)); |
||||
} |
||||
} |
||||
|
||||
static u16 wait_for_pin (void) |
||||
{ |
||||
u16 status, iv; |
||||
int timeout = 10; |
||||
|
||||
do { |
||||
udelay (1000); |
||||
status = inw (I2C_STAT); |
||||
iv = inw (I2C_IV); |
||||
} while (!iv && |
||||
!(status & |
||||
(I2C_STAT_ROVR | I2C_STAT_XUDF | I2C_STAT_XRDY | |
||||
I2C_STAT_RRDY | I2C_STAT_ARDY | I2C_STAT_NACK | |
||||
I2C_STAT_AL)) && timeout--); |
||||
|
||||
if (timeout <= 0) { |
||||
printf ("timed out in wait_for_pin: I2C_STAT=%x\n", |
||||
inw (I2C_STAT)); |
||||
} |
||||
|
||||
return status; |
||||
} |
||||
|
||||
#endif /* CONFIG_DRIVER_OMAP1510_I2C */ |
@ -0,0 +1,684 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* Based on |
||||
* linux/drivers/usbd/usbd.c.c - USB Device Core Layer |
||||
* |
||||
* Copyright (c) 2000, 2001, 2002 Lineo |
||||
* Copyright (c) 2001 Hewlett Packard |
||||
* |
||||
* By: |
||||
* Stuart Lynne <sl@lineo.com>, |
||||
* Tom Rushworth <tbr@lineo.com>, |
||||
* Bruce Balden <balden@lineo.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. |
||||
* |
||||
* 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
||||
* |
||||
*/ |
||||
|
||||
#include <malloc.h> |
||||
#include "usbdcore.h" |
||||
|
||||
#define MAX_INTERFACES 2 |
||||
|
||||
|
||||
int maxstrings = 20; |
||||
|
||||
/* Global variables ************************************************************************** */ |
||||
|
||||
struct usb_string_descriptor **usb_strings; |
||||
|
||||
int usb_devices; |
||||
|
||||
extern struct usb_function_driver ep0_driver; |
||||
|
||||
int registered_functions; |
||||
int registered_devices; |
||||
|
||||
char *usbd_device_events[] = { |
||||
"DEVICE_UNKNOWN", |
||||
"DEVICE_INIT", |
||||
"DEVICE_CREATE", |
||||
"DEVICE_HUB_CONFIGURED", |
||||
"DEVICE_RESET", |
||||
"DEVICE_ADDRESS_ASSIGNED", |
||||
"DEVICE_CONFIGURED", |
||||
"DEVICE_SET_INTERFACE", |
||||
"DEVICE_SET_FEATURE", |
||||
"DEVICE_CLEAR_FEATURE", |
||||
"DEVICE_DE_CONFIGURED", |
||||
"DEVICE_BUS_INACTIVE", |
||||
"DEVICE_BUS_ACTIVITY", |
||||
"DEVICE_POWER_INTERRUPTION", |
||||
"DEVICE_HUB_RESET", |
||||
"DEVICE_DESTROY", |
||||
"DEVICE_FUNCTION_PRIVATE", |
||||
}; |
||||
|
||||
char *usbd_device_states[] = { |
||||
"STATE_INIT", |
||||
"STATE_CREATED", |
||||
"STATE_ATTACHED", |
||||
"STATE_POWERED", |
||||
"STATE_DEFAULT", |
||||
"STATE_ADDRESSED", |
||||
"STATE_CONFIGURED", |
||||
"STATE_UNKNOWN", |
||||
}; |
||||
|
||||
char *usbd_device_requests[] = { |
||||
"GET STATUS", /* 0 */ |
||||
"CLEAR FEATURE", /* 1 */ |
||||
"RESERVED", /* 2 */ |
||||
"SET FEATURE", /* 3 */ |
||||
"RESERVED", /* 4 */ |
||||
"SET ADDRESS", /* 5 */ |
||||
"GET DESCRIPTOR", /* 6 */ |
||||
"SET DESCRIPTOR", /* 7 */ |
||||
"GET CONFIGURATION", /* 8 */ |
||||
"SET CONFIGURATION", /* 9 */ |
||||
"GET INTERFACE", /* 10 */ |
||||
"SET INTERFACE", /* 11 */ |
||||
"SYNC FRAME", /* 12 */ |
||||
}; |
||||
|
||||
char *usbd_device_descriptors[] = { |
||||
"UNKNOWN", /* 0 */ |
||||
"DEVICE", /* 1 */ |
||||
"CONFIG", /* 2 */ |
||||
"STRING", /* 3 */ |
||||
"INTERFACE", /* 4 */ |
||||
"ENDPOINT", /* 5 */ |
||||
"DEVICE QUALIFIER", /* 6 */ |
||||
"OTHER SPEED", /* 7 */ |
||||
"INTERFACE POWER", /* 8 */ |
||||
}; |
||||
|
||||
char *usbd_device_status[] = { |
||||
"USBD_OPENING", |
||||
"USBD_OK", |
||||
"USBD_SUSPENDED", |
||||
"USBD_CLOSING", |
||||
}; |
||||
|
||||
|
||||
/* Descriptor support functions ************************************************************** */ |
||||
|
||||
|
||||
/**
|
||||
* usbd_get_string - find and return a string descriptor |
||||
* @index: string index to return |
||||
* |
||||
* Find an indexed string and return a pointer to a it. |
||||
*/ |
||||
struct usb_string_descriptor *usbd_get_string (__u8 index) |
||||
{ |
||||
if (index >= maxstrings) { |
||||
return NULL; |
||||
} |
||||
return usb_strings[index]; |
||||
} |
||||
|
||||
|
||||
/* Access to device descriptor functions ***************************************************** */ |
||||
|
||||
|
||||
/* *
|
||||
* usbd_device_configuration_instance - find a configuration instance for this device |
||||
* @device: |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* |
||||
* Get specifed device configuration. Index should be bConfigurationValue-1. |
||||
*/ |
||||
static struct usb_configuration_instance *usbd_device_configuration_instance (struct usb_device_instance *device, |
||||
unsigned int port, unsigned int configuration) |
||||
{ |
||||
/* XXX */ |
||||
configuration = configuration ? configuration - 1 : 0; |
||||
|
||||
if (configuration >= device->configurations) { |
||||
return NULL; |
||||
} |
||||
return device->configuration_instance_array + configuration; |
||||
} |
||||
|
||||
|
||||
/* *
|
||||
* usbd_device_interface_instance |
||||
* @device: |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* @interface: index to interface |
||||
* |
||||
* Return the specified interface descriptor for the specified device. |
||||
*/ |
||||
struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *device, int port, int configuration, int interface) |
||||
{ |
||||
struct usb_configuration_instance *configuration_instance; |
||||
|
||||
if ((configuration_instance = usbd_device_configuration_instance (device, port, configuration)) == NULL) { |
||||
return NULL; |
||||
} |
||||
if (interface >= configuration_instance->interfaces) { |
||||
return NULL; |
||||
} |
||||
return configuration_instance->interface_instance_array + interface; |
||||
} |
||||
|
||||
/* *
|
||||
* usbd_device_alternate_descriptor_list |
||||
* @device: |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* @interface: index to interface |
||||
* @alternate: alternate setting |
||||
* |
||||
* Return the specified alternate descriptor for the specified device. |
||||
*/ |
||||
struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *device, int port, int configuration, int interface, int alternate) |
||||
{ |
||||
struct usb_interface_instance *interface_instance; |
||||
|
||||
if ((interface_instance = usbd_device_interface_instance (device, port, configuration, interface)) == NULL) { |
||||
return NULL; |
||||
} |
||||
|
||||
if (alternate >= interface_instance->alternates) { |
||||
return NULL; |
||||
} |
||||
|
||||
return interface_instance->alternates_instance_array + alternate; |
||||
} |
||||
|
||||
|
||||
/* *
|
||||
* usbd_device_device_descriptor |
||||
* @device: which device |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* @port: which port |
||||
* |
||||
* Return the specified configuration descriptor for the specified device. |
||||
*/ |
||||
struct usb_device_descriptor *usbd_device_device_descriptor (struct usb_device_instance *device, int port) |
||||
{ |
||||
return (device->device_descriptor); |
||||
} |
||||
|
||||
|
||||
/**
|
||||
* usbd_device_configuration_descriptor |
||||
* @device: which device |
||||
* @port: which port |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* |
||||
* Return the specified configuration descriptor for the specified device. |
||||
*/ |
||||
struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct |
||||
usb_device_instance |
||||
*device, int port, int configuration) |
||||
{ |
||||
struct usb_configuration_instance *configuration_instance; |
||||
if (!(configuration_instance = usbd_device_configuration_instance (device, port, configuration))) { |
||||
return NULL; |
||||
} |
||||
return (configuration_instance->configuration_descriptor); |
||||
} |
||||
|
||||
|
||||
/**
|
||||
* usbd_device_interface_descriptor |
||||
* @device: which device |
||||
* @port: which port |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* @interface: index to interface |
||||
* @alternate: alternate setting |
||||
* |
||||
* Return the specified interface descriptor for the specified device. |
||||
*/ |
||||
struct usb_interface_descriptor *usbd_device_interface_descriptor (struct usb_device_instance |
||||
*device, int port, int configuration, int interface, int alternate) |
||||
{ |
||||
struct usb_interface_instance *interface_instance; |
||||
if (!(interface_instance = usbd_device_interface_instance (device, port, configuration, interface))) { |
||||
return NULL; |
||||
} |
||||
if ((alternate < 0) || (alternate >= interface_instance->alternates)) { |
||||
return NULL; |
||||
} |
||||
return (interface_instance->alternates_instance_array[alternate].interface_descriptor); |
||||
} |
||||
|
||||
/**
|
||||
* usbd_device_endpoint_descriptor_index |
||||
* @device: which device |
||||
* @port: which port |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* @interface: index to interface |
||||
* @alternate: index setting |
||||
* @index: which index |
||||
* |
||||
* Return the specified endpoint descriptor for the specified device. |
||||
*/ |
||||
struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor_index (struct usb_device_instance |
||||
*device, int port, int configuration, int interface, int alternate, int index) |
||||
{ |
||||
struct usb_alternate_instance *alternate_instance; |
||||
|
||||
if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) { |
||||
return NULL; |
||||
} |
||||
if (index >= alternate_instance->endpoints) { |
||||
return NULL; |
||||
} |
||||
return *(alternate_instance->endpoints_descriptor_array + index); |
||||
} |
||||
|
||||
|
||||
/**
|
||||
* usbd_device_endpoint_transfersize |
||||
* @device: which device |
||||
* @port: which port |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* @interface: index to interface |
||||
* @index: which index |
||||
* |
||||
* Return the specified endpoint transfer size; |
||||
*/ |
||||
int usbd_device_endpoint_transfersize (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int index) |
||||
{ |
||||
struct usb_alternate_instance *alternate_instance; |
||||
|
||||
if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) { |
||||
return 0; |
||||
} |
||||
if (index >= alternate_instance->endpoints) { |
||||
return 0; |
||||
} |
||||
return *(alternate_instance->endpoint_transfersize_array + index); |
||||
} |
||||
|
||||
|
||||
/**
|
||||
* usbd_device_endpoint_descriptor |
||||
* @device: which device |
||||
* @port: which port |
||||
* @configuration: index to configuration, 0 - N-1 |
||||
* @interface: index to interface |
||||
* @alternate: alternate setting |
||||
* @endpoint: which endpoint |
||||
* |
||||
* Return the specified endpoint descriptor for the specified device. |
||||
*/ |
||||
struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int endpoint) |
||||
{ |
||||
struct usb_endpoint_descriptor *endpoint_descriptor; |
||||
int i; |
||||
|
||||
for (i = 0; !(endpoint_descriptor = usbd_device_endpoint_descriptor_index (device, port, configuration, interface, alternate, i)); i++) { |
||||
if (endpoint_descriptor->bEndpointAddress == endpoint) { |
||||
return endpoint_descriptor; |
||||
} |
||||
} |
||||
return NULL; |
||||
} |
||||
|
||||
/**
|
||||
* usbd_endpoint_halted |
||||
* @device: point to struct usb_device_instance |
||||
* @endpoint: endpoint to check |
||||
* |
||||
* Return non-zero if endpoint is halted. |
||||
*/ |
||||
int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint) |
||||
{ |
||||
return (device->status == USB_STATUS_HALT); |
||||
} |
||||
|
||||
|
||||
/**
|
||||
* usbd_rcv_complete - complete a receive |
||||
* @endpoint: |
||||
* @len: |
||||
* @urb_bad: |
||||
* |
||||
* Called from rcv interrupt to complete. |
||||
*/ |
||||
void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad) |
||||
{ |
||||
if (endpoint) { |
||||
struct urb *rcv_urb; |
||||
|
||||
/*usbdbg("len: %d urb: %p\n", len, endpoint->rcv_urb); */ |
||||
|
||||
/* if we had an urb then update actual_length, dispatch if neccessary */ |
||||
if ((rcv_urb = endpoint->rcv_urb)) { |
||||
|
||||
/*usbdbg("actual: %d buffer: %d\n", */ |
||||
/*rcv_urb->actual_length, rcv_urb->buffer_length); */ |
||||
|
||||
/* check the urb is ok, are we adding data less than the packetsize */ |
||||
if (!urb_bad && (len <= endpoint->rcv_packetSize)) { |
||||
/*usbdbg("updating actual_length by %d\n",len); */ |
||||
|
||||
/* increment the received data size */ |
||||
rcv_urb->actual_length += len; |
||||
|
||||
} else { |
||||
usberr(" RECV_ERROR actual: %d buffer: %d urb_bad: %d\n", |
||||
rcv_urb->actual_length, rcv_urb->buffer_length, urb_bad); |
||||
|
||||
rcv_urb->actual_length = 0; |
||||
rcv_urb->status = RECV_ERROR; |
||||
} |
||||
} else { |
||||
usberr("no rcv_urb!"); |
||||
} |
||||
} else { |
||||
usberr("no endpoint!"); |
||||
} |
||||
|
||||
} |
||||
|
||||
/**
|
||||
* usbd_tx_complete - complete a transmit |
||||
* @endpoint: |
||||
* @resetart: |
||||
* |
||||
* Called from tx interrupt to complete. |
||||
*/ |
||||
void usbd_tx_complete (struct usb_endpoint_instance *endpoint) |
||||
{ |
||||
if (endpoint) { |
||||
struct urb *tx_urb; |
||||
|
||||
/* if we have a tx_urb advance or reset, finish if complete */ |
||||
if ((tx_urb = endpoint->tx_urb)) { |
||||
int sent = endpoint->last; |
||||
endpoint->sent += sent; |
||||
endpoint->last -= sent; |
||||
|
||||
if( (endpoint->tx_urb->actual_length - endpoint->sent) <= 0 ) { |
||||
tx_urb->actual_length = 0; |
||||
endpoint->sent = 0; |
||||
endpoint->last = 0; |
||||
|
||||
/* Remove from active, save for re-use */ |
||||
urb_detach(tx_urb); |
||||
urb_append(&endpoint->done, tx_urb); |
||||
/*usbdbg("done->next %p, tx_urb %p, done %p", */ |
||||
/* endpoint->done.next, tx_urb, &endpoint->done); */ |
||||
|
||||
endpoint->tx_urb = first_urb_detached(&endpoint->tx); |
||||
if( endpoint->tx_urb ) { |
||||
endpoint->tx_queue--; |
||||
usbdbg("got urb from tx list"); |
||||
} |
||||
if( !endpoint->tx_urb ) { |
||||
/*usbdbg("taking urb from done list"); */ |
||||
endpoint->tx_urb = first_urb_detached(&endpoint->done); |
||||
} |
||||
if( !endpoint->tx_urb ) { |
||||
usbdbg("allocating new urb for tx_urb"); |
||||
endpoint->tx_urb = usbd_alloc_urb(tx_urb->device, endpoint); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* URB linked list functions ***************************************************** */ |
||||
|
||||
/*
|
||||
* Initialize an urb_link to be a single element list. |
||||
* If the urb_link is being used as a distinguished list head |
||||
* the list is empty when the head is the only link in the list. |
||||
*/ |
||||
void urb_link_init (urb_link * ul) |
||||
{ |
||||
if (ul) { |
||||
ul->prev = ul->next = ul; |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* Detach an urb_link from a list, and set it |
||||
* up as a single element list, so no dangling |
||||
* pointers can be followed, and so it can be |
||||
* joined to another list if so desired. |
||||
*/ |
||||
void urb_detach (struct urb *urb) |
||||
{ |
||||
if (urb) { |
||||
urb_link *ul = &urb->link; |
||||
ul->next->prev = ul->prev; |
||||
ul->prev->next = ul->next; |
||||
urb_link_init (ul); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* Return the first urb_link in a list with a distinguished |
||||
* head "hd", or NULL if the list is empty. This will also |
||||
* work as a predicate, returning NULL if empty, and non-NULL |
||||
* otherwise. |
||||
*/ |
||||
urb_link *first_urb_link (urb_link * hd) |
||||
{ |
||||
urb_link *nx; |
||||
if (NULL != hd && NULL != (nx = hd->next) && nx != hd) { |
||||
/* There is at least one element in the list */ |
||||
/* (besides the distinguished head). */ |
||||
return (nx); |
||||
} |
||||
/* The list is empty */ |
||||
return (NULL); |
||||
} |
||||
|
||||
/*
|
||||
* Return the first urb in a list with a distinguished |
||||
* head "hd", or NULL if the list is empty. |
||||
*/ |
||||
struct urb *first_urb (urb_link * hd) |
||||
{ |
||||
urb_link *nx; |
||||
if (NULL == (nx = first_urb_link (hd))) { |
||||
/* The list is empty */ |
||||
return (NULL); |
||||
} |
||||
return (p2surround (struct urb, link, nx)); |
||||
} |
||||
|
||||
/*
|
||||
* Detach and return the first urb in a list with a distinguished |
||||
* head "hd", or NULL if the list is empty. |
||||
* |
||||
*/ |
||||
struct urb *first_urb_detached (urb_link * hd) |
||||
{ |
||||
struct urb *urb; |
||||
if ((urb = first_urb (hd))) { |
||||
urb_detach (urb); |
||||
} |
||||
return urb; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Append an urb_link (or a whole list of |
||||
* urb_links) to the tail of another list |
||||
* of urb_links. |
||||
*/ |
||||
void urb_append (urb_link * hd, struct urb *urb) |
||||
{ |
||||
if (hd && urb) { |
||||
urb_link *new = &urb->link; |
||||
|
||||
/* This allows the new urb to be a list of urbs, */ |
||||
/* with new pointing at the first, but the link */ |
||||
/* must be initialized. */ |
||||
/* Order is important here... */ |
||||
urb_link *pul = hd->prev; |
||||
new->prev->next = hd; |
||||
hd->prev = new->prev; |
||||
new->prev = pul; |
||||
pul->next = new; |
||||
} |
||||
} |
||||
|
||||
/* URB create/destroy functions ***************************************************** */ |
||||
|
||||
/**
|
||||
* usbd_alloc_urb - allocate an URB appropriate for specified endpoint |
||||
* @device: device instance |
||||
* @endpoint: endpoint |
||||
* |
||||
* Allocate an urb structure. The usb device urb structure is used to |
||||
* contain all data associated with a transfer, including a setup packet for |
||||
* control transfers. |
||||
* |
||||
* NOTE: endpoint_address MUST contain a direction flag. |
||||
*/ |
||||
struct urb *usbd_alloc_urb (struct usb_device_instance *device, struct usb_endpoint_instance *endpoint) |
||||
{ |
||||
struct urb *urb; |
||||
|
||||
if( !(urb = (struct urb*)malloc(sizeof(struct urb))) ) { |
||||
usberr(" F A T A L: malloc(%u) FAILED!!!!", sizeof(struct urb)); |
||||
return NULL; |
||||
} |
||||
|
||||
/* Fill in known fields */ |
||||
memset(urb, 0, sizeof(struct urb)); |
||||
urb->endpoint = endpoint; |
||||
urb->device = device; |
||||
urb->buffer = (u8*)urb->buffer_data; |
||||
urb->buffer_length = sizeof(urb->buffer_data); |
||||
|
||||
urb_link_init (&urb->link); |
||||
|
||||
return urb; |
||||
} |
||||
|
||||
/**
|
||||
* usbd_dealloc_urb - deallocate an URB and associated buffer |
||||
* @urb: pointer to an urb structure |
||||
* |
||||
* Deallocate an urb structure and associated data. |
||||
*/ |
||||
void usbd_dealloc_urb (struct urb *urb) |
||||
{ |
||||
if (urb) { |
||||
free (urb); |
||||
} |
||||
} |
||||
|
||||
/* Event signaling functions ***************************************************** */ |
||||
|
||||
/**
|
||||
* usbd_device_event - called to respond to various usb events |
||||
* @device: pointer to struct device |
||||
* @event: event to respond to |
||||
* |
||||
* Used by a Bus driver to indicate an event. |
||||
*/ |
||||
void usbd_device_event_irq (struct usb_device_instance *device, usb_device_event_t event, int data) |
||||
{ |
||||
usb_device_state_t state; |
||||
|
||||
if (!device || !device->bus) { |
||||
usberr("(%p,%d) NULL device or device->bus", device, event); |
||||
return; |
||||
} |
||||
|
||||
state = device->device_state; |
||||
|
||||
usbinfo("%s", usbd_device_events[event]); |
||||
|
||||
switch (event) { |
||||
case DEVICE_UNKNOWN: |
||||
break; |
||||
case DEVICE_INIT: |
||||
device->device_state = STATE_INIT; |
||||
break; |
||||
|
||||
case DEVICE_CREATE: |
||||
device->device_state = STATE_ATTACHED; |
||||
break; |
||||
|
||||
case DEVICE_HUB_CONFIGURED: |
||||
device->device_state = STATE_POWERED; |
||||
break; |
||||
|
||||
case DEVICE_RESET: |
||||
device->device_state = STATE_DEFAULT; |
||||
device->address = 0; |
||||
break; |
||||
|
||||
case DEVICE_ADDRESS_ASSIGNED: |
||||
device->device_state = STATE_ADDRESSED; |
||||
break; |
||||
|
||||
case DEVICE_CONFIGURED: |
||||
device->device_state = STATE_CONFIGURED; |
||||
break; |
||||
|
||||
case DEVICE_DE_CONFIGURED: |
||||
device->device_state = STATE_ADDRESSED; |
||||
break; |
||||
|
||||
case DEVICE_BUS_INACTIVE: |
||||
if (device->status != USBD_CLOSING) { |
||||
device->status = USBD_SUSPENDED; |
||||
} |
||||
break; |
||||
case DEVICE_BUS_ACTIVITY: |
||||
if (device->status != USBD_CLOSING) { |
||||
device->status = USBD_OK; |
||||
} |
||||
break; |
||||
|
||||
case DEVICE_SET_INTERFACE: |
||||
break; |
||||
case DEVICE_SET_FEATURE: |
||||
break; |
||||
case DEVICE_CLEAR_FEATURE: |
||||
break; |
||||
|
||||
case DEVICE_POWER_INTERRUPTION: |
||||
device->device_state = STATE_POWERED; |
||||
break; |
||||
case DEVICE_HUB_RESET: |
||||
device->device_state = STATE_ATTACHED; |
||||
break; |
||||
case DEVICE_DESTROY: |
||||
device->device_state = STATE_UNKNOWN; |
||||
break; |
||||
|
||||
case DEVICE_FUNCTION_PRIVATE: |
||||
break; |
||||
|
||||
default: |
||||
usbdbg("event %d - not handled",event); |
||||
break; |
||||
} |
||||
/*usbdbg("%s event: %d oldstate: %d newstate: %d status: %d address: %d",
|
||||
device->name, event, state, |
||||
device->device_state, device->status, device->address); */ |
||||
|
||||
/* tell the bus interface driver */ |
||||
if( device->event ) { |
||||
/* usbdbg("calling device->event"); */ |
||||
device->event(device, event, data); |
||||
} |
||||
} |
@ -0,0 +1,686 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* Based on |
||||
* linux/drivers/usbd/ep0.c |
||||
* |
||||
* Copyright (c) 2000, 2001, 2002 Lineo |
||||
* Copyright (c) 2001 Hewlett Packard |
||||
* |
||||
* By: |
||||
* Stuart Lynne <sl@lineo.com>, |
||||
* Tom Rushworth <tbr@lineo.com>, |
||||
* Bruce Balden <balden@lineo.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. |
||||
* |
||||
* 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
||||
* |
||||
*/ |
||||
|
||||
/*
|
||||
* This is the builtin ep0 control function. It implements all required functionality |
||||
* for responding to control requests (SETUP packets). |
||||
* |
||||
* XXX |
||||
* |
||||
* Currently we do not pass any SETUP packets (or other) to the configured |
||||
* function driver. This may need to change. |
||||
* |
||||
* XXX |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
|
||||
#if defined(CONFIG_OMAP1510) && defined(CONFIG_USB_DEVICE) |
||||
#include "usbdcore.h" |
||||
|
||||
#if 0 |
||||
#define dbg_ep0(lvl,fmt,args...) serial_printf("[%s] %s:%d: "fmt"\n",__FILE__,__FUNCTION__,__LINE__,##args) |
||||
#else |
||||
#define dbg_ep0(lvl,fmt,args...) |
||||
#endif |
||||
|
||||
/* EP0 Configuration Set ********************************************************************* */ |
||||
|
||||
|
||||
/**
|
||||
* ep0_get_status - fill in URB data with appropriate status |
||||
* @device: |
||||
* @urb: |
||||
* @index: |
||||
* @requesttype: |
||||
* |
||||
*/ |
||||
static int ep0_get_status (struct usb_device_instance *device, |
||||
struct urb *urb, int index, int requesttype) |
||||
{ |
||||
char *cp; |
||||
|
||||
urb->actual_length = 2; |
||||
cp = urb->buffer; |
||||
cp[0] = cp[1] = 0; |
||||
|
||||
switch (requesttype) { |
||||
case USB_REQ_RECIPIENT_DEVICE: |
||||
cp[0] = USB_STATUS_SELFPOWERED; |
||||
break; |
||||
case USB_REQ_RECIPIENT_INTERFACE: |
||||
break; |
||||
case USB_REQ_RECIPIENT_ENDPOINT: |
||||
cp[0] = usbd_endpoint_halted (device, index); |
||||
break; |
||||
case USB_REQ_RECIPIENT_OTHER: |
||||
urb->actual_length = 0; |
||||
default: |
||||
break; |
||||
} |
||||
dbg_ep0 (2, "%02x %02x", cp[0], cp[1]); |
||||
return 0; |
||||
} |
||||
|
||||
/**
|
||||
* ep0_get_one |
||||
* @device: |
||||
* @urb: |
||||
* @result: |
||||
* |
||||
* Set a single byte value in the urb send buffer. Return non-zero to signal |
||||
* a request error. |
||||
*/ |
||||
static int ep0_get_one (struct usb_device_instance *device, struct urb *urb, |
||||
__u8 result) |
||||
{ |
||||
urb->actual_length = 1; /* XXX 2? */ |
||||
((char *) urb->buffer)[0] = result; |
||||
return 0; |
||||
} |
||||
|
||||
/**
|
||||
* copy_config |
||||
* @urb: pointer to urb |
||||
* @data: pointer to configuration data |
||||
* @length: length of data |
||||
* |
||||
* Copy configuration data to urb transfer buffer if there is room for it. |
||||
*/ |
||||
static void copy_config (struct urb *urb, void *data, int max_length, |
||||
int max_buf) |
||||
{ |
||||
int available; |
||||
int length; |
||||
|
||||
/*dbg_ep0(3, "-> actual: %d buf: %d max_buf: %d max_length: %d data: %p", */ |
||||
/* urb->actual_length, urb->buffer_length, max_buf, max_length, data); */ |
||||
|
||||
if (!data) { |
||||
dbg_ep0 (1, "data is NULL"); |
||||
return; |
||||
} |
||||
if (!(length = *(unsigned char *) data)) { |
||||
dbg_ep0 (1, "length is zero"); |
||||
return; |
||||
} |
||||
|
||||
if (length > max_length) { |
||||
dbg_ep0 (1, "length: %d >= max_length: %d", length, |
||||
max_length); |
||||
return; |
||||
} |
||||
/*dbg_ep0(1, " actual: %d buf: %d max_buf: %d max_length: %d length: %d", */ |
||||
/* urb->actual_length, urb->buffer_length, max_buf, max_length, length); */ |
||||
|
||||
if ((available = |
||||
/*urb->buffer_length */ max_buf - urb->actual_length) <= 0) { |
||||
return; |
||||
} |
||||
/*dbg_ep0(1, "actual: %d buf: %d max_buf: %d length: %d available: %d", */ |
||||
/* urb->actual_length, urb->buffer_length, max_buf, length, available); */ |
||||
|
||||
if (length > available) { |
||||
length = available; |
||||
} |
||||
/*dbg_ep0(1, "actual: %d buf: %d max_buf: %d length: %d available: %d", */ |
||||
/* urb->actual_length, urb->buffer_length, max_buf, length, available); */ |
||||
|
||||
memcpy (urb->buffer + urb->actual_length, data, length); |
||||
urb->actual_length += length; |
||||
|
||||
dbg_ep0 (3, |
||||
"copy_config: <- actual: %d buf: %d max_buf: %d max_length: %d available: %d", |
||||
urb->actual_length, urb->buffer_length, max_buf, max_length, |
||||
available); |
||||
} |
||||
|
||||
/**
|
||||
* ep0_get_descriptor |
||||
* @device: |
||||
* @urb: |
||||
* @max: |
||||
* @descriptor_type: |
||||
* @index: |
||||
* |
||||
* Called by ep0_rx_process for a get descriptor device command. Determine what |
||||
* descriptor is being requested, copy to send buffer. Return zero if ok to send, |
||||
* return non-zero to signal a request error. |
||||
*/ |
||||
static int ep0_get_descriptor (struct usb_device_instance *device, |
||||
struct urb *urb, int max, int descriptor_type, |
||||
int index) |
||||
{ |
||||
int port = 0; /* XXX compound device */ |
||||
char *cp; |
||||
|
||||
/*dbg_ep0(3, "max: %x type: %x index: %x", max, descriptor_type, index); */ |
||||
|
||||
if (!urb || !urb->buffer || !urb->buffer_length |
||||
|| (urb->buffer_length < 255)) { |
||||
dbg_ep0 (2, "invalid urb %p", urb); |
||||
return -1L; |
||||
} |
||||
|
||||
/* setup tx urb */ |
||||
urb->actual_length = 0; |
||||
cp = urb->buffer; |
||||
|
||||
dbg_ep0 (2, "%s", USBD_DEVICE_DESCRIPTORS (descriptor_type)); |
||||
|
||||
switch (descriptor_type) { |
||||
case USB_DESCRIPTOR_TYPE_DEVICE: |
||||
{ |
||||
struct usb_device_descriptor *device_descriptor; |
||||
|
||||
if (! |
||||
(device_descriptor = |
||||
usbd_device_device_descriptor (device, port))) { |
||||
return -1; |
||||
} |
||||
/* copy descriptor for this device */ |
||||
copy_config (urb, device_descriptor, |
||||
sizeof (struct usb_device_descriptor), |
||||
max); |
||||
|
||||
/* correct the correct control endpoint 0 max packet size into the descriptor */ |
||||
device_descriptor = |
||||
(struct usb_device_descriptor *) urb->buffer; |
||||
device_descriptor->bMaxPacketSize0 = |
||||
urb->device->bus->maxpacketsize; |
||||
|
||||
} |
||||
/*dbg_ep0(3, "copied device configuration, actual_length: %x", urb->actual_length); */ |
||||
break; |
||||
|
||||
case USB_DESCRIPTOR_TYPE_CONFIGURATION: |
||||
{ |
||||
int bNumInterface; |
||||
struct usb_configuration_descriptor |
||||
*configuration_descriptor; |
||||
struct usb_device_descriptor *device_descriptor; |
||||
|
||||
if (! |
||||
(device_descriptor = |
||||
usbd_device_device_descriptor (device, port))) { |
||||
return -1; |
||||
} |
||||
/*dbg_ep0(2, "%d %d", index, device_descriptor->bNumConfigurations); */ |
||||
if (index > device_descriptor->bNumConfigurations) { |
||||
dbg_ep0 (0, "index too large: %d > %d", index, |
||||
device_descriptor-> |
||||
bNumConfigurations); |
||||
return -1; |
||||
} |
||||
|
||||
if (! |
||||
(configuration_descriptor = |
||||
usbd_device_configuration_descriptor (device, |
||||
port, |
||||
index))) { |
||||
dbg_ep0 (0, |
||||
"usbd_device_configuration_descriptor failed: %d", |
||||
index); |
||||
return -1; |
||||
} |
||||
copy_config (urb, configuration_descriptor, |
||||
sizeof (struct |
||||
usb_configuration_descriptor), |
||||
max); |
||||
|
||||
|
||||
/* iterate across interfaces for specified configuration */ |
||||
dbg_ep0 (0, "bNumInterfaces: %d", |
||||
configuration_descriptor->bNumInterfaces); |
||||
for (bNumInterface = 0; |
||||
bNumInterface < |
||||
configuration_descriptor->bNumInterfaces; |
||||
bNumInterface++) { |
||||
|
||||
int bAlternateSetting; |
||||
struct usb_interface_instance |
||||
*interface_instance; |
||||
|
||||
dbg_ep0 (3, "[%d] bNumInterfaces: %d", |
||||
bNumInterface, |
||||
configuration_descriptor->bNumInterfaces); |
||||
|
||||
if (! (interface_instance = usbd_device_interface_instance (device, |
||||
port, index, bNumInterface))) |
||||
{ |
||||
dbg_ep0 (3, "[%d] interface_instance NULL", |
||||
bNumInterface); |
||||
return -1; |
||||
} |
||||
/* iterate across interface alternates */ |
||||
for (bAlternateSetting = 0; |
||||
bAlternateSetting < interface_instance->alternates; |
||||
bAlternateSetting++) { |
||||
/*int class; */ |
||||
int bNumEndpoint; |
||||
struct usb_interface_descriptor *interface_descriptor; |
||||
|
||||
struct usb_alternate_instance *alternate_instance; |
||||
|
||||
dbg_ep0 (3, "[%d:%d] alternates: %d", |
||||
bNumInterface, |
||||
bAlternateSetting, |
||||
interface_instance->alternates); |
||||
|
||||
if (! (alternate_instance = usbd_device_alternate_instance (device, port, index, bNumInterface, bAlternateSetting))) { |
||||
dbg_ep0 (3, "[%d] alternate_instance NULL", |
||||
bNumInterface); |
||||
return -1; |
||||
} |
||||
/* copy descriptor for this interface */ |
||||
copy_config (urb, alternate_instance->interface_descriptor, |
||||
sizeof (struct usb_interface_descriptor), |
||||
max); |
||||
|
||||
/*dbg_ep0(3, "[%d:%d] classes: %d endpoints: %d", bNumInterface, bAlternateSetting, */ |
||||
/* alternate_instance->classes, alternate_instance->endpoints); */ |
||||
|
||||
/* iterate across classes for this alternate interface */ |
||||
#if 0 |
||||
for (class = 0; |
||||
class < alternate_instance->classes; |
||||
class++) { |
||||
struct usb_class_descriptor *class_descriptor; |
||||
/*dbg_ep0(3, "[%d:%d:%d] classes: %d", bNumInterface, bAlternateSetting, */ |
||||
/* class, alternate_instance->classes); */ |
||||
if (!(class_descriptor = usbd_device_class_descriptor_index (device, port, index, bNumInterface, bAlternateSetting, class))) { |
||||
dbg_ep0 (3, "[%d] class NULL", |
||||
class); |
||||
return -1; |
||||
} |
||||
/* copy descriptor for this class */ |
||||
copy_config (urb, class_descriptor, |
||||
sizeof (struct usb_class_descriptor), |
||||
max); |
||||
} |
||||
#endif |
||||
|
||||
/* iterate across endpoints for this alternate interface */ |
||||
interface_descriptor = alternate_instance->interface_descriptor; |
||||
for (bNumEndpoint = 0; |
||||
bNumEndpoint < alternate_instance->endpoints; |
||||
bNumEndpoint++) { |
||||
struct usb_endpoint_descriptor *endpoint_descriptor; |
||||
dbg_ep0 (3, "[%d:%d:%d] endpoint: %d", |
||||
bNumInterface, |
||||
bAlternateSetting, |
||||
bNumEndpoint, |
||||
interface_descriptor-> |
||||
bNumEndpoints); |
||||
if (!(endpoint_descriptor = usbd_device_endpoint_descriptor_index (device, port, index, bNumInterface, bAlternateSetting, bNumEndpoint))) { |
||||
dbg_ep0 (3, "[%d] endpoint NULL", |
||||
bNumEndpoint); |
||||
return -1; |
||||
} |
||||
/* copy descriptor for this endpoint */ |
||||
copy_config (urb, endpoint_descriptor, |
||||
sizeof (struct usb_endpoint_descriptor), |
||||
max); |
||||
} |
||||
} |
||||
} |
||||
dbg_ep0 (3, "lengths: %d %d", |
||||
le16_to_cpu (configuration_descriptor->wTotalLength), |
||||
urb->actual_length); |
||||
} |
||||
break; |
||||
|
||||
case USB_DESCRIPTOR_TYPE_STRING: |
||||
{ |
||||
struct usb_string_descriptor *string_descriptor; |
||||
|
||||
if (!(string_descriptor = usbd_get_string (index))) { |
||||
return -1; |
||||
} |
||||
/*dbg_ep0(3, "string_descriptor: %p", string_descriptor); */ |
||||
copy_config (urb, string_descriptor, string_descriptor->bLength, max); |
||||
} |
||||
break; |
||||
case USB_DESCRIPTOR_TYPE_INTERFACE: |
||||
return -1; |
||||
case USB_DESCRIPTOR_TYPE_ENDPOINT: |
||||
return -1; |
||||
case USB_DESCRIPTOR_TYPE_HID: |
||||
{ |
||||
return -1; /* unsupported at this time */ |
||||
#if 0 |
||||
int bNumInterface = |
||||
le16_to_cpu (urb->device_request.wIndex); |
||||
int bAlternateSetting = 0; |
||||
int class = 0; |
||||
struct usb_class_descriptor *class_descriptor; |
||||
|
||||
if (!(class_descriptor = |
||||
usbd_device_class_descriptor_index (device, |
||||
port, 0, |
||||
bNumInterface, |
||||
bAlternateSetting, |
||||
class)) |
||||
|| class_descriptor->descriptor.hid.bDescriptorType != USB_DT_HID) { |
||||
dbg_ep0 (3, "[%d] interface is not HID", |
||||
bNumInterface); |
||||
return -1; |
||||
} |
||||
/* copy descriptor for this class */ |
||||
copy_config (urb, class_descriptor, |
||||
class_descriptor->descriptor.hid.bLength, |
||||
max); |
||||
#endif |
||||
} |
||||
break; |
||||
case USB_DESCRIPTOR_TYPE_REPORT: |
||||
{ |
||||
return -1; /* unsupported at this time */ |
||||
#if 0 |
||||
int bNumInterface = |
||||
le16_to_cpu (urb->device_request.wIndex); |
||||
int bAlternateSetting = 0; |
||||
int class = 0; |
||||
struct usb_class_report_descriptor *report_descriptor; |
||||
|
||||
if (!(report_descriptor = |
||||
usbd_device_class_report_descriptor_index |
||||
(device, port, 0, bNumInterface, |
||||
bAlternateSetting, class)) |
||||
|| report_descriptor->bDescriptorType != |
||||
USB_DT_REPORT) { |
||||
dbg_ep0 (3, "[%d] descriptor is not REPORT", |
||||
bNumInterface); |
||||
return -1; |
||||
} |
||||
/* copy report descriptor for this class */ |
||||
/*copy_config(urb, &report_descriptor->bData[0], report_descriptor->wLength, max); */ |
||||
if (max - urb->actual_length > 0) { |
||||
int length = |
||||
MIN (report_descriptor->wLength, |
||||
max - urb->actual_length); |
||||
memcpy (urb->buffer + urb->actual_length, |
||||
&report_descriptor->bData[0], length); |
||||
urb->actual_length += length; |
||||
} |
||||
#endif |
||||
} |
||||
break; |
||||
default: |
||||
return -1; |
||||
} |
||||
|
||||
|
||||
dbg_ep0 (1, "urb: buffer: %p buffer_length: %2d actual_length: %2d packet size: %2d", |
||||
urb->buffer, urb->buffer_length, urb->actual_length, |
||||
device->bus->endpoint_array[0].tx_packetSize); |
||||
/*
|
||||
if ((urb->actual_length < max) && !(urb->actual_length % device->bus->endpoint_array[0].tx_packetSize)) { |
||||
dbg_ep0(0, "adding null byte"); |
||||
urb->buffer[urb->actual_length++] = 0; |
||||
dbg_ep0(0, "urb: buffer_length: %2d actual_length: %2d packet size: %2d", |
||||
urb->buffer_length, urb->actual_length device->bus->endpoint_array[0].tx_packetSize); |
||||
} |
||||
*/ |
||||
return 0; |
||||
|
||||
} |
||||
|
||||
/**
|
||||
* ep0_recv_setup - called to indicate URB has been received |
||||
* @urb: pointer to struct urb |
||||
* |
||||
* Check if this is a setup packet, process the device request, put results |
||||
* back into the urb and return zero or non-zero to indicate success (DATA) |
||||
* or failure (STALL). |
||||
* |
||||
*/ |
||||
int ep0_recv_setup (struct urb *urb) |
||||
{ |
||||
/*struct usb_device_request *request = urb->buffer; */ |
||||
/*struct usb_device_instance *device = urb->device; */ |
||||
|
||||
struct usb_device_request *request; |
||||
struct usb_device_instance *device; |
||||
int address; |
||||
|
||||
dbg_ep0 (0, "entering ep0_recv_setup()"); |
||||
if (!urb || !urb->device) { |
||||
dbg_ep0 (3, "invalid URB %p", urb); |
||||
return -1; |
||||
} |
||||
|
||||
request = &urb->device_request; |
||||
device = urb->device; |
||||
|
||||
dbg_ep0 (3, "urb: %p device: %p", urb, urb->device); |
||||
|
||||
|
||||
/*dbg_ep0(2, "- - - - - - - - - -"); */ |
||||
|
||||
dbg_ep0 (2, |
||||
"bmRequestType:%02x bRequest:%02x wValue:%04x wIndex:%04x wLength:%04x %s", |
||||
request->bmRequestType, request->bRequest, |
||||
le16_to_cpu (request->wValue), le16_to_cpu (request->wIndex), |
||||
le16_to_cpu (request->wLength), |
||||
USBD_DEVICE_REQUESTS (request->bRequest)); |
||||
|
||||
/* handle USB Standard Request (c.f. USB Spec table 9-2) */ |
||||
if ((request->bmRequestType & USB_REQ_TYPE_MASK) != 0) { |
||||
dbg_ep0 (1, "non standard request: %x", |
||||
request->bmRequestType & USB_REQ_TYPE_MASK); |
||||
return -1; /* Stall here */ |
||||
} |
||||
|
||||
switch (device->device_state) { |
||||
case STATE_CREATED: |
||||
case STATE_ATTACHED: |
||||
case STATE_POWERED: |
||||
/* It actually is important to allow requests in these states,
|
||||
* Windows will request descriptors before assigning an |
||||
* address to the client. |
||||
*/ |
||||
|
||||
/*dbg_ep0 (1, "request %s not allowed in this state: %s", */ |
||||
/* USBD_DEVICE_REQUESTS(request->bRequest), */ |
||||
/* usbd_device_states[device->device_state]); */ |
||||
/*return -1; */ |
||||
break; |
||||
|
||||
case STATE_INIT: |
||||
case STATE_DEFAULT: |
||||
switch (request->bRequest) { |
||||
case USB_REQ_GET_STATUS: |
||||
case USB_REQ_GET_INTERFACE: |
||||
case USB_REQ_SYNCH_FRAME: /* XXX should never see this (?) */ |
||||
case USB_REQ_CLEAR_FEATURE: |
||||
case USB_REQ_SET_FEATURE: |
||||
case USB_REQ_SET_DESCRIPTOR: |
||||
/* case USB_REQ_SET_CONFIGURATION: */ |
||||
case USB_REQ_SET_INTERFACE: |
||||
dbg_ep0 (1, |
||||
"request %s not allowed in DEFAULT state: %s", |
||||
USBD_DEVICE_REQUESTS (request->bRequest), |
||||
usbd_device_states[device->device_state]); |
||||
return -1; |
||||
|
||||
case USB_REQ_SET_CONFIGURATION: |
||||
case USB_REQ_SET_ADDRESS: |
||||
case USB_REQ_GET_DESCRIPTOR: |
||||
case USB_REQ_GET_CONFIGURATION: |
||||
break; |
||||
} |
||||
case STATE_ADDRESSED: |
||||
case STATE_CONFIGURED: |
||||
break; |
||||
case STATE_UNKNOWN: |
||||
dbg_ep0 (1, "request %s not allowed in UNKNOWN state: %s", |
||||
USBD_DEVICE_REQUESTS (request->bRequest), |
||||
usbd_device_states[device->device_state]); |
||||
return -1; |
||||
} |
||||
|
||||
/* handle all requests that return data (direction bit set on bm RequestType) */ |
||||
if ((request->bmRequestType & USB_REQ_DIRECTION_MASK)) { |
||||
|
||||
dbg_ep0 (3, "Device-to-Host"); |
||||
|
||||
switch (request->bRequest) { |
||||
|
||||
case USB_REQ_GET_STATUS: |
||||
return ep0_get_status (device, urb, request->wIndex, |
||||
request->bmRequestType & |
||||
USB_REQ_RECIPIENT_MASK); |
||||
|
||||
case USB_REQ_GET_DESCRIPTOR: |
||||
return ep0_get_descriptor (device, urb, |
||||
le16_to_cpu (request->wLength), |
||||
le16_to_cpu (request->wValue) >> 8, |
||||
le16_to_cpu (request->wValue) & 0xff); |
||||
|
||||
case USB_REQ_GET_CONFIGURATION: |
||||
return ep0_get_one (device, urb, |
||||
device->configuration); |
||||
|
||||
case USB_REQ_GET_INTERFACE: |
||||
return ep0_get_one (device, urb, device->alternate); |
||||
|
||||
case USB_REQ_SYNCH_FRAME: /* XXX should never see this (?) */ |
||||
return -1; |
||||
|
||||
case USB_REQ_CLEAR_FEATURE: |
||||
case USB_REQ_SET_FEATURE: |
||||
case USB_REQ_SET_ADDRESS: |
||||
case USB_REQ_SET_DESCRIPTOR: |
||||
case USB_REQ_SET_CONFIGURATION: |
||||
case USB_REQ_SET_INTERFACE: |
||||
return -1; |
||||
} |
||||
} |
||||
/* handle the requests that do not return data */ |
||||
else { |
||||
|
||||
|
||||
/*dbg_ep0(3, "Host-to-Device"); */ |
||||
switch (request->bRequest) { |
||||
|
||||
case USB_REQ_CLEAR_FEATURE: |
||||
case USB_REQ_SET_FEATURE: |
||||
dbg_ep0 (0, "Host-to-Device"); |
||||
switch (request-> |
||||
bmRequestType & USB_REQ_RECIPIENT_MASK) { |
||||
case USB_REQ_RECIPIENT_DEVICE: |
||||
/* XXX DEVICE_REMOTE_WAKEUP or TEST_MODE would be added here */ |
||||
/* XXX fall through for now as we do not support either */ |
||||
case USB_REQ_RECIPIENT_INTERFACE: |
||||
case USB_REQ_RECIPIENT_OTHER: |
||||
dbg_ep0 (0, "request %s not", |
||||
USBD_DEVICE_REQUESTS (request->bRequest)); |
||||
default: |
||||
return -1; |
||||
|
||||
case USB_REQ_RECIPIENT_ENDPOINT: |
||||
dbg_ep0 (0, "ENDPOINT: %x", le16_to_cpu (request->wValue)); |
||||
if (le16_to_cpu (request->wValue) == USB_ENDPOINT_HALT) { |
||||
/*return usbd_device_feature (device, le16_to_cpu (request->wIndex), */ |
||||
/* request->bRequest == USB_REQ_SET_FEATURE); */ |
||||
/* NEED TO IMPLEMENT THIS!!! */ |
||||
return -1; |
||||
} else { |
||||
dbg_ep0 (1, "request %s bad wValue: %04x", |
||||
USBD_DEVICE_REQUESTS |
||||
(request->bRequest), |
||||
le16_to_cpu (request->wValue)); |
||||
return -1; |
||||
} |
||||
} |
||||
|
||||
case USB_REQ_SET_ADDRESS: |
||||
/* check if this is a re-address, reset first if it is (this shouldn't be possible) */ |
||||
if (device->device_state != STATE_DEFAULT) { |
||||
dbg_ep0 (1, "set_address: %02x state: %s", |
||||
le16_to_cpu (request->wValue), |
||||
usbd_device_states[device->device_state]); |
||||
return -1; |
||||
} |
||||
address = le16_to_cpu (request->wValue); |
||||
if ((address & 0x7f) != address) { |
||||
dbg_ep0 (1, "invalid address %04x %04x", |
||||
address, address & 0x7f); |
||||
return -1; |
||||
} |
||||
device->address = address; |
||||
|
||||
/*dbg_ep0(2, "address: %d %d %d", */ |
||||
/* request->wValue, le16_to_cpu(request->wValue), device->address); */ |
||||
|
||||
serial_printf ("DEVICE_ADDRESS_ASSIGNED.. event?\n"); |
||||
return 0; |
||||
|
||||
case USB_REQ_SET_DESCRIPTOR: /* XXX should we support this? */ |
||||
dbg_ep0 (0, "set descriptor: NOT SUPPORTED"); |
||||
return -1; |
||||
|
||||
case USB_REQ_SET_CONFIGURATION: |
||||
/* c.f. 9.4.7 - the top half of wValue is reserved */ |
||||
/* */ |
||||
if ((device->configuration = |
||||
le16_to_cpu (request->wValue) & 0x7f) != 0) { |
||||
/* c.f. 9.4.7 - zero is the default or addressed state, in our case this */ |
||||
/* is the same is configuration zero */ |
||||
device->configuration = 0; /* TBR - ?????? */ |
||||
} |
||||
/* reset interface and alternate settings */ |
||||
device->interface = device->alternate = 0; |
||||
|
||||
/*dbg_ep0(2, "set configuration: %d", device->configuration); */ |
||||
/*serial_printf("DEVICE_CONFIGURED.. event?\n"); */ |
||||
return 0; |
||||
|
||||
case USB_REQ_SET_INTERFACE: |
||||
device->interface = le16_to_cpu (request->wIndex); |
||||
device->alternate = le16_to_cpu (request->wValue); |
||||
/*dbg_ep0(2, "set interface: %d alternate: %d", device->interface, device->alternate); */ |
||||
serial_printf ("DEVICE_SET_INTERFACE.. event?\n"); |
||||
return 0; |
||||
|
||||
case USB_REQ_GET_STATUS: |
||||
case USB_REQ_GET_DESCRIPTOR: |
||||
case USB_REQ_GET_CONFIGURATION: |
||||
case USB_REQ_GET_INTERFACE: |
||||
case USB_REQ_SYNCH_FRAME: /* XXX should never see this (?) */ |
||||
return -1; |
||||
} |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
#endif |
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,647 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* 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. |
||||
* |
||||
* 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 <common.h> |
||||
|
||||
#ifdef CONFIG_USB_TTY |
||||
|
||||
#include <circbuf.h> |
||||
#include <devices.h> |
||||
#include "usbtty.h" |
||||
|
||||
#if 0 |
||||
#define TTYDBG(fmt,args...) serial_printf("[%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args) |
||||
#else |
||||
#define TTYDBG(fmt,args...) do{}while(0) |
||||
#endif |
||||
|
||||
#if 0 |
||||
#define TTYERR(fmt,args...) serial_printf("ERROR![%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args) |
||||
#else |
||||
#define TTYERR(fmt,args...) do{}while(0) |
||||
#endif |
||||
|
||||
/*
|
||||
* Buffers to hold input and output data |
||||
*/ |
||||
#define USBTTY_BUFFER_SIZE 256 |
||||
static circbuf_t usbtty_input; |
||||
static circbuf_t usbtty_output; |
||||
|
||||
|
||||
/*
|
||||
* Instance variables |
||||
*/ |
||||
static device_t usbttydev; |
||||
static struct usb_device_instance device_instance[1]; |
||||
static struct usb_bus_instance bus_instance[1]; |
||||
static struct usb_configuration_instance config_instance[NUM_CONFIGS]; |
||||
static struct usb_interface_instance interface_instance[NUM_INTERFACES]; |
||||
static struct usb_alternate_instance alternate_instance[NUM_INTERFACES]; |
||||
static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1]; /* one extra for control endpoint */ |
||||
|
||||
/*
|
||||
* Static allocation of urbs |
||||
*/ |
||||
#define RECV_ENDPOINT 1 |
||||
#define TX_ENDPOINT 2 |
||||
|
||||
/*
|
||||
* Global flag |
||||
*/ |
||||
int usbtty_configured_flag = 0; |
||||
|
||||
|
||||
/*
|
||||
* Descriptors |
||||
*/ |
||||
static u8 wstrLang[4] = {4,USB_DT_STRING,0x9,0x4}; |
||||
static u8 wstrManufacturer[2 + 2*(sizeof(CONFIG_USBD_MANUFACTURER)-1)]; |
||||
static u8 wstrProduct[2 + 2*(sizeof(CONFIG_USBD_PRODUCT_NAME)-1)]; |
||||
static u8 wstrSerial[2 + 2*(sizeof(CONFIG_USBD_SERIAL_NUMBER)-1)]; |
||||
static u8 wstrConfiguration[2 + 2*(sizeof(CONFIG_USBD_CONFIGURATION_STR)-1)]; |
||||
static u8 wstrInterface[2 + 2*(sizeof(CONFIG_USBD_INTERFACE_STR)-1)]; |
||||
|
||||
static struct usb_string_descriptor *usbtty_string_table[] = { |
||||
(struct usb_string_descriptor*)wstrLang, |
||||
(struct usb_string_descriptor*)wstrManufacturer, |
||||
(struct usb_string_descriptor*)wstrProduct, |
||||
(struct usb_string_descriptor*)wstrSerial, |
||||
(struct usb_string_descriptor*)wstrConfiguration, |
||||
(struct usb_string_descriptor*)wstrInterface |
||||
}; |
||||
extern struct usb_string_descriptor **usb_strings; /* defined and used by omap1510_ep0.c */ |
||||
|
||||
static struct usb_device_descriptor device_descriptor = { |
||||
bLength: sizeof(struct usb_device_descriptor), |
||||
bDescriptorType: USB_DT_DEVICE, |
||||
bcdUSB: USB_BCD_VERSION, |
||||
bDeviceClass: USBTTY_DEVICE_CLASS, |
||||
bDeviceSubClass: USBTTY_DEVICE_SUBCLASS, |
||||
bDeviceProtocol: USBTTY_DEVICE_PROTOCOL, |
||||
bMaxPacketSize0: EP0_MAX_PACKET_SIZE, |
||||
idVendor: CONFIG_USBD_VENDORID, |
||||
idProduct: CONFIG_USBD_PRODUCTID, |
||||
bcdDevice: USBTTY_BCD_DEVICE, |
||||
iManufacturer: STR_MANUFACTURER, |
||||
iProduct: STR_PRODUCT, |
||||
iSerialNumber: STR_SERIAL, |
||||
bNumConfigurations: NUM_CONFIGS |
||||
}; |
||||
static struct usb_configuration_descriptor config_descriptors[NUM_CONFIGS] = { |
||||
{ |
||||
bLength: sizeof(struct usb_configuration_descriptor), |
||||
bDescriptorType: USB_DT_CONFIG, |
||||
wTotalLength: (sizeof(struct usb_configuration_descriptor)*NUM_CONFIGS) + |
||||
(sizeof(struct usb_interface_descriptor)*NUM_INTERFACES) + |
||||
(sizeof(struct usb_endpoint_descriptor)*NUM_ENDPOINTS), |
||||
bNumInterfaces: NUM_INTERFACES, |
||||
bConfigurationValue: 1, |
||||
iConfiguration: STR_CONFIG, |
||||
bmAttributes: BMATTRIBUTE_SELF_POWERED | BMATTRIBUTE_RESERVED, |
||||
bMaxPower: USBTTY_MAXPOWER |
||||
}, |
||||
}; |
||||
static struct usb_interface_descriptor interface_descriptors[NUM_INTERFACES] = { |
||||
{ |
||||
bLength: sizeof(struct usb_interface_descriptor), |
||||
bDescriptorType: USB_DT_INTERFACE, |
||||
bInterfaceNumber: 0, |
||||
bAlternateSetting: 0, |
||||
bNumEndpoints: NUM_ENDPOINTS, |
||||
bInterfaceClass: USBTTY_INTERFACE_CLASS, |
||||
bInterfaceSubClass: USBTTY_INTERFACE_SUBCLASS, |
||||
bInterfaceProtocol: USBTTY_INTERFACE_PROTOCOL, |
||||
iInterface: STR_INTERFACE |
||||
}, |
||||
}; |
||||
static struct usb_endpoint_descriptor ep_descriptors[NUM_ENDPOINTS] = { |
||||
{ |
||||
bLength: sizeof(struct usb_endpoint_descriptor), |
||||
bDescriptorType: USB_DT_ENDPOINT, |
||||
bEndpointAddress: CONFIG_USBD_SERIAL_OUT_ENDPOINT | USB_DIR_OUT, |
||||
bmAttributes: USB_ENDPOINT_XFER_BULK, |
||||
wMaxPacketSize: CONFIG_USBD_SERIAL_OUT_PKTSIZE, |
||||
bInterval: 0 |
||||
}, |
||||
{ |
||||
bLength: sizeof(struct usb_endpoint_descriptor), |
||||
bDescriptorType: USB_DT_ENDPOINT, |
||||
bEndpointAddress: CONFIG_USBD_SERIAL_IN_ENDPOINT | USB_DIR_IN, |
||||
bmAttributes: USB_ENDPOINT_XFER_BULK, |
||||
wMaxPacketSize: CONFIG_USBD_SERIAL_IN_PKTSIZE, |
||||
bInterval: 0 |
||||
}, |
||||
{ |
||||
bLength: sizeof(struct usb_endpoint_descriptor), |
||||
bDescriptorType: USB_DT_ENDPOINT, |
||||
bEndpointAddress: CONFIG_USBD_SERIAL_INT_ENDPOINT | USB_DIR_IN, |
||||
bmAttributes: USB_ENDPOINT_XFER_INT, |
||||
wMaxPacketSize: CONFIG_USBD_SERIAL_INT_PKTSIZE, |
||||
bInterval: 0 |
||||
}, |
||||
}; |
||||
static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS] = { |
||||
&(ep_descriptors[0]), |
||||
&(ep_descriptors[1]), |
||||
&(ep_descriptors[2]), |
||||
}; |
||||
|
||||
/* utility function for converting char* to wide string used by USB */ |
||||
static void str2wide (char *str, u16 * wide) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < strlen (str) && str[i]; i++) |
||||
wide[i] = (u16) str[i]; |
||||
} |
||||
|
||||
/*
|
||||
* Prototypes |
||||
*/ |
||||
static void usbtty_init_strings (void); |
||||
static void usbtty_init_instances (void); |
||||
static void usbtty_init_endpoints (void); |
||||
|
||||
static void usbtty_event_handler (struct usb_device_instance *device, |
||||
usb_device_event_t event, int data); |
||||
static int usbtty_configured (void); |
||||
|
||||
static int write_buffer (circbuf_t * buf); |
||||
static int fill_buffer (circbuf_t * buf); |
||||
|
||||
void usbtty_poll (void); |
||||
static void pretend_interrupts (void); |
||||
|
||||
|
||||
/*
|
||||
* Test whether a character is in the RX buffer |
||||
*/ |
||||
int usbtty_tstc (void) |
||||
{ |
||||
usbtty_poll (); |
||||
return (usbtty_input.size > 0); |
||||
} |
||||
|
||||
/*
|
||||
* Read a single byte from the usb client port. Returns 1 on success, 0 |
||||
* otherwise. When the function is succesfull, the character read is |
||||
* written into its argument c. |
||||
*/ |
||||
int usbtty_getc (void) |
||||
{ |
||||
char c; |
||||
|
||||
while (usbtty_input.size <= 0) { |
||||
usbtty_poll (); |
||||
} |
||||
|
||||
buf_pop (&usbtty_input, &c, 1); |
||||
return c; |
||||
} |
||||
|
||||
/*
|
||||
* Output a single byte to the usb client port. |
||||
*/ |
||||
void usbtty_putc (const char c) |
||||
{ |
||||
buf_push (&usbtty_output, &c, 1); |
||||
/* If \n, also do \r */ |
||||
if (c == '\n') |
||||
buf_push (&usbtty_output, "\r", 1); |
||||
|
||||
/* Poll at end to handle new data... */ |
||||
if ((usbtty_output.size + 2) >= usbtty_output.totalsize) { |
||||
usbtty_poll (); |
||||
} |
||||
} |
||||
|
||||
|
||||
/* usbtty_puts() helper function for finding the next '\n' in a string */ |
||||
static int next_nl_pos (const char *s) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; s[i] != '\0'; i++) { |
||||
if (s[i] == '\n') |
||||
return i; |
||||
} |
||||
return i; |
||||
} |
||||
|
||||
/*
|
||||
* Output a string to the usb client port. |
||||
*/ |
||||
static void __usbtty_puts (const char *str, int len) |
||||
{ |
||||
int maxlen = usbtty_output.totalsize; |
||||
int space, n; |
||||
|
||||
/* break str into chunks < buffer size, if needed */ |
||||
while (len > 0) { |
||||
space = maxlen - usbtty_output.size; |
||||
|
||||
/* Empty buffer here, if needed, to ensure space... */ |
||||
if (space <= 0) { |
||||
write_buffer (&usbtty_output); |
||||
space = maxlen - usbtty_output.size; |
||||
if (space <= 0) { |
||||
space = len; /* allow old data to be overwritten. */ |
||||
} |
||||
} |
||||
|
||||
n = MIN (space, MIN (len, maxlen)); |
||||
buf_push (&usbtty_output, str, n); |
||||
|
||||
str += n; |
||||
len -= n; |
||||
} |
||||
} |
||||
|
||||
void usbtty_puts (const char *str) |
||||
{ |
||||
int n; |
||||
int len = strlen (str); |
||||
|
||||
/* add '\r' for each '\n' */ |
||||
while (len > 0) { |
||||
n = next_nl_pos (str); |
||||
|
||||
if (str[n] == '\n') { |
||||
__usbtty_puts (str, n + 1); |
||||
__usbtty_puts ("\r", 1); |
||||
str += (n + 1); |
||||
len -= (n + 1); |
||||
} else { |
||||
/* No \n found. All done. */ |
||||
__usbtty_puts (str, n); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Poll at end to handle new data... */ |
||||
usbtty_poll (); |
||||
} |
||||
|
||||
/*
|
||||
* Initialize the usb client port. |
||||
* |
||||
*/ |
||||
int drv_usbtty_init (void) |
||||
{ |
||||
int rc; |
||||
|
||||
|
||||
/* prepare buffers... */ |
||||
buf_init (&usbtty_input, USBTTY_BUFFER_SIZE); |
||||
buf_init (&usbtty_output, USBTTY_BUFFER_SIZE); |
||||
|
||||
/* Now, set up USB controller and infrastructure */ |
||||
udc_init (); /* Basic USB initialization */ |
||||
|
||||
usbtty_init_strings (); |
||||
usbtty_init_instances (); |
||||
|
||||
udc_startup_events (device_instance); /* Enable our device, initialize udc pointers */ |
||||
udc_connect (); /* Enable pullup for host detection */ |
||||
|
||||
usbtty_init_endpoints (); |
||||
|
||||
/* Device initialization */ |
||||
memset (&usbttydev, 0, sizeof (usbttydev)); |
||||
|
||||
strcpy (usbttydev.name, "usbtty"); |
||||
usbttydev.ext = 0; /* No extensions */ |
||||
usbttydev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT; |
||||
usbttydev.tstc = usbtty_tstc; /* 'tstc' function */ |
||||
usbttydev.getc = usbtty_getc; /* 'getc' function */ |
||||
usbttydev.putc = usbtty_putc; /* 'putc' function */ |
||||
usbttydev.puts = usbtty_puts; /* 'puts' function */ |
||||
|
||||
rc = device_register (&usbttydev); |
||||
|
||||
return (rc == 0) ? 1 : rc; |
||||
} |
||||
|
||||
static void usbtty_init_strings (void) |
||||
{ |
||||
struct usb_string_descriptor *string; |
||||
|
||||
string = (struct usb_string_descriptor *) wstrManufacturer; |
||||
string->bLength = sizeof (wstrManufacturer); |
||||
string->bDescriptorType = USB_DT_STRING; |
||||
str2wide (CONFIG_USBD_MANUFACTURER, string->wData); |
||||
|
||||
string = (struct usb_string_descriptor *) wstrProduct; |
||||
string->bLength = sizeof (wstrProduct); |
||||
string->bDescriptorType = USB_DT_STRING; |
||||
str2wide (CONFIG_USBD_PRODUCT_NAME, string->wData); |
||||
|
||||
string = (struct usb_string_descriptor *) wstrSerial; |
||||
string->bLength = sizeof (wstrSerial); |
||||
string->bDescriptorType = USB_DT_STRING; |
||||
str2wide (CONFIG_USBD_SERIAL_NUMBER, string->wData); |
||||
|
||||
string = (struct usb_string_descriptor *) wstrConfiguration; |
||||
string->bLength = sizeof (wstrConfiguration); |
||||
string->bDescriptorType = USB_DT_STRING; |
||||
str2wide (CONFIG_USBD_CONFIGURATION_STR, string->wData); |
||||
|
||||
string = (struct usb_string_descriptor *) wstrInterface; |
||||
string->bLength = sizeof (wstrInterface); |
||||
string->bDescriptorType = USB_DT_STRING; |
||||
str2wide (CONFIG_USBD_INTERFACE_STR, string->wData); |
||||
|
||||
/* Now, initialize the string table for ep0 handling */ |
||||
usb_strings = usbtty_string_table; |
||||
} |
||||
|
||||
static void usbtty_init_instances (void) |
||||
{ |
||||
int i; |
||||
|
||||
/* initialize device instance */ |
||||
memset (device_instance, 0, sizeof (struct usb_device_instance)); |
||||
device_instance->device_state = STATE_INIT; |
||||
device_instance->device_descriptor = &device_descriptor; |
||||
device_instance->event = usbtty_event_handler; |
||||
device_instance->bus = bus_instance; |
||||
device_instance->configurations = NUM_CONFIGS; |
||||
device_instance->configuration_instance_array = config_instance; |
||||
|
||||
/* initialize bus instance */ |
||||
memset (bus_instance, 0, sizeof (struct usb_bus_instance)); |
||||
bus_instance->device = device_instance; |
||||
bus_instance->endpoint_array = endpoint_instance; |
||||
bus_instance->max_endpoints = 1; |
||||
bus_instance->maxpacketsize = 64; |
||||
bus_instance->serial_number_str = CONFIG_USBD_SERIAL_NUMBER; |
||||
|
||||
/* configuration instance */ |
||||
memset (config_instance, 0, |
||||
sizeof (struct usb_configuration_instance)); |
||||
config_instance->interfaces = NUM_INTERFACES; |
||||
config_instance->configuration_descriptor = config_descriptors; |
||||
config_instance->interface_instance_array = interface_instance; |
||||
|
||||
/* interface instance */ |
||||
memset (interface_instance, 0, |
||||
sizeof (struct usb_interface_instance)); |
||||
interface_instance->alternates = 1; |
||||
interface_instance->alternates_instance_array = alternate_instance; |
||||
|
||||
/* alternates instance */ |
||||
memset (alternate_instance, 0, |
||||
sizeof (struct usb_alternate_instance)); |
||||
alternate_instance->interface_descriptor = interface_descriptors; |
||||
alternate_instance->endpoints = NUM_ENDPOINTS; |
||||
alternate_instance->endpoints_descriptor_array = ep_descriptor_ptrs; |
||||
|
||||
/* endpoint instances */ |
||||
memset (&endpoint_instance[0], 0, |
||||
sizeof (struct usb_endpoint_instance)); |
||||
endpoint_instance[0].endpoint_address = 0; |
||||
endpoint_instance[0].rcv_packetSize = EP0_MAX_PACKET_SIZE; |
||||
endpoint_instance[0].rcv_attributes = USB_ENDPOINT_XFER_CONTROL; |
||||
endpoint_instance[0].tx_packetSize = EP0_MAX_PACKET_SIZE; |
||||
endpoint_instance[0].tx_attributes = USB_ENDPOINT_XFER_CONTROL; |
||||
udc_setup_ep (device_instance, 0, &endpoint_instance[0]); |
||||
|
||||
for (i = 1; i <= NUM_ENDPOINTS; i++) { |
||||
memset (&endpoint_instance[i], 0, |
||||
sizeof (struct usb_endpoint_instance)); |
||||
|
||||
endpoint_instance[i].endpoint_address = |
||||
ep_descriptors[i - 1].bEndpointAddress; |
||||
|
||||
endpoint_instance[i].rcv_packetSize = |
||||
ep_descriptors[i - 1].wMaxPacketSize; |
||||
endpoint_instance[i].rcv_attributes = |
||||
ep_descriptors[i - 1].bmAttributes; |
||||
|
||||
endpoint_instance[i].tx_packetSize = |
||||
ep_descriptors[i - 1].wMaxPacketSize; |
||||
endpoint_instance[i].tx_attributes = |
||||
ep_descriptors[i - 1].bmAttributes; |
||||
|
||||
urb_link_init (&endpoint_instance[i].rcv); |
||||
urb_link_init (&endpoint_instance[i].rdy); |
||||
urb_link_init (&endpoint_instance[i].tx); |
||||
urb_link_init (&endpoint_instance[i].done); |
||||
|
||||
if (endpoint_instance[i].endpoint_address & USB_DIR_IN) |
||||
endpoint_instance[i].tx_urb = |
||||
usbd_alloc_urb (device_instance, |
||||
&endpoint_instance[i]); |
||||
else |
||||
endpoint_instance[i].rcv_urb = |
||||
usbd_alloc_urb (device_instance, |
||||
&endpoint_instance[i]); |
||||
} |
||||
} |
||||
|
||||
static void usbtty_init_endpoints (void) |
||||
{ |
||||
int i; |
||||
|
||||
bus_instance->max_endpoints = NUM_ENDPOINTS + 1; |
||||
for (i = 0; i <= NUM_ENDPOINTS; i++) { |
||||
udc_setup_ep (device_instance, i, &endpoint_instance[i]); |
||||
} |
||||
} |
||||
|
||||
|
||||
/*********************************************************************************/ |
||||
|
||||
static struct urb *next_urb (struct usb_device_instance *device, |
||||
struct usb_endpoint_instance *endpoint) |
||||
{ |
||||
struct urb *current_urb = NULL; |
||||
int space; |
||||
|
||||
/* If there's a queue, then we should add to the last urb */ |
||||
if (!endpoint->tx_queue) { |
||||
current_urb = endpoint->tx_urb; |
||||
} else { |
||||
/* Last urb from tx chain */ |
||||
current_urb = |
||||
p2surround (struct urb, link, endpoint->tx.prev); |
||||
} |
||||
|
||||
/* Make sure this one has enough room */ |
||||
space = current_urb->buffer_length - current_urb->actual_length; |
||||
if (space > 0) { |
||||
return current_urb; |
||||
} else { /* No space here */ |
||||
/* First look at done list */ |
||||
current_urb = first_urb_detached (&endpoint->done); |
||||
if (!current_urb) { |
||||
current_urb = usbd_alloc_urb (device, endpoint); |
||||
} |
||||
|
||||
urb_append (&endpoint->tx, current_urb); |
||||
endpoint->tx_queue++; |
||||
} |
||||
return current_urb; |
||||
} |
||||
|
||||
static int write_buffer (circbuf_t * buf) |
||||
{ |
||||
if (!usbtty_configured ()) { |
||||
return 0; |
||||
} |
||||
|
||||
if (buf->size) { |
||||
|
||||
struct usb_endpoint_instance *endpoint = |
||||
&endpoint_instance[TX_ENDPOINT]; |
||||
struct urb *current_urb = NULL; |
||||
char *dest; |
||||
|
||||
int space_avail; |
||||
int popnum, popped; |
||||
int total = 0; |
||||
|
||||
/* Break buffer into urb sized pieces, and link each to the endpoint */ |
||||
while (buf->size > 0) { |
||||
current_urb = next_urb (device_instance, endpoint); |
||||
if (!current_urb) { |
||||
TTYERR ("current_urb is NULL, buf->size %d\n", |
||||
buf->size); |
||||
return total; |
||||
} |
||||
|
||||
dest = current_urb->buffer + |
||||
current_urb->actual_length; |
||||
|
||||
space_avail = |
||||
current_urb->buffer_length - |
||||
current_urb->actual_length; |
||||
popnum = MIN (space_avail, buf->size); |
||||
if (popnum == 0) |
||||
break; |
||||
|
||||
popped = buf_pop (buf, dest, popnum); |
||||
if (popped == 0) |
||||
break; |
||||
current_urb->actual_length += popped; |
||||
total += popped; |
||||
|
||||
/* If endpoint->last == 0, then transfers have not started on this endpoint */ |
||||
if (endpoint->last == 0) { |
||||
udc_endpoint_write (endpoint); |
||||
} |
||||
|
||||
} /* end while */ |
||||
return total; |
||||
} /* end if tx_urb */ |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int fill_buffer (circbuf_t * buf) |
||||
{ |
||||
struct usb_endpoint_instance *endpoint = |
||||
&endpoint_instance[RECV_ENDPOINT]; |
||||
|
||||
if (endpoint->rcv_urb && endpoint->rcv_urb->actual_length) { |
||||
unsigned int nb = endpoint->rcv_urb->actual_length; |
||||
char *src = (char *) endpoint->rcv_urb->buffer; |
||||
|
||||
buf_push (buf, src, nb); |
||||
endpoint->rcv_urb->actual_length = 0; |
||||
|
||||
return nb; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int usbtty_configured (void) |
||||
{ |
||||
return usbtty_configured_flag; |
||||
} |
||||
|
||||
/*********************************************************************************/ |
||||
|
||||
static void usbtty_event_handler (struct usb_device_instance *device, |
||||
usb_device_event_t event, int data) |
||||
{ |
||||
switch (event) { |
||||
case DEVICE_RESET: |
||||
case DEVICE_BUS_INACTIVE: |
||||
usbtty_configured_flag = 0; |
||||
break; |
||||
case DEVICE_CONFIGURED: |
||||
usbtty_configured_flag = 1; |
||||
break; |
||||
|
||||
case DEVICE_ADDRESS_ASSIGNED: |
||||
usbtty_init_endpoints (); |
||||
|
||||
default: |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/*********************************************************************************/ |
||||
|
||||
|
||||
/*
|
||||
* Since interrupt handling has not yet been implemented, we use this function |
||||
* to handle polling. This is called by the tstc,getc,putc,puts routines to |
||||
* update the USB state. |
||||
*/ |
||||
void usbtty_poll (void) |
||||
{ |
||||
/* New interrupts? */ |
||||
pretend_interrupts (); |
||||
|
||||
/* Write any output data to host buffer (do this before checking interrupts to avoid missing one) */ |
||||
if (usbtty_configured ()) { |
||||
write_buffer (&usbtty_output); |
||||
} |
||||
|
||||
/* New interrupts? */ |
||||
pretend_interrupts (); |
||||
|
||||
/* Check for new data from host.. (do this after checking interrupts to get latest data) */ |
||||
if (usbtty_configured ()) { |
||||
fill_buffer (&usbtty_input); |
||||
} |
||||
|
||||
/* New interrupts? */ |
||||
pretend_interrupts (); |
||||
} |
||||
|
||||
static void pretend_interrupts (void) |
||||
{ |
||||
/* Loop while we have interrupts.
|
||||
* If we don't do this, the input chain |
||||
* polling delay is likely to miss |
||||
* host requests. |
||||
*/ |
||||
while (inw (UDC_IRQ_SRC) & ~UDC_SOF_Flg) { |
||||
/* Handle any new IRQs */ |
||||
omap1510_udc_irq (); |
||||
omap1510_udc_noniso_irq (); |
||||
} |
||||
} |
||||
#endif |
@ -0,0 +1,64 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* 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. |
||||
* |
||||
* 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 |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __USB_TTY_H__ |
||||
#define __USB_TTY_H__ |
||||
|
||||
|
||||
#include "usbdcore.h" |
||||
#include "usbdcore_omap1510.h" |
||||
|
||||
|
||||
#define NUM_CONFIGS 1 |
||||
#define NUM_INTERFACES 1 |
||||
#define NUM_ENDPOINTS 3 |
||||
|
||||
#define EP0_MAX_PACKET_SIZE 64 |
||||
|
||||
#define CONFIG_USBD_CONFIGURATION_STR "TTY via USB" |
||||
#define CONFIG_USBD_INTERFACE_STR "Simple Serial Data Interface - Bulk Mode" |
||||
|
||||
|
||||
#define CONFIG_USBD_SERIAL_OUT_ENDPOINT 2 |
||||
#define CONFIG_USBD_SERIAL_OUT_PKTSIZE 64 |
||||
#define CONFIG_USBD_SERIAL_IN_ENDPOINT 1 |
||||
#define CONFIG_USBD_SERIAL_IN_PKTSIZE 64 |
||||
#define CONFIG_USBD_SERIAL_INT_ENDPOINT 5 |
||||
#define CONFIG_USBD_SERIAL_INT_PKTSIZE 16 |
||||
|
||||
|
||||
#define USBTTY_DEVICE_CLASS COMMUNICATIONS_DEVICE_CLASS |
||||
#define USBTTY_DEVICE_SUBCLASS COMMUNICATIONS_NO_SUBCLASS |
||||
#define USBTTY_DEVICE_PROTOCOL COMMUNICATIONS_NO_PROTOCOL |
||||
|
||||
#define USBTTY_INTERFACE_CLASS 0xFF /* Vendor Specific */ |
||||
#define USBTTY_INTERFACE_SUBCLASS 0x02 |
||||
#define USBTTY_INTERFACE_PROTOCOL 0x01 |
||||
|
||||
#define USBTTY_BCD_DEVICE 0x0 |
||||
#define USBTTY_MAXPOWER 0x0 |
||||
|
||||
#define STR_MANUFACTURER 1 |
||||
#define STR_PRODUCT 2 |
||||
#define STR_SERIAL 3 |
||||
#define STR_CONFIG 4 |
||||
#define STR_INTERFACE 5 |
||||
|
||||
#endif |
@ -0,0 +1,40 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* 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. |
||||
* |
||||
* 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 |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __CIRCBUF_H__ |
||||
#define __CIRCBUF_H__ |
||||
|
||||
typedef struct circbuf { |
||||
unsigned int size; /* current number of bytes held */ |
||||
unsigned int totalsize; /* number of bytes allocated */ |
||||
|
||||
char *top; /* pointer to current buffer start */ |
||||
char *tail; /* pointer to space for next element */ |
||||
|
||||
char *data; /* all data */ |
||||
char *end; /* end of data buffer */ |
||||
} circbuf_t; |
||||
|
||||
int buf_init (circbuf_t * buf, unsigned int size); |
||||
int buf_free (circbuf_t * buf); |
||||
int buf_pop (circbuf_t * buf, char *dest, unsigned int len); |
||||
int buf_push (circbuf_t * buf, const char *src, unsigned int len); |
||||
|
||||
#endif |
@ -0,0 +1,177 @@ |
||||
/*
|
||||
* (C) Copyright 2004 |
||||
* Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
||||
* |
||||
* 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 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. |
||||
* |
||||
* 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 |
||||
*/ |
||||
#ifndef __CONFIG_H |
||||
#define __CONFIG_H |
||||
|
||||
/*
|
||||
* If we are developing, we might want to start armboot from ram |
||||
* so we MUST NOT initialize critical regs like mem-timing ... |
||||
*/ |
||||
#define CONFIG_INIT_CRITICAL /* undef for developing */ |
||||
|
||||
/*
|
||||
* High Level Configuration Options |
||||
* (easy to change) |
||||
*/ |
||||
#define CONFIG_ARM925T 1 /* This is an arm925t CPU */ |
||||
#define CONFIG_OMAP 1 /* in a TI OMAP core */ |
||||
#define CONFIG_OMAP1510 1 /* which is in a 1510 (helen) */ |
||||
#define CONFIG_OMAP_SX1 1 /* a SX1 Board */ |
||||
|
||||
/* input clock of PLL */ |
||||
#define CONFIG_SYS_CLK_FREQ 12000000 /* the SX1 has 12MHz input clock */ |
||||
|
||||
#undef CONFIG_USE_IRQ /* we don't need IRQ/FIQ stuff */ |
||||
|
||||
#define CONFIG_MISC_INIT_R |
||||
|
||||
#define CONFIG_CMDLINE_TAG 1 /* enable passing of ATAGs */ |
||||
#define CONFIG_SETUP_MEMORY_TAGS 1 |
||||
#define CONFIG_INITRD_TAG 1 |
||||
|
||||
/*
|
||||
* Size of malloc() pool |
||||
*/ |
||||
#define CFG_MALLOC_LEN (CFG_ENV_SIZE + 128*1024) |
||||
#define CFG_GBL_DATA_SIZE 128 /* size in bytes reserved for initial data */ |
||||
|
||||
/*
|
||||
* Hardware drivers |
||||
*/ |
||||
|
||||
/*
|
||||
* NS16550 Configuration |
||||
*/ |
||||
#define CFG_NS16550 |
||||
#define CFG_NS16550_SERIAL |
||||
#define CFG_NS16550_REG_SIZE (-4) |
||||
#define CFG_NS16550_CLK (CONFIG_SYS_CLK_FREQ) /* can be 12M/32Khz or 48Mhz */ |
||||
#define CFG_NS16550_COM1 0xfffb0000 /* uart1, bluetooth uart on helen */ |
||||
|
||||
/*
|
||||
* select serial console configuration |
||||
*/ |
||||
#define CONFIG_SERIAL1 1 /* we use SERIAL 1 on SX1 */ |
||||
|
||||
/*
|
||||
* USB device configuration |
||||
*/ |
||||
#define CONFIG_USB_DEVICE 1 |
||||
#define CONFIG_USB_TTY 1 |
||||
|
||||
#define CONFIG_USBD_VENDORID 0x1234 |
||||
#define CONFIG_USBD_PRODUCTID 0x5678 |
||||
#define CONFIG_USBD_MANUFACTURER "Siemens" |
||||
#define CONFIG_USBD_PRODUCT_NAME "SX1" |
||||
#define CONFIG_USBD_SERIAL_NUMBER "000000000001" |
||||
|
||||
|
||||
/*
|
||||
* I2C configuration |
||||
*/ |
||||
#define CONFIG_HARD_I2C |
||||
#define CFG_I2C_SPEED 100000 |
||||
#define CFG_I2C_SLAVE 1 |
||||
#define CONFIG_DRIVER_OMAP1510_I2C |
||||
|
||||
#define CONFIG_ENV_OVERWRITE |
||||
|
||||
#define CONFIG_ENV_OVERWRITE |
||||
#define CONFIG_CONS_INDEX 1 |
||||
#define CONFIG_BAUDRATE 115200 |
||||
#define CFG_BAUDRATE_TABLE { 9600, 19200, 38400, 57600, 115200 } |
||||
|
||||
#define CONFIG_COMMANDS (( CONFIG_CMD_DFL | \ |
||||
CFG_CMD_I2C ) & \
|
||||
~CFG_CMD_NET) |
||||
|
||||
/* this must be included AFTER the definition of CONFIG_COMMANDS (if any) */ |
||||
#include <cmd_confdefs.h> |
||||
#include <configs/omap1510.h> |
||||
|
||||
#define CONFIG_BOOTDELAY 3 |
||||
#define CONFIG_BOOTARGS "mem=16M console=ttyS0,115200n8 root=/dev/mtdblock3 rw" |
||||
|
||||
/*
|
||||
* Miscellaneous configurable options |
||||
*/ |
||||
#define CFG_LONGHELP /* undef to save memory */ |
||||
#define CFG_PROMPT "SX1# " /* Monitor Command Prompt */ |
||||
#define CFG_CBSIZE 256 /* Console I/O Buffer Size */ |
||||
#define CFG_PBSIZE (CFG_CBSIZE+sizeof(CFG_PROMPT)+16) /* Print Buffer Size */ |
||||
#define CFG_MAXARGS 16 /* max number of command args */ |
||||
#define CFG_BARGSIZE CFG_CBSIZE /* Boot Argument Buffer Size */ |
||||
|
||||
#define CFG_MEMTEST_START 0x10000000 /* memtest works on */ |
||||
#define CFG_MEMTEST_END 0x12000000 /* 32 MB in DRAM */ |
||||
|
||||
#undef CFG_CLKS_IN_HZ /* everything, incl board info, in Hz */ |
||||
|
||||
#define CFG_LOAD_ADDR 0x10000000 /* default load address */ |
||||
|
||||
/* The 1510 has 3 timers, they can be driven by the RefClk (12Mhz) or by DPLL1.
|
||||
* This time is further subdivided by a local divisor. |
||||
*/ |
||||
#define CFG_TIMERBASE 0xFFFEC500 /* use timer 1 */ |
||||
#define CFG_PVT 7 /* 2^(pvt+1), divide by 256 */ |
||||
#define CFG_HZ ((CONFIG_SYS_CLK_FREQ)/(2 << CFG_PVT)) |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Stack sizes |
||||
* |
||||
* The stack sizes are set up in start.S using the settings below |
||||
*/ |
||||
#define CONFIG_STACKSIZE (128*1024) /* regular stack */ |
||||
#ifdef CONFIG_USE_IRQ |
||||
#define CONFIG_STACKSIZE_IRQ (4*1024) /* IRQ stack */ |
||||
#define CONFIG_STACKSIZE_FIQ (4*1024) /* FIQ stack */ |
||||
#endif |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Physical Memory Map |
||||
*/ |
||||
#define CONFIG_NR_DRAM_BANKS 1 /* we have 1 bank of DRAM */ |
||||
#define PHYS_SDRAM_1 0x10000000 /* SDRAM Bank #1 */ |
||||
#define PHYS_SDRAM_1_SIZE 0x02000000 /* 32 MB */ |
||||
|
||||
#define PHYS_FLASH_1 0x00000000 /* Flash Bank #1 */ |
||||
#define PHYS_FLASH_2 0x04000000 /* Flash Bank #2 */ |
||||
|
||||
#define CFG_FLASH_BASE PHYS_FLASH_1 |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* FLASH and environment organization |
||||
*/ |
||||
#define CFG_MAX_FLASH_BANKS 2 /* max number of memory banks */ |
||||
#define CFG_MAX_FLASH_SECT (128) /* max number of sectors on one chip */ |
||||
#define CFG_ENV_ADDR (CFG_FLASH_BASE + 0x020000) /* addr of environment */ |
||||
|
||||
/* timeout values are in ticks */ |
||||
#define CFG_FLASH_ERASE_TOUT (20*CFG_HZ) /* Timeout for Flash Erase */ |
||||
#define CFG_FLASH_WRITE_TOUT (20*CFG_HZ) /* Timeout for Flash Write */ |
||||
|
||||
#define CFG_ENV_IS_IN_FLASH 1 |
||||
#define CFG_ENV_SIZE 0x20000 /* Total Size of Environment Sector */ |
||||
#define CFG_ENV_OFFSET 0x20000 /* environment starts here */ |
||||
|
||||
#endif /* __CONFIG_H */ |
@ -0,0 +1,671 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* Based on linux/drivers/usbd/usbd.h |
||||
* |
||||
* Copyright (c) 2000, 2001, 2002 Lineo |
||||
* Copyright (c) 2001 Hewlett Packard |
||||
* |
||||
* By: |
||||
* Stuart Lynne <sl@lineo.com>, |
||||
* Tom Rushworth <tbr@lineo.com>, |
||||
* Bruce Balden <balden@lineo.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. |
||||
* |
||||
* 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __USBDCORE_H__ |
||||
#define __USBDCORE_H__ |
||||
|
||||
#include <common.h> |
||||
#include "usbdescriptors.h" |
||||
|
||||
|
||||
#define MAX_URBS_QUEUED 5 |
||||
|
||||
|
||||
#if 1 |
||||
#define usberr(fmt,args...) serial_printf("ERROR: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args) |
||||
#else |
||||
#define usberr(fmt,args...) do{}while(0) |
||||
#endif |
||||
|
||||
#if 0 |
||||
#define usbdbg(fmt,args...) serial_printf("debug: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args) |
||||
#else |
||||
#define usbdbg(fmt,args...) do{}while(0) |
||||
#endif |
||||
|
||||
#if 0 |
||||
#define usbinfo(fmt,args...) serial_printf("info: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args) |
||||
#else |
||||
#define usbinfo(fmt,args...) do{}while(0) |
||||
#endif |
||||
|
||||
#ifndef le16_to_cpu |
||||
#define le16_to_cpu(x) (x) |
||||
#endif |
||||
|
||||
#ifndef inb |
||||
#define inb(p) (*(volatile u8*)(p)) |
||||
#endif |
||||
|
||||
#ifndef outb |
||||
#define outb(val,p) (*(volatile u8*)(p) = (val)) |
||||
#endif |
||||
|
||||
#ifndef inw |
||||
#define inw(p) (*(volatile u16*)(p)) |
||||
#endif |
||||
|
||||
#ifndef outw |
||||
#define outw(val,p) (*(volatile u16*)(p) = (val)) |
||||
#endif |
||||
|
||||
#ifndef inl |
||||
#define inl(p) (*(volatile u32*)(p)) |
||||
#endif |
||||
|
||||
#ifndef outl |
||||
#define outl(val,p) (*(volatile u32*)(p) = (val)) |
||||
#endif |
||||
|
||||
#ifndef insw |
||||
#define insw(p,to,len) mmio_insw(p,to,len) |
||||
#endif |
||||
|
||||
#ifndef outsw |
||||
#define outsw(p,from,len) mmio_outsw(p,from,len) |
||||
#endif |
||||
|
||||
#ifndef insb |
||||
#define insb(p,to,len) mmio_insb(p,to,len) |
||||
#endif |
||||
|
||||
#ifndef mmio_insw |
||||
#define mmio_insw(r,b,l) ({ int __i ; \ |
||||
u16 *__b2; \
|
||||
__b2 = (u16 *) b; \
|
||||
for (__i = 0; __i < l; __i++) { \
|
||||
*(__b2 + __i) = inw(r); \
|
||||
}; \
|
||||
}) |
||||
#endif |
||||
|
||||
#ifndef mmio_outsw |
||||
#define mmio_outsw(r,b,l) ({ int __i; \ |
||||
u16 *__b2; \
|
||||
__b2 = (u16 *) b; \
|
||||
for (__i = 0; __i < l; __i++) { \
|
||||
outw( *(__b2 + __i), r); \
|
||||
} \
|
||||
}) |
||||
#endif |
||||
|
||||
#ifndef mmio_insb |
||||
#define mmio_insb(r,b,l) ({ int __i ; \ |
||||
u8 *__b2; \
|
||||
__b2 = (u8 *) b; \
|
||||
for (__i = 0; __i < l; __i++) { \
|
||||
*(__b2 + __i) = inb(r); \
|
||||
}; \
|
||||
}) |
||||
#endif |
||||
|
||||
#ifndef MIN |
||||
#define MIN(a,b) ((a) < (b) ? (a) : (b)) |
||||
#endif |
||||
#ifndef MAX |
||||
#define MAX(a,b) ((a) > (b) ? (a) : (b)) |
||||
#endif |
||||
|
||||
|
||||
/*
|
||||
* Structure member address manipulation macros. |
||||
* These are used by client code (code using the urb_link routines), since |
||||
* the urb_link structure is embedded in the client data structures. |
||||
* |
||||
* Note: a macro offsetof equivalent to member_offset is defined in stddef.h |
||||
* but this is kept here for the sake of portability. |
||||
* |
||||
* p2surround returns a pointer to the surrounding structure given |
||||
* type of the surrounding structure, the name memb of the structure |
||||
* member pointed at by ptr. For example, if you have: |
||||
* |
||||
* struct foo { |
||||
* int x; |
||||
* float y; |
||||
* char z; |
||||
* } thingy; |
||||
* |
||||
* char *cp = &thingy.z; |
||||
* |
||||
* then |
||||
* |
||||
* &thingy == p2surround(struct foo, z, cp) |
||||
* |
||||
* Clear? |
||||
*/ |
||||
#define _cv_(ptr) ((char*)(void*)(ptr)) |
||||
#define member_offset(type,memb) (_cv_(&(((type*)0)->memb))-(char*)0) |
||||
#define p2surround(type,memb,ptr) ((type*)(void*)(_cv_(ptr)-member_offset(type,memb))) |
||||
|
||||
struct urb; |
||||
|
||||
struct usb_endpoint_instance; |
||||
struct usb_interface_instance; |
||||
struct usb_configuration_instance; |
||||
struct usb_device_instance; |
||||
struct usb_bus_instance; |
||||
|
||||
/*
|
||||
* Device and/or Interface Class codes |
||||
*/ |
||||
#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */ |
||||
#define USB_CLASS_AUDIO 1 |
||||
#define USB_CLASS_COMM 2 |
||||
#define USB_CLASS_HID 3 |
||||
#define USB_CLASS_PHYSICAL 5 |
||||
#define USB_CLASS_PRINTER 7 |
||||
#define USB_CLASS_MASS_STORAGE 8 |
||||
#define USB_CLASS_HUB 9 |
||||
#define USB_CLASS_DATA 10 |
||||
#define USB_CLASS_APP_SPEC 0xfe |
||||
#define USB_CLASS_VENDOR_SPEC 0xff |
||||
|
||||
/*
|
||||
* USB types |
||||
*/ |
||||
#define USB_TYPE_STANDARD (0x00 << 5) |
||||
#define USB_TYPE_CLASS (0x01 << 5) |
||||
#define USB_TYPE_VENDOR (0x02 << 5) |
||||
#define USB_TYPE_RESERVED (0x03 << 5) |
||||
|
||||
/*
|
||||
* USB recipients |
||||
*/ |
||||
#define USB_RECIP_DEVICE 0x00 |
||||
#define USB_RECIP_INTERFACE 0x01 |
||||
#define USB_RECIP_ENDPOINT 0x02 |
||||
#define USB_RECIP_OTHER 0x03 |
||||
|
||||
/*
|
||||
* USB directions |
||||
*/ |
||||
#define USB_DIR_OUT 0 |
||||
#define USB_DIR_IN 0x80 |
||||
|
||||
/*
|
||||
* Descriptor types |
||||
*/ |
||||
#define USB_DT_DEVICE 0x01 |
||||
#define USB_DT_CONFIG 0x02 |
||||
#define USB_DT_STRING 0x03 |
||||
#define USB_DT_INTERFACE 0x04 |
||||
#define USB_DT_ENDPOINT 0x05 |
||||
|
||||
#define USB_DT_HID (USB_TYPE_CLASS | 0x01) |
||||
#define USB_DT_REPORT (USB_TYPE_CLASS | 0x02) |
||||
#define USB_DT_PHYSICAL (USB_TYPE_CLASS | 0x03) |
||||
#define USB_DT_HUB (USB_TYPE_CLASS | 0x09) |
||||
|
||||
/*
|
||||
* Descriptor sizes per descriptor type |
||||
*/ |
||||
#define USB_DT_DEVICE_SIZE 18 |
||||
#define USB_DT_CONFIG_SIZE 9 |
||||
#define USB_DT_INTERFACE_SIZE 9 |
||||
#define USB_DT_ENDPOINT_SIZE 7 |
||||
#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ |
||||
#define USB_DT_HUB_NONVAR_SIZE 7 |
||||
#define USB_DT_HID_SIZE 9 |
||||
|
||||
/*
|
||||
* Endpoints |
||||
*/ |
||||
#define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */ |
||||
#define USB_ENDPOINT_DIR_MASK 0x80 |
||||
|
||||
#define USB_ENDPOINT_XFERTYPE_MASK 0x03 /* in bmAttributes */ |
||||
#define USB_ENDPOINT_XFER_CONTROL 0 |
||||
#define USB_ENDPOINT_XFER_ISOC 1 |
||||
#define USB_ENDPOINT_XFER_BULK 2 |
||||
#define USB_ENDPOINT_XFER_INT 3 |
||||
|
||||
/*
|
||||
* USB Packet IDs (PIDs) |
||||
*/ |
||||
#define USB_PID_UNDEF_0 0xf0 |
||||
#define USB_PID_OUT 0xe1 |
||||
#define USB_PID_ACK 0xd2 |
||||
#define USB_PID_DATA0 0xc3 |
||||
#define USB_PID_PING 0xb4 /* USB 2.0 */ |
||||
#define USB_PID_SOF 0xa5 |
||||
#define USB_PID_NYET 0x96 /* USB 2.0 */ |
||||
#define USB_PID_DATA2 0x87 /* USB 2.0 */ |
||||
#define USB_PID_SPLIT 0x78 /* USB 2.0 */ |
||||
#define USB_PID_IN 0x69 |
||||
#define USB_PID_NAK 0x5a |
||||
#define USB_PID_DATA1 0x4b |
||||
#define USB_PID_PREAMBLE 0x3c /* Token mode */ |
||||
#define USB_PID_ERR 0x3c /* USB 2.0: handshake mode */ |
||||
#define USB_PID_SETUP 0x2d |
||||
#define USB_PID_STALL 0x1e |
||||
#define USB_PID_MDATA 0x0f /* USB 2.0 */ |
||||
|
||||
/*
|
||||
* Standard requests |
||||
*/ |
||||
#define USB_REQ_GET_STATUS 0x00 |
||||
#define USB_REQ_CLEAR_FEATURE 0x01 |
||||
#define USB_REQ_SET_FEATURE 0x03 |
||||
#define USB_REQ_SET_ADDRESS 0x05 |
||||
#define USB_REQ_GET_DESCRIPTOR 0x06 |
||||
#define USB_REQ_SET_DESCRIPTOR 0x07 |
||||
#define USB_REQ_GET_CONFIGURATION 0x08 |
||||
#define USB_REQ_SET_CONFIGURATION 0x09 |
||||
#define USB_REQ_GET_INTERFACE 0x0A |
||||
#define USB_REQ_SET_INTERFACE 0x0B |
||||
#define USB_REQ_SYNCH_FRAME 0x0C |
||||
|
||||
#define USBD_DEVICE_REQUESTS(x) (((unsigned int)x <= USB_REQ_SYNCH_FRAME) ? usbd_device_requests[x] : "UNKNOWN") |
||||
|
||||
/*
|
||||
* HID requests |
||||
*/ |
||||
#define USB_REQ_GET_REPORT 0x01 |
||||
#define USB_REQ_GET_IDLE 0x02 |
||||
#define USB_REQ_GET_PROTOCOL 0x03 |
||||
#define USB_REQ_SET_REPORT 0x09 |
||||
#define USB_REQ_SET_IDLE 0x0A |
||||
#define USB_REQ_SET_PROTOCOL 0x0B |
||||
|
||||
|
||||
/*
|
||||
* USB Spec Release number |
||||
*/ |
||||
|
||||
#define USB_BCD_VERSION 0x0110 |
||||
|
||||
|
||||
/*
|
||||
* Device Requests (c.f Table 9-2) |
||||
*/ |
||||
|
||||
#define USB_REQ_DIRECTION_MASK 0x80 |
||||
#define USB_REQ_TYPE_MASK 0x60 |
||||
#define USB_REQ_RECIPIENT_MASK 0x1f |
||||
|
||||
#define USB_REQ_DEVICE2HOST 0x80 |
||||
#define USB_REQ_HOST2DEVICE 0x00 |
||||
|
||||
#define USB_REQ_TYPE_STANDARD 0x00 |
||||
#define USB_REQ_TYPE_CLASS 0x20 |
||||
#define USB_REQ_TYPE_VENDOR 0x40 |
||||
|
||||
#define USB_REQ_RECIPIENT_DEVICE 0x00 |
||||
#define USB_REQ_RECIPIENT_INTERFACE 0x01 |
||||
#define USB_REQ_RECIPIENT_ENDPOINT 0x02 |
||||
#define USB_REQ_RECIPIENT_OTHER 0x03 |
||||
|
||||
/*
|
||||
* get status bits |
||||
*/ |
||||
|
||||
#define USB_STATUS_SELFPOWERED 0x01 |
||||
#define USB_STATUS_REMOTEWAKEUP 0x02 |
||||
|
||||
#define USB_STATUS_HALT 0x01 |
||||
|
||||
/*
|
||||
* descriptor types |
||||
*/ |
||||
|
||||
#define USB_DESCRIPTOR_TYPE_DEVICE 0x01 |
||||
#define USB_DESCRIPTOR_TYPE_CONFIGURATION 0x02 |
||||
#define USB_DESCRIPTOR_TYPE_STRING 0x03 |
||||
#define USB_DESCRIPTOR_TYPE_INTERFACE 0x04 |
||||
#define USB_DESCRIPTOR_TYPE_ENDPOINT 0x05 |
||||
#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER 0x06 |
||||
#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION 0x07 |
||||
#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER 0x08 |
||||
#define USB_DESCRIPTOR_TYPE_HID 0x21 |
||||
#define USB_DESCRIPTOR_TYPE_REPORT 0x22 |
||||
|
||||
#define USBD_DEVICE_DESCRIPTORS(x) (((unsigned int)x <= USB_DESCRIPTOR_TYPE_INTERFACE_POWER) ? \ |
||||
usbd_device_descriptors[x] : "UNKNOWN") |
||||
|
||||
/*
|
||||
* standard feature selectors |
||||
*/ |
||||
#define USB_ENDPOINT_HALT 0x00 |
||||
#define USB_DEVICE_REMOTE_WAKEUP 0x01 |
||||
#define USB_TEST_MODE 0x02 |
||||
|
||||
|
||||
/* USB Requests
|
||||
* |
||||
*/ |
||||
|
||||
struct usb_device_request { |
||||
u8 bmRequestType; |
||||
u8 bRequest; |
||||
u16 wValue; |
||||
u16 wIndex; |
||||
u16 wLength; |
||||
} __attribute__ ((packed)); |
||||
|
||||
|
||||
/* USB Status
|
||||
* |
||||
*/ |
||||
typedef enum urb_send_status { |
||||
SEND_IN_PROGRESS, |
||||
SEND_FINISHED_OK, |
||||
SEND_FINISHED_ERROR, |
||||
RECV_READY, |
||||
RECV_OK, |
||||
RECV_ERROR |
||||
} urb_send_status_t; |
||||
|
||||
/*
|
||||
* Device State (c.f USB Spec 2.0 Figure 9-1) |
||||
* |
||||
* What state the usb device is in. |
||||
* |
||||
* Note the state does not change if the device is suspended, we simply set a |
||||
* flag to show that it is suspended. |
||||
* |
||||
*/ |
||||
typedef enum usb_device_state { |
||||
STATE_INIT, /* just initialized */ |
||||
STATE_CREATED, /* just created */ |
||||
STATE_ATTACHED, /* we are attached */ |
||||
STATE_POWERED, /* we have seen power indication (electrical bus signal) */ |
||||
STATE_DEFAULT, /* we been reset */ |
||||
STATE_ADDRESSED, /* we have been addressed (in default configuration) */ |
||||
STATE_CONFIGURED, /* we have seen a set configuration device command */ |
||||
STATE_UNKNOWN, /* destroyed */ |
||||
} usb_device_state_t; |
||||
|
||||
#define USBD_DEVICE_STATE(x) (((unsigned int)x <= STATE_UNKNOWN) ? usbd_device_states[x] : "UNKNOWN") |
||||
|
||||
/*
|
||||
* Device status |
||||
* |
||||
* Overall state |
||||
*/ |
||||
typedef enum usb_device_status { |
||||
USBD_OPENING, /* we are currently opening */ |
||||
USBD_OK, /* ok to use */ |
||||
USBD_SUSPENDED, /* we are currently suspended */ |
||||
USBD_CLOSING, /* we are currently closing */ |
||||
} usb_device_status_t; |
||||
|
||||
#define USBD_DEVICE_STATUS(x) (((unsigned int)x <= USBD_CLOSING) ? usbd_device_status[x] : "UNKNOWN") |
||||
|
||||
/*
|
||||
* Device Events |
||||
* |
||||
* These are defined in the USB Spec (c.f USB Spec 2.0 Figure 9-1). |
||||
* |
||||
* There are additional events defined to handle some extra actions we need |
||||
* to have handled. |
||||
* |
||||
*/ |
||||
typedef enum usb_device_event { |
||||
|
||||
DEVICE_UNKNOWN, /* bi - unknown event */ |
||||
DEVICE_INIT, /* bi - initialize */ |
||||
DEVICE_CREATE, /* bi - */ |
||||
DEVICE_HUB_CONFIGURED, /* bi - bus has been plugged int */ |
||||
DEVICE_RESET, /* bi - hub has powered our port */ |
||||
|
||||
DEVICE_ADDRESS_ASSIGNED, /* ep0 - set address setup received */ |
||||
DEVICE_CONFIGURED, /* ep0 - set configure setup received */ |
||||
DEVICE_SET_INTERFACE, /* ep0 - set interface setup received */ |
||||
|
||||
DEVICE_SET_FEATURE, /* ep0 - set feature setup received */ |
||||
DEVICE_CLEAR_FEATURE, /* ep0 - clear feature setup received */ |
||||
|
||||
DEVICE_DE_CONFIGURED, /* ep0 - set configure setup received for ?? */ |
||||
|
||||
DEVICE_BUS_INACTIVE, /* bi - bus in inactive (no SOF packets) */ |
||||
DEVICE_BUS_ACTIVITY, /* bi - bus is active again */ |
||||
|
||||
DEVICE_POWER_INTERRUPTION, /* bi - hub has depowered our port */ |
||||
DEVICE_HUB_RESET, /* bi - bus has been unplugged */ |
||||
DEVICE_DESTROY, /* bi - device instance should be destroyed */ |
||||
|
||||
DEVICE_HOTPLUG, /* bi - a hotplug event has occured */ |
||||
|
||||
DEVICE_FUNCTION_PRIVATE, /* function - private */ |
||||
|
||||
} usb_device_event_t; |
||||
|
||||
|
||||
typedef struct urb_link { |
||||
struct urb_link *next; |
||||
struct urb_link *prev; |
||||
} urb_link; |
||||
|
||||
/* USB Data structure - for passing data around.
|
||||
* |
||||
* This is used for both sending and receiving data. |
||||
* |
||||
* The callback function is used to let the function driver know when |
||||
* transmitted data has been sent. |
||||
* |
||||
* The callback function is set by the alloc_recv function when an urb is |
||||
* allocated for receiving data for an endpoint and used to call the |
||||
* function driver to inform it that data has arrived. |
||||
*/ |
||||
|
||||
#define URB_BUF_SIZE 128 /* in linux we'd malloc this, but in u-boot we prefer static data */ |
||||
struct urb { |
||||
|
||||
struct usb_endpoint_instance *endpoint; |
||||
struct usb_device_instance *device; |
||||
|
||||
struct usb_device_request device_request; /* contents of received SETUP packet */ |
||||
|
||||
struct urb_link link; /* embedded struct for circular doubly linked list of urbs */ |
||||
|
||||
u8* buffer; |
||||
unsigned int buffer_length; |
||||
unsigned int actual_length; |
||||
|
||||
urb_send_status_t status; |
||||
int data; |
||||
|
||||
u16 buffer_data[URB_BUF_SIZE]; /* data received (OUT) or being sent (IN) */ |
||||
}; |
||||
|
||||
/* Endpoint configuration
|
||||
* |
||||
* Per endpoint configuration data. Used to track which function driver owns |
||||
* an endpoint. |
||||
* |
||||
*/ |
||||
struct usb_endpoint_instance { |
||||
int endpoint_address; /* logical endpoint address */ |
||||
|
||||
/* control */ |
||||
int status; /* halted */ |
||||
int state; /* available for use by bus interface driver */ |
||||
|
||||
/* receive side */ |
||||
struct urb_link rcv; /* received urbs */ |
||||
struct urb_link rdy; /* empty urbs ready to receive */ |
||||
struct urb *rcv_urb; /* active urb */ |
||||
int rcv_attributes; /* copy of bmAttributes from endpoint descriptor */ |
||||
int rcv_packetSize; /* maximum packet size from endpoint descriptor */ |
||||
int rcv_transferSize; /* maximum transfer size from function driver */ |
||||
int rcv_queue; |
||||
|
||||
/* transmit side */ |
||||
struct urb_link tx; /* urbs ready to transmit */ |
||||
struct urb_link done; /* transmitted urbs */ |
||||
struct urb *tx_urb; /* active urb */ |
||||
int tx_attributes; /* copy of bmAttributes from endpoint descriptor */ |
||||
int tx_packetSize; /* maximum packet size from endpoint descriptor */ |
||||
int tx_transferSize; /* maximum transfer size from function driver */ |
||||
int tx_queue; |
||||
|
||||
int sent; /* data already sent */ |
||||
int last; /* data sent in last packet XXX do we need this */ |
||||
}; |
||||
|
||||
struct usb_alternate_instance { |
||||
struct usb_interface_descriptor *interface_descriptor; |
||||
|
||||
int endpoints; |
||||
int *endpoint_transfersize_array; |
||||
struct usb_endpoint_descriptor **endpoints_descriptor_array; |
||||
}; |
||||
|
||||
struct usb_interface_instance { |
||||
int alternates; |
||||
struct usb_alternate_instance *alternates_instance_array; |
||||
}; |
||||
|
||||
struct usb_configuration_instance { |
||||
int interfaces; |
||||
struct usb_configuration_descriptor *configuration_descriptor; |
||||
struct usb_interface_instance *interface_instance_array; |
||||
}; |
||||
|
||||
|
||||
/* USB Device Instance
|
||||
* |
||||
* For each physical bus interface we create a logical device structure. This |
||||
* tracks all of the required state to track the USB HOST's view of the device. |
||||
* |
||||
* Keep track of the device configuration for a real physical bus interface, |
||||
* this includes the bus interface, multiple function drivers, the current |
||||
* configuration and the current state. |
||||
* |
||||
* This will show: |
||||
* the specific bus interface driver |
||||
* the default endpoint 0 driver |
||||
* the configured function driver |
||||
* device state |
||||
* device status |
||||
* endpoint list |
||||
*/ |
||||
|
||||
struct usb_device_instance { |
||||
|
||||
/* generic */ |
||||
char *name; |
||||
struct usb_device_descriptor *device_descriptor; /* per device descriptor */ |
||||
|
||||
void (*event) (struct usb_device_instance *device, usb_device_event_t event, int data); |
||||
|
||||
/* bus interface */ |
||||
struct usb_bus_instance *bus; /* which bus interface driver */ |
||||
|
||||
/* configuration descriptors */ |
||||
int configurations; |
||||
struct usb_configuration_instance *configuration_instance_array; |
||||
|
||||
/* device state */ |
||||
usb_device_state_t device_state; /* current USB Device state */ |
||||
usb_device_state_t device_previous_state; /* current USB Device state */ |
||||
|
||||
u8 address; /* current address (zero is default) */ |
||||
u8 configuration; /* current show configuration (zero is default) */ |
||||
u8 interface; /* current interface (zero is default) */ |
||||
u8 alternate; /* alternate flag */ |
||||
|
||||
usb_device_status_t status; /* device status */ |
||||
|
||||
int urbs_queued; /* number of submitted urbs */ |
||||
|
||||
/* Shouldn't need to make this atomic, all we need is a change indicator */ |
||||
unsigned long usbd_rxtx_timestamp; |
||||
unsigned long usbd_last_rxtx_timestamp; |
||||
|
||||
}; |
||||
|
||||
/* Bus Interface configuration structure
|
||||
* |
||||
* This is allocated for each configured instance of a bus interface driver. |
||||
* |
||||
* The privdata pointer may be used by the bus interface driver to store private |
||||
* per instance state information. |
||||
*/ |
||||
struct usb_bus_instance { |
||||
|
||||
struct usb_device_instance *device; |
||||
struct usb_endpoint_instance *endpoint_array; /* array of available configured endpoints */ |
||||
|
||||
int max_endpoints; /* maximimum number of rx enpoints */ |
||||
unsigned char maxpacketsize; |
||||
|
||||
unsigned int serial_number; |
||||
char *serial_number_str; |
||||
void *privdata; /* private data for the bus interface */ |
||||
|
||||
}; |
||||
|
||||
extern char *usbd_device_events[]; |
||||
extern char *usbd_device_states[]; |
||||
extern char *usbd_device_status[]; |
||||
extern char *usbd_device_requests[]; |
||||
extern char *usbd_device_descriptors[]; |
||||
|
||||
void urb_link_init (urb_link * ul); |
||||
void urb_detach (struct urb *urb); |
||||
urb_link *first_urb_link (urb_link * hd); |
||||
struct urb *first_urb (urb_link * hd); |
||||
struct urb *first_urb_detached (urb_link * hd); |
||||
void urb_append (urb_link * hd, struct urb *urb); |
||||
|
||||
struct urb *usbd_alloc_urb (struct usb_device_instance *device, struct usb_endpoint_instance *endpoint); |
||||
void usbd_dealloc_urb (struct urb *urb); |
||||
|
||||
/*
|
||||
* usbd_device_event is used by bus interface drivers to tell the higher layers that |
||||
* certain events have taken place. |
||||
*/ |
||||
void usbd_device_event_irq (struct usb_device_instance *conf, usb_device_event_t, int); |
||||
void usbd_device_event (struct usb_device_instance *conf, usb_device_event_t, int); |
||||
|
||||
/* descriptors
|
||||
* |
||||
* Various ways of finding descriptors based on the current device and any |
||||
* possible configuration / interface / endpoint for it. |
||||
*/ |
||||
struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct usb_device_instance *, int, int); |
||||
struct usb_function_instance *usbd_device_function_instance (struct usb_device_instance *, unsigned int); |
||||
struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *, int, int, int); |
||||
struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *, int, int, int, int); |
||||
struct usb_interface_descriptor *usbd_device_interface_descriptor (struct usb_device_instance *, int, int, int, int); |
||||
struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor_index (struct usb_device_instance *, int, int, int, int, int); |
||||
struct usb_class_descriptor *usbd_device_class_descriptor_index (struct usb_device_instance *, int, int, int, int, int); |
||||
struct usb_class_report_descriptor *usbd_device_class_report_descriptor_index( struct usb_device_instance *, int , int , int , int , int ); |
||||
struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor (struct usb_device_instance *, int, int, int, int, int); |
||||
int usbd_device_endpoint_transfersize (struct usb_device_instance *, int, int, int, int, int); |
||||
struct usb_string_descriptor *usbd_get_string (u8); |
||||
struct usb_device_descriptor *usbd_device_device_descriptor (struct usb_device_instance *, int); |
||||
|
||||
int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint); |
||||
void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad); |
||||
void usbd_tx_complete (struct usb_endpoint_instance *endpoint); |
||||
|
||||
#endif |
@ -0,0 +1,39 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* Based on |
||||
* linux/drivers/usbd/ep0.c |
||||
* |
||||
* Copyright (c) 2000, 2001, 2002 Lineo |
||||
* Copyright (c) 2001 Hewlett Packard |
||||
* |
||||
* By: |
||||
* Stuart Lynne <sl@lineo.com>, |
||||
* Tom Rushworth <tbr@lineo.com>, |
||||
* Bruce Balden <balden@lineo.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. |
||||
* |
||||
* 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __USBDCORE_EP0_H__ |
||||
#define __USBDCORE_EP0_H__ |
||||
|
||||
|
||||
int ep0_recv_setup (struct urb *urb); |
||||
|
||||
|
||||
#endif |
@ -0,0 +1,183 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* Based on |
||||
* linux/drivers/usb/device/bi/omap.h |
||||
* Register definitions for TI OMAP1510 USB bus interface driver |
||||
* |
||||
* Author: MontaVista Software, Inc. |
||||
* source@mvista.com |
||||
* |
||||
* 2003 (c) MontaVista Software, Inc. This file is licensed under |
||||
* the terms of the GNU General Public License version 2. This program |
||||
* is licensed "as is" without any warranty of any kind, whether express |
||||
* or implied. |
||||
*/ |
||||
|
||||
#ifndef __USBDCORE_OMAP1510_H__ |
||||
#define __USBDCORE_OMAP1510_H__ |
||||
|
||||
|
||||
/*
|
||||
* 13.2 MPU Register Map |
||||
*/ |
||||
|
||||
/* Table 13-1. USB Function Module Registers (endpoint) */ |
||||
#define UDC_BASE 0xFFFB4000 |
||||
#define UDC_OFFSET(offset) (UDC_BASE + (offset)) |
||||
#define UDC_REV UDC_OFFSET(0x0) /* Revision */ |
||||
#define UDC_EP_NUM UDC_OFFSET(0x4) /* Endpoint selection */ |
||||
#define UDC_DATA UDC_OFFSET(0x08) /* Data */ |
||||
#define UDC_CTRL UDC_OFFSET(0x0C) /* Control */ |
||||
#define UDC_STAT_FLG UDC_OFFSET(0x10) /* Status flag */ |
||||
#define UDC_RXFSTAT UDC_OFFSET(0x14) /* Receive FIFO status */ |
||||
#define UDC_SYSCON1 UDC_OFFSET(0x18) /* System configuration 1 */ |
||||
#define UDC_SYSCON2 UDC_OFFSET(0x1C) /* System configuration 2 */ |
||||
#define UDC_DEVSTAT UDC_OFFSET(0x20) /* Device status */ |
||||
#define UDC_SOF UDC_OFFSET(0x24) /* Start of frame */ |
||||
#define UDC_IRQ_EN UDC_OFFSET(0x28) /* Interrupt enable */ |
||||
#define UDC_DMA_IRQ_EN UDC_OFFSET(0x2C) /* DMA interrupt enable */ |
||||
#define UDC_IRQ_SRC UDC_OFFSET(0x30) /* Interrupt source */ |
||||
#define UDC_EPN_STAT UDC_OFFSET(0x34) /* Endpoint interrupt status */ |
||||
#define UDC_DMAN_STAT UDC_OFFSET(0x3C) /* DMA endpoint interrupt status */ |
||||
|
||||
/* IRQ_EN register fields */ |
||||
#define UDC_Sof_IE (1 << 7) /* Start-of-frame interrupt enabled */ |
||||
#define UDC_EPn_RX_IE (1 << 5) /* Receive endpoint interrupt enabled */ |
||||
#define UDC_EPn_TX_IE (1 << 4) /* Transmit endpoint interrupt enabled */ |
||||
#define UDC_DS_Chg_IE (1 << 3) /* Device state changed interrupt enabled */ |
||||
#define UDC_EP0_IE (1 << 0) /* EP0 transaction interrupt enabled */ |
||||
|
||||
/* IRQ_SRC register fields */ |
||||
#define UDC_TXn_Done (1 << 10) /* Transmit DMA channel n done */ |
||||
#define UDC_RXn_Cnt (1 << 9) /* Receive DMA channel n transactions count */ |
||||
#define UDC_RXn_EOT (1 << 8) /* Receive DMA channel n end of transfer */ |
||||
#define UDC_SOF_Flg (1 << 7) /* Start-of-frame interrupt flag */ |
||||
#define UDC_EPn_RX (1 << 5) /* Endpoint n OUT transaction */ |
||||
#define UDC_EPn_TX (1 << 4) /* Endpoint n IN transaction */ |
||||
#define UDC_DS_Chg (1 << 3) /* Device state changed */ |
||||
#define UDC_Setup (1 << 2) /* Setup transaction */ |
||||
#define UDC_EP0_RX (1 << 1) /* EP0 OUT transaction */ |
||||
#define UDC_EP0_TX (1 << 0) /* EP0 IN transaction */ |
||||
|
||||
/* DEVSTAT register fields, 14.2.9 */ |
||||
#define UDC_R_WK_OK (1 << 6) /* Remote wakeup granted */ |
||||
#define UDC_USB_Reset (1 << 5) /* USB reset signalling is active */ |
||||
#define UDC_SUS (1 << 4) /* Suspended state */ |
||||
#define UDC_CFG (1 << 3) /* Configured state */ |
||||
#define UDC_ADD (1 << 2) /* Addressed state */ |
||||
#define UDC_DEF (1 << 1) /* Default state */ |
||||
#define UDC_ATT (1 << 0) /* Attached state */ |
||||
|
||||
/* SYSCON1 register fields */ |
||||
#define UDC_Cfg_Lock (1 << 8) /* Device configuration locked */ |
||||
#define UDC_Nak_En (1 << 4) /* NAK enable */ |
||||
#define UDC_Self_Pwr (1 << 2) /* Device is self-powered */ |
||||
#define UDC_Soff_Dis (1 << 1) /* Shutoff disabled */ |
||||
#define UDC_Pullup_En (1 << 0) /* External pullup enabled */ |
||||
|
||||
/* SYSCON2 register fields */ |
||||
#define UDC_Rmt_Wkp (1 << 6) /* Remote wakeup */ |
||||
#define UDC_Stall_Cmd (1 << 5) /* Stall endpoint */ |
||||
#define UDC_Dev_Cfg (1 << 3) /* Device configured */ |
||||
#define UDC_Clr_Cfg (1 << 2) /* Clear configured */ |
||||
|
||||
/*
|
||||
* Select and enable endpoints |
||||
*/ |
||||
|
||||
/* Table 13-1. USB Function Module Registers (endpoint configuration) */ |
||||
#define UDC_EPBASE UDC_OFFSET(0x80) /* Endpoints base address */ |
||||
#define UDC_EP0 UDC_EPBASE /* Control endpoint configuration */ |
||||
#define UDC_EP_RX_BASE UDC_OFFSET(0x84) /* Receive endpoints base address */ |
||||
#define UDC_EP_RX(endpoint) (UDC_EP_RX_BASE + ((endpoint) - 1) * 4) |
||||
#define UDC_EP_TX_BASE UDC_OFFSET(0xC4) /* Transmit endpoints base address */ |
||||
#define UDC_EP_TX(endpoint) (UDC_EP_TX_BASE + ((endpoint) - 1) * 4) |
||||
|
||||
/* EP_NUM register fields */ |
||||
#define UDC_Setup_Sel (1 << 6) /* Setup FIFO select */ |
||||
#define UDC_EP_Sel (1 << 5) /* TX/RX FIFO select */ |
||||
#define UDC_EP_Dir (1 << 4) /* Endpoint direction */ |
||||
|
||||
/* CTRL register fields */ |
||||
#define UDC_Clr_Halt (1 << 7) /* Clear halt endpoint */ |
||||
#define UDC_Set_Halt (1 << 6) /* Set halt endpoint */ |
||||
#define UDC_Set_FIFO_En (1 << 2) /* Set FIFO enable */ |
||||
#define UDC_Clr_EP (1 << 1) /* Clear endpoint */ |
||||
#define UDC_Reset_EP (1 << 0) /* Reset endpoint */ |
||||
|
||||
/* STAT_FLG register fields */ |
||||
#define UDC_Miss_In (1 << 14) |
||||
#define UDC_Data_Flush (1 << 13) |
||||
#define UDC_ISO_Err (1 << 12) |
||||
#define UDC_ISO_FIFO_Empty (1 << 9) |
||||
#define UDC_ISO_FIFO_Full (1 << 8) |
||||
#define UDC_EP_Halted (1 << 6) |
||||
#define UDC_STALL (1 << 5) |
||||
#define UDC_NAK (1 << 4) |
||||
#define UDC_ACK (1 << 3) |
||||
#define UDC_FIFO_En (1 << 2) |
||||
#define UDC_Non_ISO_FIFO_Empty (1 << 1) |
||||
#define UDC_Non_ISO_FIFO_Full (1 << 0) |
||||
|
||||
/* EPn_RX register fields */ |
||||
#define UDC_EPn_RX_Valid (1 << 15) /* valid */ |
||||
#define UDC_EPn_RX_Db (1 << 14) /* double-buffer */ |
||||
#define UDC_EPn_RX_Iso (1 << 11) /* isochronous */ |
||||
|
||||
/* EPn_TX register fields */ |
||||
#define UDC_EPn_TX_Valid (1 << 15) /* valid */ |
||||
#define UDC_EPn_TX_Db (1 << 14) /* double-buffer */ |
||||
#define UDC_EPn_TX_Iso (1 << 11) /* isochronous */ |
||||
|
||||
#define EP0_PACKETSIZE 0x40 |
||||
|
||||
/* physical to logical endpoint mapping
|
||||
* Physical endpoints are an index into device->bus->endpoint_array. |
||||
* Logical endpoints are endpoints 0 to 15 IN and OUT as defined in |
||||
* the USB specification. |
||||
* |
||||
* physical ep logical ep direction endpoint_address |
||||
* 0 0 IN and OUT 0x00 |
||||
* 1 to 15 1 to 15 OUT 0x01 to 0x0f |
||||
* 16 to 30 1 to 15 IN 0x81 to 0x8f |
||||
*/ |
||||
#define PHYS_EP_TO_EP_ADDR(ep) (((ep) < 16) ? (ep) : (((ep) - 15) | 0x80)) |
||||
#define EP_ADDR_TO_PHYS_EP(a) (((a) & 0x80) ? (((a) & ~0x80) + 15) : (a)) |
||||
|
||||
/* MOD_CONF_CTRL_0 bits (FIXME: move to board hardware.h ?) */ |
||||
#define CONF_MOD_USB_W2FC_VBUS_MODE_R (1 << 17) |
||||
|
||||
/* Other registers (may be) related to USB */ |
||||
|
||||
#define CLOCK_CTRL (0xFFFE0830) |
||||
#define APLL_CTRL (0xFFFE084C) |
||||
#define DPLL_CTRL (0xFFFE083C) |
||||
#define SOFT_REQ (0xFFFE0834) |
||||
#define STATUS_REQ (0xFFFE0840) |
||||
|
||||
/* FUNC_MUX_CTRL_0 bits related to USB */ |
||||
#define UDC_VBUS_CTRL (1 << 19) |
||||
#define UDC_VBUS_MODE (1 << 18) |
||||
|
||||
|
||||
void omap1510_udc_irq(void); |
||||
void omap1510_udc_noniso_irq(void); |
||||
|
||||
|
||||
/* Higher level functions for abstracting away from specific device */ |
||||
void udc_endpoint_write(struct usb_endpoint_instance *endpoint); |
||||
|
||||
int udc_init (void); |
||||
|
||||
void udc_enable(struct usb_device_instance *device); |
||||
void udc_disable(void); |
||||
|
||||
void udc_connect(void); |
||||
void udc_disconnect(void); |
||||
|
||||
void udc_startup_events(struct usb_device_instance *device); |
||||
void udc_setup_ep(struct usb_device_instance *device, unsigned int ep, struct usb_endpoint_instance *endpoint); |
||||
|
||||
#endif |
@ -0,0 +1,497 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Gerry Hamel, geh@ti.com, Texas Instruments |
||||
* |
||||
* Based on |
||||
* linux/drivers/usbd/usb-function.h - USB Function |
||||
* |
||||
* Copyright (c) 2000, 2001, 2002 Lineo |
||||
* Copyright (c) 2001 Hewlett Packard |
||||
* |
||||
* By: |
||||
* Stuart Lynne <sl@lineo.com>, |
||||
* Tom Rushworth <tbr@lineo.com>, |
||||
* Bruce Balden <balden@lineo.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. |
||||
* |
||||
* 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
||||
* |
||||
*/ |
||||
|
||||
/* USB Descriptors - Create a complete description of all of the
|
||||
* function driver capabilities. These map directly to the USB descriptors. |
||||
* |
||||
* This heirarchy is created by the functions drivers and is passed to the |
||||
* usb-device driver when the function driver is registered. |
||||
* |
||||
* device |
||||
* configuration |
||||
* interface |
||||
* alternate |
||||
* class |
||||
* class |
||||
* alternate |
||||
* endpoint |
||||
* endpoint |
||||
* interface |
||||
* alternate |
||||
* endpoint |
||||
* endpoint |
||||
* configuration |
||||
* interface |
||||
* alternate |
||||
* endpoint |
||||
* endpoint |
||||
* |
||||
* |
||||
* The configuration structures refer to the USB Configurations that will be |
||||
* made available to a USB HOST during the enumeration process. |
||||
* |
||||
* The USB HOST will select a configuration and optionally an interface with |
||||
* the usb set configuration and set interface commands. |
||||
* |
||||
* The selected interface (or the default interface if not specifically |
||||
* selected) will define the list of endpoints that will be used. |
||||
* |
||||
* The configuration and interfaces are stored in an array that is indexed |
||||
* by the specified configuratin or interface number minus one. |
||||
* |
||||
* A configuration number of zero is used to specify a return to the unconfigured |
||||
* state. |
||||
* |
||||
*/ |
||||
|
||||
|
||||
#ifndef __USBDESCRIPTORS_H__ |
||||
#define __USBDESCRIPTORS_H__ |
||||
|
||||
#include <asm/types.h> |
||||
|
||||
/*
|
||||
* communications class types |
||||
* |
||||
* c.f. CDC USB Class Definitions for Communications Devices |
||||
* c.f. WMCD USB CDC Subclass Specification for Wireless Mobile Communications Devices |
||||
* |
||||
*/ |
||||
|
||||
#define CLASS_BCD_VERSION 0x0110 |
||||
|
||||
/* c.f. CDC 4.1 Table 14 */ |
||||
#define COMMUNICATIONS_DEVICE_CLASS 0x02 |
||||
|
||||
/* c.f. CDC 4.2 Table 15 */ |
||||
#define COMMUNICATIONS_INTERFACE_CLASS 0x02 |
||||
|
||||
/* c.f. CDC 4.3 Table 16 */ |
||||
#define COMMUNICATIONS_NO_SUBCLASS 0x00 |
||||
#define COMMUNICATIONS_DLCM_SUBCLASS 0x01 |
||||
#define COMMUNICATIONS_ACM_SUBCLASS 0x02 |
||||
#define COMMUNICATIONS_TCM_SUBCLASS 0x03 |
||||
#define COMMUNICATIONS_MCCM_SUBCLASS 0x04 |
||||
#define COMMUNICATIONS_CCM_SUBCLASS 0x05 |
||||
#define COMMUNICATIONS_ENCM_SUBCLASS 0x06 |
||||
#define COMMUNICATIONS_ANCM_SUBCLASS 0x07 |
||||
|
||||
/* c.f. WMCD 5.1 */ |
||||
#define COMMUNICATIONS_WHCM_SUBCLASS 0x08 |
||||
#define COMMUNICATIONS_DMM_SUBCLASS 0x09 |
||||
#define COMMUNICATIONS_MDLM_SUBCLASS 0x0a |
||||
#define COMMUNICATIONS_OBEX_SUBCLASS 0x0b |
||||
|
||||
/* c.f. CDC 4.6 Table 18 */ |
||||
#define DATA_INTERFACE_CLASS 0x0a |
||||
|
||||
/* c.f. CDC 4.7 Table 19 */ |
||||
#define COMMUNICATIONS_NO_PROTOCOL 0x00 |
||||
|
||||
|
||||
/* c.f. CDC 5.2.3 Table 24 */ |
||||
#define CS_INTERFACE 0x24 |
||||
#define CS_ENDPOINT 0x25 |
||||
|
||||
/*
|
||||
* bDescriptorSubtypes |
||||
* |
||||
* c.f. CDC 5.2.3 Table 25 |
||||
* c.f. WMCD 5.3 Table 5.3 |
||||
*/ |
||||
|
||||
#define USB_ST_HEADER 0x00 |
||||
#define USB_ST_CMF 0x01 |
||||
#define USB_ST_ACMF 0x02 |
||||
#define USB_ST_DLMF 0x03 |
||||
#define USB_ST_TRF 0x04 |
||||
#define USB_ST_TCLF 0x05 |
||||
#define USB_ST_UF 0x06 |
||||
#define USB_ST_CSF 0x07 |
||||
#define USB_ST_TOMF 0x08 |
||||
#define USB_ST_USBTF 0x09 |
||||
#define USB_ST_NCT 0x0a |
||||
#define USB_ST_PUF 0x0b |
||||
#define USB_ST_EUF 0x0c |
||||
#define USB_ST_MCMF 0x0d |
||||
#define USB_ST_CCMF 0x0e |
||||
#define USB_ST_ENF 0x0f |
||||
#define USB_ST_ATMNF 0x10 |
||||
|
||||
#define USB_ST_WHCM 0x11 |
||||
#define USB_ST_MDLM 0x12 |
||||
#define USB_ST_MDLMD 0x13 |
||||
#define USB_ST_DMM 0x14 |
||||
#define USB_ST_OBEX 0x15 |
||||
#define USB_ST_CS 0x16 |
||||
#define USB_ST_CSD 0x17 |
||||
#define USB_ST_TCM 0x18 |
||||
|
||||
/* endpoint modifiers
|
||||
* static struct usb_endpoint_description function_default_A_1[] = { |
||||
* |
||||
* {this_endpoint: 0, attributes: CONTROL, max_size: 8, polling_interval: 0 }, |
||||
* {this_endpoint: 1, attributes: BULK, max_size: 64, polling_interval: 0, direction: IN}, |
||||
* {this_endpoint: 2, attributes: BULK, max_size: 64, polling_interval: 0, direction: OUT}, |
||||
* {this_endpoint: 3, attributes: INTERRUPT, max_size: 8, polling_interval: 0}, |
||||
* |
||||
* |
||||
*/ |
||||
#define OUT 0x00 |
||||
#define IN 0x80 |
||||
|
||||
#define CONTROL 0x00 |
||||
#define ISOCHRONOUS 0x01 |
||||
#define BULK 0x02 |
||||
#define INTERRUPT 0x03 |
||||
|
||||
|
||||
/* configuration modifiers
|
||||
*/ |
||||
#define BMATTRIBUTE_RESERVED 0x80 |
||||
#define BMATTRIBUTE_SELF_POWERED 0x40 |
||||
|
||||
/*
|
||||
* standard usb descriptor structures |
||||
*/ |
||||
|
||||
struct usb_endpoint_descriptor { |
||||
u8 bLength; |
||||
u8 bDescriptorType; /* 0x5 */ |
||||
u8 bEndpointAddress; |
||||
u8 bmAttributes; |
||||
u16 wMaxPacketSize; |
||||
u8 bInterval; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_interface_descriptor { |
||||
u8 bLength; |
||||
u8 bDescriptorType; /* 0x04 */ |
||||
u8 bInterfaceNumber; |
||||
u8 bAlternateSetting; |
||||
u8 bNumEndpoints; |
||||
u8 bInterfaceClass; |
||||
u8 bInterfaceSubClass; |
||||
u8 bInterfaceProtocol; |
||||
u8 iInterface; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_configuration_descriptor { |
||||
u8 bLength; |
||||
u8 bDescriptorType; /* 0x2 */ |
||||
u16 wTotalLength; |
||||
u8 bNumInterfaces; |
||||
u8 bConfigurationValue; |
||||
u8 iConfiguration; |
||||
u8 bmAttributes; |
||||
u8 bMaxPower; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_device_descriptor { |
||||
u8 bLength; |
||||
u8 bDescriptorType; /* 0x01 */ |
||||
u16 bcdUSB; |
||||
u8 bDeviceClass; |
||||
u8 bDeviceSubClass; |
||||
u8 bDeviceProtocol; |
||||
u8 bMaxPacketSize0; |
||||
u16 idVendor; |
||||
u16 idProduct; |
||||
u16 bcdDevice; |
||||
u8 iManufacturer; |
||||
u8 iProduct; |
||||
u8 iSerialNumber; |
||||
u8 bNumConfigurations; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_string_descriptor { |
||||
u8 bLength; |
||||
u8 bDescriptorType; /* 0x03 */ |
||||
u16 wData[0]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_generic_descriptor { |
||||
u8 bLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; |
||||
} __attribute__ ((packed)); |
||||
|
||||
|
||||
/*
|
||||
* communications class descriptor structures |
||||
* |
||||
* c.f. CDC 5.2 Table 25c |
||||
*/ |
||||
|
||||
struct usb_class_function_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_function_descriptor_generic { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; |
||||
u8 bmCapabilities; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_header_function_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x00 */ |
||||
u16 bcdCDC; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_call_management_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x01 */ |
||||
u8 bmCapabilities; |
||||
u8 bDataInterface; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_abstract_control_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x02 */ |
||||
u8 bmCapabilities; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_direct_line_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x03 */ |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_telephone_ringer_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x04 */ |
||||
u8 bRingerVolSeps; |
||||
u8 bNumRingerPatterns; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_telephone_call_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x05 */ |
||||
u8 bmCapabilities; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_union_function_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x06 */ |
||||
u8 bMasterInterface; |
||||
u8 bSlaveInterface0[0]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_country_selection_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x07 */ |
||||
u8 iCountryCodeRelDate; |
||||
u16 wCountryCode0[0]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
|
||||
struct usb_class_telephone_operational_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x08 */ |
||||
u8 bmCapabilities; |
||||
} __attribute__ ((packed)); |
||||
|
||||
|
||||
struct usb_class_usb_terminal_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x09 */ |
||||
u8 bEntityId; |
||||
u8 bInterfaceNo; |
||||
u8 bOutInterfaceNo; |
||||
u8 bmOptions; |
||||
u8 bChild0[0]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_network_channel_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x0a */ |
||||
u8 bEntityId; |
||||
u8 iName; |
||||
u8 bChannelIndex; |
||||
u8 bPhysicalInterface; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_protocol_unit_function_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x0b */ |
||||
u8 bEntityId; |
||||
u8 bProtocol; |
||||
u8 bChild0[0]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_extension_unit_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x0c */ |
||||
u8 bEntityId; |
||||
u8 bExtensionCode; |
||||
u8 iName; |
||||
u8 bChild0[0]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_multi_channel_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x0d */ |
||||
u8 bmCapabilities; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_capi_control_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x0e */ |
||||
u8 bmCapabilities; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_ethernet_networking_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x0f */ |
||||
u8 iMACAddress; |
||||
u32 bmEthernetStatistics; |
||||
u16 wMaxSegmentSize; |
||||
u16 wNumberMCFilters; |
||||
u8 bNumberPowerFilters; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_atm_networking_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x10 */ |
||||
u8 iEndSystermIdentifier; |
||||
u8 bmDataCapabilities; |
||||
u8 bmATMDeviceStatistics; |
||||
u16 wType2MaxSegmentSize; |
||||
u16 wType3MaxSegmentSize; |
||||
u16 wMaxVC; |
||||
} __attribute__ ((packed)); |
||||
|
||||
|
||||
struct usb_class_mdlm_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x12 */ |
||||
u16 bcdVersion; |
||||
u8 bGUID[16]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_mdlmd_descriptor { |
||||
u8 bFunctionLength; |
||||
u8 bDescriptorType; |
||||
u8 bDescriptorSubtype; /* 0x13 */ |
||||
u8 bGuidDescriptorType; |
||||
u8 bDetailData[0]; |
||||
|
||||
} __attribute__ ((packed)); |
||||
|
||||
/*
|
||||
* HID class descriptor structures |
||||
* |
||||
* c.f. HID 6.2.1 |
||||
*/ |
||||
|
||||
struct usb_class_hid_descriptor { |
||||
u8 bLength; |
||||
u8 bDescriptorType; |
||||
u16 bcdCDC; |
||||
u8 bCountryCode; |
||||
u8 bNumDescriptors; /* 0x01 */ |
||||
u8 bDescriptorType0; |
||||
u16 wDescriptorLength0; |
||||
/* optional descriptors are not supported. */ |
||||
} __attribute__((packed)); |
||||
|
||||
struct usb_class_report_descriptor { |
||||
u8 bLength; /* dummy */ |
||||
u8 bDescriptorType; |
||||
u16 wLength; |
||||
u8 bData[0]; |
||||
} __attribute__((packed)); |
||||
|
||||
/*
|
||||
* descriptor union structures |
||||
*/ |
||||
|
||||
struct usb_descriptor { |
||||
union { |
||||
struct usb_generic_descriptor generic; |
||||
struct usb_endpoint_descriptor endpoint; |
||||
struct usb_interface_descriptor interface; |
||||
struct usb_configuration_descriptor configuration; |
||||
struct usb_device_descriptor device; |
||||
struct usb_string_descriptor string; |
||||
} descriptor; |
||||
|
||||
} __attribute__ ((packed)); |
||||
|
||||
struct usb_class_descriptor { |
||||
union { |
||||
struct usb_class_function_descriptor function; |
||||
struct usb_class_function_descriptor_generic generic; |
||||
struct usb_class_header_function_descriptor header_function; |
||||
struct usb_class_call_management_descriptor call_management; |
||||
struct usb_class_abstract_control_descriptor abstract_control; |
||||
struct usb_class_direct_line_descriptor direct_line; |
||||
struct usb_class_telephone_ringer_descriptor telephone_ringer; |
||||
struct usb_class_telephone_operational_descriptor telephone_operational; |
||||
struct usb_class_telephone_call_descriptor telephone_call; |
||||
struct usb_class_union_function_descriptor union_function; |
||||
struct usb_class_country_selection_descriptor country_selection; |
||||
struct usb_class_usb_terminal_descriptor usb_terminal; |
||||
struct usb_class_network_channel_descriptor network_channel; |
||||
struct usb_class_extension_unit_descriptor extension_unit; |
||||
struct usb_class_multi_channel_descriptor multi_channel; |
||||
struct usb_class_capi_control_descriptor capi_control; |
||||
struct usb_class_ethernet_networking_descriptor ethernet_networking; |
||||
struct usb_class_atm_networking_descriptor atm_networking; |
||||
struct usb_class_mdlm_descriptor mobile_direct; |
||||
struct usb_class_mdlmd_descriptor mobile_direct_detail; |
||||
struct usb_class_hid_descriptor hid; |
||||
} descriptor; |
||||
|
||||
} __attribute__ ((packed)); |
||||
|
||||
#endif |
Loading…
Reference in new issue