rename packages/ to recipes/ per earlier agreement

See links below for more details:
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816

Signed-off-by: Denys Dmytriyenko <denis@denix.org>
Acked-by: Mike Westerhof <mwester@dls.net>
Acked-by: Philip Balister <philip@balister.org>
Acked-by: Khem Raj <raj.khem@gmail.com>
Acked-by: Marcin Juszkiewicz <hrw@openembedded.org>
Acked-by: Koen Kooi <koen@openembedded.org>
Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>

1 files changed, 1607 insertions, 0 deletions

diff --git a/recipes/u-boot/u-boot-mkimage-openmoko-native/uboot-usbtty-acm.patch b/recipes/u-boot/u-boot-mkimage-openmoko-native/uboot-usbtty-acm.patch
new file mode 100644
index 0000000000..722a227aa6
--- /dev/null
+++ b/recipes/u-boot/u-boot-mkimage-openmoko-native/uboot-usbtty-acm.patch
@@ -0,0 +1,1607 @@
+This patch adds cdc_acm interoperability to u-boot usbtty.
+
+It was taken (almost blindly) from the Linux for Siemens SX1 project on
+handhelds.org.  Please don't complain to me about coding style issues
+or whitespace changes in this one - HW.
+
+Index: u-boot/drivers/usbtty.c
+===================================================================
+--- u-boot.orig/drivers/usbtty.c	2007-02-08 21:11:27.000000000 +0100
++++ u-boot/drivers/usbtty.c	2007-02-08 21:11:55.000000000 +0100
+@@ -1,6 +1,9 @@
+ /*
+  * (C) Copyright 2003
+  * Gerry Hamel, geh@ti.com, Texas Instruments
++ * 
++ * (C) Copyright 2006
++ * Bryan O'Donoghue, bodonoghue <at> codehermit.ie
+  *
+  * 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
+@@ -22,26 +25,61 @@
+ 
+ #ifdef CONFIG_USB_TTY
+ 
++#include <asm/io.h>
+ #include <circbuf.h>
+ #include <devices.h>
+ #include "usbtty.h"
++#include "usb_cdc_acm.h"
++#include "usbdescriptors.h"
++#include <config.h>		/* If defined, override Linux identifiers with
++			   	 * vendor specific ones */
+ 
+ #if 0
+-#define TTYDBG(fmt,args...) serial_printf("[%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args)
++//+++ debug print into memory buffer,like kernel log
++static	char* log_buf = 0x10e00000; // somewhere in RAM
++static	char  log_str[512];
++#define TTYDBG(fmt,args...)\
++	sprintf(log_str,"\n[%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args);\
++	memcpy(log_buf, log_str, strlen(log_str));\
++	log_buf+=strlen(log_str);\
++	strcpy(log_buf,"\n---------------------------------------------------")\
++//---
+ #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)
++#define TTYDBG(fmt,args...)\
++	serial_printf("[%s] %s %d: "fmt"\n", __FILE__,__FUNCTION__,__LINE__,##args)
++#endif
++
++#if 0
++#define TTYERR(fmt,args...)\
++	serial_printf("ERROR![%s] %s %d: "fmt"\n", __FILE__,__FUNCTION__,\
++	__LINE__,##args)
+ #else
+ #define TTYERR(fmt,args...) do{}while(0)
+ #endif
+ 
+ /*
++ * Defines
++ */
++#define NUM_CONFIGS    1
++#define MAX_INTERFACES 2
++#define NUM_ENDPOINTS  3
++#define ACM_TX_ENDPOINT 3
++#define ACM_RX_ENDPOINT 2
++#define GSERIAL_TX_ENDPOINT 2
++#define GSERIAL_RX_ENDPOINT 1
++#define NUM_ACM_INTERFACES 2
++#define NUM_GSERIAL_INTERFACES 1
++#define CONFIG_USBD_DATA_INTERFACE_STR "Bulk Data Interface"
++#define CONFIG_USBD_CTRL_INTERFACE_STR "Control Interface"
++
++/*
+  * Buffers to hold input and output data
+  */
+-#define USBTTY_BUFFER_SIZE 256
++#define USBTTY_BUFFER_SIZE 2048
+ static circbuf_t usbtty_input;
+ static circbuf_t usbtty_output;
+ 
+@@ -50,157 +88,336 @@
+  * 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_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
++static struct usb_interface_instance interface_instance[MAX_INTERFACES];
++static struct usb_alternate_instance alternate_instance[MAX_INTERFACES];
++/* one extra for control endpoint */
++static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1];
+ 
+ /*
+  * Global flag
+  */
+ int usbtty_configured_flag = 0;
+ 
+-
+ /*
+  * Serial number
+  */
+ static char serial_number[16];
+ 
++
+ /*
+- * Descriptors
++ * Descriptors, Strings, Local variables.
+  */
++
++/* defined and used by usbdcore_ep0.c */
++extern struct usb_string_descriptor **usb_strings;
++
++/* Indicies, References */
++static unsigned short rx_endpoint = 0;
++static unsigned short tx_endpoint = 0;
++static unsigned short interface_count = 0;
++static struct usb_string_descriptor *usbtty_string_table[STR_COUNT];
++
++/* USB Descriptor Strings */
+ 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(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 u8 wstrDataInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
++static u8 wstrCtrlInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
+ 
++/* Standard USB Data Structures */
++static struct usb_interface_descriptor interface_descriptors[MAX_INTERFACES];
++static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS];
++static struct usb_configuration_descriptor	*configuration_descriptor = 0;
+ 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
+-  },
++	.bLength = sizeof(struct usb_device_descriptor),
++	.bDescriptorType =	USB_DT_DEVICE,
++	.bcdUSB = 		cpu_to_le16(USB_BCD_VERSION),
++	.bDeviceSubClass =	0x00,
++	.bDeviceProtocol =	0x00,
++	.bMaxPacketSize0 =	EP0_MAX_PACKET_SIZE,
++	.idVendor =		cpu_to_le16(CONFIG_USBD_VENDORID),
++	.bcdDevice =		cpu_to_le16(USBTTY_BCD_DEVICE),
++	.iManufacturer =	STR_MANUFACTURER,
++	.iProduct =		STR_PRODUCT,
++	.iSerialNumber =	STR_SERIAL,
++	.bNumConfigurations =	NUM_CONFIGS
+ };
+-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]),
++
++
++/*
++ * Static CDC ACM specific descriptors
++ */
++
++struct acm_config_desc {
++	struct usb_configuration_descriptor configuration_desc;
++	
++	/* Master Interface */
++	struct usb_interface_descriptor interface_desc;
++	
++	struct usb_class_header_function_descriptor usb_class_header;
++	struct usb_class_call_management_descriptor usb_class_call_mgt;
++	struct usb_class_abstract_control_descriptor usb_class_acm;
++	struct usb_class_union_function_descriptor usb_class_union;
++	struct usb_endpoint_descriptor notification_endpoint;
++
++	/* Slave Interface */
++	struct usb_interface_descriptor data_class_interface;
++	struct usb_endpoint_descriptor 
++		data_endpoints[NUM_ENDPOINTS-1] __attribute__((packed));
++} __attribute__((packed));
++
++static struct acm_config_desc acm_configuration_descriptors[NUM_CONFIGS] = {
++	{
++		.configuration_desc ={
++			.bLength = 
++				sizeof(struct usb_configuration_descriptor),
++    			.bDescriptorType = USB_DT_CONFIG,
++			.wTotalLength =	 
++				cpu_to_le16(sizeof(struct acm_config_desc)),
++	    		.bNumInterfaces = NUM_ACM_INTERFACES,
++    			.bConfigurationValue = 1,
++			.iConfiguration = STR_CONFIG,
++			.bmAttributes = 
++				BMATTRIBUTE_SELF_POWERED|BMATTRIBUTE_RESERVED,
++			.bMaxPower = USBTTY_MAXPOWER
++		},
++		/* Interface 1 */
++		.interface_desc = {
++			.bLength  = sizeof(struct usb_interface_descriptor),
++			.bDescriptorType = USB_DT_INTERFACE,
++			.bInterfaceNumber = 0,
++			.bAlternateSetting = 0,
++			.bNumEndpoints = 0x01,
++			.bInterfaceClass = 
++				COMMUNICATIONS_INTERFACE_CLASS_CONTROL,
++			.bInterfaceSubClass = COMMUNICATIONS_ACM_SUBCLASS,
++			.bInterfaceProtocol = COMMUNICATIONS_V25TER_PROTOCOL,
++			.iInterface = STR_CTRL_INTERFACE,
++		},
++		.usb_class_header = {
++			.bFunctionLength	= 
++				sizeof(struct usb_class_header_function_descriptor),
++			.bDescriptorType	= CS_INTERFACE,	
++			.bDescriptorSubtype	= USB_ST_HEADER,
++			.bcdCDC	= cpu_to_le16(110),
++		},
++		.usb_class_call_mgt = {
++			.bFunctionLength	= 
++				sizeof(struct usb_class_call_management_descriptor),
++			.bDescriptorType	= CS_INTERFACE,
++			.bDescriptorSubtype	= USB_ST_CMF,
++			.bmCapabilities		= 0x00,	
++			.bDataInterface		= 0x01,	
++		},
++		.usb_class_acm = {
++			.bFunctionLength	= 
++				sizeof(struct usb_class_abstract_control_descriptor),
++			.bDescriptorType	= CS_INTERFACE,
++			.bDescriptorSubtype	= USB_ST_ACMF,	
++			.bmCapabilities		= 0x00,	
++		},
++		.usb_class_union = {
++			.bFunctionLength	= 	
++				sizeof(struct usb_class_union_function_descriptor),
++			.bDescriptorType	= CS_INTERFACE,
++			.bDescriptorSubtype	= USB_ST_UF,
++			.bMasterInterface	= 0x00,	
++			.bSlaveInterface0	= 0x01,	
++		},
++		.notification_endpoint = {
++			.bLength =		
++				sizeof(struct usb_endpoint_descriptor),
++			.bDescriptorType	= USB_DT_ENDPOINT,
++			.bEndpointAddress	= 0x01 | USB_DIR_IN,
++			.bmAttributes		= USB_ENDPOINT_XFER_INT,
++			.wMaxPacketSize		
++				= cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
++			.bInterval		= 0xFF,
++		},
++
++		/* Interface 2 */
++		.data_class_interface = {
++			.bLength		= 
++				sizeof(struct usb_interface_descriptor),
++			.bDescriptorType	= USB_DT_INTERFACE,
++			.bInterfaceNumber	= 0x01,
++			.bAlternateSetting	= 0x00,
++			.bNumEndpoints		= 0x02,
++			.bInterfaceClass	= 
++				COMMUNICATIONS_INTERFACE_CLASS_DATA,
++			.bInterfaceSubClass	= DATA_INTERFACE_SUBCLASS_NONE,
++			.bInterfaceProtocol	= DATA_INTERFACE_PROTOCOL_NONE,
++			.iInterface		= STR_DATA_INTERFACE,
++		},
++		.data_endpoints = {
++			{
++				.bLength		= 
++					sizeof(struct usb_endpoint_descriptor),
++				.bDescriptorType	= USB_DT_ENDPOINT,
++				.bEndpointAddress	= 0x02 | USB_DIR_OUT,
++				.bmAttributes		= 
++					USB_ENDPOINT_XFER_BULK,
++				.wMaxPacketSize		= 
++					cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
++				.bInterval		= 0xFF,
++			},
++			{
++				.bLength		= 
++					sizeof(struct usb_endpoint_descriptor),
++				.bDescriptorType	= USB_DT_ENDPOINT,
++				.bEndpointAddress	= 0x03 | USB_DIR_IN,
++				.bmAttributes		= 
++					USB_ENDPOINT_XFER_BULK,
++				.wMaxPacketSize		= 
++					cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
++				.bInterval		= 0xFF,
++			},
++		},
++	},
++};	
++
++static struct rs232_emu rs232_desc={
++		.dter 		=  	115200,
++	   	.stop_bits	=	0x00,
++	   	.parity		=	0x00,
++		.data_bits	=	0x08
+ };
+ 
+-/* 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];
+-}
++/*
++ * Static Generic Serial specific data
++ */
++
++
++struct gserial_config_desc {
++	
++	struct usb_configuration_descriptor configuration_desc;
++	struct usb_interface_descriptor 
++		interface_desc[NUM_GSERIAL_INTERFACES] __attribute__((packed));
++	struct usb_endpoint_descriptor 
++		data_endpoints[NUM_ENDPOINTS] __attribute__((packed));
++
++} __attribute__((packed));
++
++static struct gserial_config_desc 
++gserial_configuration_descriptors[NUM_CONFIGS] ={
++	{
++		.configuration_desc ={
++			.bLength = sizeof(struct usb_configuration_descriptor),
++			.bDescriptorType = USB_DT_CONFIG,
++			.wTotalLength =	 
++				cpu_to_le16(sizeof(struct gserial_config_desc)),
++			.bNumInterfaces = NUM_GSERIAL_INTERFACES,
++			.bConfigurationValue = 1,
++			.iConfiguration = STR_CONFIG,
++			.bmAttributes = 
++				BMATTRIBUTE_SELF_POWERED|BMATTRIBUTE_RESERVED,
++			.bMaxPower = USBTTY_MAXPOWER
++		},
++		.interface_desc = {
++			{
++				.bLength  = 
++					sizeof(struct usb_interface_descriptor),
++				.bDescriptorType = USB_DT_INTERFACE,
++				.bInterfaceNumber = 0,
++				.bAlternateSetting = 0,
++				.bNumEndpoints = NUM_ENDPOINTS,
++				.bInterfaceClass = 
++					COMMUNICATIONS_INTERFACE_CLASS_VENDOR,
++				.bInterfaceSubClass = 
++					COMMUNICATIONS_NO_SUBCLASS,
++				.bInterfaceProtocol = 
++					COMMUNICATIONS_NO_PROTOCOL,
++				.iInterface = STR_DATA_INTERFACE
++			},
++  		},
++		.data_endpoints  = {
++			{
++				.bLength =		
++					sizeof(struct usb_endpoint_descriptor),
++				.bDescriptorType =	USB_DT_ENDPOINT,
++				.bEndpointAddress =	0x01 | USB_DIR_OUT,
++				.bmAttributes =		USB_ENDPOINT_XFER_BULK,
++				.wMaxPacketSize =	
++					cpu_to_le16(CONFIG_USBD_SERIAL_OUT_PKTSIZE),
++				.bInterval=		0xFF,
++			},
++			{
++				.bLength =		
++					sizeof(struct usb_endpoint_descriptor),
++				.bDescriptorType =	USB_DT_ENDPOINT,
++				.bEndpointAddress =	0x02 | USB_DIR_IN,
++				.bmAttributes =		USB_ENDPOINT_XFER_BULK,
++				.wMaxPacketSize = 	
++					cpu_to_le16(CONFIG_USBD_SERIAL_IN_PKTSIZE),
++				.bInterval = 		0xFF,
++			},
++			{
++				.bLength = 		
++					sizeof(struct usb_endpoint_descriptor),
++				.bDescriptorType =	USB_DT_ENDPOINT,
++				.bEndpointAddress =	0x03 | USB_DIR_IN,
++				.bmAttributes =		USB_ENDPOINT_XFER_INT,
++    				.wMaxPacketSize =	
++					cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
++				.bInterval =		0xFF,
++			},
++		},
++	},
++};
+ 
+ /*
+- * Prototypes
++ * Static Function Prototypes
+  */
++
+ static void usbtty_init_strings (void);
+ static void usbtty_init_instances (void);
+ static void usbtty_init_endpoints (void);
+-
++static void usbtty_init_terminal_type(short type);
+ static void usbtty_event_handler (struct usb_device_instance *device,
+-				  usb_device_event_t event, int data);
++				usb_device_event_t event, int data);
++static int usbtty_cdc_setup(struct usb_device_request *request, 
++				struct urb *urb);
+ 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);
+ 
++/* utility function for converting char* to wide string used by USB */
++static void str2wide (char *str, u16 * wide)
++{
++	int i;
++	for (i = 0; i < strlen (str) && str[i]; i++){
++		#if defined(__LITTLE_ENDIAN)
++			wide[i] = (u16) str[i];
++		#elif defined(__BIG_ENDIAN)
++			wide[i] = ((u16)(str[i])<<8);
++		#else
++			#error "__LITTLE_ENDIAN or __BIG_ENDIAN undefined"
++		#endif
++	}
++}
+ 
+ /*
+  * Test whether a character is in the RX buffer
+  */
++
+ int usbtty_tstc (void)
+ {
++	struct usb_endpoint_instance *endpoint =
++		&endpoint_instance[rx_endpoint];
++
++	/* If no input data exists, allow more RX to be accepted */
++	if(usbtty_input.size <= 0){
++		udc_unset_nak(endpoint->endpoint_address&0x03);
++	}
++
+ 	usbtty_poll ();
+ 	return (usbtty_input.size > 0);
+ }
+@@ -210,15 +427,21 @@
+  * otherwise. When the function is succesfull, the character read is
+  * written into its argument c.
+  */
++
+ int usbtty_getc (void)
+ {
+ 	char c;
++	struct usb_endpoint_instance *endpoint =
++		&endpoint_instance[rx_endpoint];
+ 
+ 	while (usbtty_input.size <= 0) {
++		udc_unset_nak(endpoint->endpoint_address&0x03);
+ 		usbtty_poll ();
+ 	}
+ 
+ 	buf_pop (&usbtty_input, &c, 1);
++	udc_set_nak(endpoint->endpoint_address&0x03);
++
+ 	return c;
+ }
+ 
+@@ -238,7 +461,6 @@
+ 	}
+ }
+ 
+-
+ /* usbtty_puts() helper function for finding the next '\n' in a string */
+ static int next_nl_pos (const char *s)
+ {
+@@ -252,8 +474,9 @@
+ }
+ 
+ /*
+- * Output a string to the usb client port.
++ * Output a string to the usb client port - implementing flow control
+  */
++
+ static void __usbtty_puts (const char *str, int len)
+ {
+ 	int maxlen = usbtty_output.totalsize;
+@@ -261,22 +484,19 @@
+ 
+ 	/* break str into chunks < buffer size, if needed */
+ 	while (len > 0) {
+-		space = maxlen - usbtty_output.size;
++		usbtty_poll ();
+ 
++		space = maxlen - usbtty_output.size;
+ 		/* Empty buffer here, if needed, to ensure space... */
+-		if (space <= 0) {
++		if (space) {
+ 			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);
++			
++			n = MIN (space, MIN (len, maxlen));
++			buf_push (&usbtty_output, str, n);
+ 
+-		str += n;
+-		len -= n;
++			str += n;
++			len -= n;			
++		}
+ 	}
+ }
+ 
+@@ -313,8 +533,10 @@
+ {
+ 	int rc;
+ 	char * sn;
++	char * tt;
+ 	int snlen;
+ 
++	/* Get serial number */
+ 	if (!(sn = getenv("serial#"))) {
+ 		sn = "000000000000";
+ 	}
+@@ -327,6 +549,14 @@
+ 	memcpy (serial_number, sn, snlen);
+ 	serial_number[snlen] = '\0';
+ 
++	/* Decide on which type of UDC device to be.
++	 */
++
++	if(!(tt = getenv("usbtty"))) {
++		tt = "generic";
++	}
++	usbtty_init_terminal_type(strcmp(tt,"cdc_acm"));
++	
+ 	/* prepare buffers... */
+ 	buf_init (&usbtty_input, USBTTY_BUFFER_SIZE);
+ 	buf_init (&usbtty_output, USBTTY_BUFFER_SIZE);
+@@ -337,7 +567,7 @@
+ 	usbtty_init_strings ();
+ 	usbtty_init_instances ();
+ 
+-	udc_startup_events (device_instance);	/* Enable our device, initialize udc pointers */
++	udc_startup_events (device_instance);/* Enable dev, init udc pointers */
+ 	udc_connect ();		/* Enable pullup for host detection */
+ 
+ 	usbtty_init_endpoints ();
+@@ -362,34 +592,52 @@
+ {
+ 	struct usb_string_descriptor *string;
+ 
++	usbtty_string_table[STR_LANG] = 
++		(struct usb_string_descriptor*)wstrLang;
++
+ 	string = (struct usb_string_descriptor *) wstrManufacturer;
+-	string->bLength = sizeof (wstrManufacturer);
++	string->bLength = sizeof(wstrManufacturer);
+ 	string->bDescriptorType = USB_DT_STRING;
+ 	str2wide (CONFIG_USBD_MANUFACTURER, string->wData);
++	usbtty_string_table[STR_MANUFACTURER]=string;
++
+ 
+ 	string = (struct usb_string_descriptor *) wstrProduct;
+-	string->bLength = sizeof (wstrProduct);
++	string->bLength = sizeof(wstrProduct);
+ 	string->bDescriptorType = USB_DT_STRING;
+ 	str2wide (CONFIG_USBD_PRODUCT_NAME, string->wData);
++	usbtty_string_table[STR_PRODUCT]=string;
++
+ 
+ 	string = (struct usb_string_descriptor *) wstrSerial;
+-	string->bLength = 2 + 2*strlen(serial_number);
++	string->bLength = sizeof(serial_number);
+ 	string->bDescriptorType = USB_DT_STRING;
+ 	str2wide (serial_number, string->wData);
++	usbtty_string_table[STR_SERIAL]=string;
++
+ 
+ 	string = (struct usb_string_descriptor *) wstrConfiguration;
+-	string->bLength = sizeof (wstrConfiguration);
++	string->bLength = sizeof(wstrConfiguration);
+ 	string->bDescriptorType = USB_DT_STRING;
+ 	str2wide (CONFIG_USBD_CONFIGURATION_STR, string->wData);
++	usbtty_string_table[STR_CONFIG]=string;
++
++
++	string = (struct usb_string_descriptor *) wstrDataInterface;
++	string->bLength = sizeof(wstrDataInterface);
++	string->bDescriptorType = USB_DT_STRING;
++	str2wide (CONFIG_USBD_DATA_INTERFACE_STR, string->wData);
++	usbtty_string_table[STR_DATA_INTERFACE]=string;
+ 
+-	string = (struct usb_string_descriptor *) wstrInterface;
+-	string->bLength = sizeof (wstrInterface);
++	string = (struct usb_string_descriptor *) wstrCtrlInterface;
++	string->bLength = sizeof(wstrCtrlInterface);
+ 	string->bDescriptorType = USB_DT_STRING;
+-	str2wide (CONFIG_USBD_INTERFACE_STR, string->wData);
++	str2wide (CONFIG_USBD_CTRL_INTERFACE_STR, string->wData);
++	usbtty_string_table[STR_CTRL_INTERFACE]=string;
+ 
+ 	/* Now, initialize the string table for ep0 handling */
+ 	usb_strings = usbtty_string_table;
+-}
++}	
+ 
+ static void usbtty_init_instances (void)
+ {
+@@ -400,6 +648,7 @@
+ 	device_instance->device_state = STATE_INIT;
+ 	device_instance->device_descriptor = &device_descriptor;
+ 	device_instance->event = usbtty_event_handler;
++	device_instance->cdc_recv_setup = usbtty_cdc_setup;
+ 	device_instance->bus = bus_instance;
+ 	device_instance->configurations = NUM_CONFIGS;
+ 	device_instance->configuration_instance_array = config_instance;
+@@ -415,8 +664,8 @@
+ 	/* configuration instance */
+ 	memset (config_instance, 0,
+ 		sizeof (struct usb_configuration_instance));
+-	config_instance->interfaces = NUM_INTERFACES;
+-	config_instance->configuration_descriptor = config_descriptors;
++	config_instance->interfaces = interface_count;
++	config_instance->configuration_descriptor = configuration_descriptor;
+ 	config_instance->interface_instance_array = interface_instance;
+ 
+ 	/* interface instance */
+@@ -447,17 +696,22 @@
+ 			sizeof (struct usb_endpoint_instance));
+ 
+ 		endpoint_instance[i].endpoint_address =
+-			ep_descriptors[i - 1].bEndpointAddress;
++			ep_descriptor_ptrs[i - 1]->bEndpointAddress;
+ 
+-		endpoint_instance[i].rcv_packetSize =
+-			ep_descriptors[i - 1].wMaxPacketSize;
+ 		endpoint_instance[i].rcv_attributes =
+-			ep_descriptors[i - 1].bmAttributes;
++			ep_descriptor_ptrs[i - 1]->bmAttributes;
++
++		endpoint_instance[i].rcv_packetSize =
++			le16_to_cpu(ep_descriptor_ptrs[i - 1]->wMaxPacketSize);
++		
++		endpoint_instance[i].tx_attributes =
++			ep_descriptor_ptrs[i - 1]->bmAttributes;
+ 
+ 		endpoint_instance[i].tx_packetSize =
+-			ep_descriptors[i - 1].wMaxPacketSize;
++			le16_to_cpu(ep_descriptor_ptrs[i - 1]->wMaxPacketSize);
++
+ 		endpoint_instance[i].tx_attributes =
+-			ep_descriptors[i - 1].bmAttributes;
++			ep_descriptor_ptrs[i - 1]->bmAttributes;
+ 
+ 		urb_link_init (&endpoint_instance[i].rcv);
+ 		urb_link_init (&endpoint_instance[i].rdy);
+@@ -480,13 +734,79 @@
+ 	int i;
+ 
+ 	bus_instance->max_endpoints = NUM_ENDPOINTS + 1;
+-	for (i = 0; i <= NUM_ENDPOINTS; i++) {
++	for (i = 1; i <= NUM_ENDPOINTS; i++) {		
+ 		udc_setup_ep (device_instance, i, &endpoint_instance[i]);
+ 	}
+ }
+ 
++/* usbtty_init_terminal_type
++ * 
++ * Do some late binding for our device type.
++ */
++static void usbtty_init_terminal_type(short type)
++{
++	switch(type){
++		/* CDC ACM */			
++		case 0:
++			/* Assign endpoint descriptors */
++			ep_descriptor_ptrs[0] = 
++				&acm_configuration_descriptors[0].notification_endpoint;
++			ep_descriptor_ptrs[1] = 
++				&acm_configuration_descriptors[0].data_endpoints[0];
++			ep_descriptor_ptrs[2] = 
++				&acm_configuration_descriptors[0].data_endpoints[1];
++
++			/* Enumerate Device Descriptor */
++			device_descriptor.bDeviceClass = 
++				COMMUNICATIONS_DEVICE_CLASS;
++			device_descriptor.idProduct =
++				cpu_to_le16(CONFIG_USBD_PRODUCTID_CDCACM);
++
++			/* Assign endpoint indices */
++			tx_endpoint = ACM_TX_ENDPOINT;
++			rx_endpoint = ACM_RX_ENDPOINT;
++			
++			/* Configuration Descriptor */
++			configuration_descriptor =
++				(struct usb_configuration_descriptor*)
++				&acm_configuration_descriptors;
++
++			/* Interface count */
++			interface_count = NUM_ACM_INTERFACES;
++		break;
++
++		/* BULK IN/OUT & Default */
++		case 1:
++		default:
++			/* Assign endpoint descriptors */
++			ep_descriptor_ptrs[0] = 
++				&gserial_configuration_descriptors[0].data_endpoints[0];
++			ep_descriptor_ptrs[1] = 
++				&gserial_configuration_descriptors[0].data_endpoints[1];
++			ep_descriptor_ptrs[2] = 
++				&gserial_configuration_descriptors[0].data_endpoints[2];
++
++			/* Enumerate Device Descriptor */
++			device_descriptor.bDeviceClass = 0xFF;
++			device_descriptor.idProduct =
++				cpu_to_le16(CONFIG_USBD_PRODUCTID_GSERIAL);
++
++			/* Assign endpoint indices */
++			tx_endpoint = GSERIAL_TX_ENDPOINT;
++			rx_endpoint = GSERIAL_RX_ENDPOINT;
++
++			/* Configuration Descriptor */
++			configuration_descriptor = 
++				(struct usb_configuration_descriptor*)
++				&gserial_configuration_descriptors;
++
++			/* Interface count */
++			interface_count = NUM_GSERIAL_INTERFACES;
++		break;
++	}
++}
+ 
+-/*********************************************************************************/
++/******************************************************************************/
+ 
+ static struct urb *next_urb (struct usb_device_instance *device,
+ 			     struct usb_endpoint_instance *endpoint)
+@@ -522,82 +842,179 @@
+ 
+ static int write_buffer (circbuf_t * buf)
+ {
+-	if (!usbtty_configured ()) {
+-		return 0;
+-	}
++        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) {
++		TTYDBG ("buf->size= %d",buf->size);
++                        current_urb = next_urb (device_instance, endpoint);
++                        if (!current_urb) {
++                                TTYDBG ("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;
++		TTYDBG ("space_avail= %d",space_avail);
++                        popnum = MIN (space_avail, buf->size);
++                        if (popnum == 0)
++                                break;
++
++                        popped = buf_pop (buf, dest, popnum);
++		TTYDBG ("popped= %d, %s",popped, dest);
++                        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 */
++		TTYDBG (" total= %d",total);
++                return total;
++        }                       /* end if tx_urb */
+ 
+-	if (buf->size) {
++        return 0;
++}
++// static int write_buffer (circbuf_t * buf)
++// {
++// 	if (!usbtty_configured ()) {
++// 		return 0;
++// 	}
++// 	
++// 	struct usb_endpoint_instance *endpoint =
++// 			&endpoint_instance[tx_endpoint];
++// 	struct urb *current_urb = NULL;
++// 
++// 	current_urb = next_urb (device_instance, endpoint);
++// 	/* TX data still exists - send it now 
++// 	 */	
++// 	if(endpoint->sent < current_urb->actual_length){
++// 		if(udc_endpoint_write (endpoint)){
++// 			/* Write pre-empted by RX */
++// 			return -1;
++// 		}
++// 	}
++// 
++// 	if (buf->size) {
++// 		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) {
++// 			
++// 			if (!current_urb) {
++// 				TTYERR ("current_urb is NULL, buf->size %d\n",
++// 					buf->size);
++// 				return total;
++// 			}
++// 
++// 			dest = (char*)current_urb->buffer +
++// 				current_urb->actual_length;
++// 
++// 			space_avail =
++// 				current_urb->buffer_length -
++// 				current_urb->actual_length;
++// 			popnum = MIN (space_avail, 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) {
++// 				if(udc_endpoint_write (endpoint)){
++// 					/* Write pre-empted by RX */
++// 					return -1;
++// 				}
++// 			}
++// 
++// 		}/* end while */
++// 		return total;
++// 	}
++// 
++// 	return 0;
++// }
+ 
+-		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 */
++static int fill_buffer (circbuf_t * buf)
++{
++        struct usb_endpoint_instance *endpoint =
++                &endpoint_instance[rx_endpoint];
+ 
+-	return 0;
+-}
++        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;
++
++		TTYDBG ("nb= %d",nb);
++                return nb;
++        }
++
++        return 0;
++}
++/*
+ static int fill_buffer (circbuf_t * buf)
+ {
+ 	struct usb_endpoint_instance *endpoint =
+-		&endpoint_instance[RECV_ENDPOINT];
++		&endpoint_instance[rx_endpoint];
+ 
+ 	if (endpoint->rcv_urb && endpoint->rcv_urb->actual_length) {
+-		unsigned int nb = endpoint->rcv_urb->actual_length;
++		unsigned int nb = 0; 
+ 		char *src = (char *) endpoint->rcv_urb->buffer;
++		unsigned int rx_avail = buf->totalsize - buf->size;
+ 
+-		buf_push (buf, src, nb);
+-		endpoint->rcv_urb->actual_length = 0;
++		if(rx_avail >= endpoint->rcv_urb->actual_length){
+ 
++			nb = endpoint->rcv_urb->actual_length;
++			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)
+@@ -619,8 +1036,34 @@
+ 	}
+ }
+ 
+-/*********************************************************************************/
++/******************************************************************************/
+ 
++int usbtty_cdc_setup(struct usb_device_request *request, struct urb *urb)
++{
++	switch (request->bRequest){
++
++	   	case ACM_SET_CONTROL_LINE_STATE:	/* Implies DTE ready */
++			break;
++	   	case ACM_SEND_ENCAPSULATED_COMMAND :	/* Required */
++			break;
++		case ACM_SET_LINE_ENCODING :		/* DTE stop/parity bits
++							 * per character */		
++			break;
++	   	case ACM_GET_ENCAPSULATED_RESPONSE :	/* request response */
++			break;
++		case ACM_GET_LINE_ENCODING :		/* request DTE rate,
++							 * stop/parity bits */
++			memcpy (urb->buffer , &rs232_desc, sizeof(rs232_desc));
++			urb->actual_length = sizeof(rs232_desc);
++
++			break;
++	 	default:
++			return 1;
++	}
++	return 0;
++}
++
++/******************************************************************************/
+ 
+ /*
+  * Since interrupt handling has not yet been implemented, we use this function
+@@ -630,36 +1073,29 @@
+ void usbtty_poll (void)
+ {
+ 	/* New interrupts? */
+-	pretend_interrupts ();
++	udc_irq();
+ 
+-	/* Write any output data to host buffer (do this before checking interrupts to avoid missing one) */
++	/* 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) */
++	udc_irq();
++	
++	/* 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 ();
+-}
++	udc_irq();
+ 
+-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
+Index: u-boot/drivers/usbtty.h
+===================================================================
+--- u-boot.orig/drivers/usbtty.h	2007-02-08 21:11:27.000000000 +0100
++++ u-boot/drivers/usbtty.h	2007-02-08 21:11:55.000000000 +0100
+@@ -2,6 +2,9 @@
+  * (C) Copyright 2003
+  * Gerry Hamel, geh@ti.com, Texas Instruments
+  *
++ * (C) Copyright 2006
++ * Bryan O'Donoghue, bodonoghue <at> codehermit.ie, CodeHermit
++ *
+  * 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
+@@ -21,44 +24,49 @@
+ #ifndef __USB_TTY_H__
+ #define __USB_TTY_H__
+ 
+-
+ #include "usbdcore.h"
++#if defined(CONFIG_PPC)
++#include "usbdcore_mpc8xx.h"
++#elif defined(CONFIG_OMAP1510)
+ #include "usbdcore_omap1510.h"
++#endif
+ 
++#include <config.h>
++#include <version.h>
+ 
+-#define NUM_CONFIGS    1
+-#define NUM_INTERFACES 1
+-#define NUM_ENDPOINTS  3
++/* If no VendorID/ProductID is defined in config.h, pretend to be Linux 
++ * DO NOT Reuse this Vendor/Product setup with protocol incompatible devices */
+ 
+-#define EP0_MAX_PACKET_SIZE 64
++#ifndef CONFIG_USBD_VENDORID
++#define CONFIG_USBD_VENDORID 0x0525 	/* Linux/NetChip */
++#define CONFIG_USBD_PRODUCTID_GSERIAL 0xa4a6	/* gserial */
++#define CONFIG_USBD_PRODUCTID_CDCACM  0xa4a7	/* CDC ACM */
++#define CONFIG_USBD_MANUFACTURER "Das U-Boot"
++#define CONFIG_USBD_PRODUCT_NAME U_BOOT_VERSION
++#endif /* CONFIG_USBD_VENDORID */
+ 
+ #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 CONFIG_USBD_SERIAL_OUT_ENDPOINT UDC_OUT_ENDPOINT 
++#define CONFIG_USBD_SERIAL_OUT_PKTSIZE	UDC_OUT_PACKET_SIZE
++#define CONFIG_USBD_SERIAL_IN_ENDPOINT	UDC_IN_ENDPOINT
++#define CONFIG_USBD_SERIAL_IN_PKTSIZE	UDC_IN_PACKET_SIZE
++#define CONFIG_USBD_SERIAL_INT_ENDPOINT UDC_INT_ENDPOINT
++#define CONFIG_USBD_SERIAL_INT_PKTSIZE	UDC_INT_PACKET_SIZE
++#define CONFIG_USBD_SERIAL_BULK_PKTSIZE	UDC_BULK_PACKET_SIZE
+ 
+ #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
++#define USBTTY_BCD_DEVICE	0x00
++#define USBTTY_MAXPOWER  	0x00
++
++#define STR_LANG		0x00
++#define STR_MANUFACTURER	0x01
++#define STR_PRODUCT		0x02
++#define STR_SERIAL		0x03
++#define STR_CONFIG		0x04
++#define STR_DATA_INTERFACE	0x05
++#define STR_CTRL_INTERFACE	0x06
++#define STR_COUNT		0x07
+ 
+ #endif
+Index: u-boot/drivers/usbdcore_omap1510.c
+===================================================================
+--- u-boot.orig/drivers/usbdcore_omap1510.c	2007-02-08 21:11:27.000000000 +0100
++++ u-boot/drivers/usbdcore_omap1510.c	2007-02-08 21:11:55.000000000 +0100
+@@ -960,7 +960,7 @@
+ /* Handle general USB interrupts and dispatch according to type.
+  * This function implements TRM Figure 14-13.
+  */
+-void omap1510_udc_irq (void)
++static void omap1510_udc_irq (void)
+ {
+ 	u16 irq_src = inw (UDC_IRQ_SRC);
+ 	int valid_irq = 0;
+@@ -1000,7 +1000,7 @@
+ }
+ 
+ /* This function implements TRM Figure 14-26. */
+-void omap1510_udc_noniso_irq (void)
++static void omap1510_udc_noniso_irq (void)
+ {
+ 	unsigned short epnum;
+ 	unsigned short irq_src = inw (UDC_IRQ_SRC);
+@@ -1054,6 +1054,20 @@
+ 			       irq_src);
+ }
+ 
++void udc_irq(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 ();
++	}
++}
++
+ /*
+ -------------------------------------------------------------------------------
+ */
+Index: u-boot/include/usb_cdc_acm.h
+===================================================================
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ u-boot/include/usb_cdc_acm.h	2007-02-08 21:11:55.000000000 +0100
+@@ -0,0 +1,43 @@
++/*
++ * (C) Copyright 2006
++ * Bryan O'Donoghue, deckard <at> codehermit.ie, CodeHermit
++ *
++ * 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.
++ *
++ */
++
++/* ACM Control Requests */
++#define ACM_SEND_ENCAPSULATED_COMMAND	0x00
++#define ACM_GET_ENCAPSULATED_RESPONSE	0x01
++#define ACM_SET_COMM_FEATURE		0x02
++#define ACM_GET_COMM_FEATRUE		0x03
++#define ACM_CLEAR_COMM_FEATURE		0x04
++#define ACM_SET_LINE_ENCODING		0x20
++#define ACM_GET_LINE_ENCODING		0x21
++#define ACM_SET_CONTROL_LINE_STATE	0x22
++#define ACM_SEND_BREAK			0x23
++
++/* ACM Notification Codes */
++#define ACM_NETWORK_CONNECTION		0x00
++#define ACM_RESPONSE_AVAILABLE		0x01
++#define ACM_SERIAL_STATE		0x20
++
++/* Format of response expected by a ACM_GET_LINE_ENCODING request */ 
++struct rs232_emu{
++		unsigned long dter;
++		unsigned char stop_bits;
++		unsigned char parity;
++		unsigned char data_bits;
++}__attribute__((packed));
+Index: u-boot/include/usbdcore_omap1510.h
+===================================================================
+--- u-boot.orig/include/usbdcore_omap1510.h	2007-02-08 21:11:27.000000000 +0100
++++ u-boot/include/usbdcore_omap1510.h	2007-02-08 21:11:55.000000000 +0100
+@@ -161,13 +161,23 @@
+ #define UDC_VBUS_CTRL	    (1 << 19)
+ #define UDC_VBUS_MODE	    (1 << 18)
+ 
+-
+-void omap1510_udc_irq(void);
+-void omap1510_udc_noniso_irq(void);
+-
++/* OMAP Endpoint parameters */
++#define EP0_MAX_PACKET_SIZE 64
++#define UDC_OUT_ENDPOINT 2
++#define UDC_OUT_PACKET_SIZE 64
++#define UDC_IN_ENDPOINT		1
++#define UDC_IN_PACKET_SIZE 64
++#define UDC_INT_ENDPOINT 5
++#define UDC_INT_PACKET_SIZE	16
++#define UDC_BULK_PACKET_SIZE	16
++
++void udc_irq (void);
++/* Flow control */
++void udc_set_nak(int epid);
++void udc_unset_nak (int epid);
+ 
+ /* Higher level functions for abstracting away from specific device */
+-void udc_endpoint_write(struct usb_endpoint_instance *endpoint);
++int udc_endpoint_write(struct usb_endpoint_instance *endpoint);
+ 
+ int  udc_init (void);
+ 
+Index: u-boot/include/usbdescriptors.h
+===================================================================
+--- u-boot.orig/include/usbdescriptors.h	2007-02-08 21:11:27.000000000 +0100
++++ u-boot/include/usbdescriptors.h	2007-02-08 21:11:55.000000000 +0100
+@@ -92,15 +92,17 @@
+ #define COMMUNICATIONS_DEVICE_CLASS	0x02
+ 
+ /* c.f. CDC 4.2 Table 15 */
+-#define COMMUNICATIONS_INTERFACE_CLASS	0x02
++#define COMMUNICATIONS_INTERFACE_CLASS_CONTROL	0x02
++#define COMMUNICATIONS_INTERFACE_CLASS_DATA	0x0A
++#define COMMUNICATIONS_INTERFACE_CLASS_VENDOR	0x0FF
+ 
+ /* c.f. CDC 4.3 Table 16 */
+-#define COMMUNICATIONS_NO_SUBCLASS	0x00
++#define COMMUNICATIONS_NO_SUBCLASS            0x00
+ #define COMMUNICATIONS_DLCM_SUBCLASS	0x01
+-#define COMMUNICATIONS_ACM_SUBCLASS	0x02
+-#define COMMUNICATIONS_TCM_SUBCLASS	0x03
++#define COMMUNICATIONS_ACM_SUBCLASS           0x02
++#define COMMUNICATIONS_TCM_SUBCLASS           0x03
+ #define COMMUNICATIONS_MCCM_SUBCLASS	0x04
+-#define COMMUNICATIONS_CCM_SUBCLASS	0x05
++#define COMMUNICATIONS_CCM_SUBCLASS           0x05
+ #define COMMUNICATIONS_ENCM_SUBCLASS	0x06
+ #define COMMUNICATIONS_ANCM_SUBCLASS	0x07
+ 
+@@ -110,15 +112,22 @@
+ #define COMMUNICATIONS_MDLM_SUBCLASS	0x0a
+ #define COMMUNICATIONS_OBEX_SUBCLASS	0x0b
+ 
+-/* c.f. CDC 4.6 Table 18 */
++/* c.f. CDC 4.4 Table 17 */
++#define COMMUNICATIONS_NO_PROTOCOL            0x00
++#define COMMUNICATIONS_V25TER_PROTOCOL        0x01    /*Common AT Hayes compatible*/
++
++/* c.f. CDC 4.5 Table 18 */
+ #define DATA_INTERFACE_CLASS		0x0a
+ 
++/* c.f. CDC 4.6 No Table */
++#define DATA_INTERFACE_SUBCLASS_NONE  0x00    /* No subclass pertinent */
++
+ /* c.f. CDC 4.7 Table 19 */
+-#define COMMUNICATIONS_NO_PROTOCOL	0x00
++#define DATA_INTERFACE_PROTOCOL_NONE  0x00    /* No class protcol required */
+ 
+ 
+ /* c.f. CDC 5.2.3 Table 24 */
+-#define CS_INTERFACE			0x24
++#define CS_INTERFACE          0x24
+ #define CS_ENDPOINT			0x25
+ 
+ /*
+@@ -128,7 +137,7 @@
+  * c.f. WMCD 5.3 Table 5.3
+  */
+ 
+-#define USB_ST_HEADER			0x00
++#define USB_ST_HEADER         0x00
+ #define USB_ST_CMF			0x01
+ #define USB_ST_ACMF			0x02
+ #define USB_ST_DLMF			0x03
+@@ -137,18 +146,18 @@
+ #define USB_ST_UF			0x06
+ #define USB_ST_CSF			0x07
+ #define USB_ST_TOMF			0x08
+-#define USB_ST_USBTF			0x09
++#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_ATMNF          0x10
+ 
+ #define USB_ST_WHCM			0x11
+ #define USB_ST_MDLM			0x12
+-#define USB_ST_MDLMD			0x13
++#define USB_ST_MDLMD          0x13
+ #define USB_ST_DMM			0x14
+ #define USB_ST_OBEX			0x15
+ #define USB_ST_CS			0x16
+@@ -312,7 +321,8 @@
+ 	u8 bDescriptorType;
+ 	u8 bDescriptorSubtype;	/* 0x06 */
+ 	u8 bMasterInterface;
+-	u8 bSlaveInterface0[0];
++      //u8 bSlaveInterface0[0];
++      u8 bSlaveInterface0;
+ } __attribute__ ((packed));
+ 
+ struct usb_class_country_selection_descriptor {
+Index: u-boot/include/usbdcore.h
+===================================================================
+--- u-boot.orig/include/usbdcore.h	2007-02-08 21:11:27.000000000 +0100
++++ u-boot/include/usbdcore.h	2007-02-08 21:11:55.000000000 +0100
+@@ -576,6 +576,9 @@
+ 
+ 	void (*event) (struct usb_device_instance *device, usb_device_event_t event, int data);
+ 
++	/* Do cdc device specific control requests */
++	int (*cdc_recv_setup)(struct usb_device_request *request, struct urb *urb);
++
+ 	/* bus interface */
+ 	struct usb_bus_instance *bus;	/* which bus interface driver */
+ 
+Index: u-boot/drivers/usbdcore_ep0.c
+===================================================================
+--- u-boot.orig/drivers/usbdcore_ep0.c	2007-02-08 21:12:05.000000000 +0100
++++ u-boot/drivers/usbdcore_ep0.c	2007-02-08 21:12:08.000000000 +0100
+@@ -223,7 +223,6 @@
+ 
+ 	case USB_DESCRIPTOR_TYPE_CONFIGURATION:
+ 		{
+-			int bNumInterface;
+ 			struct usb_configuration_descriptor
+ 				*configuration_descriptor;
+ 			struct usb_device_descriptor *device_descriptor;
+@@ -256,105 +255,6 @@
+ 					     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;
+ 
+@@ -363,6 +263,7 @@
+ 			struct usb_string_descriptor *string_descriptor;
+ 
+ 			if (!(string_descriptor = usbd_get_string (index))) {
++				dbg_ep0(0, "Invalid string index %u\n", index);
+ 				return -1;
+ 			}
+ 			/*dbg_ep0(3, "string_descriptor: %p", string_descriptor); */
+@@ -495,6 +396,8 @@
+ 
+ 	/* handle USB Standard Request (c.f. USB Spec table 9-2) */
+ 	if ((request->bmRequestType & USB_REQ_TYPE_MASK) != 0) {
++		if (device->device_state <= STATE_CONFIGURED)
++			return device->cdc_recv_setup(request, urb);
+ 		dbg_ep0 (1, "non standard request: %x",
+ 			 request->bmRequestType & USB_REQ_TYPE_MASK);
+ 		return -1;	/* Stall here */