andy/tinyUSB
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Code reformat

Browse Source 
Signed-off-by: HiFiPhile <admin@hifiphile.com>
This commit is contained in:
HiFiPhile
2025-06-08 14:27:57 +02:00
parent 95be35b587
commit 69f6b57772
1 changed files with 336 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

247
src/class/usbtmc/usbtmc_device.c
View File

@@ -76,11 +76,6 @@
#include "usbtmc_device.h" #include "usbtmc_device.h"
#ifdef xDEBUG
#include "uart_util.h"
tu_static char logMsg[150];
#endif
// Buffer size must be an exact multiple of the max packet size for both // Buffer size must be an exact multiple of the max packet size for both
// bulk (up to 64 bytes for FS, 512 bytes for HS). In addation, this driver // bulk (up to 64 bytes for FS, 512 bytes for HS). In addation, this driver
// imposes a minimum buffer size of 32 bytes. // imposes a minimum buffer size of 32 bytes.
@@ -96,8 +91,7 @@ tu_static char logMsg[150];
* consistent with USBTMC. * consistent with USBTMC.
*/ */
typedef enum typedef enum {
{
STATE_CLOSED,// Endpoints have not yet been opened since USB reset STATE_CLOSED,// Endpoints have not yet been opened since USB reset
STATE_NAK, // Bulk-out endpoint is in NAK state. STATE_NAK, // Bulk-out endpoint is in NAK state.
STATE_IDLE, // Bulk-out endpoint is waiting for CMD. STATE_IDLE, // Bulk-out endpoint is waiting for CMD.
@@ -179,20 +173,18 @@ static OSAL_MUTEX_DEF(usbtmcLockBuffer);
osal_mutex_t usbtmcLock; osal_mutex_t usbtmcLock;
// Our own private lock, mostly for the state variable. // Our own private lock, mostly for the state variable.
#define criticalEnter() do { (void) osal_mutex_lock(usbtmcLock,OSAL_TIMEOUT_WAIT_FOREVER); } while (0) #define criticalEnter() \
#define criticalLeave() do { (void) osal_mutex_unlock(usbtmcLock); } while (0) do { (void) osal_mutex_lock(usbtmcLock, OSAL_TIMEOUT_WAIT_FOREVER); } while (0)
#define criticalLeave() \
do { (void) osal_mutex_unlock(usbtmcLock); } while (0)
static bool atomicChangeState(usbtmcd_state_enum expectedState, usbtmcd_state_enum newState) static bool atomicChangeState(usbtmcd_state_enum expectedState, usbtmcd_state_enum newState) {
{
bool ret = true; bool ret = true;
criticalEnter(); criticalEnter();
usbtmcd_state_enum oldState = usbtmc_state.state; usbtmcd_state_enum oldState = usbtmc_state.state;
if (oldState == expectedState) if (oldState == expectedState) {
{
usbtmc_state.state = newState; usbtmc_state.state = newState;
} } else {
else
{
ret = false; ret = false;
} }
criticalLeave(); criticalLeave();
@@ -209,16 +201,14 @@ static bool atomicChangeState(usbtmcd_state_enum expectedState, usbtmcd_state_en
bool tud_usbtmc_transmit_dev_msg_data( bool tud_usbtmc_transmit_dev_msg_data(
const void *data, size_t len, const void *data, size_t len,
bool endOfMessage, bool endOfMessage,
bool usingTermChar) bool usingTermChar) {
{
const unsigned int txBufLen = USBTMCD_BUFFER_SIZE; const unsigned int txBufLen = USBTMCD_BUFFER_SIZE;
#ifndef NDEBUG #ifndef NDEBUG
TU_ASSERT(len > 0u); TU_ASSERT(len > 0u);
TU_ASSERT(len <= usbtmc_state.transfer_size_remaining); TU_ASSERT(len <= usbtmc_state.transfer_size_remaining);
TU_ASSERT(usbtmc_state.transfer_size_sent == 0u); TU_ASSERT(usbtmc_state.transfer_size_sent == 0u);
if(usingTermChar) if (usingTermChar) {
{
TU_ASSERT(usbtmc_state.capabilities->bmDevCapabilities.canEndBulkInOnTermChar); TU_ASSERT(usbtmc_state.capabilities->bmDevCapabilities.canEndBulkInOnTermChar);
TU_ASSERT(termCharRequested); TU_ASSERT(termCharRequested);
TU_ASSERT(((uint8_t const *) data)[len - 1u] == termChar); TU_ASSERT(((uint8_t const *) data)[len - 1u] == termChar);
@@ -228,12 +218,9 @@ bool tud_usbtmc_transmit_dev_msg_data(
TU_VERIFY(usbtmc_state.state == STATE_TX_REQUESTED); TU_VERIFY(usbtmc_state.state == STATE_TX_REQUESTED);
usbtmc_msg_dev_dep_msg_in_header_t *hdr = (usbtmc_msg_dev_dep_msg_in_header_t *) usbtmc_epbuf.epin; usbtmc_msg_dev_dep_msg_in_header_t *hdr = (usbtmc_msg_dev_dep_msg_in_header_t *) usbtmc_epbuf.epin;
tu_varclr(hdr); tu_varclr(hdr);
if(usbtmcVendorSpecificRequested) if (usbtmcVendorSpecificRequested) {
{
hdr->header.MsgID = USBTMC_MSGID_VENDOR_SPECIFIC_IN; hdr->header.MsgID = USBTMC_MSGID_VENDOR_SPECIFIC_IN;
} } else {
else
{
hdr->header.MsgID = USBTMC_MSGID_DEV_DEP_MSG_IN; hdr->header.MsgID = USBTMC_MSGID_DEV_DEP_MSG_IN;
} }
hdr->header.bTag = usbtmc_state.lastBulkInTag; hdr->header.bTag = usbtmc_state.lastBulkInTag;
@@ -244,8 +231,7 @@ bool tud_usbtmc_transmit_dev_msg_data(
// Copy in the header // Copy in the header
const size_t headerLen = sizeof(*hdr); const size_t headerLen = sizeof(*hdr);
const size_t dataLen = ((headerLen + hdr->TransferSize) <= txBufLen) ? const size_t dataLen = ((headerLen + hdr->TransferSize) <= txBufLen) ? len : (txBufLen - headerLen);
len : (txBufLen - headerLen);
const size_t packetLen = headerLen + dataLen; const size_t packetLen = headerLen + dataLen;
memcpy((uint8_t *) (usbtmc_epbuf.epin) + headerLen, data, dataLen); memcpy((uint8_t *) (usbtmc_epbuf.epin) + headerLen, data, dataLen);
@@ -260,8 +246,7 @@ bool tud_usbtmc_transmit_dev_msg_data(
return true; return true;
} }
bool tud_usbtmc_transmit_notification_data(const void * data, size_t len) bool tud_usbtmc_transmit_notification_data(const void *data, size_t len) {
{
#ifndef NDEBUG #ifndef NDEBUG
TU_ASSERT(len > 0); TU_ASSERT(len > 0);
TU_ASSERT(usbtmc_state.ep_int_in != 0); TU_ASSERT(usbtmc_state.ep_int_in != 0);
@@ -273,8 +258,7 @@ bool tud_usbtmc_transmit_notification_data(const void * data, size_t len)
return true; return true;
} }
void usbtmcd_init_cb(void) void usbtmcd_init_cb(void) {
{
usbtmc_state.capabilities = tud_usbtmc_get_capabilities_cb(); usbtmc_state.capabilities = tud_usbtmc_get_capabilities_cb();
#ifndef NDEBUG #ifndef NDEBUG
#if CFG_TUD_USBTMC_ENABLE_488 #if CFG_TUD_USBTMC_ENABLE_488
@@ -300,8 +284,7 @@ bool usbtmcd_deinit(void) {
return true; return true;
} }
uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len) uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
{
(void) rhport; (void) rhport;
uint16_t drv_len; uint16_t drv_len;
@@ -325,17 +308,14 @@ uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc,
usbtmc_state.itf_id = itf_desc->bInterfaceNumber; usbtmc_state.itf_id = itf_desc->bInterfaceNumber;
usbtmc_state.rhport = rhport; usbtmc_state.rhport = rhport;
while (found_endpoints < itf_desc->bNumEndpoints && drv_len <= max_len) while (found_endpoints < itf_desc->bNumEndpoints && drv_len <= max_len) {
{ if (TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE]) {
if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
{
tusb_desc_endpoint_t const *ep_desc = (tusb_desc_endpoint_t const *) p_desc; tusb_desc_endpoint_t const *ep_desc = (tusb_desc_endpoint_t const *) p_desc;
switch (ep_desc->bmAttributes.xfer) { switch (ep_desc->bmAttributes.xfer) {
case TUSB_XFER_BULK: case TUSB_XFER_BULK:
// Ensure buffer is an exact multiple of the maxPacketSize // Ensure buffer is an exact multiple of the maxPacketSize
TU_ASSERT((USBTMCD_BUFFER_SIZE % tu_edpt_packet_size(ep_desc)) == 0, 0); TU_ASSERT((USBTMCD_BUFFER_SIZE % tu_edpt_packet_size(ep_desc)) == 0, 0);
if (tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN) if (tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN) {
{
usbtmc_state.ep_bulk_in = ep_desc->bEndpointAddress; usbtmc_state.ep_bulk_in = ep_desc->bEndpointAddress;
usbtmc_state.ep_bulk_in_wMaxPacketSize = tu_edpt_packet_size(ep_desc); usbtmc_state.ep_bulk_in_wMaxPacketSize = tu_edpt_packet_size(ep_desc);
} else { } else {
@@ -366,18 +346,14 @@ uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc,
#ifndef NDEBUG #ifndef NDEBUG
TU_ASSERT(usbtmc_state.ep_bulk_in != 0, 0); TU_ASSERT(usbtmc_state.ep_bulk_in != 0, 0);
TU_ASSERT(usbtmc_state.ep_bulk_out != 0, 0); TU_ASSERT(usbtmc_state.ep_bulk_out != 0, 0);
if (itf_desc->bNumEndpoints == 2) if (itf_desc->bNumEndpoints == 2) {
{
TU_ASSERT(usbtmc_state.ep_int_in == 0, 0); TU_ASSERT(usbtmc_state.ep_int_in == 0, 0);
} } else if (itf_desc->bNumEndpoints == 3) {
else if (itf_desc->bNumEndpoints == 3)
{
TU_ASSERT(usbtmc_state.ep_int_in != 0, 0); TU_ASSERT(usbtmc_state.ep_int_in != 0, 0);
} }
#if (CFG_TUD_USBTMC_ENABLE_488) #if (CFG_TUD_USBTMC_ENABLE_488)
if (usbtmc_state.capabilities->bmIntfcCapabilities488.is488_2 || if (usbtmc_state.capabilities->bmIntfcCapabilities488.is488_2 ||
usbtmc_state.capabilities->bmDevCapabilities488.SR1) usbtmc_state.capabilities->bmDevCapabilities488.SR1) {
{
TU_ASSERT(usbtmc_state.ep_int_in != 0, 0); TU_ASSERT(usbtmc_state.ep_int_in != 0, 0);
} }
#endif #endif
@@ -393,11 +369,9 @@ uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc,
// processing a command (such as a clear). Returns true if it was // processing a command (such as a clear). Returns true if it was
// in the NAK state and successfully transitioned to the ACK wait // in the NAK state and successfully transitioned to the ACK wait
// state. // state.
bool tud_usbtmc_start_bus_read(void) bool tud_usbtmc_start_bus_read(void) {
{
usbtmcd_state_enum oldState = usbtmc_state.state; usbtmcd_state_enum oldState = usbtmc_state.state;
switch(oldState) switch (oldState) {
{
// These may transition to IDLE // These may transition to IDLE
case STATE_NAK: case STATE_NAK:
case STATE_ABORTING_BULK_IN_ABORTED: case STATE_ABORTING_BULK_IN_ABORTED:
@@ -413,8 +387,7 @@ bool tud_usbtmc_start_bus_read(void)
return true; return true;
} }
void usbtmcd_reset_cb(uint8_t rhport) void usbtmcd_reset_cb(uint8_t rhport) {
{
(void) rhport; (void) rhport;
usbtmc_capabilities_specific_t const *capabilities = tud_usbtmc_get_capabilities_cb(); usbtmc_capabilities_specific_t const *capabilities = tud_usbtmc_get_capabilities_cb();
@@ -425,8 +398,7 @@ void usbtmcd_reset_cb(uint8_t rhport)
criticalLeave(); criticalLeave();
} }
static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len) static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len) {
{
(void) rhport; (void) rhport;
// return true upon failure, as we can assume error is being handled elsewhere. // return true upon failure, as we can assume error is being handled elsewhere.
TU_VERIFY(atomicChangeState(STATE_IDLE, STATE_RCV), true); TU_VERIFY(atomicChangeState(STATE_IDLE, STATE_RCV), true);
@@ -442,8 +414,7 @@ static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len)
return true; return true;
} }
static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t packetLen) static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t packetLen) {
{
(void) rhport; (void) rhport;
// return true upon failure, as we can assume error is being handled elsewhere. // return true upon failure, as we can assume error is being handled elsewhere.
TU_VERIFY(usbtmc_state.state == STATE_RCV, true); TU_VERIFY(usbtmc_state.state == STATE_RCV, true);
@@ -452,8 +423,7 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
// Packet is to be considered complete when we get enough data or at a short packet. // Packet is to be considered complete when we get enough data or at a short packet.
bool atEnd = false; bool atEnd = false;
if(len >= usbtmc_state.transfer_size_remaining || shortPacket) if (len >= usbtmc_state.transfer_size_remaining || shortPacket) {
{
atEnd = true; atEnd = true;
TU_VERIFY(atomicChangeState(STATE_RCV, STATE_NAK)); TU_VERIFY(atomicChangeState(STATE_RCV, STATE_NAK));
} }
@@ -464,8 +434,7 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
usbtmc_state.transfer_size_sent += len; usbtmc_state.transfer_size_sent += len;
// App may (should?) call the wait_for_bus() command at this point // App may (should?) call the wait_for_bus() command at this point
if(!tud_usbtmc_msg_data_cb(data, len, atEnd)) if (!tud_usbtmc_msg_data_cb(data, len, atEnd)) {
{
// TODO: Go to an error state upon failure other than just stalling the EP? // TODO: Go to an error state upon failure other than just stalling the EP?
return false; return false;
} }
@@ -474,8 +443,7 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
return true; return true;
} }
static bool handle_devMsgIn(void *data, size_t len) static bool handle_devMsgIn(void *data, size_t len) {
{
TU_VERIFY(len == sizeof(usbtmc_msg_request_dev_dep_in)); TU_VERIFY(len == sizeof(usbtmc_msg_request_dev_dep_in));
usbtmc_msg_request_dev_dep_in *msg = (usbtmc_msg_request_dev_dep_in *) data; usbtmc_msg_request_dev_dep_in *msg = (usbtmc_msg_request_dev_dep_in *) data;
bool stateChanged = atomicChangeState(STATE_IDLE, STATE_TX_REQUESTED); bool stateChanged = atomicChangeState(STATE_IDLE, STATE_TX_REQUESTED);
@@ -497,22 +465,18 @@ static bool handle_devMsgIn(void *data, size_t len)
return true; return true;
} }
bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
{
TU_VERIFY(result == XFER_RESULT_SUCCESS); TU_VERIFY(result == XFER_RESULT_SUCCESS);
//uart_tx_str_sync("TMC XFER CB\r\n"); //uart_tx_str_sync("TMC XFER CB\r\n");
if (usbtmc_state.state == STATE_CLEARING) { if (usbtmc_state.state == STATE_CLEARING) {
return true; /* I think we can ignore everything here */ return true; /* I think we can ignore everything here */
} }
if(ep_addr == usbtmc_state.ep_bulk_out) if (ep_addr == usbtmc_state.ep_bulk_out) {
{
usbtmc_msg_generic_t *msg = NULL; usbtmc_msg_generic_t *msg = NULL;
switch(usbtmc_state.state) switch (usbtmc_state.state) {
{ case STATE_IDLE: {
case STATE_IDLE:
{
TU_VERIFY(xferred_bytes >= sizeof(usbtmc_msg_generic_t)); TU_VERIFY(xferred_bytes >= sizeof(usbtmc_msg_generic_t));
msg = (usbtmc_msg_generic_t *) (usbtmc_epbuf.epout); msg = (usbtmc_msg_generic_t *) (usbtmc_epbuf.epout);
uint8_t invInvTag = (uint8_t) ~(msg->header.bTagInverse); uint8_t invInvTag = (uint8_t) ~(msg->header.bTagInverse);
@@ -522,8 +486,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
switch (msg->header.MsgID) { switch (msg->header.MsgID) {
case USBTMC_MSGID_DEV_DEP_MSG_OUT: case USBTMC_MSGID_DEV_DEP_MSG_OUT:
usbtmcVendorSpecificRequested = false; usbtmcVendorSpecificRequested = false;
if(!handle_devMsgOutStart(rhport, msg, xferred_bytes)) if (!handle_devMsgOutStart(rhport, msg, xferred_bytes)) {
{
usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out); usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
return false; return false;
} }
@@ -544,8 +507,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
#endif #endif
case USBTMC_MSGID_VENDOR_SPECIFIC_MSG_OUT: case USBTMC_MSGID_VENDOR_SPECIFIC_MSG_OUT:
usbtmcVendorSpecificRequested = true; usbtmcVendorSpecificRequested = true;
if(!handle_devMsgOutStart(rhport, msg, xferred_bytes)) if (!handle_devMsgOutStart(rhport, msg, xferred_bytes)) {
{
usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out); usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
return false; return false;
} }
@@ -563,8 +525,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
return true; return true;
} }
case STATE_RCV: case STATE_RCV:
if(!handle_devMsgOut(rhport, usbtmc_epbuf.epout, xferred_bytes, xferred_bytes)) if (!handle_devMsgOut(rhport, usbtmc_epbuf.epout, xferred_bytes, xferred_bytes)) {
{
usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out); usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
return false; return false;
} }
@@ -582,9 +543,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
default: default:
return false; return false;
} }
} } else if (ep_addr == usbtmc_state.ep_bulk_in) {
else if(ep_addr == usbtmc_state.ep_bulk_in)
{
switch (usbtmc_state.state) { switch (usbtmc_state.state) {
case STATE_TX_SHORTED: case STATE_TX_SHORTED:
TU_VERIFY(atomicChangeState(STATE_TX_SHORTED, STATE_NAK)); TU_VERIFY(atomicChangeState(STATE_TX_SHORTED, STATE_NAK));
@@ -592,16 +551,14 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
break; break;
case STATE_TX_INITIATED: case STATE_TX_INITIATED:
if(usbtmc_state.transfer_size_remaining >= USBTMCD_BUFFER_SIZE) if (usbtmc_state.transfer_size_remaining >= USBTMCD_BUFFER_SIZE) {
{
// Copy buffer to ensure alignment correctness // Copy buffer to ensure alignment correctness
memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, USBTMCD_BUFFER_SIZE); memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, USBTMCD_BUFFER_SIZE);
TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, USBTMCD_BUFFER_SIZE)); TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, USBTMCD_BUFFER_SIZE));
usbtmc_state.devInBuffer += USBTMCD_BUFFER_SIZE; usbtmc_state.devInBuffer += USBTMCD_BUFFER_SIZE;
usbtmc_state.transfer_size_remaining -= USBTMCD_BUFFER_SIZE; usbtmc_state.transfer_size_remaining -= USBTMCD_BUFFER_SIZE;
usbtmc_state.transfer_size_sent += USBTMCD_BUFFER_SIZE; usbtmc_state.transfer_size_sent += USBTMCD_BUFFER_SIZE;
} } else// last packet
else // last packet
{ {
size_t packetLen = usbtmc_state.transfer_size_remaining; size_t packetLen = usbtmc_state.transfer_size_remaining;
memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining); memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining);
@@ -609,8 +566,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
usbtmc_state.transfer_size_remaining = 0; usbtmc_state.transfer_size_remaining = 0;
usbtmc_state.devInBuffer = NULL; usbtmc_state.devInBuffer = NULL;
TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) packetLen)); TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) packetLen));
if(((packetLen % usbtmc_state.ep_bulk_in_wMaxPacketSize) != 0) || (packetLen == 0 )) if (((packetLen % usbtmc_state.ep_bulk_in_wMaxPacketSize) != 0) || (packetLen == 0)) {
{
usbtmc_state.state = STATE_TX_SHORTED; usbtmc_state.state = STATE_TX_SHORTED;
} }
} }
@@ -630,8 +586,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
default: default:
TU_ASSERT(false); TU_ASSERT(false);
} }
} } else if (ep_addr == usbtmc_state.ep_int_in) {
else if (ep_addr == usbtmc_state.ep_int_in) {
if (tud_usbtmc_notification_complete_cb) { if (tud_usbtmc_notification_complete_cb) {
TU_VERIFY(tud_usbtmc_notification_complete_cb()); TU_VERIFY(tud_usbtmc_notification_complete_cb());
} }
@@ -643,8 +598,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
// Invoked when a control transfer occurred on an interface of this class // Invoked when a control transfer occurred on an interface of this class
// Driver response accordingly to the request and the transfer stage (setup/data/ack) // Driver response accordingly to the request and the transfer stage (setup/data/ack)
// return false to stall control endpoint (e.g unsupported request) // return false to stall control endpoint (e.g unsupported request)
bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request) bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const *request) {
{
// nothing to do with DATA and ACK stage // nothing to do with DATA and ACK stage
if (stage != CONTROL_STAGE_SETUP) return true; if (stage != CONTROL_STAGE_SETUP) return true;
@@ -656,54 +610,43 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
if ((request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD) && if ((request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD) &&
(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_ENDPOINT) && (request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_ENDPOINT) &&
(request->bRequest == TUSB_REQ_CLEAR_FEATURE) && (request->bRequest == TUSB_REQ_CLEAR_FEATURE) &&
(request->wValue == TUSB_REQ_FEATURE_EDPT_HALT)) (request->wValue == TUSB_REQ_FEATURE_EDPT_HALT)) {
{
uint32_t ep_addr = (request->wIndex); uint32_t ep_addr = (request->wIndex);
// At this point, a transfer MAY be in progress. Based on USB spec, when clearing bulk EP HALT, // At this point, a transfer MAY be in progress. Based on USB spec, when clearing bulk EP HALT,
// the EP transfer buffer needs to be cleared and DTOG needs to be reset, even if // the EP transfer buffer needs to be cleared and DTOG needs to be reset, even if
// the EP is not halted. The only USBD API interface to do this is to stall and then un-stall the EP. // the EP is not halted. The only USBD API interface to do this is to stall and then un-stall the EP.
if(ep_addr == usbtmc_state.ep_bulk_out) if (ep_addr == usbtmc_state.ep_bulk_out) {
{
criticalEnter(); criticalEnter();
usbd_edpt_stall(rhport, (uint8_t) ep_addr); usbd_edpt_stall(rhport, (uint8_t) ep_addr);
usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr); usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr);
usbtmc_state.state = STATE_NAK;// USBD core has placed EP in NAK state for us usbtmc_state.state = STATE_NAK;// USBD core has placed EP in NAK state for us
criticalLeave(); criticalLeave();
tud_usbtmc_bulkOut_clearFeature_cb(); tud_usbtmc_bulkOut_clearFeature_cb();
} } else if (ep_addr == usbtmc_state.ep_bulk_in) {
else if (ep_addr == usbtmc_state.ep_bulk_in)
{
usbd_edpt_stall(rhport, (uint8_t) ep_addr); usbd_edpt_stall(rhport, (uint8_t) ep_addr);
usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr); usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr);
tud_usbtmc_bulkIn_clearFeature_cb(); tud_usbtmc_bulkIn_clearFeature_cb();
} } else if ((usbtmc_state.ep_int_in != 0) && (ep_addr == usbtmc_state.ep_int_in)) {
else if ((usbtmc_state.ep_int_in != 0) && (ep_addr == usbtmc_state.ep_int_in))
{
// Clearing interrupt in EP // Clearing interrupt in EP
usbd_edpt_stall(rhport, (uint8_t) ep_addr); usbd_edpt_stall(rhport, (uint8_t) ep_addr);
usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr); usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr);
} } else {
else
{
return false; return false;
} }
return true; return true;
} }
// Otherwise, we only handle class requests. // Otherwise, we only handle class requests.
if(request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS) if (request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS) {
{
return false; return false;
} }
// Verification that we own the interface is unneeded since it's been routed to us specifically. // Verification that we own the interface is unneeded since it's been routed to us specifically.
switch(request->bRequest) switch (request->bRequest) {
{
// USBTMC required requests // USBTMC required requests
case USBTMC_bREQUEST_INITIATE_ABORT_BULK_OUT: case USBTMC_bREQUEST_INITIATE_ABORT_BULK_OUT: {
{
usbtmc_initiate_abort_rsp_t rsp = { usbtmc_initiate_abort_rsp_t rsp = {
.bTag = usbtmc_state.lastBulkOutTag, .bTag = usbtmc_state.lastBulkOutTag,
}; };
@@ -712,16 +655,11 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out); TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
// wValue is the requested bTag to abort // wValue is the requested bTag to abort
if(usbtmc_state.state != STATE_RCV) if (usbtmc_state.state != STATE_RCV) {
{
rsp.USBTMC_status = USBTMC_STATUS_FAILED; rsp.USBTMC_status = USBTMC_STATUS_FAILED;
} } else if (usbtmc_state.lastBulkOutTag == (request->wValue & 0x7Fu)) {
else if(usbtmc_state.lastBulkOutTag == (request->wValue & 0x7Fu))
{
rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS; rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
} } else {
else
{
rsp.USBTMC_status = USBTMC_STATUS_SUCCESS; rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
// Check if we've queued a short packet // Check if we've queued a short packet
criticalEnter(); criticalEnter();
@@ -734,12 +672,10 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
return true; return true;
} }
case USBTMC_bREQUEST_CHECK_ABORT_BULK_OUT_STATUS: case USBTMC_bREQUEST_CHECK_ABORT_BULK_OUT_STATUS: {
{
usbtmc_check_abort_bulk_rsp_t rsp = { usbtmc_check_abort_bulk_rsp_t rsp = {
.USBTMC_status = USBTMC_STATUS_SUCCESS, .USBTMC_status = USBTMC_STATUS_SUCCESS,
.NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent .NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent};
};
TU_VERIFY(request->bmRequestType == 0xA2);// in,class,EP TU_VERIFY(request->bmRequestType == 0xA2);// in,class,EP
TU_VERIFY(request->wLength == sizeof(rsp)); TU_VERIFY(request->wLength == sizeof(rsp));
TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out); TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
@@ -748,8 +684,7 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
return true; return true;
} }
case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN: case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN: {
{
usbtmc_initiate_abort_rsp_t rsp = { usbtmc_initiate_abort_rsp_t rsp = {
.bTag = usbtmc_state.lastBulkInTag, .bTag = usbtmc_state.lastBulkInTag,
}; };
@@ -758,37 +693,29 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_in); TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_in);
// wValue is the requested bTag to abort // wValue is the requested bTag to abort
if ((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED) && if ((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED) &&
usbtmc_state.lastBulkInTag == (request->wValue & 0x7Fu)) usbtmc_state.lastBulkInTag == (request->wValue & 0x7Fu)) {
{
rsp.USBTMC_status = USBTMC_STATUS_SUCCESS; rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
usbtmc_state.transfer_size_remaining = 0u; usbtmc_state.transfer_size_remaining = 0u;
// Check if we've queued a short packet // Check if we've queued a short packet
criticalEnter(); criticalEnter();
usbtmc_state.state = ((usbtmc_state.transfer_size_sent % usbtmc_state.ep_bulk_in_wMaxPacketSize) == 0) ? usbtmc_state.state = ((usbtmc_state.transfer_size_sent % usbtmc_state.ep_bulk_in_wMaxPacketSize) == 0) ? STATE_ABORTING_BULK_IN : STATE_ABORTING_BULK_IN_SHORTED;
STATE_ABORTING_BULK_IN : STATE_ABORTING_BULK_IN_SHORTED;
criticalLeave(); criticalLeave();
if(usbtmc_state.transfer_size_sent == 0) if (usbtmc_state.transfer_size_sent == 0) {
{
// Send short packet, nothing is in the buffer yet // Send short packet, nothing is in the buffer yet
TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) 0u)); TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) 0u));
usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED; usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
} }
TU_VERIFY(tud_usbtmc_initiate_abort_bulk_in_cb(&(rsp.USBTMC_status))); TU_VERIFY(tud_usbtmc_initiate_abort_bulk_in_cb(&(rsp.USBTMC_status)));
} } else if ((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED)) {// FIXME: Unsure how to check if the OUT endpoint fifo is non-empty....
else if((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED))
{ // FIXME: Unsure how to check if the OUT endpoint fifo is non-empty....
rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS; rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
} } else {
else
{
rsp.USBTMC_status = USBTMC_STATUS_FAILED; rsp.USBTMC_status = USBTMC_STATUS_FAILED;
} }
TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp))); TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp)));
return true; return true;
} }
case USBTMC_bREQUEST_CHECK_ABORT_BULK_IN_STATUS: case USBTMC_bREQUEST_CHECK_ABORT_BULK_IN_STATUS: {
{
TU_VERIFY(request->bmRequestType == 0xA2);// in,class,EP TU_VERIFY(request->bmRequestType == 0xA2);// in,class,EP
TU_VERIFY(request->wLength == 8u); TU_VERIFY(request->wLength == 8u);
@@ -797,14 +724,12 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
.USBTMC_status = USBTMC_STATUS_FAILED, .USBTMC_status = USBTMC_STATUS_FAILED,
.bmAbortBulkIn = .bmAbortBulkIn =
{ {
.BulkInFifoBytes = (usbtmc_state.state != STATE_ABORTING_BULK_IN_ABORTED) .BulkInFifoBytes = (usbtmc_state.state != STATE_ABORTING_BULK_IN_ABORTED)},
},
.NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent, .NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent,
}; };
TU_VERIFY(tud_usbtmc_check_abort_bulk_in_cb(&rsp)); TU_VERIFY(tud_usbtmc_check_abort_bulk_in_cb(&rsp));
criticalEnter(); criticalEnter();
switch(usbtmc_state.state) switch (usbtmc_state.state) {
{
case STATE_ABORTING_BULK_IN_ABORTED: case STATE_ABORTING_BULK_IN_ABORTED:
rsp.USBTMC_status = USBTMC_STATUS_SUCCESS; rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
usbtmc_state.state = STATE_IDLE; usbtmc_state.state = STATE_IDLE;
@@ -822,8 +747,7 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
return true; return true;
} }
case USBTMC_bREQUEST_INITIATE_CLEAR: case USBTMC_bREQUEST_INITIATE_CLEAR: {
{
TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
TU_VERIFY(request->wLength == sizeof(tmcStatusCode)); TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
// After receiving an INITIATE_CLEAR request, the device must Halt the Bulk-OUT endpoint, queue the // After receiving an INITIATE_CLEAR request, the device must Halt the Bulk-OUT endpoint, queue the
@@ -838,25 +762,20 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
return true; return true;
} }
case USBTMC_bREQUEST_CHECK_CLEAR_STATUS: case USBTMC_bREQUEST_CHECK_CLEAR_STATUS: {
{
TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
usbtmc_get_clear_status_rsp_t clearStatusRsp = {0}; usbtmc_get_clear_status_rsp_t clearStatusRsp = {0};
TU_VERIFY(request->wLength == sizeof(clearStatusRsp)); TU_VERIFY(request->wLength == sizeof(clearStatusRsp));
if(usbd_edpt_busy(rhport, usbtmc_state.ep_bulk_in)) if (usbd_edpt_busy(rhport, usbtmc_state.ep_bulk_in)) {
{
// Stuff stuck in TX buffer? // Stuff stuck in TX buffer?
clearStatusRsp.bmClear.BulkInFifoBytes = 1; clearStatusRsp.bmClear.BulkInFifoBytes = 1;
clearStatusRsp.USBTMC_status = USBTMC_STATUS_PENDING; clearStatusRsp.USBTMC_status = USBTMC_STATUS_PENDING;
} } else {
else
{
// Let app check if it's clear // Let app check if it's clear
TU_VERIFY(tud_usbtmc_check_clear_cb(&clearStatusRsp)); TU_VERIFY(tud_usbtmc_check_clear_cb(&clearStatusRsp));
} }
if(clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS) if (clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS) {
{
criticalEnter(); criticalEnter();
usbtmc_state.state = STATE_IDLE; usbtmc_state.state = STATE_IDLE;
criticalLeave(); criticalLeave();
@@ -865,8 +784,7 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
return true; return true;
} }
case USBTMC_bREQUEST_GET_CAPABILITIES: case USBTMC_bREQUEST_GET_CAPABILITIES: {
{
TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
TU_VERIFY(request->wLength == sizeof(*(usbtmc_state.capabilities))); TU_VERIFY(request->wLength == sizeof(*(usbtmc_state.capabilities)));
TU_VERIFY(tud_control_xfer(rhport, request, (void *) (uintptr_t) usbtmc_state.capabilities, sizeof(*usbtmc_state.capabilities))); TU_VERIFY(tud_control_xfer(rhport, request, (void *) (uintptr_t) usbtmc_state.capabilities, sizeof(*usbtmc_state.capabilities)));
@@ -886,8 +804,7 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
#if (CFG_TUD_USBTMC_ENABLE_488) #if (CFG_TUD_USBTMC_ENABLE_488)
// USB488 required requests // USB488 required requests
case USB488_bREQUEST_READ_STATUS_BYTE: case USB488_bREQUEST_READ_STATUS_BYTE: {
{
usbtmc_read_stb_rsp_488_t rsp; usbtmc_read_stb_rsp_488_t rsp;
TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
TU_VERIFY(request->wLength == sizeof(rsp));// in,class,interface TU_VERIFY(request->wLength == sizeof(rsp));// in,class,interface
@@ -899,15 +816,11 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
TU_VERIFY(request->wIndex == usbtmc_state.itf_id); TU_VERIFY(request->wIndex == usbtmc_state.itf_id);
TU_VERIFY(request->wLength == 0x0003); TU_VERIFY(request->wLength == 0x0003);
rsp.bTag = (uint8_t) bTag; rsp.bTag = (uint8_t) bTag;
if(usbtmc_state.ep_int_in != 0) if (usbtmc_state.ep_int_in != 0) {
{
rsp.statusByte = 0x00;// Use interrupt endpoint, instead. Must be 0x00 (USB488v1.0 4.3.1.2) rsp.statusByte = 0x00;// Use interrupt endpoint, instead. Must be 0x00 (USB488v1.0 4.3.1.2)
if(usbd_edpt_busy(rhport, usbtmc_state.ep_int_in)) if (usbd_edpt_busy(rhport, usbtmc_state.ep_int_in)) {
{
rsp.USBTMC_status = USB488_STATUS_INTERRUPT_IN_BUSY; rsp.USBTMC_status = USB488_STATUS_INTERRUPT_IN_BUSY;
} } else {
else
{
rsp.USBTMC_status = USBTMC_STATUS_SUCCESS; rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
usbtmc_read_stb_interrupt_488_t intMsg = usbtmc_read_stb_interrupt_488_t intMsg =
{ {
@@ -915,14 +828,11 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
.one = 1, .one = 1,
.bTag = bTag & 0x7Fu, .bTag = bTag & 0x7Fu,
}, },
.StatusByte = tud_usbtmc_get_stb_cb(&(rsp.USBTMC_status)) .StatusByte = tud_usbtmc_get_stb_cb(&(rsp.USBTMC_status))};
};
// Must be queued before control request response sent (USB488v1.0 4.3.1.2) // Must be queued before control request response sent (USB488v1.0 4.3.1.2)
usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void *) &intMsg, sizeof(intMsg)); usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void *) &intMsg, sizeof(intMsg));
} }
} } else {
else
{
rsp.statusByte = tud_usbtmc_get_stb_cb(&(rsp.USBTMC_status)); rsp.statusByte = tud_usbtmc_get_stb_cb(&(rsp.USBTMC_status));
} }
TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp))); TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp)));
@@ -931,8 +841,7 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
// USB488 optional requests // USB488 optional requests
case USB488_bREQUEST_REN_CONTROL: case USB488_bREQUEST_REN_CONTROL:
case USB488_bREQUEST_GO_TO_LOCAL: case USB488_bREQUEST_GO_TO_LOCAL:
case USB488_bREQUEST_LOCAL_LOCKOUT: case USB488_bREQUEST_LOCAL_LOCKOUT: {
{
TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
return false; return false;
} }