[J-u-boot.git] / include / usbdcore.h

/*
 * (C) Copyright 2003
 * Gerry Hamel, [email protected], Texas Instruments
 *
 * Based on linux/drivers/usbd/usbd.h
 *
 * Copyright (c) 2000, 2001, 2002 Lineo
 * Copyright (c) 2001 Hewlett Packard
 *
 * By:
 *	Stuart Lynne <[email protected]>,
 *	Tom Rushworth <[email protected]>,
 *	Bruce Balden <[email protected]>
 *
 * 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);

	/* 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 */

	/* 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
Commit	Line	Data
232c150a WD	1	/*
	2	* (C) Copyright 2003
	3	* Gerry Hamel, [email protected], Texas Instruments
	4	*
	5	* Based on linux/drivers/usbd/usbd.h
	6	*
	7	* Copyright (c) 2000, 2001, 2002 Lineo
	8	* Copyright (c) 2001 Hewlett Packard
	9	*
	10	* By:
	11	* Stuart Lynne <[email protected]>,
	12	* Tom Rushworth <[email protected]>,
	13	* Bruce Balden <[email protected]>
	14	*
	15	* This program is free software; you can redistribute it and/or modify
	16	* it under the terms of the GNU General Public License as published by
	17	* the Free Software Foundation; either version 2 of the License, or
	18	* (at your option) any later version.
	19	*
	20	* This program is distributed in the hope that it will be useful,
	21	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	23	* GNU General Public License for more details.
	24	*
	25	* You should have received a copy of the GNU General Public License
	26	* along with this program; if not, write to the Free Software
	27	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	28	*
	29	*/
	30
	31	#ifndef __USBDCORE_H__
	32	#define __USBDCORE_H__
	33
	34	#include <common.h>
	35	#include "usbdescriptors.h"
	36
	37
	38	#define MAX_URBS_QUEUED 5
	39
	40
	41	#if 1
	42	#define usberr(fmt,args...) serial_printf("ERROR: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
	43	#else
	44	#define usberr(fmt,args...) do{}while(0)
	45	#endif
	46
	47	#if 0
	48	#define usbdbg(fmt,args...) serial_printf("debug: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
	49	#else
	50	#define usbdbg(fmt,args...) do{}while(0)
	51	#endif
	52
	53	#if 0
	54	#define usbinfo(fmt,args...) serial_printf("info: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
	55	#else
	56	#define usbinfo(fmt,args...) do{}while(0)
	57	#endif
	58
	59	#ifndef le16_to_cpu
	60	#define le16_to_cpu(x) (x)
	61	#endif
	62
	63	#ifndef inb
	64	#define inb(p) ((volatile u8)(p))
65	#endif
66
67	#ifndef outb
68	#define outb(val,p) ((volatile u8)(p) = (val))
69	#endif
70
71	#ifndef inw
72	#define inw(p) ((volatile u16)(p))
73	#endif
74
75	#ifndef outw
76	#define outw(val,p) ((volatile u16)(p) = (val))
77	#endif
78
79	#ifndef inl
80	#define inl(p) ((volatile u32)(p))
81	#endif
82
83	#ifndef outl
84	#define outl(val,p) ((volatile u32)(p) = (val))
85	#endif
86
87	#ifndef insw
88	#define insw(p,to,len) mmio_insw(p,to,len)
89	#endif
90
91	#ifndef outsw
92	#define outsw(p,from,len) mmio_outsw(p,from,len)
93	#endif
94
95	#ifndef insb
96	#define insb(p,to,len) mmio_insb(p,to,len)
97	#endif
98
99	#ifndef mmio_insw
100	#define mmio_insw(r,b,l) ({ int __i ; \
101	u16 *__b2; \
102	__b2 = (u16 *) b; \
103	for (__i = 0; __i < l; __i++) { \
104	*(__b2 + __i) = inw(r); \
105	}; \
106	})
107	#endif
108
109	#ifndef mmio_outsw
110	#define mmio_outsw(r,b,l) ({ int __i; \
111	u16 *__b2; \
112	__b2 = (u16 *) b; \
113	for (__i = 0; __i < l; __i++) { \
114	outw( *(__b2 + __i), r); \
115	} \
116	})
117	#endif
118
119	#ifndef mmio_insb
120	#define mmio_insb(r,b,l) ({ int __i ; \
121	u8 *__b2; \
122	__b2 = (u8 *) b; \
123	for (__i = 0; __i < l; __i++) { \
124	*(__b2 + __i) = inb(r); \
125	}; \
126	})
127	#endif
128
129	#ifndef MIN
130	#define MIN(a,b) ((a) < (b) ? (a) : (b))
131	#endif
132	#ifndef MAX
133	#define MAX(a,b) ((a) > (b) ? (a) : (b))
134	#endif
135
136
137	/*
138	* Structure member address manipulation macros.
139	* These are used by client code (code using the urb_link routines), since
140	* the urb_link structure is embedded in the client data structures.
141	*
142	* Note: a macro offsetof equivalent to member_offset is defined in stddef.h
143	* but this is kept here for the sake of portability.
144	*
145	* p2surround returns a pointer to the surrounding structure given
146	* type of the surrounding structure, the name memb of the structure
147	* member pointed at by ptr. For example, if you have:
148	*
149	* struct foo {
150	* int x;
151	* float y;
152	* char z;
153	* } thingy;
154	*
155	* char *cp = &thingy.z;
156	*
157	* then
158	*
159	* &thingy == p2surround(struct foo, z, cp)
160	*
161	* Clear?
162	*/
163	#define _cv_(ptr) ((char)(void)(ptr))
164	#define member_offset(type,memb) (_cv_(&(((type)0)->memb))-(char)0)
165	#define p2surround(type,memb,ptr) ((type)(void)(_cv_(ptr)-member_offset(type,memb)))
166
167	struct urb;
168
169	struct usb_endpoint_instance;
170	struct usb_interface_instance;
171	struct usb_configuration_instance;
172	struct usb_device_instance;
173	struct usb_bus_instance;
174
175	/*
176	* Device and/or Interface Class codes
177	*/
178	#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */
179	#define USB_CLASS_AUDIO 1
180	#define USB_CLASS_COMM 2
181	#define USB_CLASS_HID 3
182	#define USB_CLASS_PHYSICAL 5
183	#define USB_CLASS_PRINTER 7
184	#define USB_CLASS_MASS_STORAGE 8
185	#define USB_CLASS_HUB 9
186	#define USB_CLASS_DATA 10
187	#define USB_CLASS_APP_SPEC 0xfe
188	#define USB_CLASS_VENDOR_SPEC 0xff
189
190	/*
191	* USB types
192	*/
193	#define USB_TYPE_STANDARD (0x00 << 5)
194	#define USB_TYPE_CLASS (0x01 << 5)
195	#define USB_TYPE_VENDOR (0x02 << 5)
196	#define USB_TYPE_RESERVED (0x03 << 5)
197
198	/*
199	* USB recipients
200	*/
201	#define USB_RECIP_DEVICE 0x00
202	#define USB_RECIP_INTERFACE 0x01
203	#define USB_RECIP_ENDPOINT 0x02
204	#define USB_RECIP_OTHER 0x03
205
206	/*
207	* USB directions
208	*/
209	#define USB_DIR_OUT 0
210	#define USB_DIR_IN 0x80
211
212	/*
213	* Descriptor types
214	*/
215	#define USB_DT_DEVICE 0x01
216	#define USB_DT_CONFIG 0x02
217	#define USB_DT_STRING 0x03
218	#define USB_DT_INTERFACE 0x04
219	#define USB_DT_ENDPOINT 0x05
220
221	#define USB_DT_HID (USB_TYPE_CLASS \| 0x01)
222	#define USB_DT_REPORT (USB_TYPE_CLASS \| 0x02)
223	#define USB_DT_PHYSICAL (USB_TYPE_CLASS \| 0x03)
224	#define USB_DT_HUB (USB_TYPE_CLASS \| 0x09)
225
226	/*
227	* Descriptor sizes per descriptor type
228	*/
229	#define USB_DT_DEVICE_SIZE 18
230	#define USB_DT_CONFIG_SIZE 9
231	#define USB_DT_INTERFACE_SIZE 9
232	#define USB_DT_ENDPOINT_SIZE 7
233	#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
234	#define USB_DT_HUB_NONVAR_SIZE 7
235	#define USB_DT_HID_SIZE 9
236
237	/*
238	* Endpoints
239	*/
240	#define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */
241	#define USB_ENDPOINT_DIR_MASK 0x80
242
243	#define USB_ENDPOINT_XFERTYPE_MASK 0x03 /* in bmAttributes */
244	#define USB_ENDPOINT_XFER_CONTROL 0
245	#define USB_ENDPOINT_XFER_ISOC 1
246	#define USB_ENDPOINT_XFER_BULK 2
247	#define USB_ENDPOINT_XFER_INT 3
248
249	/*
250	* USB Packet IDs (PIDs)
251	*/
252	#define USB_PID_UNDEF_0 0xf0
253	#define USB_PID_OUT 0xe1
254	#define USB_PID_ACK 0xd2
255	#define USB_PID_DATA0 0xc3
256	#define USB_PID_PING 0xb4 /* USB 2.0 */
257	#define USB_PID_SOF 0xa5
258	#define USB_PID_NYET 0x96 /* USB 2.0 */
259	#define USB_PID_DATA2 0x87 /* USB 2.0 */
260	#define USB_PID_SPLIT 0x78 /* USB 2.0 */
261	#define USB_PID_IN 0x69
262	#define USB_PID_NAK 0x5a
263	#define USB_PID_DATA1 0x4b
264	#define USB_PID_PREAMBLE 0x3c /* Token mode */
265	#define USB_PID_ERR 0x3c /* USB 2.0: handshake mode */
266	#define USB_PID_SETUP 0x2d
267	#define USB_PID_STALL 0x1e
268	#define USB_PID_MDATA 0x0f /* USB 2.0 */
269
270	/*
271	* Standard requests
272	*/
273	#define USB_REQ_GET_STATUS 0x00
274	#define USB_REQ_CLEAR_FEATURE 0x01
275	#define USB_REQ_SET_FEATURE 0x03
276	#define USB_REQ_SET_ADDRESS 0x05
277	#define USB_REQ_GET_DESCRIPTOR 0x06
278	#define USB_REQ_SET_DESCRIPTOR 0x07
279	#define USB_REQ_GET_CONFIGURATION 0x08
280	#define USB_REQ_SET_CONFIGURATION 0x09
281	#define USB_REQ_GET_INTERFACE 0x0A
282	#define USB_REQ_SET_INTERFACE 0x0B
283	#define USB_REQ_SYNCH_FRAME 0x0C
284
285	#define USBD_DEVICE_REQUESTS(x) (((unsigned int)x <= USB_REQ_SYNCH_FRAME) ? usbd_device_requests[x] : "UNKNOWN")
286
287	/*
288	* HID requests
289	*/
290	#define USB_REQ_GET_REPORT 0x01
291	#define USB_REQ_GET_IDLE 0x02
292	#define USB_REQ_GET_PROTOCOL 0x03
293	#define USB_REQ_SET_REPORT 0x09
294	#define USB_REQ_SET_IDLE 0x0A
295	#define USB_REQ_SET_PROTOCOL 0x0B
296
297
298	/*
299	* USB Spec Release number
300	*/
301
302	#define USB_BCD_VERSION 0x0110
303
304
305	/*
306	* Device Requests (c.f Table 9-2)
307	*/
308
309	#define USB_REQ_DIRECTION_MASK 0x80
310	#define USB_REQ_TYPE_MASK 0x60
311	#define USB_REQ_RECIPIENT_MASK 0x1f
312
313	#define USB_REQ_DEVICE2HOST 0x80
314	#define USB_REQ_HOST2DEVICE 0x00
315
316	#define USB_REQ_TYPE_STANDARD 0x00
317	#define USB_REQ_TYPE_CLASS 0x20
318	#define USB_REQ_TYPE_VENDOR 0x40
319
320	#define USB_REQ_RECIPIENT_DEVICE 0x00
321	#define USB_REQ_RECIPIENT_INTERFACE 0x01
322	#define USB_REQ_RECIPIENT_ENDPOINT 0x02
323	#define USB_REQ_RECIPIENT_OTHER 0x03
324
325	/*
326	* get status bits
327	*/
328
329	#define USB_STATUS_SELFPOWERED 0x01
330	#define USB_STATUS_REMOTEWAKEUP 0x02
331
332	#define USB_STATUS_HALT 0x01
333
334	/*
335	* descriptor types
336	*/
337
338	#define USB_DESCRIPTOR_TYPE_DEVICE 0x01
339	#define USB_DESCRIPTOR_TYPE_CONFIGURATION 0x02
340	#define USB_DESCRIPTOR_TYPE_STRING 0x03
341	#define USB_DESCRIPTOR_TYPE_INTERFACE 0x04
342	#define USB_DESCRIPTOR_TYPE_ENDPOINT 0x05
343	#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER 0x06
344	#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION 0x07
345	#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER 0x08
346	#define USB_DESCRIPTOR_TYPE_HID 0x21
347	#define USB_DESCRIPTOR_TYPE_REPORT 0x22
348
349	#define USBD_DEVICE_DESCRIPTORS(x) (((unsigned int)x <= USB_DESCRIPTOR_TYPE_INTERFACE_POWER) ? \
350	usbd_device_descriptors[x] : "UNKNOWN")
351
352	/*
353	* standard feature selectors
354	*/
355	#define USB_ENDPOINT_HALT 0x00
356	#define USB_DEVICE_REMOTE_WAKEUP 0x01
357	#define USB_TEST_MODE 0x02
358
359
360	/* USB Requests
361	*
362	*/
363
364	struct usb_device_request {
365	u8 bmRequestType;
366	u8 bRequest;
367	u16 wValue;
368	u16 wIndex;
369	u16 wLength;
370	} __attribute__ ((packed));
371
372
373	/* USB Status
374	*
375	*/
376	typedef enum urb_send_status {
377	SEND_IN_PROGRESS,
378	SEND_FINISHED_OK,
379	SEND_FINISHED_ERROR,
380	RECV_READY,
381	RECV_OK,
382	RECV_ERROR
383	} urb_send_status_t;
384
385	/*
386	* Device State (c.f USB Spec 2.0 Figure 9-1)
387	*
388	* What state the usb device is in.
389	*
390	* Note the state does not change if the device is suspended, we simply set a
391	* flag to show that it is suspended.
392	*
393	*/
394	typedef enum usb_device_state {
395	STATE_INIT, /* just initialized */
396	STATE_CREATED, /* just created */
397	STATE_ATTACHED, /* we are attached */
398	STATE_POWERED, /* we have seen power indication (electrical bus signal) */
399	STATE_DEFAULT, /* we been reset */
400	STATE_ADDRESSED, /* we have been addressed (in default configuration) */
401	STATE_CONFIGURED, /* we have seen a set configuration device command */
402	STATE_UNKNOWN, /* destroyed */
403	} usb_device_state_t;
404
405	#define USBD_DEVICE_STATE(x) (((unsigned int)x <= STATE_UNKNOWN) ? usbd_device_states[x] : "UNKNOWN")
406
407	/*
408	* Device status
409	*
410	* Overall state
411	*/
412	typedef enum usb_device_status {
413	USBD_OPENING, /* we are currently opening */
414	USBD_OK, /* ok to use */
415	USBD_SUSPENDED, /* we are currently suspended */
416	USBD_CLOSING, /* we are currently closing */
417	} usb_device_status_t;
418
419	#define USBD_DEVICE_STATUS(x) (((unsigned int)x <= USBD_CLOSING) ? usbd_device_status[x] : "UNKNOWN")
420
421	/*
422	* Device Events
423	*
424	* These are defined in the USB Spec (c.f USB Spec 2.0 Figure 9-1).
425	*
426	* There are additional events defined to handle some extra actions we need
427	* to have handled.
428	*
429	*/
430	typedef enum usb_device_event {
431
432	DEVICE_UNKNOWN, /* bi - unknown event */
433	DEVICE_INIT, /* bi - initialize */
434	DEVICE_CREATE, /* bi - */
435	DEVICE_HUB_CONFIGURED, /* bi - bus has been plugged int */
436	DEVICE_RESET, /* bi - hub has powered our port */
437
438	DEVICE_ADDRESS_ASSIGNED, /* ep0 - set address setup received */
439	DEVICE_CONFIGURED, /* ep0 - set configure setup received */
440	DEVICE_SET_INTERFACE, /* ep0 - set interface setup received */
441
442	DEVICE_SET_FEATURE, /* ep0 - set feature setup received */
443	DEVICE_CLEAR_FEATURE, /* ep0 - clear feature setup received */
444
445	DEVICE_DE_CONFIGURED, /* ep0 - set configure setup received for ?? */
446
447	DEVICE_BUS_INACTIVE, /* bi - bus in inactive (no SOF packets) */
448	DEVICE_BUS_ACTIVITY, /* bi - bus is active again */
449
450	DEVICE_POWER_INTERRUPTION, /* bi - hub has depowered our port */
451	DEVICE_HUB_RESET, /* bi - bus has been unplugged */
452	DEVICE_DESTROY, /* bi - device instance should be destroyed */
453
454	DEVICE_HOTPLUG, /* bi - a hotplug event has occured */
455
456	DEVICE_FUNCTION_PRIVATE, /* function - private */
457
458	} usb_device_event_t;
459
460
461	typedef struct urb_link {
462	struct urb_link *next;
463	struct urb_link *prev;
464	} urb_link;
465
466	/* USB Data structure - for passing data around.
467	*
468	* This is used for both sending and receiving data.
469	*
470	* The callback function is used to let the function driver know when
471	* transmitted data has been sent.
472	*
473	* The callback function is set by the alloc_recv function when an urb is
474	* allocated for receiving data for an endpoint and used to call the
475	* function driver to inform it that data has arrived.
476	*/
477
478	#define URB_BUF_SIZE 128 /* in linux we'd malloc this, but in u-boot we prefer static data */
479	struct urb {
480
481	struct usb_endpoint_instance *endpoint;
482	struct usb_device_instance *device;
483
484	struct usb_device_request device_request; /* contents of received SETUP packet */
485
486	struct urb_link link; /* embedded struct for circular doubly linked list of urbs */
487
488	u8* buffer;
489	unsigned int buffer_length;
490	unsigned int actual_length;
491
492	urb_send_status_t status;
493	int data;
494
495	u16 buffer_data[URB_BUF_SIZE]; /* data received (OUT) or being sent (IN) */
496	};
497
498	/* Endpoint configuration
499	*
500	* Per endpoint configuration data. Used to track which function driver owns
501	* an endpoint.
502	*
503	*/
504	struct usb_endpoint_instance {
505	int endpoint_address; /* logical endpoint address */
506
507	/* control */
508	int status; /* halted */
509	int state; /* available for use by bus interface driver */
510
511	/* receive side */
512	struct urb_link rcv; /* received urbs */
513	struct urb_link rdy; /* empty urbs ready to receive */
514	struct urb rcv_urb; / active urb */
515	int rcv_attributes; /* copy of bmAttributes from endpoint descriptor */
516	int rcv_packetSize; /* maximum packet size from endpoint descriptor */
517	int rcv_transferSize; /* maximum transfer size from function driver */
518	int rcv_queue;
519
520	/* transmit side */
521	struct urb_link tx; /* urbs ready to transmit */
522	struct urb_link done; /* transmitted urbs */
523	struct urb tx_urb; / active urb */
524	int tx_attributes; /* copy of bmAttributes from endpoint descriptor */
525	int tx_packetSize; /* maximum packet size from endpoint descriptor */
526	int tx_transferSize; /* maximum transfer size from function driver */
527	int tx_queue;
528
529	int sent; /* data already sent */
530	int last; /* data sent in last packet XXX do we need this */
531	};
532
533	struct usb_alternate_instance {
534	struct usb_interface_descriptor *interface_descriptor;
535
536	int endpoints;
537	int *endpoint_transfersize_array;
538	struct usb_endpoint_descriptor **endpoints_descriptor_array;
539	};
540
541	struct usb_interface_instance {
542	int alternates;
543	struct usb_alternate_instance *alternates_instance_array;
544	};
545
546	struct usb_configuration_instance {
547	int interfaces;
548	struct usb_configuration_descriptor *configuration_descriptor;
549	struct usb_interface_instance *interface_instance_array;
550	};
551
552
553	/* USB Device Instance
554	*
555	* For each physical bus interface we create a logical device structure. This
556	* tracks all of the required state to track the USB HOST's view of the device.
557	*
558	* Keep track of the device configuration for a real physical bus interface,
559	* this includes the bus interface, multiple function drivers, the current
560	* configuration and the current state.
561	*
562	* This will show:
563	* the specific bus interface driver
564	* the default endpoint 0 driver
565	* the configured function driver
566	* device state
567	* device status
568	* endpoint list
569	*/
570
571	struct usb_device_instance {
572
573	/* generic */
574	char *name;
575	struct usb_device_descriptor device_descriptor; / per device descriptor */
576
577	void (event) (struct usb_device_instance device, usb_device_event_t event, int data);
578
16c8d5e7 WD	579	/* Do cdc device specific control requests */
	580	int (cdc_recv_setup)(struct usb_device_request request, struct urb *urb);
	581
232c150a WD	582	/* bus interface */
	583	struct usb_bus_instance bus; / which bus interface driver */
	584
	585	/* configuration descriptors */
	586	int configurations;
	587	struct usb_configuration_instance *configuration_instance_array;
	588
	589	/* device state */
	590	usb_device_state_t device_state; /* current USB Device state */
	591	usb_device_state_t device_previous_state; /* current USB Device state */
	592
	593	u8 address; /* current address (zero is default) */
	594	u8 configuration; /* current show configuration (zero is default) */
	595	u8 interface; /* current interface (zero is default) */
	596	u8 alternate; /* alternate flag */
	597
	598	usb_device_status_t status; /* device status */
	599
	600	int urbs_queued; /* number of submitted urbs */
	601
	602	/* Shouldn't need to make this atomic, all we need is a change indicator */
	603	unsigned long usbd_rxtx_timestamp;
	604	unsigned long usbd_last_rxtx_timestamp;
	605
	606	};
	607
	608	/* Bus Interface configuration structure
	609	*
	610	* This is allocated for each configured instance of a bus interface driver.
	611	*
	612	* The privdata pointer may be used by the bus interface driver to store private
	613	* per instance state information.
	614	*/
	615	struct usb_bus_instance {
	616
	617	struct usb_device_instance *device;
	618	struct usb_endpoint_instance endpoint_array; / array of available configured endpoints */
	619
	620	int max_endpoints; /* maximimum number of rx enpoints */
	621	unsigned char maxpacketsize;
	622
	623	unsigned int serial_number;
	624	char *serial_number_str;
	625	void privdata; / private data for the bus interface */
	626
	627	};
	628
	629	extern char *usbd_device_events[];
	630	extern char *usbd_device_states[];
	631	extern char *usbd_device_status[];
	632	extern char *usbd_device_requests[];
	633	extern char *usbd_device_descriptors[];
	634
	635	void urb_link_init (urb_link * ul);
	636	void urb_detach (struct urb *urb);
	637	urb_link first_urb_link (urb_link hd);
	638	struct urb first_urb (urb_link hd);
	639	struct urb first_urb_detached (urb_link hd);
	640	void urb_append (urb_link * hd, struct urb *urb);
	641
	642	struct urb usbd_alloc_urb (struct usb_device_instance device, struct usb_endpoint_instance *endpoint);
	643	void usbd_dealloc_urb (struct urb *urb);
	644
	645	/*
646	* usbd_device_event is used by bus interface drivers to tell the higher layers that
647	* certain events have taken place.
648	*/
649	void usbd_device_event_irq (struct usb_device_instance *conf, usb_device_event_t, int);
650	void usbd_device_event (struct usb_device_instance *conf, usb_device_event_t, int);
651
652	/* descriptors
653	*
654	* Various ways of finding descriptors based on the current device and any
655	* possible configuration / interface / endpoint for it.
656	*/
657	struct usb_configuration_descriptor usbd_device_configuration_descriptor (struct usb_device_instance , int, int);
658	struct usb_function_instance usbd_device_function_instance (struct usb_device_instance , unsigned int);
659	struct usb_interface_instance usbd_device_interface_instance (struct usb_device_instance , int, int, int);
660	struct usb_alternate_instance usbd_device_alternate_instance (struct usb_device_instance , int, int, int, int);
661	struct usb_interface_descriptor usbd_device_interface_descriptor (struct usb_device_instance , int, int, int, int);
662	struct usb_endpoint_descriptor usbd_device_endpoint_descriptor_index (struct usb_device_instance , int, int, int, int, int);
663	struct usb_class_descriptor usbd_device_class_descriptor_index (struct usb_device_instance , int, int, int, int, int);
664	struct usb_class_report_descriptor usbd_device_class_report_descriptor_index( struct usb_device_instance , int , int , int , int , int );
665	struct usb_endpoint_descriptor usbd_device_endpoint_descriptor (struct usb_device_instance , int, int, int, int, int);
666	int usbd_device_endpoint_transfersize (struct usb_device_instance *, int, int, int, int, int);
667	struct usb_string_descriptor *usbd_get_string (u8);
668	struct usb_device_descriptor usbd_device_device_descriptor (struct usb_device_instance , int);
669
670	int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint);
671	void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad);
672	void usbd_tx_complete (struct usb_endpoint_instance *endpoint);
673
674	#endif