363 lines
12 KiB
C
363 lines
12 KiB
C
/****************************************************************************
|
|
* Grainuum Software USB Stack *
|
|
* *
|
|
* MIT License: *
|
|
* Copyright (c) 2016 Sean Cross *
|
|
* *
|
|
* 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, distribute with modifications, 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 ABOVE 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. *
|
|
* *
|
|
* Except as contained in this notice, the name(s) of the above copyright *
|
|
* holders shall not be used in advertising or otherwise to promote the *
|
|
* sale, use or other dealings in this Software without prior written *
|
|
* authorization. *
|
|
****************************************************************************/
|
|
#include "grainuum.h"
|
|
|
|
#ifndef NULL
|
|
#define NULL ((void *)0)
|
|
#endif
|
|
|
|
void *memcpy(void *dest, const void *src, unsigned int n);
|
|
|
|
enum usb_state_packet_type {
|
|
packet_type_none,
|
|
packet_type_setup,
|
|
packet_type_setup_in,
|
|
packet_type_setup_out,
|
|
packet_type_in,
|
|
packet_type_out,
|
|
};
|
|
|
|
__attribute__((weak))
|
|
void grainuumSendWait(struct GrainuumUSB *usb, int epnum,
|
|
const void *data, int size)
|
|
{
|
|
(void)usb;
|
|
(void)epnum;
|
|
(void)data;
|
|
(void)size;
|
|
}
|
|
|
|
static uint16_t crc16_add(uint16_t crc, uint8_t c, uint16_t poly)
|
|
{
|
|
uint8_t i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if ((crc ^ c) & 1)
|
|
crc = (crc >> 1) ^ poly;
|
|
else
|
|
crc >>= 1;
|
|
c >>= 1;
|
|
}
|
|
return crc;
|
|
}
|
|
|
|
static uint16_t crc16(const uint8_t *data, uint32_t size,
|
|
uint16_t init, uint32_t poly)
|
|
{
|
|
|
|
while (size--)
|
|
init = crc16_add(init, *data++, poly);
|
|
|
|
return init;
|
|
}
|
|
|
|
static void grainuum_state_clear_tx(struct GrainuumState *state, int result)
|
|
{
|
|
struct GrainuumUSB *usb = state->usb;
|
|
|
|
/* If a thread is blocking, wake it up with a failure */
|
|
if (usb->cfg->sendDataFinished && state->packet_queued)
|
|
usb->cfg->sendDataFinished(usb, result);
|
|
state->data_out_left = 0;
|
|
state->data_out_max = 0;
|
|
state->data_out = NULL;
|
|
state->packet_queued = 0;
|
|
}
|
|
|
|
static void grainuum_state_process_tx(struct GrainuumState *state)
|
|
{
|
|
|
|
uint16_t crc;
|
|
struct GrainuumUSB *usb = state->usb;
|
|
|
|
/* Don't allow us to re-prepare data */
|
|
if (state->packet_queued) {
|
|
return;
|
|
}
|
|
state->packet_queued = 1;
|
|
|
|
/* If there's no data to send, then don't send any */
|
|
if (!state->data_out) {
|
|
state->packet_queued = 0;
|
|
return;
|
|
}
|
|
|
|
/* If we've sent all of our data, then there's nothing else to send */
|
|
if ((state->data_out_left < 0) || (state->data_out_max < 0)) {
|
|
grainuum_state_clear_tx(state, 0);
|
|
return;
|
|
}
|
|
|
|
/* Pick the correct PID, DATA0 or DATA1 */
|
|
if (state->data_buffer & (1 << state->tok_epnum))
|
|
state->packet.pid = USB_PID_DATA1;
|
|
else
|
|
state->packet.pid = USB_PID_DATA0;
|
|
|
|
/* If there's no data, prepare a special NULL packet */
|
|
if ((state->data_out_left == 0) || (state->data_out_max == 0)) {
|
|
|
|
/* The special-null thing only happens for EP0 */
|
|
if (state->data_out_epnum != 0) {
|
|
grainuum_state_clear_tx(state, 0);
|
|
return;
|
|
}
|
|
state->packet.data[0] = 0; /* CRC16 for empty packets is 0 */
|
|
state->packet.data[1] = 0;
|
|
state->packet.size = 2;
|
|
grainuumWriteQueue(usb, state->data_out_epnum,
|
|
&state->packet, state->packet.size + 1);
|
|
return;
|
|
}
|
|
|
|
/* Keep the packet size to 8 bytes max */
|
|
if (state->data_out_left > GRAINUUM_PACKET_SIZE_MAX)
|
|
state->packet.size = GRAINUUM_PACKET_SIZE_MAX;
|
|
else
|
|
state->packet.size = state->data_out_left;
|
|
|
|
/* Limit the amount of data transferred to data_out_max */
|
|
if (state->packet.size > state->data_out_max)
|
|
state->packet.size = state->data_out_max;
|
|
|
|
/* Copy over data bytes */
|
|
memcpy(state->packet.data, state->data_out, state->packet.size);
|
|
|
|
/* Calculate and copy the crc16 */
|
|
crc = ~crc16(state->packet.data, state->packet.size, 0xffff, 0xa001);
|
|
state->packet.data[state->packet.size++] = crc;
|
|
state->packet.data[state->packet.size++] = crc >> 8;
|
|
|
|
/* Prepare the packet, including the PID at the end */
|
|
grainuumWriteQueue(usb, state->data_out_epnum,
|
|
&state->packet, state->packet.size + 1);
|
|
}
|
|
|
|
/* Called when a packet is ACKed.
|
|
* Updates the outgoing packet buffer.
|
|
*/
|
|
static void usbStateTransferSuccess(struct GrainuumState *state)
|
|
{
|
|
|
|
/* Reduce the amount of data left.
|
|
* If the packet is divisible by 8, this will cause one more call
|
|
* to this function with state->data_out_left == 0. This will send
|
|
* a NULL packet, which indicates end-of-transfer.
|
|
*/
|
|
state->data_out_left -= GRAINUUM_PACKET_SIZE_MAX;
|
|
state->data_out_max -= GRAINUUM_PACKET_SIZE_MAX;
|
|
state->data_out += GRAINUUM_PACKET_SIZE_MAX;
|
|
|
|
if ((state->data_out_left < 0) || (state->data_out_max < 0)) {
|
|
grainuum_state_clear_tx(state, 0);
|
|
|
|
/* End of a State setup packet */
|
|
if (state->packet_type == packet_type_setup_out)
|
|
state->packet_type = packet_type_none;
|
|
if (state->packet_type == packet_type_setup_in)
|
|
state->packet_type = packet_type_none;
|
|
if (state->packet_type == packet_type_out)
|
|
state->packet_type = packet_type_none;
|
|
}
|
|
|
|
state->packet_queued = 0;
|
|
}
|
|
|
|
/* Send data down the wire, interrupting any existing
|
|
* data that may be queued.
|
|
*/
|
|
static int grainuum_state_send_data(struct GrainuumState *state,
|
|
int epnum,
|
|
const void *data,
|
|
int size,
|
|
int max)
|
|
{
|
|
|
|
/* De-queue any data that may already be queued. */
|
|
grainuum_state_clear_tx(state, 1);
|
|
|
|
state->data_out_epnum = epnum;
|
|
state->data_out_left = size;
|
|
state->data_out_max = max;
|
|
state->data_out = data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void grainuumDropData(struct GrainuumUSB *usb)
|
|
{
|
|
usb->state.packet_queued = 0;
|
|
usb->state.data_out = 0;
|
|
grainuumWriteQueue(usb, 0, NULL, 0);
|
|
}
|
|
|
|
int grainuumDataQueued(struct GrainuumUSB *usb)
|
|
{
|
|
return (usb->state.data_out || usb->state.packet_queued);
|
|
}
|
|
|
|
int grainuumSendData(struct GrainuumUSB *usb, int epnum,
|
|
const void *data, int size)
|
|
{
|
|
|
|
struct GrainuumState *state = &usb->state;
|
|
int ret;
|
|
|
|
if (state->data_out || !state->address || state->packet_queued) {
|
|
return -11; /* EAGAIN */
|
|
}
|
|
|
|
ret = grainuum_state_send_data(state, epnum, data, size, size);
|
|
if (ret)
|
|
return ret;
|
|
|
|
grainuum_state_process_tx(state);
|
|
|
|
if (usb->cfg->sendDataStarted)
|
|
usb->cfg->sendDataStarted(usb, epnum, data, size);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int grainuum_state_process_setup(struct GrainuumState *state, const uint8_t packet[10])
|
|
{
|
|
|
|
const struct usb_setup_packet *setup;
|
|
const void *response = (void *)-1;
|
|
uint32_t response_len = 0;
|
|
struct GrainuumUSB *usb = state->usb;
|
|
struct GrainuumConfig *cfg = usb->cfg;
|
|
|
|
setup = (const struct usb_setup_packet *)packet;
|
|
|
|
if ((setup->bmRequestType == 0x00) && (setup->bRequest == SET_ADDRESS)) {
|
|
state->address = setup->wValue;
|
|
}
|
|
else if ((setup->bmRequestType == 0x00) && (setup->bRequest == SET_CONFIGURATION)) {
|
|
if (cfg->setConfigNum)
|
|
cfg->setConfigNum(usb, setup->wValue);
|
|
}
|
|
else {
|
|
response_len = cfg->getDescriptor(usb, setup, &response);
|
|
}
|
|
grainuum_state_send_data(state, state->tok_epnum, response, response_len, setup->wLength);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void grainuum_state_parse_data(struct GrainuumState *state,
|
|
const uint8_t packet[GRAINUUM_PACKET_SIZE_MAX + 2],
|
|
uint32_t size)
|
|
{
|
|
(void)size;
|
|
struct GrainuumUSB *usb = state->usb;
|
|
|
|
switch (state->packet_type) {
|
|
|
|
case packet_type_setup:
|
|
grainuum_state_process_setup(state, packet);
|
|
grainuum_state_process_tx(state);
|
|
state->packet_type = packet_type_none;
|
|
break;
|
|
|
|
case packet_type_out:
|
|
// XXX HACK: An OUT packet gets generated (on Windows at least) when
|
|
// terminating a SETUP sequence. This seems odd.
|
|
if (state->tok_epnum == 0)
|
|
break;
|
|
// Copy over the packet, minus the CRC16
|
|
memcpy(state->tok_buf + state->tok_pos, packet, size - 2);
|
|
state->tok_pos += (size - 2);
|
|
if (!usb->cfg->receiveData(usb, state->tok_epnum, size - 2, packet))
|
|
state->packet_type = packet_type_none;
|
|
break;
|
|
|
|
case packet_type_in:
|
|
case packet_type_none:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static inline void grainuum_state_parse_token(struct GrainuumState *state,
|
|
const uint8_t packet[2])
|
|
{
|
|
|
|
state->tok_epnum = (((const uint16_t *)packet)[0] >> 7) & 0xf;
|
|
/*state->tok_addr = (((const uint16_t *)packet)[0] >> 11) & 0x1f; // Field unused in this code*/
|
|
}
|
|
|
|
void grainuumProcess(struct GrainuumUSB *usb,
|
|
const uint8_t packet[GRAINUUM_PACKET_SIZE_MAX + 3])
|
|
{
|
|
|
|
uint32_t size = packet[GRAINUUM_PACKET_SIZE_MAX + 3];
|
|
struct GrainuumState *state = &usb->state;
|
|
switch(packet[0]) {
|
|
case USB_PID_SETUP:
|
|
state->packet_type = packet_type_setup;
|
|
grainuum_state_clear_tx(state, 1);
|
|
grainuum_state_parse_token(state, packet + 1);
|
|
break;
|
|
|
|
case USB_PID_DATA0:
|
|
state->data_buffer |= (1 << state->tok_epnum);
|
|
grainuum_state_parse_data(state, packet + 1, size - 1);
|
|
break;
|
|
|
|
case USB_PID_DATA1:
|
|
state->data_buffer &= ~(1 << state->tok_epnum);
|
|
grainuum_state_parse_data(state, packet + 1, size - 1);
|
|
break;
|
|
|
|
case USB_PID_OUT:
|
|
grainuum_state_parse_token(state, packet + 1);
|
|
state->packet_type = packet_type_out;
|
|
state->tok_pos = 0;
|
|
state->tok_buf = usb->cfg->getReceiveBuffer(usb, state->tok_epnum, NULL);
|
|
break;
|
|
|
|
case USB_PID_ACK:
|
|
state->data_buffer ^= (1 << state->tok_epnum);
|
|
usbStateTransferSuccess(state);
|
|
if (state->data_out) {
|
|
grainuum_state_process_tx(state);
|
|
}
|
|
else {
|
|
grainuum_state_clear_tx(state, 0);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|