/* * (C) Copyright 2003 * Gerry Hamel, geh@ti.com, Texas Instruments * * Based on * linux/drivers/usbd/ep0.c * * Copyright (c) 2000, 2001, 2002 Lineo * Copyright (c) 2001 Hewlett Packard * * By: *	Stuart Lynne <sl@lineo.com>, *	Tom Rushworth <tbr@lineo.com>, *	Bruce Balden <balden@lineo.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * *//* * This is the builtin ep0 control function. It implements all required functionality * for responding to control requests (SETUP packets). * * XXX * * Currently we do not pass any SETUP packets (or other) to the configured * function driver. This may need to change. * * XXX */#include <common.h>#if defined(CONFIG_OMAP1510) && defined(CONFIG_USB_DEVICE)#include "usbdcore.h"#if 0#define dbg_ep0(lvl,fmt,args...) serial_printf("[%s] %s:%d: "fmt"\n",__FILE__,__FUNCTION__,__LINE__,##args)#else#define dbg_ep0(lvl,fmt,args...)#endif/* EP0 Configuration Set ********************************************************************* *//** * ep0_get_status - fill in URB data with appropriate status * @device: * @urb: * @index: * @requesttype: * */static int ep0_get_status (struct usb_device_instance *device,			   struct urb *urb, int index, int requesttype){	char *cp;	urb->actual_length = 2;	cp = urb->buffer;	cp[0] = cp[1] = 0;	switch (requesttype) {	case USB_REQ_RECIPIENT_DEVICE:		cp[0] = USB_STATUS_SELFPOWERED;		break;	case USB_REQ_RECIPIENT_INTERFACE:		break;	case USB_REQ_RECIPIENT_ENDPOINT:		cp[0] = usbd_endpoint_halted (device, index);		break;	case USB_REQ_RECIPIENT_OTHER:		urb->actual_length = 0;	default:		break;	}	dbg_ep0 (2, "%02x %02x", cp[0], cp[1]);	return 0;}/** * ep0_get_one * @device: * @urb: * @result: * * Set a single byte value in the urb send buffer. Return non-zero to signal * a request error. */static int ep0_get_one (struct usb_device_instance *device, struct urb *urb,			__u8 result){	urb->actual_length = 1;	/* XXX 2? */	((char *) urb->buffer)[0] = result;	return 0;}/** * copy_config * @urb: pointer to urb * @data: pointer to configuration data * @length: length of data * * Copy configuration data to urb transfer buffer if there is room for it. */static void copy_config (struct urb *urb, void *data, int max_length,			 int max_buf){	int available;	int length;	/*dbg_ep0(3, "-> actual: %d buf: %d max_buf: %d max_length: %d data: %p", */	/*        urb->actual_length, urb->buffer_length, max_buf, max_length, data); */	if (!data) {		dbg_ep0 (1, "data is NULL");		return;	}	if (!(length = *(unsigned char *) data)) {		dbg_ep0 (1, "length is zero");		return;	}	if (length > max_length) {		dbg_ep0 (1, "length: %d >= max_length: %d", length,			 max_length);		return;	}	/*dbg_ep0(1, "   actual: %d buf: %d max_buf: %d max_length: %d length: %d", */	/*        urb->actual_length, urb->buffer_length, max_buf, max_length, length); */	if ((available =	     /*urb->buffer_length */ max_buf - urb->actual_length) <= 0) {		return;	}	/*dbg_ep0(1, "actual: %d buf: %d max_buf: %d length: %d available: %d", */	/*        urb->actual_length, urb->buffer_length, max_buf, length, available); */	if (length > available) {		length = available;	}	/*dbg_ep0(1, "actual: %d buf: %d max_buf: %d length: %d available: %d", */	/*        urb->actual_length, urb->buffer_length, max_buf, length, available); */	memcpy (urb->buffer + urb->actual_length, data, length);	urb->actual_length += length;	dbg_ep0 (3,		 "copy_config: <- actual: %d buf: %d max_buf: %d max_length: %d available: %d",		 urb->actual_length, urb->buffer_length, max_buf, max_length,		 available);}/** * ep0_get_descriptor * @device: * @urb: * @max: * @descriptor_type: * @index: * * Called by ep0_rx_process for a get descriptor device command. Determine what * descriptor is being requested, copy to send buffer. Return zero if ok to send, * return non-zero to signal a request error. */static int ep0_get_descriptor (struct usb_device_instance *device,			       struct urb *urb, int max, int descriptor_type,			       int index){	int port = 0;		/* XXX compound device */	char *cp;	/*dbg_ep0(3, "max: %x type: %x index: %x", max, descriptor_type, index); */	if (!urb || !urb->buffer || !urb->buffer_length	    || (urb->buffer_length < 255)) {		dbg_ep0 (2, "invalid urb %p", urb);		return -1L;	}	/* setup tx urb */	urb->actual_length = 0;	cp = urb->buffer;	dbg_ep0 (2, "%s", USBD_DEVICE_DESCRIPTORS (descriptor_type));	switch (descriptor_type) {	case USB_DESCRIPTOR_TYPE_DEVICE:		{			struct usb_device_descriptor *device_descriptor;			if (!			    (device_descriptor =			     usbd_device_device_descriptor (device, port))) {				return -1;			}			/* copy descriptor for this device */			copy_config (urb, device_descriptor,				     sizeof (struct usb_device_descriptor),				     max);			/* correct the correct control endpoint 0 max packet size into the descriptor */			device_descriptor =				(struct usb_device_descriptor *) urb->buffer;			device_descriptor->bMaxPacketSize0 =				urb->device->bus->maxpacketsize;		}		/*dbg_ep0(3, "copied device configuration, actual_length: %x", urb->actual_length); */		break;	case USB_DESCRIPTOR_TYPE_CONFIGURATION:		{			int bNumInterface;			struct usb_configuration_descriptor				*configuration_descriptor;			struct usb_device_descriptor *device_descriptor;			if (!			    (device_descriptor =			     usbd_device_device_descriptor (device, port))) {				return -1;			}			/*dbg_ep0(2, "%d %d", index, device_descriptor->bNumConfigurations); */			if (index > device_descriptor->bNumConfigurations) {				dbg_ep0 (0, "index too large: %d > %d", index,					 device_descriptor->					 bNumConfigurations);				return -1;			}			if (!			    (configuration_descriptor =			     usbd_device_configuration_descriptor (device,								   port,								   index))) {				dbg_ep0 (0,					 "usbd_device_configuration_descriptor failed: %d",					 index);				return -1;			}			copy_config (urb, configuration_descriptor,				     sizeof (struct					     usb_configuration_descriptor),				     max);			/* iterate across interfaces for specified configuration */			dbg_ep0 (0, "bNumInterfaces: %d",				 configuration_descriptor->bNumInterfaces);			for (bNumInterface = 0;			     bNumInterface <			     configuration_descriptor->bNumInterfaces;			     bNumInterface++) {				int bAlternateSetting;				struct usb_interface_instance					*interface_instance;				dbg_ep0 (3, "[%d] bNumInterfaces: %d",					 bNumInterface,					 configuration_descriptor->bNumInterfaces);				if (! (interface_instance = usbd_device_interface_instance (device,								     port, index, bNumInterface)))				{					dbg_ep0 (3, "[%d] interface_instance NULL",						 bNumInterface);					return -1;				}				/* iterate across interface alternates */				for (bAlternateSetting = 0;				     bAlternateSetting < interface_instance->alternates;				     bAlternateSetting++) {					/*int class; */					int bNumEndpoint;					struct usb_interface_descriptor *interface_descriptor;					struct usb_alternate_instance *alternate_instance;					dbg_ep0 (3, "[%d:%d] alternates: %d",						 bNumInterface,						 bAlternateSetting,						 interface_instance->alternates);					if (! (alternate_instance = usbd_device_alternate_instance (device, port, index, bNumInterface, bAlternateSetting))) {						dbg_ep0 (3, "[%d] alternate_instance NULL",							 bNumInterface);						return -1;					}					/* copy descriptor for this interface */					copy_config (urb, alternate_instance->interface_descriptor,						     sizeof (struct usb_interface_descriptor),						     max);					/*dbg_ep0(3, "[%d:%d] classes: %d endpoints: %d", bNumInterface, bAlternateSetting, */					/*        alternate_instance->classes, alternate_instance->endpoints); */					/* iterate across classes for this alternate interface */#if 0					for (class = 0;					     class < alternate_instance->classes;					     class++) {						struct usb_class_descriptor *class_descriptor;						/*dbg_ep0(3, "[%d:%d:%d] classes: %d", bNumInterface, bAlternateSetting, */						/*        class, alternate_instance->classes); */						if (!(class_descriptor = usbd_device_class_descriptor_index (device, port, index, bNumInterface, bAlternateSetting, class))) {							dbg_ep0 (3, "[%d] class NULL",								 class);							return -1;						}						/* copy descriptor for this class */						copy_config (urb, class_descriptor,							sizeof (struct usb_class_descriptor),							max);					}#endif					/* iterate across endpoints for this alternate interface */					interface_descriptor = alternate_instance->interface_descriptor;					for (bNumEndpoint = 0;					     bNumEndpoint < alternate_instance->endpoints;					     bNumEndpoint++) {						struct usb_endpoint_descriptor *endpoint_descriptor;						dbg_ep0 (3, "[%d:%d:%d] endpoint: %d",							 bNumInterface,							 bAlternateSetting,							 bNumEndpoint,							 interface_descriptor->							 bNumEndpoints);						if (!(endpoint_descriptor = usbd_device_endpoint_descriptor_index (device, port, index, bNumInterface, bAlternateSetting, bNumEndpoint))) {							dbg_ep0 (3, "[%d] endpoint NULL",