538 lines
15 KiB
C
Executable file
538 lines
15 KiB
C
Executable file
/*
|
|
* Implementation of generic HCD
|
|
*/
|
|
|
|
#include <time.h> /* nanosleep */
|
|
#include <string.h> /* memcpy */
|
|
|
|
#include <usb/hcd_common.h>
|
|
#include <usb/hcd_ddekit.h>
|
|
#include <usb/hcd_interface.h>
|
|
#include <usb/usb_common.h>
|
|
|
|
|
|
/*===========================================================================*
|
|
* Local declarations *
|
|
*===========================================================================*/
|
|
/* Thread to handle device logic */
|
|
static void hcd_device_thread(void *);
|
|
|
|
/* Procedure that locks device thread forever in case of error/completion */
|
|
static void hcd_device_finish(hcd_device_state *, const char *);
|
|
|
|
/* Typical USD device communication procedures */
|
|
static int hcd_enumerate(hcd_device_state *);
|
|
static int hcd_get_device_descriptor(hcd_device_state *);
|
|
static int hcd_set_address(hcd_device_state *, int);
|
|
static int hcd_get_descriptor_tree(hcd_device_state *);
|
|
static int hcd_set_configuration(hcd_device_state *, int);
|
|
static int hcd_handle_urb(hcd_device_state *);
|
|
|
|
/* For internal use by more general methods */
|
|
static int hcd_setup_packet(hcd_device_state *, hcd_ctrlrequest *);
|
|
|
|
|
|
/*===========================================================================*
|
|
* Local definitions *
|
|
*===========================================================================*/
|
|
/* TODO: Only one device at a time */
|
|
static hcd_device_state hcd_device[1];
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_handle_event *
|
|
*===========================================================================*/
|
|
void
|
|
hcd_handle_event(hcd_driver_state * driver)
|
|
{
|
|
hcd_device_state * this_device;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
/* TODO: Finding which hcd_device is in use should be performed here */
|
|
this_device = &(hcd_device[0]);
|
|
|
|
/* Sometimes interrupts occur in a weird order (EP after disconnect)
|
|
* This helps finding ordering errors in DEBUG */
|
|
USB_DBG("Event: 0x%02X, state: 0x%02X",
|
|
driver->event, this_device->state);
|
|
|
|
/* Set what was received for device thread to use */
|
|
this_device->driver = driver;
|
|
|
|
/* Handle event and forward control to device thread when required */
|
|
switch (driver->event) {
|
|
case HCD_EVENT_CONNECTED:
|
|
if (HCD_STATE_DISCONNECTED == this_device->state) {
|
|
if (EXIT_SUCCESS != hcd_connect_device(
|
|
this_device,
|
|
hcd_device_thread))
|
|
USB_MSG("Device creation failed");
|
|
} else
|
|
USB_MSG("Device not marked as 'disconnected' "
|
|
"for 'connection' event");
|
|
|
|
break;
|
|
|
|
case HCD_EVENT_DISCONNECTED:
|
|
if (HCD_STATE_DISCONNECTED != this_device->state) {
|
|
/* If connect callback was used before, call
|
|
* it's equivalent to signal disconnection */
|
|
if (HCD_STATE_CONNECTED == this_device->state)
|
|
hcd_disconnect_cb(this_device);
|
|
hcd_disconnect_device(this_device);
|
|
this_device->state = HCD_STATE_DISCONNECTED;
|
|
} else
|
|
USB_MSG("Device is marked as 'disconnected' "
|
|
"for 'disconnection' event");
|
|
|
|
break;
|
|
|
|
case HCD_EVENT_ENDPOINT:
|
|
/* Allow device thread to continue with it's logic */
|
|
if (HCD_STATE_DISCONNECTED != this_device->state)
|
|
hcd_device_continue(this_device);
|
|
else
|
|
USB_MSG("Device is marked as 'disconnected' "
|
|
"for 'EP' event");
|
|
|
|
break;
|
|
|
|
default:
|
|
USB_ASSERT(0, "Illegal HCD event");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_device_thread *
|
|
*===========================================================================*/
|
|
static void
|
|
hcd_device_thread(void * thread_args)
|
|
{
|
|
hcd_device_state * this_device;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
/* Retrieve structures from generic data */
|
|
this_device = (hcd_device_state *)thread_args;
|
|
|
|
/* Plugged in */
|
|
this_device->state = HCD_STATE_CONNECTION_PENDING;
|
|
|
|
/* Enumeration sequence */
|
|
if (EXIT_SUCCESS != hcd_enumerate(this_device))
|
|
hcd_device_finish(this_device, "USB device enumeration failed");
|
|
|
|
/* Tell everyone that device was connected */
|
|
hcd_connect_cb(this_device);
|
|
|
|
/* Fully configured */
|
|
this_device->state = HCD_STATE_CONNECTED;
|
|
|
|
USB_DBG("Waiting for URBs");
|
|
|
|
/* No URB's yet */
|
|
this_device->urb = NULL;
|
|
|
|
/* Start handling URB's */
|
|
for(;;) {
|
|
/* Block and wait for something like 'submit URB' */
|
|
hcd_device_wait(this_device);
|
|
|
|
if (EXIT_SUCCESS != hcd_handle_urb(this_device))
|
|
hcd_device_finish(this_device, "URB handling failed");
|
|
}
|
|
|
|
/* Finish device handling to avoid leaving thread */
|
|
hcd_device_finish(this_device, "USB device handling completed");
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_device_finish *
|
|
*===========================================================================*/
|
|
static void
|
|
hcd_device_finish(hcd_device_state * this_device, const char * finish_msg)
|
|
{
|
|
DEBUG_DUMP;
|
|
|
|
USB_MSG("USB device handling finished with message: '%s'", finish_msg);
|
|
|
|
/* Lock forever */
|
|
for (;;) {
|
|
hcd_device_wait(this_device);
|
|
USB_MSG("Failed attempt to continue finished thread");
|
|
}
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_enumerate *
|
|
*===========================================================================*/
|
|
static int
|
|
hcd_enumerate(hcd_device_state * this_device)
|
|
{
|
|
hcd_driver_state * d;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
d = this_device->driver;
|
|
|
|
/* First let driver reset device */
|
|
d->reset_device(d->private_data);
|
|
|
|
/* Set parameters for further communication */
|
|
d->setup_device(d->private_data, HCD_DEFAULT_EP, HCD_DEFAULT_ADDR);
|
|
|
|
/* Get device descriptor */
|
|
if (EXIT_SUCCESS != hcd_get_device_descriptor(this_device)) {
|
|
USB_MSG("Failed to get device descriptor");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* TODO: dynamic device address when more devices are available */
|
|
|
|
/* Set address */
|
|
if (EXIT_SUCCESS != hcd_set_address(this_device, HCD_ATTACHED_ADDR)) {
|
|
USB_MSG("Failed to set device address");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* Set parameters for further communication */
|
|
d->setup_device(d->private_data, HCD_DEFAULT_EP, HCD_ATTACHED_ADDR);
|
|
|
|
/* Get other descriptors */
|
|
if (EXIT_SUCCESS != hcd_get_descriptor_tree(this_device)) {
|
|
USB_MSG("Failed to get configuration descriptor tree");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* TODO: always first configuration */
|
|
/* Set configuration */
|
|
if (EXIT_SUCCESS != hcd_set_configuration(this_device, 0x01)) {
|
|
USB_MSG("Failed to set configuration");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
USB_DBG("Enumeration completed");
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_get_device_descriptor *
|
|
*===========================================================================*/
|
|
static int
|
|
hcd_get_device_descriptor(hcd_device_state * this_device)
|
|
{
|
|
hcd_ctrlrequest setup;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
/* TODO: magic numbers, no header for these */
|
|
|
|
/* Format setup packet */
|
|
setup.bRequestType = 0x80; /* IN */
|
|
setup.bRequest = 0x06; /* Get descriptor */
|
|
setup.wValue = 0x0100; /* Device */
|
|
setup.wIndex = 0x0000;
|
|
setup.wLength = sizeof(this_device->device_desc);
|
|
|
|
/* Handle formatted setup packet */
|
|
if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
|
|
USB_MSG("Handling setup packet failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* Put what was read in device descriptor */
|
|
memcpy(&(this_device->device_desc), this_device->buffer,
|
|
sizeof(this_device->device_desc));
|
|
|
|
/* Remember max packet size from device descriptor */
|
|
this_device->max_packet_size = this_device->device_desc.bMaxPacketSize;
|
|
|
|
/* Output VID/PID when debugging */
|
|
USB_DBG("idVendor: %02X%02X", this_device->device_desc.idVendor[1],
|
|
this_device->device_desc.idVendor[0]);
|
|
USB_DBG("idProduct: %02X%02X", this_device->device_desc.idProduct[1],
|
|
this_device->device_desc.idProduct[0]);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_set_address *
|
|
*===========================================================================*/
|
|
static int
|
|
hcd_set_address(hcd_device_state * this_device, int address)
|
|
{
|
|
hcd_ctrlrequest setup;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
USB_ASSERT((address > 0) && (address < 128), "Illegal address");
|
|
|
|
/* TODO: magic numbers, no header for these */
|
|
setup.bRequestType = 0x00; /* OUT */
|
|
setup.bRequest = 0x05; /* Set address */
|
|
setup.wValue = address;
|
|
setup.wIndex = 0x0000;
|
|
setup.wLength = 0x0000;
|
|
|
|
/* Handle formatted setup packet */
|
|
if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
|
|
USB_MSG("Handling setup packet failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
{
|
|
/* Sleep 5ms for proper addressing */
|
|
struct timespec nanotm = {0, HCD_NANOSLEEP_MSEC(5)};
|
|
nanosleep(&nanotm, NULL);
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_get_descriptor_tree *
|
|
*===========================================================================*/
|
|
static int
|
|
hcd_get_descriptor_tree(hcd_device_state * this_device)
|
|
{
|
|
hcd_config_descriptor config_descriptor;
|
|
hcd_ctrlrequest setup;
|
|
int completed;
|
|
int total_length;
|
|
int buffer_length;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
/* First, ask only for configuration itself to get length info */
|
|
buffer_length = sizeof(config_descriptor);
|
|
completed = 0;
|
|
|
|
do {
|
|
/* TODO: configuration 0 is hard-coded
|
|
* but others are rarely used anyway */
|
|
/* TODO: magic numbers, no header for these */
|
|
setup.bRequestType = 0x80; /* IN */
|
|
setup.bRequest = 0x06; /* Get descriptor */
|
|
setup.wValue = 0x0200; /* Configuration 0 */
|
|
setup.wIndex = 0x0000;
|
|
setup.wLength = buffer_length;
|
|
|
|
/* Handle formatted setup packet */
|
|
if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
|
|
USB_MSG("Handling setup packet failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* If we only asked for configuration itself
|
|
* then ask again for other descriptors */
|
|
if (sizeof(config_descriptor) == buffer_length) {
|
|
|
|
/* Put what was read in configuration descriptor */
|
|
memcpy(&config_descriptor, this_device->buffer,
|
|
sizeof(config_descriptor));
|
|
|
|
/* Continue only if there is more data */
|
|
total_length = config_descriptor.wTotalLength[0] +
|
|
(config_descriptor.wTotalLength[1] << 8);
|
|
|
|
if (total_length < (int)sizeof(config_descriptor)) {
|
|
/* This should never happen for a fine device */
|
|
USB_MSG("Illegal wTotalLength value");
|
|
return EXIT_FAILURE;
|
|
}
|
|
else if (sizeof(config_descriptor) == total_length) {
|
|
/* Nothing more was in descriptor anyway */
|
|
completed = 1;
|
|
}
|
|
else {
|
|
/* Read whatever is needed */
|
|
buffer_length = total_length;
|
|
}
|
|
|
|
} else {
|
|
/* All data for given configuration was read */
|
|
completed = 1;
|
|
}
|
|
}
|
|
while (!completed);
|
|
|
|
/* Create tree based on received buffer */
|
|
if (EXIT_SUCCESS != hcd_buffer_to_tree(this_device->buffer,
|
|
this_device->data_len,
|
|
&(this_device->config_tree))) {
|
|
/* This should never happen for a fine device */
|
|
USB_MSG("Illegal descriptor values");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_set_configuration *
|
|
*===========================================================================*/
|
|
static int
|
|
hcd_set_configuration(hcd_device_state * this_device, int configuration)
|
|
{
|
|
hcd_ctrlrequest setup;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
/* TODO: magic numbers, no header for these */
|
|
setup.bRequestType = 0x00; /* OUT */
|
|
setup.bRequest = 0x09; /* Set configuration */
|
|
setup.wValue = configuration;
|
|
setup.wIndex = 0x0000;
|
|
setup.wLength = 0x0000;
|
|
|
|
/* Handle formatted setup packet */
|
|
if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
|
|
USB_MSG("Handling setup packet failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_handle_urb *
|
|
*===========================================================================*/
|
|
static int
|
|
hcd_handle_urb(hcd_device_state * this_device)
|
|
{
|
|
DEBUG_DUMP;
|
|
|
|
USB_ASSERT(NULL != this_device->urb, "NULL URB received");
|
|
|
|
/* TODO: URB handling will be here */
|
|
|
|
/* TODO: call completion */
|
|
/* hcd_completion_cb */
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* hcd_setup_packet *
|
|
*===========================================================================*/
|
|
static int
|
|
hcd_setup_packet(hcd_device_state * this_device, hcd_ctrlrequest * setup)
|
|
{
|
|
hcd_driver_state * d;
|
|
hcd_reg1 * current_byte;
|
|
int expected_len;
|
|
int received_len;
|
|
|
|
DEBUG_DUMP;
|
|
|
|
/* Initially... */
|
|
d = this_device->driver;
|
|
expected_len = (int)setup->wLength;
|
|
current_byte = this_device->buffer;
|
|
|
|
/* Send setup packet */
|
|
d->setup_stage(d->private_data, setup);
|
|
|
|
/* Wait for response */
|
|
hcd_device_wait(this_device);
|
|
|
|
/* Check response */
|
|
if (EXIT_SUCCESS != d->check_error(d->private_data))
|
|
return EXIT_FAILURE;
|
|
|
|
/* For data packets... */
|
|
if (expected_len > 0) {
|
|
|
|
/* TODO: magic number */
|
|
/* ...IN data packets */
|
|
if (setup->bRequestType & 0x80) {
|
|
|
|
/* What was received until now */
|
|
this_device->data_len = 0;
|
|
|
|
do {
|
|
/* Try getting data */
|
|
d->in_data_stage(d->private_data);
|
|
|
|
/* Wait for response */
|
|
hcd_device_wait(this_device);
|
|
|
|
/* Check response */
|
|
if (EXIT_SUCCESS != d->check_error(
|
|
d->private_data))
|
|
return EXIT_FAILURE;
|
|
|
|
/* Read data received as response */
|
|
received_len = d->read_data(d->private_data,
|
|
current_byte, 0);
|
|
|
|
/* Data reading should always yield positive
|
|
* results for proper setup packet */
|
|
if (received_len > 0) {
|
|
/* Try next packet */
|
|
this_device->data_len += received_len;
|
|
current_byte += received_len;
|
|
} else
|
|
return EXIT_FAILURE;
|
|
|
|
} while (expected_len > this_device->data_len);
|
|
|
|
/* Should be exactly what we requested, no more */
|
|
if (this_device->data_len != expected_len) {
|
|
USB_MSG("Received more data than expected");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
} else {
|
|
/* TODO: unimplemented */
|
|
USB_MSG("Illegal non-zero length OUT setup packet");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
|
|
/* Status stages */
|
|
if (setup->bRequestType & 0x80) {
|
|
|
|
/* Try confirming data receive */
|
|
d->out_status_stage(d->private_data);
|
|
|
|
/* Wait for response */
|
|
hcd_device_wait(this_device);
|
|
|
|
/* Check response */
|
|
if (EXIT_SUCCESS != d->check_error(d->private_data))
|
|
return EXIT_FAILURE;
|
|
|
|
} else {
|
|
|
|
/* Try getting status confirmation */
|
|
d->in_status_stage(d->private_data);
|
|
|
|
/* Wait for response */
|
|
hcd_device_wait(this_device);
|
|
|
|
/* Check response */
|
|
if (EXIT_SUCCESS != d->check_error(d->private_data))
|
|
return EXIT_FAILURE;
|
|
|
|
/* Read zero data from response to clear registers */
|
|
if (0 != d->read_data(d->private_data, NULL, 0))
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|