usbd.h

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

	// control
        int status;             // halted

	struct urb_link events;	// events
	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_interrupts;

	// 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_interrupts;

	int sent;		// data already sent
	int last;		// data sent in last packet XXX do we need this
	int errors;		// number of tx errors seen

	int ep0_interrupts;
};


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

struct urb {

	struct usb_endpoint_instance *endpoint;

	struct usb_device_instance *device;
	struct usb_function_instance *function_instance;

	__u8 pid;		// PID of received packet (SETUP or OUT)
	struct usb_device_request device_request;	// contents of received SETUP packet

	unsigned char *buffer;	// data received (OUT) or being sent (IN)
	unsigned int buffer_length;
	unsigned int actual_length;


	struct list_head urbs;	// linked list of urbs(s)

	void *privdata;

	struct urb_link link;	// embedded struct for circular doubly linked list of urbs

	urb_send_status_t status;
	time_t jiffies;
	usb_device_event_t event;
	int data;
};


/* What to do with submitted urb
 *
 */
typedef enum urb_submit {
	SUBMIT_SEND,		// send buffer as DATA (control) or IN (bulk/interrupt)
	SUBMIT_OK,		// send zero length packet to indicate succes (control) 
	SUBMIT_STALL		// indicate a request error
} urb_submit_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")

#if 0
typedef enum usb_module_status {
	MODULE_OPENED,
	MODULE_ACTIVE,
	MODULE_SUSPENDED,
	MODULE_CLOSING,
	MODULE_CLOSED,
} usb_module_status_t;
#endif


/* BUS Configuration
 *
 * These are used by the ep0 function driver to indicate type of
 * configuratin change that should take place
 */
typedef enum usb_bus_change {
	BUS_RESET,		// error occurred, reset to STATE_UNKNOWN 
	BUS_ADDRESS,		// set address device command received
	BUS_CONFIGURE,		// set configuration device command received
	BUS_INTERFACE,		// set interface device command received
	BUS_CLOSE		// please shutdown 
} usb_bus_change_t;

/* Function Configuration
 *
 * These are used by the ep0 function driver to indicate type of
 * configuratin change that should take place
 */
typedef enum usb_function_change {
	FUNCTION_START,		// open function
	FUNCTION_STOP		// close function
} usb_function_change_t;


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

	// bus interface 
	struct usb_bus_instance *bus;	// which bus interface driver

	// function driver(s)
	struct usb_function_instance *ep0;	// ep0 configuration

	// function configuration descriptors
	unsigned int functions;	//configurations;
	struct usb_function_instance *function_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

	// housekeeping
	struct list_head devices;	// linked list usb_device_instance(s)

	unsigned char dev_addr[ETH_ALEN];

	struct tq_struct device_bh;	// runs as bottom half, equivalent to interrupt time
	struct tq_struct function_bh;	// runs as process

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

};



/* Function configuration structure
 *
 * This is allocated for each configured instance of a function driver.
 *
 * It stores pointers to the usb_function_driver for the appropriate function,
 * and pointers to the USB HOST requested usb_configuration_description and
 * usb_interface_description.
 *
 * The privdata pointer may be used by the function driver to store private
 * per instance state information.
 *
 */
struct usb_function_instance {

	//struct usb_device_instance *device;

	struct usb_function_driver *function_driver;
	void *privdata;		// private data for the function
};


/* Bus Interface configuration structure
 *
 * This is allocated for each configured instance of a bus interface driver.
 *
 * It contains a pointer to the appropriate 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_bus_driver *driver;
	struct usb_device_instance *device;
	struct usb_endpoint_instance *endpoint_array;	// array of available configured endpoints

	unsigned int serial_number;
	char *serial_number_str;
	void *privdata;		// private data for the bus interface

};


/**
 * usbd_hotplug - call a hotplug script
 * @interface: hotplug action
 * @action: hotplug action
 */
int usbd_hotplug (char *, char *);


/* USB-Device 
 *
 * The USB Device layer has three components. 
 *
 *      - maintain a list of function drivers
 *      - create and manage each device instance based on bus interface registrations
 *      - implement the default endpoint 0 control driver
 *
 * Function drivers register speculatively. Their use depends in the end on
 * have one of their configurations being selected by the USB HOST.
 *
 * Bus Interface drivers register specifically. For each physical device
 * they find they register, thereby creating a usb_device_instance.
 *
 * For each bus interface configuration registered the USB Device layer will
 * create device configuration instance. The default endpoint 0 driver will
 * be automatically installed to handle SETUP packets.
 *
 * Bus Interface drivers should not enable their upstream port until the bus
 * interface registration has completed.
 *
 */

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[];


/* function driver registration
 *
 * Called by function drivers to register themselves when loaded
 * or de-register when unloading.
 */
//int usbd_strings_init(void);
int usbd_register_function (struct usb_function_driver *);
void usbd_deregister_function (struct usb_function_driver *);

/* bus driver registration
 *
 * Called by bus interface drivers to register themselves when loaded
 * or de-register when unloading.
 */
struct usb_bus_instance *usbd_register_bus (struct usb_bus_driver *);
void usbd_deregister_bus (struct usb_bus_instance *);

/* device
 *
 * Called by bus interface drivers to register a virtual device for a
 * physical interface that has been detected. Typically when actually
 * plugged into a usb bus. The device can be de-register, typically
 * when unplugged from the usb bus.
 */
struct usb_device_instance *usbd_register_device (char *, struct usb_bus_instance *, int);
void usbd_deregister_device (struct usb_device_instance *);

/* 
 * usbd_configure_device is used by function drivers (usually the control endpoint)
 * to change the device configuration.
 *
 * usbd_device_event is used by bus interface drivers to tell the higher layers that
 * certain events have taken place.
 */
//int usbd_configure_device(usb_bus_change_t, struct usb_device_instance *);
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);


int usbd_endpoint_halted (struct usb_device_instance *, int);
int usbd_device_feature (struct usb_device_instance *, int, int);

/* urb allocation
 *
 * Used to allocate and de-allocate urb structures.
 */
int usbd_alloc_urb_data (struct urb *, int);
struct urb *usbd_alloc_urb (struct usb_device_instance *, struct usb_function_instance *, __u8, int length);
//static __inline__ void usbd_dealloc_urb(struct urb *);

/*
 * Detach and return the first urb in a list with a distinguished
 * head "hd", or NULL if the list is empty.
 */
//static __inline__ struct urb *first_urb_detached_irq(urb_link *);

/*
 * Detach and return the first urb in a list with a distinguished
 * head "hd", or NULL if the list is empty.
 */
// XXX XXX need to implement
//static __inline__ struct urb *usbd_next_rcv_urb(struct usb_endpoint_instance *);



/*
 * usb_send_urb is used to submit a data urb for sending.
 */
//static __inline__ int usbd_send_urb(struct urb *);

/*
 * usb_cancel_urb is used to cancel a previously submitted data urb for sending.
 */
int usbd_cancel_urb (struct usb_device_instance *, struct urb *);

/*
 * usb_receive_setup is used by the bus interface driver to pass a SETUP 
 * packet into the the system.
 */
//static __inline__ int usbd_recv_setup(struct urb *);

/**
 * usbd_rcv_complete_irq - complete a receive
 * @endpoint:
 * @len:
 * @status:
 *
 * Called from rcv interrupt to complete.
 */
//static __inline__ void usbd_rcv_complete_irq(struct usb_endpoint_instance *, int, int );

/**
 * usbd_tx_complete_irq - complete a transmit
 * @endpoint:
 *
 * Called from tx interrupt to complete.
 */
//static __inline__ void usbd_tx_complete_irq(struct usb_endpoint_instance *, int );

/*
 * usb_receive_urb is used by the bus interface driver to pass a 
 * DATA packet into the the system.
 */
//static __inline__ void usbd_recv_urb_irq(struct urb *);

/*
 * usb_urb_sent is used by the bus interface driver to signal that
 * an urb has been sent
 */
//static void usbd_urb_sent_irq(struct urb *, 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);


void usbd_flush_tx (struct usb_endpoint_instance *);
void usbd_fill_rcv (struct usb_device_instance *, struct usb_endpoint_instance *, int);

void usbd_flush_rcv (struct usb_endpoint_instance *);
void usbd_flush_ep (struct usb_endpoint_instance *);



static __inline__ void *ckmalloc (int n, int f)
{
	void *p;
	if ((p = kmalloc (n, f)) == NULL) {
		return NULL;
	}
	memset (p, 0, n);
	return p;
}

static __inline__ char *strdup (char *str)
{
	int n;
	char *s;
	if (str && (n = strlen (str) + 1) && (s = kmalloc (n, GFP_ATOMIC))) {
		return strcpy (s, str);
	}
	return NULL;
}