A realtime `lf read` streams samples straight to the host at the LF sample rate, around 125 kB/s. If the host stopped draining for even a moment, async_usb_write_requestWrite() returned false, and ReadLF_realtime() treated that as fatal: it returned PM3_EIO through a goto that also skipped async_usb_write_stop(). The IN endpoint was left busy, every later usb_write() then returned PM3_EIO, and the device went silent until it was physically replugged. A USB bus reset does not clear it -- EP0 keeps working, descriptors read fine, only bulk IN is dead. That is what a long `lf read` looked like from the client: a transfer that stopped early, and then a device that would not answer the next command. A busy endpoint is back pressure, not an error. The sampling loop now waits for the host, up to 100ms, and only gives up if it never comes back. Every exit path closes the async write. The spins inside the USB helpers are bounded and drop the stuck packet instead of turning into an infinite loop, which is the other half of why the device never recovered. Measured against a reader deliberately held at 41 kB/s: before, the stream died at 212238 of 300000 bytes and the unit needed a replug; after, 300000 of 300000 and it still answers. The last packet of a stream was being lost as well. The host's CDC read buffer is two max sized packets, and a bulk IN transfer only completes on a short packet or a full buffer, so a stream ending on a full 64 byte packet was left sitting in a half filled buffer. It showed as exact parity on the packet count: 513 packets requested -> 512 delivered 514 -> 514 515 packets requested -> 514 delivered 516 -> 516 async_usb_write_stop() now always sends a closing packet, the leftover partial bytes when there are any and a zero length packet otherwise, the same way usb_write() already did for its own transfers. On the client side a short transfer is reported instead of being presented as a complete read, the device is told to stop streaming on that path too, and the in place byte counter is repeated with its final value, since the loop only samples it every 10ms and the last line printed was stale. Lastly `lf read` and `lf sniff` cap the sample count to the graph buffer size. Anything past it was streamed and then discarded by getSamplesFromBufEx(), so `-s 1500000` spent about two extra seconds collecting 220000 samples that were thrown away, and printed "Received 1500000 / 1500000 bytes" followed by "Got 1280000 samples" with nothing to explain the gap. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
997 lines
34 KiB
C
997 lines
34 KiB
C
//-----------------------------------------------------------------------------
|
||
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
|
||
//
|
||
// This program is free software: you can redistribute it and/or modify
|
||
// it under the terms of the GNU General Public License as published by
|
||
// the Free Software Foundation, either version 3 of the License, or
|
||
// (at your option) any later version.
|
||
//
|
||
// This program is distributed in the hope that it will be useful,
|
||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
// GNU General Public License for more details.
|
||
//
|
||
// See LICENSE.txt for the text of the license.
|
||
//-----------------------------------------------------------------------------
|
||
// at91sam7s USB CDC device implementation
|
||
// based on the "Basic USB Example" from ATMEL (doc6123.pdf)
|
||
//-----------------------------------------------------------------------------
|
||
|
||
#include "usb_cdc_apis.h"
|
||
#include "at91sam7s512.h"
|
||
#include "proxmark3_arm.h"
|
||
#include "usart_defs.h"
|
||
#include "ticks_apis.h"
|
||
#include "wdt_apis.h"
|
||
#include "usb_read_ng.h"
|
||
#include "usb_cdc_desc.h"
|
||
|
||
/*
|
||
AT91SAM7S256 USB Device Port
|
||
• Embedded 328-byte dual-port RAM for endpoints
|
||
• Four endpoints
|
||
– Endpoint 0: 8 bytes
|
||
– Endpoint 1 and 2: 64 bytes ping-pong
|
||
– Endpoint 3: 64 bytes
|
||
– Ping-pong Mode (two memory banks) for bulk endpoints
|
||
*/
|
||
|
||
// EP for CDC definition
|
||
#define AT91C_EP_CONTROL 0
|
||
#define AT91C_EP_OUT 1 // cfg bulk out - 0x01
|
||
#define AT91C_EP_IN 2 // cfg bulk in - 0x82
|
||
#define AT91C_EP_NOTIFY 3 // cfg cdc notification interrup - 0x83
|
||
|
||
// The definition of endpoint size has been moved back from the original file to this source file.
|
||
// Because the usb_cdc.h header file is now a universally defined header file.
|
||
#define AT91C_USB_EP_CONTROL_SIZE 8
|
||
#define AT91C_USB_EP_OUT_SIZE 64
|
||
#define AT91C_USB_EP_IN_SIZE 64
|
||
|
||
/* WCID specific Request Code */
|
||
/* MS_OS_DESCRIPTOR_INDEX, MS_EXTENDED_COMPAT_ID, MS_EXTENDED_PROPERTIES and
|
||
the MS_WCID_* request types come from usb_cdc_desc.h */
|
||
#define MS_VENDOR_CODE USB_CDC_DESC_MS_VENDOR_CODE
|
||
|
||
/* USB standard request code */
|
||
#define STD_GET_STATUS_ZERO 0x0080
|
||
#define STD_GET_STATUS_INTERFACE 0x0081
|
||
#define STD_GET_STATUS_ENDPOINT 0x0082
|
||
|
||
#define STD_CLEAR_FEATURE_ZERO 0x0100
|
||
#define STD_CLEAR_FEATURE_INTERFACE 0x0101
|
||
#define STD_CLEAR_FEATURE_ENDPOINT 0x0102
|
||
|
||
#define STD_SET_FEATURE_ZERO 0x0300
|
||
#define STD_SET_FEATURE_INTERFACE 0x0301
|
||
#define STD_SET_FEATURE_ENDPOINT 0x0302
|
||
|
||
#define STD_SET_ADDRESS 0x0500
|
||
#define STD_GET_DESCRIPTOR 0x0680
|
||
#define STD_SET_DESCRIPTOR 0x0700
|
||
#define STD_GET_CONFIGURATION 0x0880
|
||
#define STD_SET_CONFIGURATION 0x0900
|
||
#define STD_GET_INTERFACE 0x0A81
|
||
#define STD_SET_INTERFACE 0x0B01
|
||
#define STD_SYNCH_FRAME 0x0C82
|
||
|
||
/* CDC Class Specific Request Code */
|
||
#define GET_LINE_CODING 0x21A1
|
||
#define SET_LINE_CODING 0x2021
|
||
#define SET_CONTROL_LINE_STATE 0x2221
|
||
|
||
// !!!! NOTE: If we need inline a function, then don't set the variables to static.
|
||
|
||
bool isAsyncRequestFinished = false;
|
||
AT91PS_UDP pUdp = AT91C_BASE_UDP;
|
||
|
||
static uint8_t btConfiguration = 0;
|
||
static uint8_t btConnection = 0;
|
||
static uint8_t btReceiveBank = AT91C_UDP_RX_DATA_BK0;
|
||
|
||
// -- pre def functions
|
||
void AT91F_USB_SendData(AT91PS_UDP pudp, const char *pData, uint32_t length, uint32_t wLength);
|
||
void AT91F_USB_SendZlp(AT91PS_UDP pudp);
|
||
void AT91F_USB_SendStall(AT91PS_UDP pudp);
|
||
void AT91F_CDC_Enumerate(void);
|
||
// --
|
||
void SetUSBreconnect(int value);
|
||
int GetUSBreconnect(void);
|
||
void SetUSBconfigured(int value);
|
||
int GetUSBconfigured(void);
|
||
|
||
static const char *getStringDescriptor(uint8_t idx) {
|
||
switch (idx) {
|
||
case 0:
|
||
return StrLanguageCodes;
|
||
case 1:
|
||
return StrManufacturer;
|
||
case 2:
|
||
return StrProduct;
|
||
case 3:
|
||
return StrSerialNumber;
|
||
case MS_OS_DESCRIPTOR_INDEX:
|
||
return StrMS_OSDescriptor;
|
||
default:
|
||
return (NULL);
|
||
}
|
||
}
|
||
|
||
// Bitmap for all status bits in CSR which must be written as 1 to cause no effect
|
||
#define REG_NO_EFFECT_1_ALL AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 \
|
||
|AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP \
|
||
|AT91C_UDP_TXCOMP
|
||
|
||
// Clear flags in the UDP_CSR register and waits for synchronization
|
||
#define UDP_CLEAR_EP_FLAGS(endpoint, flags) { \
|
||
volatile unsigned int reg; \
|
||
reg = pUdp->UDP_CSR[(endpoint)]; \
|
||
reg |= REG_NO_EFFECT_1_ALL; \
|
||
reg &= ~(flags); \
|
||
pUdp->UDP_CSR[(endpoint)] = reg; \
|
||
}
|
||
|
||
// reset flags in the UDP_CSR register and waits for synchronization
|
||
#define UDP_SET_EP_FLAGS(endpoint, flags) { \
|
||
volatile unsigned int reg; \
|
||
reg = pUdp->UDP_CSR[(endpoint)]; \
|
||
reg |= REG_NO_EFFECT_1_ALL; \
|
||
reg |= (flags); \
|
||
pUdp->UDP_CSR[(endpoint)] = reg; \
|
||
}
|
||
|
||
|
||
// CDC LineCoding is 7 bytes on the wire, so this must not pick up the padding
|
||
// byte that natural alignment would add after DataBits.
|
||
typedef struct {
|
||
uint32_t BitRate;
|
||
uint8_t Format;
|
||
uint8_t ParityType;
|
||
uint8_t DataBits;
|
||
} PACKED AT91S_CDC_LINE_CODING, *AT91PS_CDC_LINE_CODING;
|
||
|
||
static AT91S_CDC_LINE_CODING line = { // purely informative, actual values don't matter
|
||
USART_BAUD_RATE, // baudrate
|
||
0, // 1 Stop Bit
|
||
0, // None Parity
|
||
8 // 8 Data bits
|
||
};
|
||
|
||
#ifndef AS_BOOTROM
|
||
|
||
// buffer of read_ng apis.
|
||
static uint8_t usb_read_ng_buffer[64] = {0};
|
||
|
||
// Implemented for read_ng
|
||
static bool usb_read_ng_link_ready(void) {
|
||
// old: if (usb_check() == false)
|
||
return usb_check(); // reuse 'usb_check()'
|
||
}
|
||
|
||
// Implemented for read_ng
|
||
static bool usb_read_ng_data_ready(void) {
|
||
// old: if ((pUdp->UDP_CSR[AT91C_EP_OUT] & bank))
|
||
return (pUdp->UDP_CSR[AT91C_EP_OUT] & btReceiveBank) != 0;
|
||
}
|
||
|
||
// Implemented for read_ng
|
||
static uint16_t usb_read_ng_data_available(void) {
|
||
// old: uint16_t available = (((pUdp->UDP_CSR[AT91C_EP_OUT] & AT91C_UDP_RXBYTECNT) >> 16) & 0x7FF);
|
||
return usb_available_length();
|
||
}
|
||
|
||
// Implemented for read_ng
|
||
static uint8_t usb_read_ng_data_read(void) {
|
||
return pUdp->UDP_FDR[AT91C_EP_OUT];
|
||
}
|
||
|
||
// Implemented for read_ng
|
||
static void usb_read_ng_clear(void) {
|
||
// flip bank
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_OUT, btReceiveBank)
|
||
if (btReceiveBank == AT91C_UDP_RX_DATA_BK0) {
|
||
btReceiveBank = AT91C_UDP_RX_DATA_BK1;
|
||
} else {
|
||
btReceiveBank = AT91C_UDP_RX_DATA_BK0;
|
||
}
|
||
}
|
||
|
||
// Instance for 'read_ng' apis
|
||
static const usb_read_ng_config_t g_usb_read_ng_config = {
|
||
.is_link_ready = usb_read_ng_link_ready,
|
||
.is_data_ready = usb_read_ng_data_ready,
|
||
.get_byte_count = usb_read_ng_data_available,
|
||
.read_fifo = usb_read_ng_data_read,
|
||
.clear_ready = usb_read_ng_clear,
|
||
.buffer = usb_read_ng_buffer,
|
||
.buffer_size = sizeof(usb_read_ng_buffer),
|
||
.timeout = 0x1FFF
|
||
};
|
||
#endif
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn usb_disable
|
||
* \brief This function deactivates the USB device
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
void usb_disable(void) {
|
||
// Disconnect the USB device
|
||
AT91C_BASE_PIOA->PIO_ODR = GPIO_USB_PU;
|
||
|
||
// Clear all lingering interrupts
|
||
if (pUdp->UDP_ISR & AT91C_UDP_ENDBUSRES) {
|
||
pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES;
|
||
}
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn usb_enable
|
||
* \brief This function Activates the USB device
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
void usb_enable(void) {
|
||
// Set the PLL USB Divider
|
||
AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1 ;
|
||
|
||
// Specific Chip USB Initialisation
|
||
// Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock
|
||
AT91C_BASE_PMC->PMC_SCER |= AT91C_PMC_UDP;
|
||
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);
|
||
|
||
AT91C_BASE_UDP->UDP_FADDR = 0;
|
||
AT91C_BASE_UDP->UDP_GLBSTATE = 0;
|
||
|
||
// Enable UDP PullUp (USB_DP_PUP) : enable & Clear of the corresponding PIO
|
||
// Set in PIO mode and Configure in Output
|
||
AT91C_BASE_PIOA->PIO_PER = GPIO_USB_PU; // Set in PIO mode
|
||
AT91C_BASE_PIOA->PIO_OER = GPIO_USB_PU; // Configure as Output
|
||
|
||
// Clear for set the Pullup resistor
|
||
AT91C_BASE_PIOA->PIO_CODR = GPIO_USB_PU;
|
||
|
||
// Disconnect and reconnect USB controller for 100ms
|
||
usb_disable();
|
||
|
||
SpinDelayUs(100 * 1000);
|
||
// Wait for a short while
|
||
//for (volatile size_t i=0; i<0x100000; i++) {};
|
||
|
||
// Reconnect USB reconnect
|
||
AT91C_BASE_PIOA->PIO_SODR = GPIO_USB_PU;
|
||
AT91C_BASE_PIOA->PIO_OER = GPIO_USB_PU;
|
||
|
||
#ifndef AS_BOOTROM
|
||
// setup read_ng implement.
|
||
usb_read_ng_init(&g_usb_read_ng_config);
|
||
#endif
|
||
}
|
||
|
||
static int usb_reconnect = 0;
|
||
static int usb_configured = 0;
|
||
void SetUSBreconnect(int value) {
|
||
usb_reconnect = value;
|
||
}
|
||
int GetUSBreconnect(void) {
|
||
return usb_reconnect;
|
||
}
|
||
void SetUSBconfigured(int value) {
|
||
usb_configured = value;
|
||
}
|
||
int GetUSBconfigured(void) {
|
||
return usb_configured;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn usb_check
|
||
* \brief Test if the device is configured and handle enumeration
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
bool usb_check(void) {
|
||
|
||
/*
|
||
// reconnected ONCE and
|
||
if ( !USB_ATTACHED() ){
|
||
usb_reconnect = 1;
|
||
return false;
|
||
}
|
||
|
||
// only one time after USB been disengaged and re-engaged
|
||
if ( USB_ATTACHED() && usb_reconnect == 1 ) {
|
||
|
||
if ( usb_configured == 0) {
|
||
usb_disable();
|
||
usb_enable();
|
||
|
||
AT91F_CDC_Enumerate();
|
||
|
||
usb_configured = 1;
|
||
return false;
|
||
}
|
||
}
|
||
*/
|
||
|
||
// interrupt status register
|
||
AT91_REG isr = pUdp->UDP_ISR;
|
||
|
||
// end of bus reset
|
||
if (isr & AT91C_UDP_ENDBUSRES) {
|
||
pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES;
|
||
// reset all endpoints
|
||
pUdp->UDP_RSTEP = (unsigned int) - 1;
|
||
pUdp->UDP_RSTEP = 0;
|
||
// Enable the function
|
||
pUdp->UDP_FADDR = AT91C_UDP_FEN;
|
||
// Configure endpoint 0 (enable control endpoint)
|
||
pUdp->UDP_CSR[AT91C_EP_CONTROL] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL);
|
||
} else if (isr & AT91C_UDP_EPINT0) {
|
||
pUdp->UDP_ICR = AT91C_UDP_EPINT0;
|
||
AT91F_CDC_Enumerate();
|
||
}
|
||
/*
|
||
else if (isr & AT91C_UDP_EPINT3 ) {
|
||
pUdp->UDP_ICR = AT91C_UDP_EPINT3;
|
||
AT91F_CDC_Enumerate();
|
||
//pUdp->UDP_ICR |= AT91C_UDP_EPINT3;
|
||
}
|
||
*/
|
||
return (btConfiguration) ? true : false;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn usb_poll
|
||
* \brief Test if the device link ok and data received.
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
bool usb_poll(void) {
|
||
if (usb_check() == false) {
|
||
return false;
|
||
}
|
||
return (pUdp->UDP_CSR[AT91C_EP_OUT] & btReceiveBank);
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn usb_available_length
|
||
* \brief Get data received length of out endpoint.
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
FORCE_INLINE uint16_t usb_available_length(void) {
|
||
return (((pUdp->UDP_CSR[AT91C_EP_OUT] & AT91C_UDP_RXBYTECNT) >> 16) & 0x7FF);
|
||
}
|
||
|
||
/**
|
||
In github PR #129, some users appears to get a false positive from
|
||
usb_poll, which returns true, but the usb_read operation
|
||
still returns 0.
|
||
This check is basically the same as above, but also checks
|
||
that the length available to read is non-zero, thus hopefully fixes the
|
||
bug.
|
||
**/
|
||
bool usb_poll_validate_length(void) {
|
||
// Reuse 'usb_poll()' implemented.
|
||
if (usb_poll() == false) {
|
||
return false;
|
||
}
|
||
// Why code this: return (((pUdp->UDP_CSR[AT91C_EP_OUT] & AT91C_UDP_RXBYTECNT) >> 16) > 0);
|
||
// For speed? but 'usb_available_length()' is a inline function.
|
||
return (usb_available_length() > 0);
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn usb_read
|
||
* \brief Read available data from Endpoint 1 OUT (host to device, blocking read.)
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
uint32_t usb_read(uint8_t *data, size_t len) {
|
||
|
||
if (len == 0) {
|
||
return 0;
|
||
}
|
||
|
||
uint8_t bank = btReceiveBank;
|
||
uint16_t packetSize, nbBytesRcv = 0;
|
||
uint16_t time_out = 0;
|
||
|
||
while (len) {
|
||
if (usb_check() == false) {
|
||
break;
|
||
}
|
||
|
||
if (pUdp->UDP_CSR[AT91C_EP_OUT] & bank) {
|
||
|
||
packetSize = (((pUdp->UDP_CSR[AT91C_EP_OUT] & AT91C_UDP_RXBYTECNT) >> 16) & 0x7FF);
|
||
packetSize = MIN(packetSize, len);
|
||
len -= packetSize;
|
||
|
||
while (packetSize--) {
|
||
data[nbBytesRcv++] = pUdp->UDP_FDR[AT91C_EP_OUT];
|
||
}
|
||
|
||
// flip bank
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_OUT, bank)
|
||
|
||
if (bank == AT91C_UDP_RX_DATA_BK0) {
|
||
bank = AT91C_UDP_RX_DATA_BK1;
|
||
} else {
|
||
bank = AT91C_UDP_RX_DATA_BK0;
|
||
}
|
||
}
|
||
|
||
if (time_out++ == 0x1FFF) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
btReceiveBank = bank;
|
||
return nbBytesRcv;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn usb_write
|
||
* \brief Send through endpoint 2 (device to host, blocking write.)
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
int usb_write(const uint8_t *data, const size_t len) {
|
||
|
||
if (len == 0) {
|
||
return PM3_EINVARG;
|
||
}
|
||
|
||
if (usb_check() == false) {
|
||
return PM3_EIO;
|
||
}
|
||
|
||
// can we write?
|
||
if ((pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY) != 0) {
|
||
return PM3_EIO;
|
||
}
|
||
|
||
size_t length = len;
|
||
uint32_t cpt = 0;
|
||
|
||
// send first chunk
|
||
cpt = MIN(length, AT91C_USB_EP_IN_SIZE);
|
||
length -= cpt;
|
||
while (cpt--) {
|
||
pUdp->UDP_FDR[AT91C_EP_IN] = *data++;
|
||
}
|
||
|
||
UDP_SET_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXPKTRDY);
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY)) {};
|
||
|
||
while (length) {
|
||
// Send next chunk
|
||
cpt = MIN(length, AT91C_USB_EP_IN_SIZE);
|
||
length -= cpt;
|
||
while (cpt--) {
|
||
pUdp->UDP_FDR[AT91C_EP_IN] = *data++;
|
||
}
|
||
|
||
// Wait for previous chunk to be sent
|
||
// (iceman) when is the bankswapping done?
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {
|
||
if (usb_check() == false) {
|
||
return PM3_EIO;
|
||
}
|
||
}
|
||
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXCOMP);
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) {};
|
||
|
||
UDP_SET_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXPKTRDY);
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY)) {};
|
||
}
|
||
|
||
// Wait for the end of transfer
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {
|
||
if (usb_check() == false) {
|
||
return PM3_EIO;
|
||
}
|
||
}
|
||
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXCOMP);
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) {};
|
||
|
||
|
||
if (len % AT91C_USB_EP_IN_SIZE == 0) {
|
||
// like AT91F_USB_SendZlp(), in non ping-pong mode
|
||
UDP_SET_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXPKTRDY);
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {};
|
||
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXCOMP);
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) {};
|
||
}
|
||
|
||
return PM3_SUCCESS;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn async_usb_write_start
|
||
* \brief Start async write process
|
||
* \return PM3_EIO if USB is invalid, PM3_SUCCESS if it is ready for write
|
||
*
|
||
* This function checks if the USB is connected, and wait until the FIFO
|
||
* is ready to be filled.
|
||
*
|
||
* Warning: usb_write() should not be called between
|
||
* async_usb_write_start() and async_usb_write_stop().
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
int async_usb_write_start(void) {
|
||
|
||
if (usb_check() == false) {
|
||
return PM3_EIO;
|
||
}
|
||
|
||
uint32_t spins = 0;
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY) {
|
||
|
||
if (usb_check() == false) {
|
||
return PM3_EIO;
|
||
}
|
||
|
||
WDT_HIT();
|
||
|
||
if (++spins > ASYNC_WRITE_SPIN_LIMIT) {
|
||
async_usb_write_discard();
|
||
break;
|
||
}
|
||
}
|
||
|
||
isAsyncRequestFinished = false;
|
||
return PM3_SUCCESS;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn async_usb_write_discard
|
||
* \brief Drop a packet the host refuses to collect
|
||
*
|
||
* Without this the endpoint stays busy forever and usb_write() keeps bailing
|
||
* out with PM3_EIO, which looks like a dead device.
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
void async_usb_write_discard(void) {
|
||
// Clearing TXPKTRDY by hand is not enough on this silicon, the FIFO keeps
|
||
// its content. Reset the endpoint the same way the bus reset handler does
|
||
// and re-enable it, so the next usb_write() starts from a clean FIFO.
|
||
pUdp->UDP_RSTEP |= (1u << AT91C_EP_IN);
|
||
pUdp->UDP_RSTEP &= ~(1u << AT91C_EP_IN);
|
||
pUdp->UDP_CSR[AT91C_EP_IN] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN);
|
||
isAsyncRequestFinished = true;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn async_usb_write_pushByte
|
||
* \brief Push one byte to the FIFO of IN endpoint (time-critical)
|
||
*
|
||
* This function simply push a byte to the FIFO of IN endpoint.
|
||
* The FIFO size is AT91C_USB_EP_IN_SIZE. Make sure this function is not called
|
||
* over AT91C_USB_EP_IN_SIZE times between each async_usb_write_requestWrite().
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
inline void async_usb_write_pushByte(uint8_t data) {
|
||
pUdp->UDP_FDR[AT91C_EP_IN] = data;
|
||
isAsyncRequestFinished = false;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn async_usb_write_requestWrite
|
||
* \brief Request a write operation (time-critical)
|
||
* \return false if the last write request is not finished, true if success
|
||
*
|
||
* This function requests a write operation from FIFO to the USB bus,
|
||
* and switch the internal banks of FIFO. It doesn't wait for the end of
|
||
* transmission from FIFO to the USB bus.
|
||
*
|
||
* Note: This function doesn't check if the usb is valid, as it is
|
||
* time-critical.
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
inline bool async_usb_write_requestWrite(void) {
|
||
|
||
// check if last request is finished
|
||
if (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY) {
|
||
return false;
|
||
}
|
||
|
||
// clear transmission completed flag
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXCOMP);
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) {};
|
||
|
||
// start of transmission
|
||
UDP_SET_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXPKTRDY);
|
||
|
||
// hack: no need to wait if UDP_CSR and UDP_FDR are not used immediately.
|
||
// while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY)) {};
|
||
isAsyncRequestFinished = true;
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn async_usb_write_stop
|
||
* \brief Stop async write process
|
||
* \return PM3_EIO if USB is invalid, PM3_SUCCESS if data is written
|
||
*
|
||
* This function makes sure the data left in the FIFO is written to the
|
||
* USB bus.
|
||
*
|
||
* Warning: usb_write() should not be called between
|
||
* async_usb_write_start() and async_usb_write_stop().
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
int async_usb_write_stop(void) {
|
||
|
||
uint32_t spins = 0;
|
||
|
||
// Wait for the end of transfer
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY) {
|
||
|
||
if (usb_check() == false) {
|
||
return PM3_EIO;
|
||
}
|
||
|
||
WDT_HIT();
|
||
|
||
if (++spins > ASYNC_WRITE_SPIN_LIMIT) {
|
||
async_usb_write_discard();
|
||
return PM3_ETIMEOUT;
|
||
}
|
||
}
|
||
|
||
// clear transmission completed flag
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXCOMP);
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) {};
|
||
|
||
// FIFO is not empty, request a write in non-ping-pong mode.
|
||
// Must send ZLP to close transfer
|
||
{
|
||
UDP_SET_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXPKTRDY);
|
||
|
||
spins = 0;
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {
|
||
|
||
if (usb_check() == false) {
|
||
return PM3_EIO;
|
||
}
|
||
|
||
WDT_HIT();
|
||
|
||
if (++spins > ASYNC_WRITE_SPIN_LIMIT) {
|
||
async_usb_write_discard();
|
||
return PM3_ETIMEOUT;
|
||
}
|
||
}
|
||
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_IN, AT91C_UDP_TXCOMP);
|
||
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) {};
|
||
}
|
||
return PM3_SUCCESS;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------------
|
||
* \fn AT91F_USB_SendData
|
||
* \brief Send Data through the control endpoint
|
||
*
|
||
* length is how much the device has to give, wLength how much the host asked
|
||
* for. When less than wLength is sent and that amount is a whole number of
|
||
* control endpoint packets, the transfer needs a zero length packet to end it,
|
||
* or the host keeps polling until it times out.
|
||
*----------------------------------------------------------------------------
|
||
*/
|
||
void AT91F_USB_SendData(AT91PS_UDP pudp, const char *pData, uint32_t length, uint32_t wLength) {
|
||
AT91_REG csr;
|
||
|
||
length = MIN(length, wLength);
|
||
|
||
bool send_zlp = (length > 0) &&
|
||
(length < wLength) &&
|
||
((length % AT91C_USB_EP_CONTROL_SIZE) == 0);
|
||
|
||
do {
|
||
uint32_t cpt = MIN(length, AT91C_USB_EP_CONTROL_SIZE);
|
||
length -= cpt;
|
||
|
||
while (cpt--) {
|
||
pudp->UDP_FDR[AT91C_EP_CONTROL] = *pData++;
|
||
}
|
||
|
||
if (pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_TXCOMP) {
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_TXCOMP);
|
||
while (pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_TXCOMP) {};
|
||
}
|
||
|
||
UDP_SET_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_TXPKTRDY);
|
||
|
||
do {
|
||
csr = pudp->UDP_CSR[AT91C_EP_CONTROL];
|
||
// Data IN stage has been stopped by a status OUT
|
||
if (csr & AT91C_UDP_RX_DATA_BK0) {
|
||
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_RX_DATA_BK0)
|
||
return;
|
||
}
|
||
} while (!(csr & AT91C_UDP_TXCOMP));
|
||
|
||
} while (length);
|
||
|
||
if (pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_TXCOMP) {
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_TXCOMP);
|
||
while (pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_TXCOMP) {};
|
||
}
|
||
|
||
if (send_zlp) {
|
||
AT91F_USB_SendZlp(pudp);
|
||
}
|
||
}
|
||
|
||
//*----------------------------------------------------------------------------
|
||
//* \fn AT91F_USB_SendZlp
|
||
//* \brief Send zero length packet through the control endpoint
|
||
//*----------------------------------------------------------------------------
|
||
void AT91F_USB_SendZlp(AT91PS_UDP pudp) {
|
||
UDP_SET_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_TXPKTRDY);
|
||
// for non ping-pong operation, wait until the FIFO is released
|
||
// the flag for FIFO released is AT91C_UDP_TXCOMP rather than AT91C_UDP_TXPKTRDY
|
||
while (!(pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_TXCOMP)) {};
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_TXCOMP);
|
||
while (pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_TXCOMP) {};
|
||
}
|
||
|
||
//*----------------------------------------------------------------------------
|
||
//* \fn AT91F_USB_SendStall
|
||
//* \brief Stall the control endpoint
|
||
//*----------------------------------------------------------------------------
|
||
void AT91F_USB_SendStall(AT91PS_UDP pudp) {
|
||
|
||
UDP_SET_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_FORCESTALL);
|
||
|
||
// STALLSENT only arrives once the host polls the endpoint and takes the
|
||
// handshake, so every way the host can fail to do that needs an exit.
|
||
// usb_check() is not one of them, it calls back into AT91F_CDC_Enumerate().
|
||
uint16_t time_out = 0;
|
||
while (!(pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_STALLSENT)) {
|
||
|
||
// host dropped this request and started another one
|
||
if (pudp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_RXSETUP) {
|
||
break;
|
||
}
|
||
|
||
// bus reset. Not RXSUSP: nothing in this driver writes it back to
|
||
// UDP_ICR, so once the bus first idles it stays latched for good.
|
||
if (pudp->UDP_ISR & AT91C_UDP_ENDBUSRES) {
|
||
break;
|
||
}
|
||
|
||
if (time_out++ == 0x1FFF) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_CONTROL, (AT91C_UDP_FORCESTALL | AT91C_UDP_STALLSENT));
|
||
|
||
// leaving the loop above early can let the host set STALLSENT after the
|
||
// clear, so this wait is bounded too
|
||
time_out = 0;
|
||
while (pudp->UDP_CSR[AT91C_EP_CONTROL] & (AT91C_UDP_FORCESTALL | AT91C_UDP_STALLSENT)) {
|
||
if (time_out++ == 0x1FFF) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//*----------------------------------------------------------------------------
|
||
//* \fn AT91F_CDC_Enumerate
|
||
//* \brief This function is a callback invoked when a SETUP packet is received
|
||
//* problem:
|
||
//* 1. this is for USB endpoint0. the control endpoint.
|
||
//* 2. mixed with CDC ACM endpoint3 , interrupt, control endpoint
|
||
//*----------------------------------------------------------------------------
|
||
void AT91F_CDC_Enumerate(void) {
|
||
uint8_t bmRequestType, bRequest;
|
||
uint16_t wValue, wIndex, wLength, wStatus;
|
||
|
||
if (!(pUdp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_RXSETUP)) {
|
||
return;
|
||
}
|
||
|
||
bmRequestType = pUdp->UDP_FDR[AT91C_EP_CONTROL];
|
||
bRequest = pUdp->UDP_FDR[AT91C_EP_CONTROL];
|
||
wValue = (pUdp->UDP_FDR[AT91C_EP_CONTROL] & 0xFF);
|
||
wValue |= (pUdp->UDP_FDR[AT91C_EP_CONTROL] << 8);
|
||
wIndex = (pUdp->UDP_FDR[AT91C_EP_CONTROL] & 0xFF);
|
||
wIndex |= (pUdp->UDP_FDR[AT91C_EP_CONTROL] << 8);
|
||
wLength = (pUdp->UDP_FDR[AT91C_EP_CONTROL] & 0xFF);
|
||
wLength |= (pUdp->UDP_FDR[AT91C_EP_CONTROL] << 8);
|
||
|
||
if (bmRequestType & 0x80) { // Data Phase Transfer Direction Device to Host
|
||
UDP_SET_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_DIR);
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_DIR)) {};
|
||
}
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_RXSETUP);
|
||
while ((pUdp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_RXSETUP)) {};
|
||
|
||
// WCID vendor request. StrMS_OSDescriptor advertises MS_VENDOR_CODE, so
|
||
// every request carrying it has to be answered here. Falling through to the
|
||
// standard switch below stalls it, which makes Windows cache the device as
|
||
// having no MS OS descriptors and stop asking.
|
||
if (bRequest == MS_VENDOR_CODE) {
|
||
|
||
if (bmRequestType == MS_WCID_GET_DESCRIPTOR && wIndex == MS_EXTENDED_COMPAT_ID) {
|
||
AT91F_USB_SendData(pUdp, CompatIDFeatureDescriptor, sizeof(CompatIDFeatureDescriptor), wLength);
|
||
return;
|
||
}
|
||
|
||
// wValue holds the interface number, wIndex the descriptor index.
|
||
if (bmRequestType == MS_WCID_GET_FEATURE_DESCRIPTOR && wIndex == MS_EXTENDED_PROPERTIES) {
|
||
AT91F_USB_SendData(pUdp, OSprop, sizeof(OSprop), wLength);
|
||
return;
|
||
}
|
||
|
||
AT91F_USB_SendStall(pUdp);
|
||
return;
|
||
}
|
||
|
||
// Handle supported standard device request Cf Table 9-3 in USB specification Rev 1.1
|
||
switch ((bRequest << 8) | bmRequestType) {
|
||
case STD_GET_DESCRIPTOR: {
|
||
|
||
if (wValue == 0x100) { // Return Device Descriptor
|
||
AT91F_USB_SendData(pUdp, devDescriptor, sizeof(devDescriptor), wLength);
|
||
} else if (wValue == 0x200) { // Return Configuration Descriptor
|
||
AT91F_USB_SendData(pUdp, cfgDescriptor, sizeof(cfgDescriptor), wLength);
|
||
} else if ((wValue & 0xF00) == 0xF00) { // Return BOS Descriptor
|
||
AT91F_USB_SendData(pUdp, bosDescriptor, sizeof(bosDescriptor), wLength);
|
||
} else if ((wValue & 0x300) == 0x300) { // Return String Descriptor
|
||
|
||
const char *strDescriptor = getStringDescriptor(wValue & 0xff);
|
||
if (strDescriptor != NULL) {
|
||
AT91F_USB_SendData(pUdp, strDescriptor, strDescriptor[0], wLength);
|
||
} else {
|
||
AT91F_USB_SendStall(pUdp);
|
||
}
|
||
} else {
|
||
AT91F_USB_SendStall(pUdp);
|
||
}
|
||
}
|
||
break;
|
||
case STD_SET_ADDRESS:
|
||
AT91F_USB_SendZlp(pUdp);
|
||
pUdp->UDP_FADDR = (AT91C_UDP_FEN | (wValue & 0x7F));
|
||
pUdp->UDP_GLBSTATE = (wValue) ? AT91C_UDP_FADDEN : 0;
|
||
break;
|
||
case STD_SET_CONFIGURATION:
|
||
|
||
/*
|
||
* Set or clear the device "configured" state.
|
||
* The LSB of wValue is the "Configuration Number". If this value is non-zero,
|
||
* it should be the same number as defined in the Configuration Descriptor;
|
||
* otherwise an error must have occurred.
|
||
* This device has only one configuration and its Config Number is CONF_NB (= 1).
|
||
*/
|
||
AT91F_USB_SendZlp(pUdp);
|
||
btConfiguration = wValue;
|
||
pUdp->UDP_GLBSTATE = (wValue) ? AT91C_UDP_CONFG : AT91C_UDP_FADDEN;
|
||
|
||
// make sure we are not stalled
|
||
/*
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_OUT , AT91C_UDP_FORCESTALL);
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_IN , AT91C_UDP_FORCESTALL);
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_NOTIFY, AT91C_UDP_FORCESTALL);
|
||
*/
|
||
|
||
// enable endpoints
|
||
pUdp->UDP_CSR[AT91C_EP_OUT] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT) : 0;
|
||
pUdp->UDP_CSR[AT91C_EP_IN] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN) : 0;
|
||
pUdp->UDP_CSR[AT91C_EP_NOTIFY] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN) : 0;
|
||
break;
|
||
case STD_GET_CONFIGURATION:
|
||
AT91F_USB_SendData(pUdp, (char *) & (btConfiguration), sizeof(btConfiguration), wLength);
|
||
break;
|
||
case STD_GET_STATUS_ZERO:
|
||
wStatus = 0; // Device is Bus powered, remote wakeup disabled
|
||
AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus), wLength);
|
||
break;
|
||
case STD_GET_STATUS_INTERFACE:
|
||
wStatus = 0; // reserved for future use
|
||
AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus), wLength);
|
||
break;
|
||
case STD_GET_STATUS_ENDPOINT:
|
||
wStatus = 0;
|
||
wIndex &= 0x0F;
|
||
if ((pUdp->UDP_GLBSTATE & AT91C_UDP_CONFG) && (wIndex <= AT91C_EP_NOTIFY)) {
|
||
wStatus = (pUdp->UDP_CSR[wIndex] & AT91C_UDP_EPEDS) ? 0 : 1;
|
||
AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus), wLength);
|
||
} else if ((pUdp->UDP_GLBSTATE & AT91C_UDP_FADDEN) && (wIndex == AT91C_EP_CONTROL)) {
|
||
wStatus = (pUdp->UDP_CSR[wIndex] & AT91C_UDP_EPEDS) ? 0 : 1;
|
||
AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus), wLength);
|
||
} else {
|
||
AT91F_USB_SendStall(pUdp);
|
||
}
|
||
break;
|
||
case STD_SET_FEATURE_ZERO:
|
||
AT91F_USB_SendStall(pUdp);
|
||
break;
|
||
case STD_SET_FEATURE_INTERFACE:
|
||
AT91F_USB_SendZlp(pUdp);
|
||
break;
|
||
case STD_SET_FEATURE_ENDPOINT:
|
||
wIndex &= 0x0F;
|
||
if ((wValue == 0) && (wIndex >= AT91C_EP_OUT) && (wIndex <= AT91C_EP_NOTIFY)) {
|
||
pUdp->UDP_CSR[wIndex] = 0;
|
||
AT91F_USB_SendZlp(pUdp);
|
||
} else {
|
||
AT91F_USB_SendStall(pUdp);
|
||
}
|
||
break;
|
||
case STD_CLEAR_FEATURE_ZERO:
|
||
AT91F_USB_SendStall(pUdp);
|
||
break;
|
||
case STD_CLEAR_FEATURE_INTERFACE:
|
||
AT91F_USB_SendZlp(pUdp);
|
||
break;
|
||
case STD_CLEAR_FEATURE_ENDPOINT:
|
||
wIndex &= 0x0F;
|
||
if ((wValue == 0) && (wIndex >= AT91C_EP_OUT) && (wIndex <= AT91C_EP_NOTIFY)) {
|
||
|
||
if (wIndex == AT91C_EP_OUT) {
|
||
pUdp->UDP_CSR[AT91C_EP_OUT] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT);
|
||
} else if (wIndex == AT91C_EP_IN) {
|
||
pUdp->UDP_CSR[AT91C_EP_IN] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN);
|
||
} else if (wIndex == AT91C_EP_NOTIFY) {
|
||
pUdp->UDP_CSR[AT91C_EP_NOTIFY] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN);
|
||
}
|
||
|
||
AT91F_USB_SendZlp(pUdp);
|
||
} else {
|
||
AT91F_USB_SendStall(pUdp);
|
||
}
|
||
break;
|
||
|
||
// handle CDC class requests
|
||
case SET_LINE_CODING: {
|
||
/*
|
||
uint8_t i;
|
||
for ( i = 0 ; i < 7 ; i++ ) {
|
||
((uint8_t*)&line)[i] = pUdp->UDP_FDR[AT91C_EP_CONTROL];
|
||
} */
|
||
// ignore SET_LINE_CODING...
|
||
while (!(pUdp->UDP_CSR[AT91C_EP_CONTROL] & AT91C_UDP_RX_DATA_BK0)) {};
|
||
UDP_CLEAR_EP_FLAGS(AT91C_EP_CONTROL, AT91C_UDP_RX_DATA_BK0);
|
||
AT91F_USB_SendZlp(pUdp);
|
||
break;
|
||
}
|
||
case GET_LINE_CODING:
|
||
AT91F_USB_SendData(pUdp, (char *) &line, sizeof(line), wLength);
|
||
break;
|
||
case SET_CONTROL_LINE_STATE:
|
||
btConnection = wValue;
|
||
AT91F_USB_SendZlp(pUdp);
|
||
break;
|
||
default:
|
||
AT91F_USB_SendStall(pUdp);
|
||
break;
|
||
}
|
||
}
|
||
|
||
//*----------------------------------------------------------------------------
|
||
//* \fn usb_get_ep_size
|
||
//* \brief This function can get usb endpoint buffer size
|
||
//*----------------------------------------------------------------------------
|
||
void usb_get_ep_size(uint32_t *epCtl, uint32_t *epIn, uint32_t *epOut) {
|
||
if (epCtl) *epCtl = AT91C_USB_EP_CONTROL_SIZE;
|
||
if (epIn) *epIn = AT91C_USB_EP_IN_SIZE;
|
||
if (epOut) *epOut = AT91C_USB_EP_OUT_SIZE;
|
||
}
|