576 lines
19 KiB
C
576 lines
19 KiB
C
#include <grainuum.h>
|
|
#include <usb.h>
|
|
#include <irq.h>
|
|
#include <generated/csr.h>
|
|
#include <string.h>
|
|
#include <printf.h>
|
|
#include <uart.h>
|
|
|
|
#ifdef CSR_USB_EP_0_OUT_EV_PENDING_ADDR
|
|
|
|
#define NUM_BUFFERS 4
|
|
#define BUFFER_SIZE 64
|
|
#define EP_INTERVAL_MS 6
|
|
|
|
//static struct GrainuumUSB usb;
|
|
//static uint8_t usb_buf[67];
|
|
static const uint8_t hid_report_descriptor[] = {
|
|
0x06, 0x00, 0xFF, // (GLOBAL) USAGE_PAGE 0xFF00 Vendor-defined
|
|
0x09, 0x00, // (LOCAL) USAGE 0xFF000000
|
|
0xA1, 0x01, // (MAIN) COLLECTION 0x01 Application (Usage=0xFF000000: Page=Vendor-defined, Usage=, Type=)
|
|
0x26, 0xFF, 0x00, // (GLOBAL) LOGICAL_MAXIMUM 0x00FF (255)
|
|
0x75, 0x08, // (GLOBAL) REPORT_SIZE 0x08 (8) Number of bits per field
|
|
0x95, 0x08, // (GLOBAL) REPORT_COUNT 0x08 (8) Number of fields
|
|
0x06, 0xFF, 0xFF, // (GLOBAL) USAGE_PAGE 0xFFFF Vendor-defined
|
|
0x09, 0x01, // (LOCAL) USAGE 0xFFFF0001
|
|
0x81, 0x02, // (MAIN) INPUT 0x00000002 (8 fields x 8 bits) 0=Data 1=Variable 0=Absolute 0=NoWrap 0=Linear 0=PrefState 0=NoNull 0=NonVolatile 0=Bitmap
|
|
0x09, 0x01, // (LOCAL) USAGE 0xFFFF0001
|
|
0x91, 0x02, // (MAIN) OUTPUT 0x00000002 (8 fields x 8 bits) 0=Data 1=Variable 0=Absolute 0=NoWrap 0=Linear 0=PrefState 0=NoNull 0=NonVolatile 0=Bitmap
|
|
0xC0, // (MAIN) END_COLLECTION Application
|
|
};
|
|
|
|
static const struct usb_device_descriptor device_descriptor = {
|
|
.bLength = 18, //sizeof(struct usb_device_descriptor),
|
|
.bDescriptorType = DT_DEVICE, /* DEVICE */
|
|
.bcdUSB = 0x0200, /* USB 2.0 */
|
|
.bDeviceClass = 0x00,
|
|
.bDeviceSubClass = 0x00,
|
|
.bDeviceProtocol = 0x00,
|
|
.bMaxPacketSize0 = 0x08, /* 8-byte packets max */
|
|
.idVendor = 0x1209,
|
|
.idProduct = 0x9317,
|
|
.bcdDevice = 0x0114, /* Device release 1.14 */
|
|
.iManufacturer = 0x02, /* No manufacturer string */
|
|
.iProduct = 0x01, /* Product name in string #2 */
|
|
.iSerialNumber = 0x03, /* No serial number */
|
|
.bNumConfigurations = 0x01,
|
|
};
|
|
|
|
static const struct usb_configuration_descriptor configuration_descriptor = {
|
|
.bLength = 9, //sizeof(struct usb_configuration_descriptor),
|
|
.bDescriptorType = DT_CONFIGURATION,
|
|
.wTotalLength = (9 + /*9 + 9 + 7 +*/ 9 + 9 + 7 + 7) /*
|
|
(sizeof(struct usb_configuration_descriptor)
|
|
+ sizeof(struct usb_interface_descriptor)
|
|
+ sizeof(struct usb_hid_descriptor)
|
|
+ sizeof(struct usb_endpoint_descriptor)*/,
|
|
.bNumInterfaces = 1,
|
|
.bConfigurationValue = 1,
|
|
.iConfiguration = 5,
|
|
.bmAttributes = 0x80, /* Remote wakeup not supported */
|
|
.bMaxPower = 100 / 2, /* 100 mA (in 2-mA units) */
|
|
.data = {
|
|
/* struct usb_interface_descriptor { */
|
|
/* uint8_t bLength; */ 9,
|
|
/* uint8_t bDescriptorType; */ DT_INTERFACE,
|
|
/* uint8_t bInterfaceNumber; */ 0,
|
|
/* uint8_t bAlternateSetting; */ 0,
|
|
/* uint8_t bNumEndpoints; */ 2, /* Two extra EPs */
|
|
/* uint8_t bInterfaceClass; */ 3, /* HID class */
|
|
/* uint8_t bInterfaceSubclass; */ 0, /* Boot Device subclass */
|
|
/* uint8_t bInterfaceProtocol; */ 0, /* 1 == keyboard, 2 == mouse */
|
|
/* uint8_t iInterface; */ 4, /* String index #4 */
|
|
/* }*/
|
|
|
|
/* struct usb_hid_descriptor { */
|
|
/* uint8_t bLength; */ 9,
|
|
/* uint8_t bDescriptorType; */ DT_HID,
|
|
/* uint16_t bcdHID; */ 0x11, 0x01,
|
|
/* uint8_t bCountryCode; */ 0,
|
|
/* uint8_t bNumDescriptors; */ 1, /* We have only one REPORT */
|
|
/* uint8_t bReportDescriptorType; */ DT_HID_REPORT,
|
|
/* uint16_t wReportDescriptorLength; */ sizeof(hid_report_descriptor),
|
|
sizeof(hid_report_descriptor) >> 8,
|
|
/* } */
|
|
|
|
/* struct usb_endpoint_descriptor { */
|
|
/* uint8_t bLength; */ 7,
|
|
/* uint8_t bDescriptorType; */ DT_ENDPOINT,
|
|
/* uint8_t bEndpointAddress; */ 0x81, /* EP1 (IN) */
|
|
/* uint8_t bmAttributes; */ 3, /* Interrupt */
|
|
/* uint16_t wMaxPacketSize; */ 0x08, 0x00,
|
|
/* uint8_t bInterval; */ EP_INTERVAL_MS, /* Every 6 ms */
|
|
/* } */
|
|
|
|
/* struct usb_endpoint_descriptor { */
|
|
/* uint8_t bLength; */ 7,
|
|
/* uint8_t bDescriptorType; */ DT_ENDPOINT,
|
|
/* uint8_t bEndpointAddress; */ 0x01, /* EP1 (OUT) */
|
|
/* uint8_t bmAttributes; */ 3, /* Interrupt */
|
|
/* uint16_t wMaxPacketSize; */ 0x08, 0x00,
|
|
/* uint8_t bInterval; */ EP_INTERVAL_MS, /* Every 6 ms */
|
|
/* } */
|
|
},
|
|
};
|
|
|
|
enum epfifo_response {
|
|
EPF_ACK = 0,
|
|
EPF_NAK = 1,
|
|
EPF_NONE = 2,
|
|
EPF_STALL = 3,
|
|
};
|
|
|
|
#define USB_EV_ERROR 1
|
|
#define USB_EV_PACKET 2
|
|
|
|
void usb_connect(void) {
|
|
usb_pullup_out_write(1);
|
|
|
|
// By default, it wants to respond with NAK.
|
|
usb_ep_0_out_respond_write(EPF_ACK);
|
|
usb_ep_0_in_respond_write(EPF_NAK);
|
|
|
|
usb_ep_0_out_ev_pending_write(usb_ep_0_out_ev_enable_read());
|
|
usb_ep_0_in_ev_pending_write(usb_ep_0_in_ev_pending_read());
|
|
usb_ep_0_out_ev_enable_write(USB_EV_PACKET | USB_EV_ERROR);
|
|
usb_ep_0_in_ev_enable_write(USB_EV_PACKET | USB_EV_ERROR);
|
|
|
|
irq_setmask(irq_getmask() | (1 << USB_INTERRUPT));
|
|
}
|
|
|
|
void usb_init(void) {
|
|
return;
|
|
}
|
|
|
|
volatile int irq_count = 0;
|
|
|
|
#define EP0OUT_BUFFERS 64
|
|
static uint8_t usb_ep0out_buffer[EP0OUT_BUFFERS][128];
|
|
uint8_t usb_ep0out_wr_ptr;
|
|
uint8_t usb_ep0out_rd_ptr;
|
|
int descriptor_ptr;
|
|
int max_byte_length = 8;
|
|
|
|
static const uint8_t *current_data;
|
|
static int current_length;
|
|
static int current_offset;
|
|
static int current_to_send;
|
|
|
|
static int maybe_send_more_data(int epnum) {
|
|
(void)epnum;
|
|
// Don't allow requeueing
|
|
if (usb_ep_0_in_respond_read() != EPF_NAK)
|
|
return -1;
|
|
// if (!usb_ep_0_in_ibuf_empty_read())
|
|
// return -2;
|
|
|
|
int this_offset;
|
|
current_to_send = current_length - current_offset;
|
|
if (current_to_send > max_byte_length)
|
|
current_to_send = max_byte_length;
|
|
|
|
for (this_offset = current_offset; this_offset < current_offset + current_to_send; this_offset++) {
|
|
usb_ep_0_in_ibuf_head_write(current_data[this_offset]);
|
|
}
|
|
usb_ep_0_in_respond_write(EPF_ACK);
|
|
return 0;
|
|
}
|
|
|
|
static int send_data(int epnum, const void *data, int total_count) {
|
|
// Don't allow requeueing
|
|
if (usb_ep_0_in_respond_read() != EPF_NAK)
|
|
return -1;
|
|
current_data = (uint8_t *)data;
|
|
current_length = total_count;
|
|
current_offset = 0;
|
|
maybe_send_more_data(epnum);
|
|
return 0;
|
|
}
|
|
|
|
void usb_isr(void) {
|
|
irq_count++;
|
|
|
|
uint8_t ep0o_pending = usb_ep_0_out_ev_pending_read();
|
|
uint8_t ep0i_pending = usb_ep_0_in_ev_pending_read();
|
|
|
|
if (ep0o_pending) {
|
|
int byte_count = 0;
|
|
uint8_t *obuf = usb_ep0out_buffer[usb_ep0out_wr_ptr];
|
|
while (1) {
|
|
if (usb_ep_0_out_obuf_empty_read())
|
|
break;
|
|
obuf[++byte_count] = usb_ep_0_out_obuf_head_read();
|
|
usb_ep_0_out_obuf_head_write(0);
|
|
}
|
|
usb_ep_0_out_ev_pending_write(ep0o_pending);
|
|
|
|
if (byte_count) {
|
|
obuf[0] = byte_count;
|
|
usb_ep0out_wr_ptr = (usb_ep0out_wr_ptr + 1) & (EP0OUT_BUFFERS-1);
|
|
|
|
// usb_ep_0_in_dtb_write(1);
|
|
send_data(0, &device_descriptor, sizeof(device_descriptor));
|
|
}
|
|
else {
|
|
usb_ep_0_out_respond_write(EPF_ACK);
|
|
}
|
|
}
|
|
|
|
if (ep0i_pending) {
|
|
/*
|
|
uint8_t *descriptor = (uint8_t *)&device_descriptor;
|
|
if (descriptor_ptr < 0) {
|
|
usb_ep_0_in_respond_write(EPF_NAK);
|
|
}
|
|
else if (descriptor_ptr >= sizeof(device_descriptor)) {
|
|
descriptor_ptr = -1;
|
|
usb_ep_0_in_respond_write(EPF_ACK);
|
|
}
|
|
else {
|
|
usb_ep_0_in_respond_write(EPF_NAK);
|
|
for (descriptor_ptr; descriptor_ptr < sizeof(device_descriptor); descriptor_ptr++) {
|
|
usb_ep_0_in_ibuf_head_write(descriptor[descriptor_ptr]);
|
|
}
|
|
usb_ep_0_in_respond_write(EPF_ACK);
|
|
}
|
|
*/
|
|
usb_ep_0_in_respond_write(EPF_NAK);
|
|
current_offset += current_to_send;
|
|
maybe_send_more_data(0);
|
|
usb_ep_0_in_ev_pending_write(ep0i_pending);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void usb_wait(void) {
|
|
while (!irq_count)
|
|
;
|
|
}
|
|
|
|
int usb_irq_happened(void) {
|
|
return irq_count;
|
|
}
|
|
|
|
static const char hex[] = "0123456789abcdef";
|
|
void usb_print_status(void) {
|
|
/*
|
|
printf("EP0_OUT Status: %02x\n", usb_ep_0_out_ev_status_read());
|
|
printf("EP0_OUT Pending: %02x\n", usb_ep_0_out_ev_pending_read());
|
|
printf("EP0_OUT Enable: %02x\n", usb_ep_0_out_ev_enable_read());
|
|
printf("EP0_OUT Last Tok: %02x\n", usb_ep_0_out_last_tok_read());
|
|
printf("EP0_OUT Respond: %02x\n", usb_ep_0_out_respond_read());
|
|
printf("EP0_OUT DTB: %02x\n", usb_ep_0_out_dtb_read());
|
|
printf("EP0_OUT OBUF Head: %02x\n", usb_ep_0_out_obuf_head_read());
|
|
printf("EP0_OUT OBUF Empty: %02x\n", usb_ep_0_out_obuf_empty_read());
|
|
printf("EP0_IN Status: %02x\n", usb_ep_0_in_ev_status_read());
|
|
printf("EP0_IN Pending: %02x\n", usb_ep_0_in_ev_pending_read());
|
|
printf("EP0_IN Enable: %02x\n", usb_ep_0_in_ev_enable_read());
|
|
printf("EP0_IN Last Tok: %02x\n", usb_ep_0_in_last_tok_read());
|
|
printf("EP0_IN Respond: %02x\n", usb_ep_0_in_respond_read());
|
|
printf("EP0_IN DTB: %02x\n", usb_ep_0_in_dtb_read());
|
|
printf("EP0_IN IBUF Head: %02x\n", usb_ep_0_in_ibuf_head_read());
|
|
printf("EP0_IN IBUF Empty: %02x\n", usb_ep_0_in_ibuf_empty_read());
|
|
*/
|
|
while (usb_ep0out_rd_ptr != usb_ep0out_wr_ptr) {
|
|
// printf("for (this_offset = current_offset; this_offset < this_offset + current_to_send; this_offset++) {\n");
|
|
// printf("for (this_offset = %d; this_offset < %d; %d++) {\n", current_offset, this_offset, this_offset + current_to_send, this_offset);
|
|
printf("current_data: 0x%08x\n", current_data);
|
|
printf("current_length: %d\n", current_length);
|
|
printf("current_offset: %d\n", current_offset);
|
|
printf("current_to_send: %d\n", current_to_send);
|
|
uint8_t *obuf = usb_ep0out_buffer[usb_ep0out_rd_ptr];
|
|
uint8_t cnt = obuf[0];
|
|
unsigned int i;
|
|
if (cnt) {
|
|
for (i = 0; i < cnt; i++) {
|
|
uart_write(' ');
|
|
uart_write(hex[(obuf[i+1] >> 4) & 0xf]);
|
|
uart_write(hex[obuf[i+1] & (0xf)]);
|
|
// printf(" %02x", obufbuf[i]);
|
|
}
|
|
uart_write('\r');
|
|
uart_write('\n');
|
|
}
|
|
// printf("\n");
|
|
usb_ep0out_rd_ptr = (usb_ep0out_rd_ptr + 1) & (EP0OUT_BUFFERS-1);
|
|
}
|
|
}
|
|
|
|
|
|
// static inline unsigned char usb_pullup_out_read(void);
|
|
// static inline void usb_pullup_out_write(unsigned char value);
|
|
|
|
|
|
// static inline unsigned char usb_ep_0_out_ev_status_read(void);
|
|
// static inline void usb_ep_0_out_ev_status_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_out_ev_pending_read(void);
|
|
// static inline void usb_ep_0_out_ev_pending_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_out_ev_enable_read(void);
|
|
// static inline void usb_ep_0_out_ev_enable_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_out_last_tok_read(void);
|
|
|
|
// static inline unsigned char usb_ep_0_out_respond_read(void);
|
|
// static inline void usb_ep_0_out_respond_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_out_dtb_read(void);
|
|
// static inline void usb_ep_0_out_dtb_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_out_obuf_head_read(void);
|
|
// static inline void usb_ep_0_out_obuf_head_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_out_obuf_empty_read(void);
|
|
|
|
|
|
// static inline unsigned char usb_ep_0_in_ev_status_read(void);
|
|
// static inline void usb_ep_0_in_ev_status_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_in_ev_pending_read(void);
|
|
// static inline void usb_ep_0_in_ev_pending_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_in_ev_enable_read(void);
|
|
// static inline void usb_ep_0_in_ev_enable_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_in_last_tok_read(void);
|
|
|
|
// static inline unsigned char usb_ep_0_in_respond_read(void);
|
|
// static inline void usb_ep_0_in_respond_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_in_dtb_read(void);
|
|
// static inline void usb_ep_0_in_dtb_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_in_ibuf_head_read(void);
|
|
// static inline void usb_ep_0_in_ibuf_head_write(unsigned char value);
|
|
|
|
// static inline unsigned char usb_ep_0_in_ibuf_empty_read(void);
|
|
|
|
|
|
#if 0
|
|
static uint32_t rx_buffer[NUM_BUFFERS][BUFFER_SIZE / sizeof(uint32_t)];
|
|
static uint8_t rx_buffer_head;
|
|
static uint8_t rx_buffer_tail;
|
|
|
|
static uint32_t rx_buffer_queries = 0;
|
|
static void set_usb_config_num(struct GrainuumUSB *usb, int configNum)
|
|
{
|
|
(void)usb;
|
|
(void)configNum;
|
|
;
|
|
}
|
|
|
|
|
|
#define USB_STR_BUF_LEN 64
|
|
|
|
static uint32_t str_buf_storage[USB_STR_BUF_LEN / sizeof(uint32_t)];
|
|
static int send_string_descriptor(const char *str, const void **data)
|
|
{
|
|
int len;
|
|
int max_len;
|
|
uint8_t *str_buf = (uint8_t *)str_buf_storage;
|
|
uint8_t *str_offset = str_buf;
|
|
|
|
len = strlen(str);
|
|
max_len = (USB_STR_BUF_LEN / 2) - 2;
|
|
|
|
if (len > max_len)
|
|
len = max_len;
|
|
|
|
*str_offset++ = (len * 2) + 2; // Two bytes for length count
|
|
*str_offset++ = DT_STRING; // Sending a string descriptor
|
|
|
|
while (len--)
|
|
{
|
|
*str_offset++ = *str++;
|
|
*str_offset++ = 0;
|
|
}
|
|
|
|
*data = str_buf;
|
|
|
|
// Return the size, which is stored in the first byte of the output data.
|
|
return str_buf[0];
|
|
}
|
|
|
|
static int get_string_descriptor(struct GrainuumUSB *usb,
|
|
uint32_t num,
|
|
const void **data)
|
|
{
|
|
|
|
static const uint8_t en_us[] = {0x04, DT_STRING, 0x09, 0x04};
|
|
|
|
(void)usb;
|
|
|
|
if (num == 0)
|
|
{
|
|
*data = en_us;
|
|
return sizeof(en_us);
|
|
}
|
|
|
|
// Product
|
|
if (num == 1)
|
|
return send_string_descriptor("Palawan Bootloader", data);
|
|
|
|
if (num == 2)
|
|
return send_string_descriptor("21", data);
|
|
|
|
if (num == 3)
|
|
return send_string_descriptor("1236", data);
|
|
|
|
if (num == 4)
|
|
return send_string_descriptor("12345", data);
|
|
|
|
if (num == 5)
|
|
return send_string_descriptor("54", data);
|
|
|
|
if (num == 6)
|
|
return send_string_descriptor("12345678901234", data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int get_device_descriptor(struct GrainuumUSB *usb,
|
|
uint32_t num,
|
|
const void **data)
|
|
{
|
|
|
|
(void)usb;
|
|
|
|
if (num == 0)
|
|
{
|
|
*data = &device_descriptor;
|
|
return sizeof(device_descriptor);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int get_hid_report_descriptor(struct GrainuumUSB *usb,
|
|
uint32_t num,
|
|
const void **data)
|
|
{
|
|
|
|
(void)usb;
|
|
|
|
if (num == 0)
|
|
{
|
|
*data = &hid_report_descriptor;
|
|
return sizeof(hid_report_descriptor);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int get_configuration_descriptor(struct GrainuumUSB *usb,
|
|
uint32_t num,
|
|
const void **data)
|
|
{
|
|
|
|
(void)usb;
|
|
|
|
if (num == 0)
|
|
{
|
|
*data = &configuration_descriptor;
|
|
return configuration_descriptor.wTotalLength;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int get_descriptor(struct GrainuumUSB *usb,
|
|
const void *packet,
|
|
const void **response)
|
|
{
|
|
|
|
const struct usb_setup_packet *setup = packet;
|
|
printf("In get_Descriptor()\n");
|
|
switch (setup->wValueH)
|
|
{
|
|
case DT_DEVICE:
|
|
printf("Returning device descriptor %d\n", setup->wValueL);
|
|
return get_device_descriptor(usb, setup->wValueL, response);
|
|
|
|
case DT_STRING:
|
|
printf("Returning string descriptor %d\n", setup->wValueL);
|
|
return get_string_descriptor(usb, setup->wValueL, response);
|
|
|
|
case DT_CONFIGURATION:
|
|
printf("Returning configuration descriptor %d\n", setup->wValueL);
|
|
return get_configuration_descriptor(usb, setup->wValueL, response);
|
|
|
|
case DT_HID_REPORT:
|
|
printf("Returning HID descriptor %d\n", setup->wValueL);
|
|
return get_hid_report_descriptor(usb, setup->wValueL, response);
|
|
}
|
|
|
|
printf("Returning no descriptor %d\n", setup->wValueL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void *get_usb_rx_buffer(struct GrainuumUSB *usb,
|
|
uint8_t epNum,
|
|
int32_t *size)
|
|
{
|
|
(void)usb;
|
|
(void)epNum;
|
|
|
|
if (size)
|
|
*size = sizeof(rx_buffer[0]);
|
|
rx_buffer_queries++;
|
|
return rx_buffer[rx_buffer_head];
|
|
}
|
|
|
|
static int received_data(struct GrainuumUSB *usb,
|
|
uint8_t epNum,
|
|
uint32_t bytes,
|
|
const void *data)
|
|
{
|
|
(void)usb;
|
|
(void)epNum;
|
|
(void)bytes;
|
|
(void)data;
|
|
|
|
if (epNum == 1)
|
|
{
|
|
rx_buffer_head = (rx_buffer_head + 1) & (NUM_BUFFERS - 1);
|
|
}
|
|
|
|
/* Return 0, indicating this packet is complete. */
|
|
return 0;
|
|
}
|
|
|
|
static int send_data_finished(struct GrainuumUSB *usb, int result)
|
|
{
|
|
(void)usb;
|
|
(void)result;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct GrainuumConfig cfg = {
|
|
.getDescriptor = get_descriptor,
|
|
.getReceiveBuffer = get_usb_rx_buffer,
|
|
.receiveData = received_data,
|
|
.sendDataFinished = send_data_finished,
|
|
.setConfigNum = set_usb_config_num,
|
|
};
|
|
|
|
// void usb_isr(void) {
|
|
// // grainuumCaptureI(&usb, usb_buf);
|
|
// return;
|
|
// }
|
|
|
|
// void usb_init(void) {
|
|
// // grainuumInit(&usb, &cfg);
|
|
// // grainuumConnect(&usb);
|
|
// return;
|
|
// }
|
|
|
|
void usbPhyWriteI(const struct GrainuumUSB *usb, const void *buffer, uint32_t size) {
|
|
// (void)usb;
|
|
// const uint8_t *ubuffer = (const uint8_t *)buffer;
|
|
// uint32_t i = 0;
|
|
// while (i < size)
|
|
// usb_obuf_head_write(ubuffer[i]);
|
|
}
|
|
|
|
int usbPhyReadI(const struct GrainuumUSB *usb, uint8_t *samples) {
|
|
(void)usb;
|
|
int count = 0;
|
|
// while (!usb_ibuf_empty_read()) {
|
|
// samples[count++] = usb_ibuf_head_read();
|
|
// }
|
|
return count;
|
|
}
|
|
#endif
|
|
#endif /* CSR_USB_EP_0_OUT_EV_PENDING_ADDR */ |