mirror of
https://github.com/gdsports/USBHost_t36
synced 2024-11-05 08:45:10 -05:00
231 lines
7.5 KiB
C++
231 lines
7.5 KiB
C++
/* USB EHCI Host for Teensy 3.6
|
|
* Copyright 2017 Paul Stoffregen (paul@pjrc.com)
|
|
*
|
|
* 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 <Arduino.h>
|
|
#include "USBHost.h"
|
|
|
|
|
|
void mk_setup(setup_t &s, uint32_t bmRequestType, uint32_t bRequest,
|
|
uint32_t wValue, uint32_t wIndex, uint32_t wLength)
|
|
{
|
|
s.word1 = bmRequestType | (bRequest << 8) | (wValue << 16);
|
|
s.word2 = wIndex | (wLength << 16);
|
|
}
|
|
|
|
static uint8_t enumbuf[256] __attribute__ ((aligned(16)));
|
|
|
|
|
|
// Create a new device and begin the enumeration process
|
|
//
|
|
Device_t * new_Device(uint32_t speed, uint32_t hub_addr, uint32_t hub_port)
|
|
{
|
|
Device_t *dev;
|
|
|
|
Serial.print("new_Device: ");
|
|
switch (speed) {
|
|
case 0: Serial.print("12"); break;
|
|
case 1: Serial.print("1.5"); break;
|
|
case 2: Serial.print("480"); break;
|
|
default: Serial.print("??");
|
|
}
|
|
Serial.println(" Mbit/sec");
|
|
dev = allocate_Device();
|
|
if (!dev) return NULL;
|
|
memset(dev, 0, sizeof(Device_t));
|
|
dev->speed = speed;
|
|
dev->address = 0;
|
|
dev->hub_address = hub_addr;
|
|
dev->hub_port = hub_port;
|
|
dev->control_pipe = new_Pipe(dev, 0, 0, 0, 8);
|
|
if (!dev->control_pipe) {
|
|
free_Device(dev);
|
|
return NULL;
|
|
}
|
|
dev->control_pipe->callback_function = &enumeration;
|
|
dev->control_pipe->direction = 1; // 1=IN
|
|
mk_setup(dev->setup, 0x80, 6, 0x0100, 0, 8); // 6=GET_DESCRIPTOR
|
|
new_Transfer(dev->control_pipe, enumbuf, 8);
|
|
|
|
return dev;
|
|
}
|
|
|
|
|
|
|
|
void enumeration(const Transfer_t *transfer)
|
|
{
|
|
uint32_t len;
|
|
|
|
Serial.print(" CALLBACK: ");
|
|
print_hexbytes(transfer->buffer, transfer->length);
|
|
//print(transfer);
|
|
Device_t *dev = transfer->pipe->device;
|
|
|
|
while (1) {
|
|
// Within this large switch/case, "break" means we've done
|
|
// some work, but more remains to be done in a different
|
|
// state. Generally break is used after parsing received
|
|
// data, but what happens next could be different states.
|
|
// When completed, return is used. Generally, return happens
|
|
// only after a new control transfer is queued, or when
|
|
// enumeration is complete and no more communication is needed.
|
|
switch (dev->enum_state) {
|
|
case 0: // read 8 bytes of device desc, set max packet, and send set address
|
|
pipe_set_maxlen(dev->control_pipe, enumbuf[7]);
|
|
mk_setup(dev->setup, 0, 5, assign_addr(), 0, 0); // 5=SET_ADDRESS
|
|
new_Transfer(dev->control_pipe, NULL, 0);
|
|
dev->enum_state = 1;
|
|
return;
|
|
case 1: // request all 18 bytes of device descriptor
|
|
pipe_set_addr(dev->control_pipe, dev->setup.wValue);
|
|
mk_setup(dev->setup, 0x80, 6, 0x0100, 0, 18); // 6=GET_DESCRIPTOR
|
|
new_Transfer(dev->control_pipe, enumbuf, 18);
|
|
dev->enum_state = 2;
|
|
return;
|
|
case 2: // parse 18 device desc bytes
|
|
dev->bDeviceClass = enumbuf[4];
|
|
dev->bDeviceSubClass = enumbuf[5];
|
|
dev->bDeviceProtocol = enumbuf[6];
|
|
dev->idVendor = enumbuf[8] | (enumbuf[9] << 8);
|
|
dev->idProduct = enumbuf[10] | (enumbuf[11] << 8);
|
|
enumbuf[0] = enumbuf[14];
|
|
enumbuf[1] = enumbuf[15];
|
|
enumbuf[2] = enumbuf[16];
|
|
if ((enumbuf[0] | enumbuf[1] | enumbuf[2]) > 0) {
|
|
dev->enum_state = 3;
|
|
} else {
|
|
dev->enum_state = 11;
|
|
}
|
|
break;
|
|
case 3: // request Language ID
|
|
len = sizeof(enumbuf) - 4;
|
|
mk_setup(dev->setup, 0x80, 6, 0x0300, 0, len); // 6=GET_DESCRIPTOR
|
|
new_Transfer(dev->control_pipe, enumbuf + 4, len);
|
|
dev->enum_state = 4;
|
|
return;
|
|
case 4: // parse Language ID
|
|
if (enumbuf[4] < 4 || enumbuf[5] != 3) {
|
|
dev->enum_state = 11;
|
|
} else {
|
|
dev->LanguageID = enumbuf[6] | (enumbuf[7] << 8);
|
|
if (enumbuf[0]) dev->enum_state = 5;
|
|
else if (enumbuf[1]) dev->enum_state = 7;
|
|
else if (enumbuf[2]) dev->enum_state = 9;
|
|
else dev->enum_state = 11;
|
|
}
|
|
break;
|
|
case 5: // request Manufacturer string
|
|
len = sizeof(enumbuf) - 4;
|
|
mk_setup(dev->setup, 0x80, 6, 0x0300 | enumbuf[0], dev->LanguageID, len);
|
|
new_Transfer(dev->control_pipe, enumbuf + 4, len);
|
|
dev->enum_state = 6;
|
|
return;
|
|
case 6: // parse Manufacturer string
|
|
// TODO: receive the string...
|
|
if (enumbuf[1]) dev->enum_state = 7;
|
|
else if (enumbuf[2]) dev->enum_state = 9;
|
|
else dev->enum_state = 11;
|
|
break;
|
|
case 7: // request Product string
|
|
len = sizeof(enumbuf) - 4;
|
|
mk_setup(dev->setup, 0x80, 6, 0x0300 | enumbuf[1], dev->LanguageID, len);
|
|
new_Transfer(dev->control_pipe, enumbuf + 4, len);
|
|
dev->enum_state = 8;
|
|
return;
|
|
case 8: // parse Product string
|
|
// TODO: receive the string...
|
|
if (enumbuf[2]) dev->enum_state = 9;
|
|
else dev->enum_state = 11;
|
|
break;
|
|
case 9: // request Serial Number string
|
|
len = sizeof(enumbuf) - 4;
|
|
mk_setup(dev->setup, 0x80, 6, 0x0300 | enumbuf[2], dev->LanguageID, len);
|
|
new_Transfer(dev->control_pipe, enumbuf + 4, len);
|
|
dev->enum_state = 10;
|
|
return;
|
|
case 10: // parse Serial Number string
|
|
// TODO: receive the string...
|
|
dev->enum_state = 11;
|
|
break;
|
|
case 11: // request first 9 bytes of config desc
|
|
mk_setup(dev->setup, 0x80, 6, 0x0200, 0, 9); // 6=GET_DESCRIPTOR
|
|
new_Transfer(dev->control_pipe, enumbuf, 9);
|
|
dev->enum_state = 12;
|
|
return;
|
|
case 12: // read 9 bytes, request all of config desc
|
|
len = enumbuf[2] | (enumbuf[3] << 8);
|
|
Serial.print("Config data length = ");
|
|
Serial.println(len);
|
|
if (len > sizeof(enumbuf)) {
|
|
// TODO: how to handle device with too much config data
|
|
}
|
|
mk_setup(dev->setup, 0x80, 6, 0x0200, 0, len); // 6=GET_DESCRIPTOR
|
|
new_Transfer(dev->control_pipe, enumbuf, len);
|
|
dev->enum_state = 13;
|
|
return;
|
|
case 13: // read all config desc, send set config
|
|
Serial.print("bNumInterfaces = ");
|
|
Serial.println(enumbuf[4]);
|
|
Serial.print("bConfigurationValue = ");
|
|
Serial.println(enumbuf[5]);
|
|
// TODO: actually do something with interface descriptor?
|
|
mk_setup(dev->setup, 0, 9, enumbuf[5], 0, 0); // 9=SET_CONFIGURATION
|
|
new_Transfer(dev->control_pipe, NULL, 0);
|
|
dev->enum_state = 14;
|
|
return;
|
|
case 14: // device is now configured
|
|
// TODO: initialize drivers??
|
|
dev->enum_state = 15;
|
|
return;
|
|
case 15: // control transfers for other stuff??
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t assign_addr(void)
|
|
{
|
|
return 29; // TODO: when multiple devices, assign a unique address
|
|
}
|
|
|
|
void pipe_set_maxlen(Pipe_t *pipe, uint32_t maxlen)
|
|
{
|
|
Serial.print("pipe_set_maxlen ");
|
|
Serial.println(maxlen);
|
|
pipe->qh.capabilities[0] = (pipe->qh.capabilities[0] & 0x8000FFFF) | (maxlen << 16);
|
|
}
|
|
|
|
void pipe_set_addr(Pipe_t *pipe, uint32_t addr)
|
|
{
|
|
Serial.print("pipe_set_addr ");
|
|
Serial.println(addr);
|
|
pipe->qh.capabilities[0] = (pipe->qh.capabilities[0] & 0xFFFFFF80) | addr;
|
|
}
|
|
|
|
uint32_t pipe_get_addr(Pipe_t *pipe)
|
|
{
|
|
return pipe->qh.capabilities[0] & 0xFFFFFF80;
|
|
}
|
|
|
|
|