ep0.c

Linux2.4.20针对三星公司的s3c2440内核基础上的一些设备驱动代码

/*
 * linux/drivers/usbd/ep0.c
 *
 * Copyright (c) 2000, 2001, 2002 Lineo
 * Copyright (c) 2001 Hewlett Packard
 *
 * By: 
 *      Stuart Lynne <[e-mail]>, 
 *      Tom Rushworth <[e-mail]>, 
 *      Bruce Balden <[e-mail]>
 *
 * 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 <linux/config.h>
#include <linux/module.h>

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <asm/uaccess.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/etherdevice.h>
#include <net/arp.h>
#include <linux/rtnetlink.h>
#include <linux/smp_lock.h>
#include <linux/ctype.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/atmdev.h>
#include <linux/pkt_sched.h>

#include "usbd.h"
#include "usbd-debug.h"
#include "usbd-func.h"
#include "usbd-bus.h"
#include "usbd-inline.h"

extern int dbgflg_usbdcore_ep0;
#define dbg_ep0(lvl,fmt,args...) dbgPRINT(dbgflg_usbdcore_ep0,lvl,fmt,##args)

/* EP0 Configuration Set ********************************************************************* */

#if 0

// XXX ep0 does not have or need any configuration

static struct usb_endpoint_description ep0_endpoints[] = {
      {bEndpointAddress: 0x00, attributes: 0, max_size: 8, polling_interval:0}
};


static struct usb_interface_description ep0_interfaces[] = {
      {class: 0, sub_class: 0, protocol:0,
	      endpoints:sizeof (ep0_endpoints) / sizeof (struct usb_endpoint_description),
      endpoint_list:ep0_endpoints},
};

struct usb_configuration_description ep0_description[] = {
      {name: "EP0", attributes: 0, max_power:0,
	      interfaces:sizeof (ep0_interfaces) /
	 sizeof (struct usb_interface_description),
      interface_list:ep0_interfaces},
};

#endif

/**
 * ep0_event - respond to USB event
 * @device:
 * @event:
 *
 * Called by lower layers to indicate some event has taken place. Typically
 * this is reset, suspend, resume and close.
 */
static void ep0_event (struct usb_device_instance *device,
		       usb_device_event_t event, int dummy /* to make fn signature correct */ )
{
        // do nothing
}

/**
 * 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, "<- 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 -EINVAL;
	}

	// 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 -EINVAL;
			}
			// 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->driver->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 -EINVAL;
			}
			//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 -EINVAL;
			}

			if (!
			    (configuration_descriptor =
			     usbd_device_configuration_descriptor (device, port, index))) {
				dbg_ep0 (0, "usbd_device_configuration_descriptor failed: %d", index);
				return -EINVAL;
			}
			copy_config (urb, configuration_descriptor,
				     sizeof (struct usb_configuration_descriptor), max);


			// iterate across interfaces for specified configuration
			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 -EINVAL;
				}
				// 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 -EINVAL;
					}
					// 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
					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 -EINVAL;
						}
						// copy descriptor for this class
						copy_config (urb, class_descriptor,
							     sizeof (struct usb_class_descriptor),
							     max);
					}

					// iterate across endpoints for this alternate interface