dev/usb/usb.c

/*
 * Copyright (c) 2008 Travis Geiselbrecht
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include <debug.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>
#include <dev/usbc.h>
#include <dev/usb.h>

#define LOCAL_TRACE 0

#define MAX_STRINGS 8
static usb_string strings[MAX_STRINGS];

static usb_config *config;

static uint8_t active_config;
static bool usb_active = false;

static void append_desc_data(usb_descriptor *desc, const void *dat, size_t len)
{
	uint8_t *ptr = malloc(desc->len + len);

	memcpy(ptr, desc->desc, desc->len);
	memcpy(ptr + desc->len, dat, len);
	free(desc->desc);
	desc->desc = ptr;
	desc->len += len;
}

/* returns the interface number assigned */
static int usb_append_interface(usb_descriptor *desc, const uint8_t *int_descr, size_t len)
{
	uint8_t *ptr = malloc(len);
	int interface_num;

	// create a temporary copy of the interface
	memcpy(ptr, int_descr, len);

	// find the last interface used
	interface_num = ((uint8_t *)desc->desc)[4]; // current interface

	// patch our interface descriptor with the new id
	ptr[2] = interface_num;

	// append it to our config desriptor
	append_desc_data(desc, ptr, len);
	free(ptr);

	// patch the total length of the config descriptor and set the number of interfaces
	((uint16_t *)desc->desc)[1] += len;
	interface_num++;
	((uint8_t *)desc->desc)[4] = interface_num;

	return interface_num - 1;
}

int usb_append_interface_highspeed(const uint8_t *int_descr, size_t len)
{
	return usb_append_interface(&config->highspeed.config, int_descr, len);
}

int usb_append_interface_lowspeed(const uint8_t *int_descr, size_t len)
{
	return usb_append_interface(&config->lowspeed.config, int_descr, len);
}

void usb_set_string_descriptor(usb_descriptor *desc, const char *string)
{
	int len = strlen(string);
	ushort *data;
	int datalen = len * 2 + 2;

	data = malloc(datalen);
	
	/* write length field */
	data[0] = 0x0300 + datalen;

	/* copy the string into the uint16_t based usb string */
	int i;
	for (i = 0; i < len; i++) {
		data[i + 1] = string[i];
	}

	desc->desc = (void *)data;
	desc->len = datalen;
}

static void set_usb_id(uint16_t vendor, uint16_t product)
{
	// patch the current configuration to with the vendor/product id
	((uint16_t *)config->lowspeed.device.desc)[4] = vendor;
	((uint16_t *)config->lowspeed.device.desc)[5] = product;

	((uint16_t *)config->highspeed.device.desc)[4] = vendor;
	((uint16_t *)config->highspeed.device.desc)[5] = product;
}

void usb_add_string(const char *string, uint8_t id) 
{
	uint i;
	size_t len = strlen(string);
	uint16_t *strbuf = malloc(len * 2 + 2);

	/* build the usb string descriptor */
	strbuf[0] = 0x300 | (len * 2 + 2);
	for (i = 0; i < len; i++) {
		strbuf[i + 1] = (uint16_t)string[i];
	}

	/* find a slot to put it */
	for (i = 0; i < MAX_STRINGS; i++) {
		if (strings[i].id == 0) {
			strings[i].string.desc = strbuf;
			strings[i].string.len = len * 2 + 2;
			strings[i].id = id;
			break;
		}
	}
}

static int default_usb_callback(usbc_callback_op_t op, const union usb_callback_args *args)
{
	LTRACEF("op %d, args %p\n", op, args);

	/* start looking for specific things to handle */
	if (op == CB_SETUP_MSG) {
		const struct usb_setup *setup = args->setup;
		DEBUG_ASSERT(setup);
		LTRACEF("SETUP: req_type=%#x req=%#x value=%#x index=%#x len=%#x\n", setup->request_type, setup->request, setup->value, setup->index, setup->length);

		if ((setup->request_type & TYPE_MASK) == TYPE_STANDARD) {
			switch (setup->request) {
				case SET_ADDRESS:
					LTRACEF("SET_ADDRESS 0x%x\n", setup->value);
					usbc_ep0_ack();
					break;
				case SET_FEATURE:
				case CLEAR_FEATURE:
					// OTAY
					LTRACEF("SET/CLEAR_FEATURE, feature 0x%x\n", setup->value);
					usbc_ep0_ack();
					break;
				case SET_DESCRIPTOR:
					LTRACEF("SET_DESCRIPTOR\n");
					usbc_ep0_stall();
					break;
				case GET_DESCRIPTOR: {
					/* Get the right descriptors based on current speed */
					const struct usb_descriptor_speed *speed;
					if (usbc_is_highspeed()) {
						speed = &config->highspeed;
					} else {
						speed = &config->lowspeed;
					}

					if ((setup->request_type & RECIP_MASK) == RECIP_DEVICE)	{
						switch (setup->value) {
							case 0x100: /* device */
								LTRACEF("got GET_DESCRIPTOR, device descriptor\n");
								usbc_ep0_send(speed->device.desc, speed->device.len, 
										setup->length);
								break;
							case 0x200:    /* CONFIGURATION */
								LTRACEF("got GET_DESCRIPTOR, config descriptor\n");
								usbc_ep0_send(speed->config.desc, speed->config.len,
										setup->length);
								break;
							case 0x300:    /* Language ID */
								LTRACEF("got GET_DESCRIPTOR, language id\n");
								usbc_ep0_send(config->langid.desc,
										config->langid.len, setup->length);
								break;
							case (0x301)...(0x3ff): {
								/* string descriptor, search our list for a match */
								uint i;
								bool found = false;
								uint8_t id = setup->value & 0xff;
								for (i = 0; i < MAX_STRINGS; i++) {
									if (strings[i].id == id) {
										usbc_ep0_send(strings[i].string.desc,
											strings[i].string.len, 
											setup->length);
										found = true;
										break;
									}
								}
								if (!found) {
									/* couldn't find one, stall */
									usbc_ep0_stall();
								}
								break;
							}
							case 0x600:    /* DEVICE QUALIFIER */
								LTRACEF("got GET_DESCRIPTOR, device qualifier\n");
								usbc_ep0_send(speed->device_qual.desc, 
										speed->device_qual.len, setup->length);
								break;
							case 0xa00:
								/* we aint got one of these */
								LTRACEF("got GET_DESCRIPTOR, debug descriptor\n");
								usbc_ep0_stall();
								break;
							default:
								LTRACEF("unhandled descriptor %#x\n", setup->value);
								// stall
								break;
						}
					} else {
						// interface/endpoint descriptors? let someone else handle it
						// STALL
					}
					break;
				}

				case SET_CONFIGURATION:
					LTRACEF("SET_CONFIGURATION %d\n", setup->value);
					active_config = setup->value;
					usbc_ep0_ack();
					break;

				case GET_CONFIGURATION:
					LTRACEF("GET_CONFIGURATION\n");
					usbc_ep0_send(&active_config, 1, setup->length);
					break;

				case SET_INTERFACE:
					LTRACEF("SET_INTERFACE %d\n", setup->value);
					usbc_ep0_ack();
					break;

				case GET_INTERFACE: {
					static uint8_t i = 1;
					LTRACEF("GET_INTERFACE\n");
					usbc_ep0_send(&i, 1, setup->length);
					break;
				}

				case GET_STATUS: {
					static uint16_t i = 1; // self powered
					LTRACEF("GET_STATUS\n");
					usbc_ep0_send(&i, 2, setup->length);
					break;
				}
				default:
					LTRACEF("unhandled standard request 0x%x\n", setup->request);
			}
		}
	}

	return 0;
}

void usb_setup(usb_config *_config)
{
	ASSERT(_config);

	config = _config;

	ASSERT(usb_active == false);

	// set the default usb control callback handler	
	usbc_set_callback(&default_usb_callback);
}

void usb_start(void)
{
	ASSERT(config);
	ASSERT(usb_active == false);

	// go online
	usbc_set_active(true);
	usb_active = true;
}

void usb_stop(void)
{
	ASSERT(usb_active == true);

	usb_active = false;
	usbc_set_active(false);
}

void usb_init(void)
{
}