dev/usb/usb.c - kernel/lk - Gitiles

 /*
  * 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)
 {
 }
	/*
	* 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)
	{
	}