603 lines
22 KiB
C
603 lines
22 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. *
|
|
****************************************************************************/
|
|
|
|
#ifndef _GRAINUUM_H
|
|
#define _GRAINUUM_H
|
|
|
|
#include <stdint.h>
|
|
|
|
/**
|
|
* @brief Extra fields for GrainuumState struct.
|
|
* @note You probably can ignore this.
|
|
*/
|
|
#ifndef GRAINUUM_STATE_EXTRA
|
|
#define GRAINUUM_STATE_EXTRA
|
|
#endif /* GRAINUUM_STATE_EXTRA */
|
|
|
|
#define GRAINUUM_PACKET_SIZE_MAX 64
|
|
|
|
/**
|
|
* @brief Extra fields for GrainuumUSB struct.
|
|
* @note Use this to store context and thread information.
|
|
*/
|
|
#ifndef GRAINUUM_EXTRA
|
|
#define GRAINUUM_EXTRA
|
|
#endif /* GRAINUUM_EXTRA */
|
|
|
|
#define GET_STATUS 0
|
|
#define CLEAR_FEATURE 1
|
|
#define SET_FEATURE 3
|
|
#define SET_ADDRESS 5
|
|
#define GET_DESCRIPTOR 6
|
|
#define SET_DESCRIPTOR 7
|
|
#define GET_CONFIGURATION 8
|
|
#define SET_CONFIGURATION 9
|
|
#define GET_INTERFACE 10
|
|
#define SET_INTERFACE 11
|
|
#define SYNC_FRAME 12
|
|
|
|
#define GET_REPORT 1
|
|
#define GET_IDLE 2
|
|
#define GET_PROTOCOL 3
|
|
#define SET_REPORT 9
|
|
#define SET_IDLE 10
|
|
#define SET_PROTOCOL 11
|
|
|
|
enum usb_pids {
|
|
USB_PID_RESERVED = 0xf0,
|
|
USB_PID_OUT = 0xe1,
|
|
USB_PID_ACK = 0xd2,
|
|
USB_PID_DATA0 = 0xc3,
|
|
USB_PID_PING = 0xb4,
|
|
USB_PID_SOF = 0xa5,
|
|
USB_PID_NYET = 0x96,
|
|
USB_PID_DATA2 = 0x87,
|
|
USB_PID_SPLIT = 0x78,
|
|
USB_PID_IN = 0x69,
|
|
USB_PID_NAK = 0x5a,
|
|
USB_PID_DATA1 = 0x4b,
|
|
USB_PID_ERR = 0x3c,
|
|
USB_PID_SETUP = 0x2d,
|
|
USB_PID_STALL = 0x1e,
|
|
USB_PID_MDATA = 0x0f,
|
|
};
|
|
|
|
enum valenty_usb_pids {
|
|
VUSB_PID_IN = 0x2,
|
|
VUSB_PID_OUT = 0x0,
|
|
VUSB_PID_SETUP = 0x3,
|
|
};
|
|
|
|
struct GrainuumUSB;
|
|
struct GrainuumState;
|
|
struct GrainuumConfig;
|
|
|
|
/* Function callbacks */
|
|
|
|
/* Each of these functions are called by the USB system to get a buffer.
|
|
* On return, *data will point to the buffer, and the number of bytes
|
|
* in the buffer will be returned.
|
|
*
|
|
* If the data does not exist, return 0.
|
|
*/
|
|
typedef int (*get_usb_descriptor_t)(struct GrainuumUSB *usb,
|
|
const void *pkt,
|
|
const void **data);
|
|
typedef void (*usb_set_config_num_t)(struct GrainuumUSB *usb,
|
|
int configNum);
|
|
|
|
/*
|
|
* Called when doing an OUT xfer (data to device) to get a buffer for
|
|
* the specified endpoint.
|
|
* It is up to the user to ensure the buffer is large enough.
|
|
*/
|
|
typedef void * (*usb_get_buffer_t)(struct GrainuumUSB *usb,
|
|
uint8_t epnum,
|
|
int32_t *size);
|
|
|
|
/*
|
|
* When data is received (i.e. OUT EP), this function will be called.
|
|
*/
|
|
typedef int (*usb_data_in_t)(struct GrainuumUSB *usb,
|
|
uint8_t epnum,
|
|
uint32_t bytes,
|
|
const void *data);
|
|
|
|
/**
|
|
* @brief Called immediately after @p grainuumSendData() has queued data.
|
|
* @note This function can be used to e.g. sleep a thread.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @param[in] epnum endpoint number of the transfer
|
|
* @param[in] data pointer to the data being written
|
|
* @param[in] size number of bytes being written
|
|
* @api
|
|
*/
|
|
typedef void (*usb_data_out_start_t)(struct GrainuumUSB *usb,
|
|
int epnum,
|
|
const void *data,
|
|
int size);
|
|
|
|
/**
|
|
* @brief Called once all data has been sent.
|
|
* @note This function can be used to e.g. wake up a thread.
|
|
* @param[out] usb pointer to the @p GrainuumUSB object
|
|
* @param[out] result whether the transfer was successful (0), or had an error.
|
|
* @api
|
|
*/
|
|
typedef int (*usb_data_out_finish_t)(struct GrainuumUSB *usb,
|
|
int result);
|
|
|
|
/* Structure of a USB packet on the wire, plus size field */
|
|
struct usb_packet {
|
|
union {
|
|
struct {
|
|
// uint8_t pid;
|
|
uint8_t data[GRAINUUM_PACKET_SIZE_MAX + 2]; /* Including CRC */
|
|
} __attribute((packed, aligned(4)));
|
|
uint8_t raw_data[GRAINUUM_PACKET_SIZE_MAX + 2];
|
|
} __attribute((packed, aligned(4)));
|
|
uint8_t size; /* Not including pid (so may be 0) */
|
|
/* Checksum omitted */
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
/* USB Descriptors */
|
|
|
|
#define DT_DEVICE 0x01
|
|
#define DT_CONFIGURATION 0x02
|
|
#define DT_STRING 0x03
|
|
#define DT_INTERFACE 0x04
|
|
#define DT_ENDPOINT 0x05
|
|
#define DT_DEVICE_QUALIFIER 0x06
|
|
#define DT_OTHER_SPEED_CONFIGURATION 0x07
|
|
#define DT_INTERFACE_POWER 0x08
|
|
|
|
#define DT_HID 0x21
|
|
#define DT_HID_REPORT 0x22
|
|
#define DT_PID 0x23
|
|
|
|
struct usb_setup_packet {
|
|
uint8_t bmRequestType;
|
|
uint8_t bRequest;
|
|
union {
|
|
uint16_t wValue;
|
|
struct {
|
|
uint8_t wValueL;
|
|
uint8_t wValueH;
|
|
};
|
|
};
|
|
uint16_t wIndex;
|
|
uint16_t wLength;
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct usb_device_descriptor {
|
|
uint8_t bLength;
|
|
uint8_t bDescriptorType;
|
|
uint16_t bcdUSB;
|
|
uint8_t bDeviceClass;
|
|
uint8_t bDeviceSubClass;
|
|
uint8_t bDeviceProtocol;
|
|
uint8_t bMaxPacketSize0;
|
|
uint16_t idVendor;
|
|
uint16_t idProduct;
|
|
uint16_t bcdDevice;
|
|
uint8_t iManufacturer;
|
|
uint8_t iProduct;
|
|
uint8_t iSerialNumber;
|
|
uint8_t bNumConfigurations;
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct usb_configuration_descriptor {
|
|
uint8_t bLength; /* Size of this descriptor, in bytes (9) */
|
|
uint8_t bDescriptorType; /* DT_CONFIGURATION (2) */
|
|
uint16_t wTotalLength; /* Total length of this, plus sizeof(data) */
|
|
uint8_t bNumInterfaces; /* Number of interfaces supported by config */
|
|
uint8_t bConfigurationValue; /* Value used by Set Configuration */
|
|
uint8_t iConfiguration; /* index of string descriptor for config */
|
|
uint8_t bmAttributes; /* Bitmap of attributes. D7 must be 1. */
|
|
uint8_t bMaxPower; /* Maximum power, in units of 2mA */
|
|
uint8_t data[]; /* Remaining descriptors */
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct usb_string_descriptor {
|
|
uint8_t bLength; /* sizeof(usb_string_descriptor) + sizeof(data) */
|
|
uint8_t bDescriptorType; /* DT_STRING (3) */
|
|
uint8_t data[]; /* UTF-16LE string data or lang data(for string 0 */
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct usb_interface_descriptor {
|
|
uint8_t bLength; /* sizeof(usb_interface_descriptor) (9) */
|
|
uint8_t bDescriptorType; /* DT_INTERFACE (4) */
|
|
uint8_t bInterfaceNumber; /* Which interface this describes. Usually 0. */
|
|
uint8_t bAlternateSetting; /* ??? */
|
|
uint8_t bNumEndpoints; /* Number of endpoints, minus 1 */
|
|
uint8_t bInterfaceClass; /* Class code */
|
|
uint8_t bInterfaceSubclass; /* Class sub-code */
|
|
uint8_t bInterfaceProtocol; /* Protocol code, assigned by USB */
|
|
uint8_t iInterface; /* Index of string for this interface */
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct usb_endpoint_descriptor {
|
|
uint8_t bLength; /* sizeof(usb_endpoint_descriptor) (7) */
|
|
uint8_t bDescriptorType; /* DT_ENDPOINT (5) */
|
|
uint8_t bEndpointAddress; /* High bit 1:IN, 0:OUT. Lower 4-bits are EP# */
|
|
uint8_t bmAttributes; /* 0=control, 2=bulk, 3=interrupt */
|
|
uint16_t wMaxPacketSize; /* Max packet size for this EP */
|
|
uint8_t bInterval; /* Polling rate (in 1ms units) */
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct usb_hid_descriptor {
|
|
uint8_t bLength; /* sizeof(usb_hid_descriptor) (9) */
|
|
uint8_t bDescriptorType; /* DT_HID (0x21) */
|
|
uint16_t bcdHID; /* HID class version number, in BCD */
|
|
uint8_t bCountryCode; /* Target country (usually 0) */
|
|
uint8_t bNumDescriptors; /* Number of HID class descriptors (usually 1) */
|
|
uint8_t bReportDescriptorType; /* Report descriptor type (usually 0x22) */
|
|
uint16_t wReportDescriptorLength; /* Length of the HID/PID report descriptor */
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
#define GRAINUUM_BUFFER_ELEMENT_SIZE 12 /* 1 PID, 8 data, 2 CRC16, 1 size */
|
|
/* grainuum_buffer is aligned such that its first byte is on a word boundary.
|
|
* This is because the first byte of every packet is a PID, which is
|
|
* immediately discarded. This leaves the remainder of the packet
|
|
* word-aligned.
|
|
*/
|
|
|
|
#define GRAINUUM_BUFFER(name, sz) \
|
|
struct { \
|
|
uint8_t head; \
|
|
uint8_t tail; \
|
|
uint8_t padding; \
|
|
union { \
|
|
uint8_t buffer[(sz) * GRAINUUM_BUFFER_ELEMENT_SIZE]; \
|
|
uint8_t elements[sz][GRAINUUM_BUFFER_ELEMENT_SIZE]; \
|
|
}; \
|
|
} name __attribute__((aligned(4))); \
|
|
uint8_t * name ## _head_ptr;
|
|
#define GRAINUUM_BUFFER_INIT(name) \
|
|
do { \
|
|
(name).head = 0; \
|
|
(name).tail = 0; \
|
|
name ## _head_ptr = (name).buffer; \
|
|
} while(0)
|
|
#define GRAINUUM_BUFFER_ADVANCE(name) \
|
|
do { \
|
|
(name).head += GRAINUUM_BUFFER_ELEMENT_SIZE; \
|
|
if ((name).head >= sizeof((name).buffer)) \
|
|
(name).head = 0; \
|
|
name ## _head_ptr = ((name).buffer + (name).head); \
|
|
} while(0)
|
|
#define GRAINUUM_BUFFER_TOP(name) \
|
|
(&((name).buffer[(name).tail]))
|
|
#define GRAINUUM_BUFFER_REMOVE(name) \
|
|
do { \
|
|
(name).tail += GRAINUUM_BUFFER_ELEMENT_SIZE; \
|
|
if ((name).tail >= sizeof((name).buffer)) \
|
|
(name).tail = 0; \
|
|
} while(0)
|
|
#define GRAINUUM_BUFFER_IS_EMPTY(name) \
|
|
((name).head == (name).tail)
|
|
#define GRAINUUM_BUFFER_ENTRY(name) \
|
|
name ## _head_ptr
|
|
|
|
/* Grainuum Structs */
|
|
|
|
struct GrainuumConfig {
|
|
get_usb_descriptor_t getDescriptor;
|
|
usb_set_config_num_t setConfigNum;
|
|
usb_get_buffer_t getReceiveBuffer;
|
|
usb_data_in_t receiveData;
|
|
usb_data_out_start_t sendDataStarted;
|
|
usb_data_out_finish_t sendDataFinished;
|
|
void *data;
|
|
struct GrainuumUSB *usb;
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct GrainuumState {
|
|
struct GrainuumUSB *usb;
|
|
|
|
const void *data_out; /* Pointer to the data that's being sent */
|
|
int32_t data_out_left; /* How much data has yet to be sent */
|
|
int32_t data_out_max; /* The maximum number of bytes to send */
|
|
int32_t data_out_epnum; /* Which endpoint the data is for */
|
|
|
|
struct usb_packet packet; /* Currently-queued packet */
|
|
int packet_queued; /* Whether a packet is queued */
|
|
|
|
uint32_t tok_pos; /* Position within the current token */
|
|
void *tok_buf; /* Buffer storing current token's data */
|
|
uint8_t tok_epnum; /* Last token's endpoint */
|
|
|
|
uint8_t data_buffer; /* Whether we're sending DATA0 or DATA1 */
|
|
uint8_t packet_type; /* PACKET_SETUP, PACKET_IN, or PACKET_OUT */
|
|
|
|
uint8_t address; /* Our configured address */
|
|
|
|
GRAINUUM_STATE_EXTRA
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
struct GrainuumUSB {
|
|
|
|
struct GrainuumConfig *cfg; /* Callbacks */
|
|
int initialized;
|
|
|
|
/* USB D- pin specification */
|
|
uint32_t usbdnIAddr;
|
|
uint32_t usbdnSAddr;
|
|
uint32_t usbdnCAddr;
|
|
uint32_t usbdnDAddr;
|
|
uint32_t usbdnShift;
|
|
|
|
/* USB D+ pin specification */
|
|
uint32_t usbdpIAddr;
|
|
uint32_t usbdpSAddr;
|
|
uint32_t usbdpCAddr;
|
|
uint32_t usbdpDAddr;
|
|
uint32_t usbdpShift;
|
|
|
|
uint32_t usbdnMask;
|
|
uint32_t usbdpMask;
|
|
|
|
uint32_t queued_size;
|
|
uint32_t queued_epnum;
|
|
const void *queued_data;
|
|
|
|
struct GrainuumState state; /* Associated state */
|
|
|
|
GRAINUUM_EXTRA
|
|
} __attribute__((packed, aligned(4)));
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
static inline void grainuumWritel(uint32_t value, uint32_t addr)
|
|
{
|
|
*((volatile uint32_t *)addr) = value;
|
|
}
|
|
|
|
static inline uint32_t grainuumReadl(uint32_t addr)
|
|
{
|
|
return *(volatile uint32_t *)addr;
|
|
}
|
|
|
|
/*===========================================================================*/
|
|
/* Weak hook functions. */
|
|
/*===========================================================================*/
|
|
|
|
/**
|
|
* @brief Called just before the USB device is plugged in.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @api
|
|
*/
|
|
void grainuumConnectPre(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Called just after the USB device is plugged in.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @api
|
|
*/
|
|
void grainuumConnectPost(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Called just before the USB device is unplugged.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @api
|
|
*/
|
|
void grainuumDisconnectPre(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Called just after the USB device is unplugged.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @api
|
|
*/
|
|
void grainuumDisconnectPost(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Called just before the USB device is first initialized.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @api
|
|
*/
|
|
void grainuumInitPre(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Called just before the USB device is first initialized.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @api
|
|
*/
|
|
void grainuumInitPost(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Called immediately after a packet has been received.
|
|
* @note This is called from an interrupt context. Data will
|
|
* be stored in the buffer that was passed to @p grainuumCaptureI()
|
|
* @param[in] usb pointer to the @p GrainuumUSB object
|
|
* @iclass
|
|
*/
|
|
void grainuumReceivePacket(struct GrainuumUSB *usb);
|
|
|
|
/*===========================================================================*/
|
|
/* External declarations. */
|
|
/*===========================================================================*/
|
|
|
|
/**
|
|
* @brief Returns nonzero if Grainuum has been initialized.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @return nonzero if @p GrainuumUSB is initialized.
|
|
* @retval 0 Object is not initilized.
|
|
* @api
|
|
*/
|
|
int grainuumInitialized(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Queues some data to be sent to the host.
|
|
* @note After the first 8 bytes, @p data must remain valid
|
|
* until the transfer has completed. This generally
|
|
* means you can send const data stored in the text
|
|
* section, or small 8-byte packets.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @param[in] epnum endpoint number of the transfer.
|
|
* @param[in] data pointer to the data being written.
|
|
* @param[in] size number of bytes being written.
|
|
* @return 0 if the transfer completed successfully.
|
|
* @retval 0 Transfer completed successfully.
|
|
* @api
|
|
*/
|
|
int grainuumSendData(struct GrainuumUSB *usb, int epnum, const void *data, int size);
|
|
|
|
/**
|
|
* @brief Clears the send buffer, if not empty.
|
|
* @note If data has already been queued for the PHY, then
|
|
* this will not prevent it from being sent.
|
|
* This function is intended to be used to prevent
|
|
* grainuumSendData() from returning -EAGAIN.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @api
|
|
*/
|
|
void grainuumDropData(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Determines if data is already queued.
|
|
* @note If data has been queued, then this will return
|
|
* nonzero. If this returns zero, then you can
|
|
* trust grainuumSendData() will succeed.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @return Nonzero if data is already queued.
|
|
* @api
|
|
*/
|
|
int grainuumDataQueued(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Process one received packet through the Grainuum state machine.
|
|
* @note This feeds USB packets into the state machine. It should not
|
|
* be called as part of an interrupt.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @param[in] packet The USB packet that was most recently received, with byte 12 holding the size.
|
|
* @api
|
|
*/
|
|
void grainuumProcess(struct GrainuumUSB *usb,
|
|
uint8_t pid,
|
|
const uint8_t packet[12],
|
|
uint32_t size);
|
|
|
|
/**
|
|
* @brief Initialize the Grainuum USB system.
|
|
* @note This is meant to run as part of an interrupt. Pass
|
|
* the storage buffer in as @p samples. The number
|
|
* of bytes that were read will be stored in the last
|
|
* byte of the array. For best performance, make
|
|
* sure that @p sample is on byte 3 of a 4-byte boundary,
|
|
* so that samples[1] is on a word boundary. The @p GrainuumUSB
|
|
* object will start out disconnected.
|
|
* @param[in] usb Pointer to the @p GrainuumUSB object to initialize.
|
|
* @param[in] link Pointer to the @p GrainuumConfig object to use.
|
|
* @api
|
|
*/
|
|
void grainuumInit(struct GrainuumUSB *usb, struct GrainuumConfig *link);
|
|
|
|
/**
|
|
* @brief Capture a USB packet from the wire.
|
|
* @note This is meant to run as part of an interrupt. Pass
|
|
* the storage buffer in as @p samples. The number
|
|
* of bytes that were read will be stored in the last
|
|
* byte of the array. For best performance, make
|
|
* sure that @p sample is on byte 3 of a 4-byte boundary,
|
|
* so that samples[1] is on a word boundary.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @param[in] packet Buffer to store the read samples.
|
|
* @api
|
|
*/
|
|
int grainuumCaptureI(struct GrainuumUSB *usb, uint8_t samples[67]);
|
|
|
|
/**
|
|
* @brief Internal function. Queues 8 bytes to be sent by the phy.
|
|
* @note This is an internal function, and is not meant to be called.
|
|
* It is meant to queue properly-formatted USB packets complete
|
|
* with CRC-16 (if required).
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @param[in] epnum The endpoint number to queue data for.
|
|
* @param[in] buffer The data to queue.
|
|
* @param[in] size The number of bytes that are queued.
|
|
* @notapi
|
|
*/
|
|
void grainuumWriteQueue(struct GrainuumUSB *usb, int epnum,
|
|
const void *buffer, int size);
|
|
|
|
/**
|
|
* @brief Simulates plugging the device into USB.
|
|
* @note All USB Connect hooks will be called.
|
|
* The default USB state is "disconnected",
|
|
* so @p grainuumConnect() must be called
|
|
* to start communications.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @api
|
|
*/
|
|
void grainuumConnect(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Simulates unplugging the device from USB.
|
|
* @note All USB Disconnect hooks will be called.
|
|
* @param[in] usb pointer to the @p GrainuumUSB object.
|
|
* @api
|
|
*/
|
|
void grainuumDisconnect(struct GrainuumUSB *usb);
|
|
|
|
/**
|
|
* @brief Reads one packet from the wire.
|
|
* @note This must be called from an interrupt context with
|
|
* interrupts disabled.
|
|
* @param[in] usb Pointer to the @p GrainuumUSB object.
|
|
* @param[out] samples Buffer where the samples will be stored.
|
|
* @return The number of bytes read, or negative on error
|
|
* @retval -1 Timeout while reading.
|
|
* @retval -2 Read too many bits.
|
|
* @retval -3 Unable to find sync end.
|
|
* @retval -4 Probably a keepalive packet.
|
|
* @notapi
|
|
*/
|
|
int usbPhyReadI(const struct GrainuumUSB *usb, uint8_t samples[11]);
|
|
|
|
/**
|
|
* @brief Writes one packet from the wire.
|
|
* @note This must be called from an interrupt context with
|
|
* interrupts disabled.
|
|
* @param[in] usb Pointer to the @p GrainuumUSB object.
|
|
* @param[in] samples Buffer where the samples will be stored.
|
|
* @param[in] size Number of bytes to write.
|
|
* @notapi
|
|
*/
|
|
void usbPhyWriteI(const struct GrainuumUSB *usb, const void *buffer, uint32_t size);
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|
|
|
|
#endif /* _GRAINUUM_H */
|