usbd.c

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

/*
 * linux/drivers/usbd/usbd.c.c - USB Device Core Layer
 *
 * Copyright (c) 2000, 2001, 2002 Lineo
 * Copyright (c) 2001 Hewlett Packard
 *
 * By: 
 *      Stuart Lynne <[e-mail]>, 
 *      Tom Rushworth <[e-mail]>, 
 *      Bruce Balden <[e-mail]>
 *
 * Changes copyright (c) 2003 MontaVista Software, Inc.
 *
 * 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.
 *
 */


/*
 * Notes...
 *
 * 1. The order of loading must be:
 *
 *        usb-device
 *        usb-function(s)
 *        usb-bus(s)
 *
 * 2. Loading usb-function modules allows them to register with the usb-device
 * layer. This makes their usb configuration descriptors available. Currently
 * function modules cannot be loaded after a bus module has been loaded.
 *
 * 3. Loading usb-bus modules causes them to register with the usb-device
 * layer and then enable their upstream port. This in turn will cause the
 * upstream host to enumerate this device. Note that bus modules can create
 * multiple devices, one per physical interface.
 *
 * 4. The usb-device layer provides a default configuration for endpoint 0 for
 * each device. 
 *
 * 5. Additional configurations are added to support the configuration
 * function driver when entering the configured state.
 *
 * 6. The usb-device maintains a list of configurations from the loaded
 * function drivers. It will provide this to the USB HOST as part of the
 * enumeration process and will add someof them as the active configuration as
 * per the USB HOST instructions.  
 *
 * 6. Two types of bus interface modules can be implemented: simple and compound.
 *
 * 7. Simple bus interface modules can only support a single function module. The
 * first function module is used.
 *
 * 8. Compound bus interface modules can support multiple functions. When implemented
 * these will use all available function modules.
 *
 */

#include <linux/config.h>
#include <linux/module.h>

#include "usbd-export.h"
#include "usbd-build.h"
#include "usbd-module.h"

MODULE_AUTHOR ("[e-mail], [e-mail]");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION ("USB Device Core Support");

USBD_MODULE_INFO ("usbdcore 0.1");

#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"

#include "hotplug.h"

#define MAX_INTERFACES 2

/* Module Parameters ************************************************************************* */

MODULE_PARM (maxstrings, "i");
MODULE_PARM (dbg, "s");

MODULE_PARM_DESC (maxstrings, "Maximum number of strings to allow (0..255)");
MODULE_PARM_DESC (dbg, "debug parameters");

int maxstrings = 20;
static char *dbg = NULL;

/* Debug switches (module parameter "dbg=...") *********************************************** */

int dbgflg_usbdcore_init;
int dbgflg_usbdcore_ep0;
int dbgflg_usbdcore_rx;
int dbgflg_usbdcore_tx;
int dbgflg_usbdcore_usbe;
int dbgflg_usbdcore_urbmem;

static debug_option dbg_table[] = {
	{&dbgflg_usbdcore_init, NULL, "init", "initialization and termination"},
	{&dbgflg_usbdcore_ep0, NULL, "ep0", "End Point 0 (setup) packet handling"},
	{&dbgflg_usbdcore_rx, NULL, "rx", "USB RX (host->device) handling"},
	{&dbgflg_usbdcore_tx, NULL, "tx", "USB TX (device->host) handling"},
	{&dbgflg_usbdcore_usbe, NULL, "usbe", "USB events"},
	{&dbgflg_usbdcore_urbmem, NULL, "mem", "URB memory allocation"},
#if 0
	{NULL, NULL, "hot", "hotplug actions"},
	{NULL, NULL, "mon", "USB conection monitor"},
#endif
	{NULL, NULL, NULL, NULL}
};

#define dbg_init(lvl,fmt,args...) dbgPRINT(dbgflg_usbdcore_init,lvl,fmt,##args)
#define dbg_ep0(lvl,fmt,args...) dbgPRINT(dbgflg_usbdcore_ep0,lvl,fmt,##args)
#define dbg_rx(lvl,fmt,args...) dbgPRINT(dbgflg_usbdcore_rx,lvl,fmt,##args)
#define dbg_tx(lvl,fmt,args...) dbgPRINT(dbgflg_usbdcore_tx,lvl,fmt,##args)
#define dbg_usbe(lvl,fmt,args...) dbgPRINT(dbgflg_usbdcore_usbe,lvl,fmt,##args)
#define dbg_urbmem(lvl,fmt,args...) dbgPRINT(dbgflg_usbdcore_urbmem,lvl,fmt,##args)

/* Global variables ************************************************************************** */

struct usb_string_descriptor **usb_strings;

int usb_devices;

extern struct usb_function_driver ep0_driver;

int registered_functions;
int registered_devices;

EXPORT_SYMBOL(usbd_device_events);
char *usbd_device_events[] = {
	"DEVICE_UNKNOWN",
	"DEVICE_INIT",
	"DEVICE_CREATE",
	"DEVICE_HUB_CONFIGURED",
	"DEVICE_RESET",
	"DEVICE_ADDRESS_ASSIGNED",
	"DEVICE_CONFIGURED",
	"DEVICE_SET_INTERFACE",
	"DEVICE_SET_FEATURE",
	"DEVICE_CLEAR_FEATURE",
	"DEVICE_DE_CONFIGURED",
	"DEVICE_BUS_INACTIVE",
	"DEVICE_BUS_ACTIVITY",
	"DEVICE_POWER_INTERRUPTION",
	"DEVICE_HUB_RESET",
	"DEVICE_DESTROY",
	"DEVICE_FUNCTION_PRIVATE",
};

EXPORT_SYMBOL(usbd_device_states);
char *usbd_device_states[] = {
	"STATE_INIT",
	"STATE_CREATED",
	"STATE_ATTACHED",
	"STATE_POWERED",
	"STATE_DEFAULT",
	"STATE_ADDRESSED",
	"STATE_CONFIGURED",
	"STATE_UNKNOWN",
};

EXPORT_SYMBOL(usbd_device_requests);
char *usbd_device_requests[] = {
        "GET STATUS",           // 0
        "CLEAR FEATURE",        // 1
        "RESERVED",             // 2
        "SET FEATURE",          // 3
        "RESERVED",             // 4
        "SET ADDRESS",          // 5
        "GET DESCRIPTOR",       // 6
        "SET DESCRIPTOR",       // 7
        "GET CONFIGURATION",    // 8
        "SET CONFIGURATION",    // 9
        "GET INTERFACE",        // 10
        "SET INTERFACE",        // 11
        "SYNC FRAME",           // 12
};

EXPORT_SYMBOL(usbd_device_descriptors);
char *usbd_device_descriptors[] = {
        "UNKNOWN",              // 0
        "DEVICE",               // 1
        "CONFIG",               // 2
        "STRING",               // 3
        "INTERFACE",            // 4
        "ENDPOINT",             // 5
        "DEVICE QUALIFIER",     // 6
        "OTHER SPEED",          // 7
        "INTERFACE POWER",      // 8
};

EXPORT_SYMBOL(usbd_device_status);
char *usbd_device_status[] = {
	"USBD_OPENING",
	"USBD_OK",
	"USBD_SUSPENDED",
	"USBD_CLOSING",	
};

/* List support functions ******************************************************************** */

LIST_HEAD (function_drivers);	// list of all registered function modules
LIST_HEAD (devices);		// list of all registered devices


static inline struct usb_function_driver *list_entry_func (const struct list_head *le)
{
	return list_entry (le, struct usb_function_driver, drivers);
}

static inline struct usb_device_instance *list_entry_device (const struct list_head *le)
{
	return list_entry (le, struct usb_device_instance, devices);
}


/* Support Functions ************************************************************************* */

/**
 * usbd_hotplug - call a hotplug script
 * @action: hotplug action
 */
EXPORT_SYMBOL(usbd_hotplug);
int usbd_hotplug (char *interface, char *action)
{
#ifdef CONFIG_HOTPLUG
	dbg_init (1, "agent: usbd interface: %s action: %s", interface, action);
	return hotplug ("usbd", interface, action);
#else
	return (0);
#endif
}

/* Descriptor support functions ************************************************************** */


/**
 * usbd_get_string - find and return a string descriptor
 * @index: string index to return
 *
 * Find an indexed string and return a pointer to a it.
 */
EXPORT_SYMBOL(usbd_get_string);
struct usb_string_descriptor *usbd_get_string (__u8 index)
{
	if (index >= maxstrings) {
		return NULL;
	}
	return usb_strings[index];
}


/**
 * usbd_cancel_urb - cancel an urb being sent
 * @urb: pointer to an urb structure
 *
 * Used by a USB Function driver to cancel an urb that is being
 * sent.
 */
EXPORT_SYMBOL(usbd_cancel_urb);
int usbd_cancel_urb (struct usb_device_instance *device, struct urb *urb)
{
	dbg_tx (3, "%p", urb);
	if (!device->bus->driver->ops->cancel_urb) {
		// XXX should we do usbd_dealloc_urb(urb);
		return 0;
	}
	//urb->device->urbs_queued++;
	return device->bus->driver->ops->cancel_urb (urb);
}


/* Access to device descriptor functions ***************************************************** */


/* *
 * usbd_device_function_instance - find a function instance for this device
 * @device: 
 * @configuration: index to configuration, 0 - N-1 
 *
 * Get specifed device configuration. Index should be bConfigurationValue-1. 
 */
EXPORT_SYMBOL(usbd_device_function_instance);
struct usb_function_instance *usbd_device_function_instance (struct usb_device_instance *device, unsigned int port)
{
	//dbg_init(2,"device: %p port: %d functions: %d", device, port, device->functions);
	if (port >= device->functions) {
		dbg_init (0, "configuration out of range: %d %d", port, device->functions);
		return NULL;
	}
	return device->function_instance_array + port;
}


/* *
 * usbd_device_configuration_instance - find a configuration instance for this device
 * @device: 
 * @configuration: index to configuration, 0 - N-1 
 *
 * Get specifed device configuration. Index should be bConfigurationValue-1. 
 */
static struct usb_configuration_instance *usbd_device_configuration_instance (struct usb_device_instance *device, 
                unsigned int port, unsigned int configuration)
{
	struct usb_function_instance *function_instance;
	struct usb_function_driver *function_driver;

        // XXX
        configuration = configuration ? configuration - 1 : 0;

	if (!(function_instance = usbd_device_function_instance (device, port))) {
		dbg_init (0, "function_instance NULL");
		return NULL;
	}
	if (!(function_driver = function_instance->function_driver)) {
		dbg_init (0, "function_driver NULL");
		return NULL;
	}

	if (configuration >= function_driver->configurations) {
		dbg_init (0, "configuration out of range: %d %d %d", port, configuration, function_driver->configurations);
		return NULL;
	}
	return function_driver->configuration_instance_array + configuration;
}


/* *
 * usbd_device_interface_instance
 * @device: 
 * @configuration: index to configuration, 0 - N-1 
 * @interface: index to interface
 *
 * Return the specified interface descriptor for the specified device.
 */
EXPORT_SYMBOL(usbd_device_interface_instance);
struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *device, int port, int configuration, int interface)
{
	struct usb_configuration_instance *configuration_instance;

	if ((configuration_instance = usbd_device_configuration_instance (device, port, configuration)) == NULL) {
		return NULL;
	}
	if (interface >= configuration_instance->interfaces) {
		return NULL;
	}
	return configuration_instance->interface_instance_array + interface;
}

/* *
 * usbd_device_alternate_descriptor_list
 * @device: 
 * @configuration: index to configuration, 0 - N-1 
 * @interface: index to interface
 * @alternate: alternate setting
 *
 * Return the specified alternate descriptor for the specified device.
 */
EXPORT_SYMBOL(usbd_device_alternate_instance);
struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *device, int port, int configuration, int interface, int alternate)
{
	struct usb_interface_instance *interface_instance;

	if ((interface_instance = usbd_device_interface_instance (device, port, configuration, interface)) == NULL) {
		return NULL;
	}

	if (alternate >= interface_instance->alternates) {
		return NULL;
	}

	return interface_instance->alternates_instance_array + alternate;
}


/* *
 * usbd_device_device_descriptor
 * @device: which device
 * @configuration: index to configuration, 0 - N-1 
 * @port: which port
 *
 * Return the specified configuration descriptor for the specified device.
 */
EXPORT_SYMBOL(usbd_device_device_descriptor);
struct usb_device_descriptor *usbd_device_device_descriptor (struct usb_device_instance *device, int port)
{
	struct usb_function_instance *function_instance;
	if (!(function_instance = usbd_device_function_instance (device, port))) {
		return NULL;
	}
	if (!function_instance->function_driver || !function_instance->function_driver->device_descriptor) {
		return NULL;
	}
	return (function_instance->function_driver->device_descriptor);
}


/**
 * usbd_device_configuration_descriptor
 * @device: which device
 * @port: which port
 * @configuration: index to configuration, 0 - N-1 
 *
 * Return the specified configuration descriptor for the specified device.
 */
EXPORT_SYMBOL(usbd_device_configuration_descriptor);
struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct
									   usb_device_instance
									   *device, int port, int configuration)
{
	struct usb_configuration_instance *configuration_instance;
	if (!(configuration_instance = usbd_device_configuration_instance (device, port, configuration))) {
		return NULL;
	}
	return (configuration_instance->configuration_descriptor);
}


/**
 * usbd_device_interface_descriptor
 * @device: which device
 * @port: which port
 * @configuration: index to configuration, 0 - N-1 
 * @interface: index to interface
 * @alternate: alternate setting
 *