mirror/tinyusb
1
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2025-04-16 14:42:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

usbtmc updates....

Browse Source
This commit is contained in:
Nathan Conrad 2019-09-18 19:24:54 -04:00
parent f9a2e8e405
commit eea71a8b3b
5 changed files with 261 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/device/usbtmc/src/tusb_config.h
View File

@ -56,8 +56,8 @@
//------------- CLASS -------------// //------------- CLASS -------------//
#define CFG_TUD_USBTMC 1 #define CFG_TUD_USBTMC 1
#define CFG_TUD_USBTMC_ENABLE_INT_EP #define CFG_TUD_USBTMC_ENABLE_INT_EP 1
//#define USBTMC_CFG_ENABLE_488 0 #define USBTMC_CFG_ENABLE_488 1
#ifdef __cplusplus #ifdef __cplusplus
} }

32
examples/device/usbtmc/src/usbtmc_app.c
View File

@ -64,8 +64,8 @@ usbtmcd_app_capabilities =
} }
#endif #endif
}; };
//static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer"; static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer123456\r\n";
static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer and a bunch of other text to make it longer than a packet, perhaps?\n"; //static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer and a bunch of other text to make it longer than a packet, perhaps? lets make it three transfers...\n";
static volatile uint8_t status; static volatile uint8_t status;
// 0=not query, 1=queried, 2=delay,set(MAV), 3=delay 4=ready? // 0=not query, 1=queried, 2=delay,set(MAV), 3=delay 4=ready?
@ -154,14 +154,14 @@ void usbtmc_app_task_iter(void) {
queryState = 2; queryState = 2;
break; break;
case 2: case 2:
if( (board_millis() - queryDelayStart) > 5u) { if( (board_millis() - queryDelayStart) > 200u) {
queryDelayStart = board_millis(); queryDelayStart = board_millis();
queryState=3; queryState=3;
status |= 0x10u; // MAV status |= 0x10u; // MAV
} }
break; break;
case 3: case 3:
if( (board_millis() - queryDelayStart) > 10u) { if( (board_millis() - queryDelayStart) > 400u) {
queryState = 4; queryState = 4;
} }
break; break;
@ -169,6 +169,7 @@ void usbtmc_app_task_iter(void) {
if(bulkInStarted) { if(bulkInStarted) {
queryState = 0; queryState = 0;
bulkInStarted = 0; bulkInStarted = 0;
uart_tx_str_sync("usbtmc_app_task_iter: sending rsp!\r\n");
usbtmcd_transmit_dev_msg_data(rhport, idn, tu_min32(sizeof(idn)-1,msgReqLen),false); usbtmcd_transmit_dev_msg_data(rhport, idn, tu_min32(sizeof(idn)-1,msgReqLen),false);
// MAV is cleared in the transfer complete callback. // MAV is cleared in the transfer complete callback.
} }
@ -189,7 +190,7 @@ bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult)
return true; return true;
} }
bool usbtmcd_app_get_clear_status(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp) bool usbtmcd_app_check_clear(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp)
{ {
(void)rhport; (void)rhport;
queryState = 0; queryState = 0;
@ -199,6 +200,27 @@ bool usbtmcd_app_get_clear_status(uint8_t rhport, usbtmc_get_clear_status_rsp_t
rsp->bmClear.BulkInFifoBytes = 0u; rsp->bmClear.BulkInFifoBytes = 0u;
return true; return true;
} }
bool usbtmcd_app_initiate_abort_bulk_in(uint8_t rhport, uint8_t *tmcResult)
{
bulkInStarted = 0;
*tmcResult = USBTMC_STATUS_SUCCESS;
return true;
}
bool usbtmcd_app_check_abort_bulk_in(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp)
{
return true;
}
bool usbtmcd_app_initiate_abort_bulk_out(uint8_t rhport, uint8_t *tmcResult)
{
*tmcResult = USBTMC_STATUS_SUCCESS;
return true;
}
bool usbtmcd_app_check_abort_bulk_out(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp)
{
return true;
}
void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport) void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport)
{ {

14
src/class/usbtmc/usbtmc.h
View File

@ -237,6 +237,20 @@ typedef struct TU_ATTR_PACKED
TU_VERIFY_STATIC(sizeof(usbtmc_get_clear_status_rsp_t) == 2u, "struct wrong length"); TU_VERIFY_STATIC(sizeof(usbtmc_get_clear_status_rsp_t) == 2u, "struct wrong length");
// Used for both check_abort_bulk_in_status and check_abort_bulk_out_status
typedef struct TU_ATTR_PACKED
{
uint8_t USBTMC_status;
struct TU_ATTR_PACKED
{
unsigned int BulkInFifoBytes : 1; ///< Has queued data or a short packet that is queued
} bmAbortBulkIn;
uint8_t _reserved[2]; ///< Must be zero
uint32_t NBYTES_RXD_TXD;
} usbtmc_check_abort_bulk_rsp_t;
TU_VERIFY_STATIC(sizeof(usbtmc_check_abort_bulk_rsp_t) == 8u, "struct wrong length");
typedef struct TU_ATTR_PACKED typedef struct TU_ATTR_PACKED
{ {
uint8_t USBTMC_status; ///< usbtmc_status_enum uint8_t USBTMC_status; ///< usbtmc_status_enum

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

@ -93,8 +93,11 @@ typedef enum
STATE_RCV, STATE_RCV,
STATE_TX_REQUESTED, STATE_TX_REQUESTED,
STATE_TX_INITIATED, STATE_TX_INITIATED,
STATE_TX_SHORTED,
STATE_CLEARING, STATE_CLEARING,
STATE_ABORTING_BULK_IN, STATE_ABORTING_BULK_IN,
STATE_ABORTING_BULK_IN_SHORTED, // aborting, and short packet has been queued for transmission
STATE_ABORTING_BULK_IN_ABORTED, // aborting, and short packet has been queued for transmission
STATE_ABORTING_BULK_OUT, STATE_ABORTING_BULK_OUT,
STATE_NUM_STATES STATE_NUM_STATES
} usbtmcd_state_enum; } usbtmcd_state_enum;
@ -113,6 +116,7 @@ typedef struct
// OUT buffer receives one packet at a time // OUT buffer receives one packet at a time
uint8_t ep_bulk_out_buf[USBTMCD_MAX_PACKET_SIZE]; uint8_t ep_bulk_out_buf[USBTMCD_MAX_PACKET_SIZE];
uint32_t transfer_size_remaining; // also used for requested length for bulk IN. uint32_t transfer_size_remaining; // also used for requested length for bulk IN.
uint32_t transfer_size_sent; // To keep track of data bytes that have been queued in FIFO (not header bytes)
uint8_t lastBulkOutTag; // used for aborts (mostly) uint8_t lastBulkOutTag; // used for aborts (mostly)
uint8_t lastBulkInTag; // used for aborts (mostly) uint8_t lastBulkInTag; // used for aborts (mostly)
@ -128,6 +132,11 @@ static usbtmc_interface_state_t usbtmc_state =
.ep_bulk_out = 0, .ep_bulk_out = 0,
.ep_int_in = 0 .ep_int_in = 0
}; };
#ifdef xDEBUG
#define TRACE(str) uart_tx_str_sync(str)
#else
#define TRACE(STR) do {} while (0)
#endif
// We need all headers to fit in a single packet in this implementation. // We need all headers to fit in a single packet in this implementation.
TU_VERIFY_STATIC(USBTMCD_MAX_PACKET_SIZE >= 32u,"USBTMC dev EP packet size too small"); TU_VERIFY_STATIC(USBTMCD_MAX_PACKET_SIZE >= 32u,"USBTMC dev EP packet size too small");
@ -188,7 +197,7 @@ bool usbtmcd_transmit_dev_msg_data(
if((packetLen + hdr->TransferSize) <= txBufLen) if((packetLen + hdr->TransferSize) <= txBufLen)
{ {
memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + packetLen, data, hdr->TransferSize); memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + packetLen, data, hdr->TransferSize);
packetLen = (uint16_t)(packetLen+ hdr->TransferSize); packetLen = (uint16_t)(packetLen + hdr->TransferSize);
// Pad up to multiple of 4 bytes // Pad up to multiple of 4 bytes
while((packetLen % 4) != 0) while((packetLen % 4) != 0)
{ {
@ -196,13 +205,15 @@ bool usbtmcd_transmit_dev_msg_data(
packetLen++; packetLen++;
} }
usbtmc_state.transfer_size_remaining = 0; usbtmc_state.transfer_size_remaining = 0;
usbtmc_state.transfer_size_sent = len;
usbtmc_state.devInBuffer = NULL; usbtmc_state.devInBuffer = NULL;
} }
else /* partial packet */ else /* partial packet */
{ {
memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + packetLen, data, txBufLen - packetLen); memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + packetLen, data, txBufLen - packetLen);
usbtmc_state.devInBuffer += txBufLen - packetLen; usbtmc_state.devInBuffer = (uint8_t*)data + (txBufLen - packetLen);
usbtmc_state.transfer_size_remaining = hdr->TransferSize - (txBufLen - packetLen); usbtmc_state.transfer_size_remaining = len - (txBufLen - packetLen);
usbtmc_state.transfer_size_sent = txBufLen - packetLen;
packetLen = txBufLen; packetLen = txBufLen;
} }
@ -210,7 +221,8 @@ bool usbtmcd_transmit_dev_msg_data(
criticalEnter(); criticalEnter();
{ {
TU_VERIFY(usbtmc_state.state == STATE_TX_REQUESTED); TU_VERIFY(usbtmc_state.state == STATE_TX_REQUESTED);
usbtmc_state.state = STATE_TX_INITIATED; // We used packetlen as a max, not the buffer size, so this is OK here, no need for modulus
usbtmc_state.state = (packetLen >= txBufLen) ? STATE_TX_INITIATED : STATE_TX_SHORTED;
} }
criticalLeave(); criticalLeave();
@ -322,6 +334,8 @@ void usbtmcd_reset(uint8_t rhport)
usbtmc_state.ep_bulk_in = 0; usbtmc_state.ep_bulk_in = 0;
usbtmc_state.ep_bulk_out = 0; usbtmc_state.ep_bulk_out = 0;
usbtmc_state.ep_int_in = 0; usbtmc_state.ep_int_in = 0;
usbtmc_state.lastBulkInTag = 0;
usbtmc_state.lastBulkOutTag = 0;
(void)rhport; (void)rhport;
} }
@ -351,10 +365,16 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
if(len > usbtmc_state.transfer_size_remaining) if(len > usbtmc_state.transfer_size_remaining)
len = usbtmc_state.transfer_size_remaining; len = usbtmc_state.transfer_size_remaining;
usbtmcd_app_msg_data(rhport,data, len, atEnd); usbtmcd_app_msg_data(rhport,data, len, atEnd);
usbtmc_state.transfer_size_sent += len;
if(atEnd) if(atEnd)
{
usbtmc_state.state = STATE_IDLE; usbtmc_state.state = STATE_IDLE;
}
else else
{
usbtmc_state.state = STATE_RCV; usbtmc_state.state = STATE_RCV;
}
return true; return true;
} }
@ -363,8 +383,10 @@ static bool handle_devMsgIn(uint8_t rhport, 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;
#ifdef xDebug
sprintf(logMsg," handle_devMsgIn len=%ul\r\n",len); sprintf(logMsg," handle_devMsgIn len=%ul\r\n",len);
uart_tx_str_sync(logMsg); TRACE(logMsg);
#endif
criticalEnter(); criticalEnter();
{ {
@ -387,10 +409,13 @@ static bool handle_devMsgIn(uint8_t rhport, void *data, size_t len)
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)
{ {
TRACE("USBTMC Xfer CB" );
TU_VERIFY(result == XFER_RESULT_SUCCESS); TU_VERIFY(result == XFER_RESULT_SUCCESS);
uart_tx_str_sync("USBTMC Xfer CB" );
#ifdef xDebug
sprintf(logMsg," STATE=%lu ", (uint32_t)usbtmc_state.state); sprintf(logMsg," STATE=%lu ", (uint32_t)usbtmc_state.state);
uart_tx_str_sync(logMsg); TRACE(logMsg);
#endif
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 */
@ -398,23 +423,26 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
if(ep_addr == usbtmc_state.ep_bulk_out) if(ep_addr == usbtmc_state.ep_bulk_out)
{ {
uart_tx_str_sync("OUT"); usbtmc_msg_generic_t *msg = NULL;
TRACE("OUT");
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));
usbtmc_msg_generic_t *msg = (usbtmc_msg_generic_t*)(usbtmc_state.ep_bulk_out_buf); msg = (usbtmc_msg_generic_t*)(usbtmc_state.ep_bulk_out_buf);
uint8_t invInvTag = (uint8_t)~(msg->header.bTagInverse); uint8_t invInvTag = (uint8_t)~(msg->header.bTagInverse);
TU_VERIFY(msg->header.bTag == invInvTag); TU_VERIFY(msg->header.bTag == invInvTag);
TU_VERIFY(msg->header.bTag != 0x00); TU_VERIFY(msg->header.bTag != 0x00);
#ifdef xDebug
sprintf(logMsg," type=%lu\r\n",(uint32_t)msg->header.MsgID); sprintf(logMsg," type=%lu\r\n",(uint32_t)msg->header.MsgID);
uart_tx_str_sync(logMsg); TRACE(logMsg);
#endif
switch(msg->header.MsgID) { switch(msg->header.MsgID) {
case USBTMC_MSGID_DEV_DEP_MSG_OUT: case USBTMC_MSGID_DEV_DEP_MSG_OUT:
usbtmc_state.transfer_size_sent = 0u;
TU_VERIFY(handle_devMsgOutStart(rhport, msg, xferred_bytes)); TU_VERIFY(handle_devMsgOutStart(rhport, msg, xferred_bytes));
TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_out, usbtmc_state.ep_bulk_out_buf, USBTMCD_MAX_PACKET_SIZE));
usbtmc_state.lastBulkOutTag = msg->header.bTag; usbtmc_state.lastBulkOutTag = msg->header.bTag;
break; break;
@ -428,7 +456,6 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
// Spec says we halt the EP if we didn't declare we support it. // Spec says we halt the EP if we didn't declare we support it.
TU_VERIFY(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger); TU_VERIFY(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger);
TU_VERIFY(usbtmcd_app_msg_trigger(rhport, msg)); TU_VERIFY(usbtmcd_app_msg_trigger(rhport, msg));
TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_out, usbtmc_state.ep_bulk_out_buf, USBTMCD_MAX_PACKET_SIZE));
break; break;
#endif #endif
@ -439,58 +466,95 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
TU_VERIFY(false); TU_VERIFY(false);
return false; return false;
} }
TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_out, usbtmc_state.ep_bulk_out_buf, USBTMCD_MAX_PACKET_SIZE));
return true; return true;
case STATE_RCV: case STATE_RCV:
TU_VERIFY(handle_devMsgOut(rhport, usbtmc_state.ep_bulk_out_buf, xferred_bytes, xferred_bytes)); TU_VERIFY(handle_devMsgOut(rhport, usbtmc_state.ep_bulk_out_buf, xferred_bytes, xferred_bytes));
return true; return true;
case STATE_ABORTING_BULK_OUT:
TU_VERIFY(false);
return false; // Shold be stalled by now...
case STATE_TX_REQUESTED: case STATE_TX_REQUESTED:
case STATE_TX_INITIATED: case STATE_TX_INITIATED:
case STATE_ABORTING_BULK_IN: case STATE_ABORTING_BULK_IN:
case STATE_ABORTING_BULK_OUT: case STATE_ABORTING_BULK_IN_SHORTED:
case STATE_ABORTING_BULK_IN_ABORTED:
default: default:
#ifdef xDebug
if(msg == NULL) if(msg == NULL)
sprintf(logMsg," Unknown received control?\r\n "); sprintf(logMsg," Unknown received control?\r\n ");
else { else {
sprintf(logMsg," msg=%lu\r\n ", (uint32_t)msg->header.MsgID); sprintf(logMsg," msg=%lu\r\n ", (uint32_t)msg->header.MsgID);
} }
uart_tx_str_sync(logMsg); TRACE(logMsg);
#endif
TU_VERIFY(false); TU_VERIFY(false);
} }
} }
else if(ep_addr == usbtmc_state.ep_bulk_in) else if(ep_addr == usbtmc_state.ep_bulk_in)
{ {
#ifdef xDebug
sprintf(logMsg,"IN\r\n"); sprintf(logMsg,"IN\r\n");
uart_tx_str_sync(logMsg); TRACE(logMsg);
TU_ASSERT(usbtmc_state.state == STATE_TX_INITIATED); #endif
if(usbtmc_state.transfer_size_remaining == 0) switch(usbtmc_state.state) {
{ case STATE_TX_SHORTED:
TRACE("IN TX shorted done\r\n");
usbtmc_state.state = STATE_IDLE; usbtmc_state.state = STATE_IDLE;
TU_VERIFY(usbtmcd_app_msgBulkIn_complete(rhport)); TU_VERIFY(usbtmcd_app_msgBulkIn_complete(rhport));
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_out, usbtmc_state.ep_bulk_out_buf, USBTMCD_MAX_PACKET_SIZE)); break;
}
else if(usbtmc_state.transfer_size_remaining > sizeof(usbtmc_state.devInBuffer)) case STATE_TX_INITIATED:
{ if(usbtmc_state.transfer_size_remaining >=sizeof(usbtmc_state.ep_bulk_in_buf))
memcpy(usbtmc_state.ep_bulk_in_buf, usbtmc_state.devInBuffer, sizeof(usbtmc_state.ep_bulk_in_buf));
usbtmc_state.devInBuffer += sizeof(usbtmc_state.devInBuffer);
usbtmc_state.transfer_size_remaining -= sizeof(usbtmc_state.devInBuffer);
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,sizeof(usbtmc_state.devInBuffer)));
}
else // last packet
{
size_t packetLen = usbtmc_state.transfer_size_remaining;
memcpy(usbtmc_state.ep_bulk_in_buf, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining);
while((packetLen % 4) != 0)
{ {
usbtmc_state.ep_bulk_in_buf[packetLen] = 0; TRACE("IN TX continuing\r\n");
packetLen++; memcpy(usbtmc_state.ep_bulk_in_buf, usbtmc_state.devInBuffer, sizeof(usbtmc_state.ep_bulk_in_buf));
usbtmc_state.devInBuffer += sizeof(usbtmc_state.devInBuffer);
usbtmc_state.transfer_size_remaining -= sizeof(usbtmc_state.devInBuffer);
usbtmc_state.transfer_size_sent += sizeof(usbtmc_state.devInBuffer);
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,sizeof(usbtmc_state.devInBuffer)));
} }
usbtmc_state.transfer_size_remaining = 0; else // last packet
usbtmc_state.devInBuffer = NULL; {
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,(uint16_t)packetLen)); TRACE("IN TX last packet\r\n");
size_t packetLen = usbtmc_state.transfer_size_remaining;
memcpy(usbtmc_state.ep_bulk_in_buf, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining);
while((packetLen % 4) != 0)
{
usbtmc_state.ep_bulk_in_buf[packetLen] = 0u;
packetLen++;
}
usbtmc_state.transfer_size_sent += sizeof(usbtmc_state.transfer_size_remaining);
usbtmc_state.transfer_size_remaining = 0;
usbtmc_state.devInBuffer = NULL;
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,(uint16_t)packetLen));
if(((packetLen % USBTMCD_MAX_PACKET_SIZE) != 0) || (packetLen == 0 ))
{
usbtmc_state.state = STATE_TX_SHORTED;
}
}
return true;
case STATE_ABORTING_BULK_IN:
// need to send short packet (ZLP?)
TRACE("IN aborting\r\n");
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,(uint16_t)0u));
usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
return true;
case STATE_ABORTING_BULK_IN_SHORTED:
/* Done. :)*/
TRACE("IN shorted\r\n");
usbtmc_state.state = STATE_ABORTING_BULK_IN_ABORTED;
return true;
default:
TRACE("IN unknown\r\n");
TU_ASSERT(false);
return false;
} }
return true;
} }
else if (ep_addr == usbtmc_state.ep_int_in) { else if (ep_addr == usbtmc_state.ep_int_in) {
// Good? // Good?
@ -505,13 +569,14 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
#if (USBTMC_CFG_ENABLE_488) #if (USBTMC_CFG_ENABLE_488)
uint8_t bTag; uint8_t bTag;
#endif #endif
TRACE("xfer cb\r\n");
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))
{ {
uart_tx_str_sync("feature clear\r\n"); TRACE("feature clear\r\n");
if((request->wIndex) == usbtmc_state.ep_bulk_out) if((request->wIndex) == usbtmc_state.ep_bulk_out)
{ {
usmtmcd_app_bulkOut_clearFeature(rhport); usmtmcd_app_bulkOut_clearFeature(rhport);
@ -536,42 +601,124 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
{ {
// USBTMC required requests // USBTMC required requests
case USBTMC_bREQUEST_INITIATE_ABORT_BULK_OUT: case USBTMC_bREQUEST_INITIATE_ABORT_BULK_OUT:
case USBTMC_bREQUEST_CHECK_ABORT_BULK_OUT_STATUS:
{ {
TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP usbtmc_initiate_abort_rsp_t rsp = {
TU_VERIFY(request->wLength == 1u); .bTag = usbtmc_state.lastBulkOutTag,
tmcStatusCode = USBTMC_STATUS_FAILED; };
usbd_edpt_xfer(rhport, 0u, (void*)&tmcStatusCode,sizeof(tmcStatusCode)); TRACE("init abort bulk out\r\n");
TU_VERIFY(request->bmRequestType == 0xA2); // in,class,interface
TU_VERIFY(request->wLength == sizeof(rsp));
TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
// wValue is the requested bTag to abort
if(usbtmc_state.state != STATE_RCV)
{
rsp.USBTMC_status = USBTMC_STATUS_FAILED;
TRACE("init abort bulk out failed\r\n");
}
else if(usbtmc_state.lastBulkOutTag == (request->wValue & 0xf7u))
{
rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
TRACE("init abort bulk out not inprogress\r\n");
}
else
{
rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
// Check if we've queued a short packet
usbtmc_state.state = STATE_ABORTING_BULK_OUT;
TU_VERIFY(usbtmcd_app_initiate_abort_bulk_out(rhport, &(rsp.USBTMC_status)));
usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
TRACE("init abort bulk out success\r\n");
}
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_OUT_STATUS:
{ {
TRACE("init check abort bulk out\r\n");
usbtmc_check_abort_bulk_rsp_t rsp = {
.USBTMC_status = USBTMC_STATUS_SUCCESS,
.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 == 1u); TU_VERIFY(request->wLength == sizeof(rsp));
usbtmc_get_clear_status_rsp_t clearStatusRsp = {0}; TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
tmcStatusCode = USBTMC_STATUS_FAILED; TU_VERIFY(usbtmcd_app_check_abort_bulk_out(rhport, &(rsp.USBTMC_status)));
usbd_edpt_xfer(rhport, 0u, (void*)&tmcStatusCode,sizeof(tmcStatusCode)); TU_VERIFY(usbd_edpt_xfer(rhport, 0u, (void*)&rsp,sizeof(rsp)));
return true; return true;
} }
case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN: case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN:
{ {
usbtmc_initiate_abort_rsp_t rsp = {0}; usbtmc_initiate_abort_rsp_t rsp = {
uart_tx_str_sync("init abort bulk in\r\n"); .bTag = usbtmc_state.lastBulkInTag,
TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface };
TU_VERIFY(request->wLength == sizeof(tmcStatusCode)); TRACE("init abort bulk in\r\n");
TU_VERIFY(request->wIndex == usbtmc_state.ep_int_in); TU_VERIFY(request->bmRequestType == 0xA2); // in,class,interface
TU_VERIFY(request->wLength == sizeof(rsp));
TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_in);
// wValue is the requested bTag to abort // wValue is the requested bTag to abort
usbtmc_state.transfer_size_remaining = 0; if((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED) &&
usbtmc_state.state = STATE_ABORTING_BULK_IN; usbtmc_state.lastBulkInTag == (request->wValue & 0xf7u))
TU_VERIFY(usbtmcd_app_initiate_clear(rhport, &tmcStatusCode)); {
TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode,sizeof(tmcStatusCode))); rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
usbtmc_state.transfer_size_remaining = 0;
// Check if we've queued a short packet
usbtmc_state.state = ((usbtmc_state.transfer_size_sent % USBTMCD_MAX_PACKET_SIZE) != 0) ?
STATE_ABORTING_BULK_IN : STATE_ABORTING_BULK_IN_SHORTED;
TU_VERIFY(usbtmcd_app_initiate_abort_bulk_in(rhport, &(rsp.USBTMC_status)));
TRACE("init abort bulk success\r\n");
}
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;
TRACE("init abort bulk in not in progress\r\n");
}
else
{
rsp.USBTMC_status = USBTMC_STATUS_FAILED;
TRACE("init abort bulk in failed\r\n");
}
TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp)));
return true;
}
case USBTMC_bREQUEST_CHECK_ABORT_BULK_IN_STATUS:
{
TRACE("xfer check abort in\r\n");
TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
TU_VERIFY(request->wLength == 8u);
usbtmc_check_abort_bulk_rsp_t rsp =
{
.USBTMC_status = USBTMC_STATUS_FAILED,
.bmAbortBulkIn =
{
.BulkInFifoBytes = (usbtmc_state.state == STATE_ABORTING_BULK_IN_ABORTED)
},
.NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent,
};
TU_VERIFY(usbtmcd_app_check_abort_bulk_in(rhport, &rsp));
switch(usbtmc_state.state)
{
case STATE_ABORTING_BULK_IN_ABORTED:
rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
break;
case STATE_ABORTING_BULK_IN:
case STATE_ABORTING_BULK_OUT:
rsp.USBTMC_status = USBTMC_STATUS_PENDING;
break;
default:
break;
}
TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp)));
return true; return true;
} }
case USBTMC_bREQUEST_INITIATE_CLEAR: case USBTMC_bREQUEST_INITIATE_CLEAR:
{ {
uart_tx_str_sync("init clear\r\n"); TRACE("init clear\r\n");
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
@ -586,7 +733,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
case USBTMC_bREQUEST_CHECK_CLEAR_STATUS: case USBTMC_bREQUEST_CHECK_CLEAR_STATUS:
{ {
uart_tx_str_sync("check clear\r\n"); TRACE("check clear\r\n");
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));
@ -600,7 +747,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
else else
{ {
// Let app check if it's clear // Let app check if it's clear
TU_VERIFY(usbtmcd_app_get_clear_status(rhport, &clearStatusRsp)); TU_VERIFY(usbtmcd_app_check_clear(rhport, &clearStatusRsp));
} }
if(clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS) if(clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS)
usbtmc_state.state = STATE_IDLE; usbtmc_state.state = STATE_IDLE;
@ -610,7 +757,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
case USBTMC_bREQUEST_GET_CAPABILITIES: case USBTMC_bREQUEST_GET_CAPABILITIES:
{ {
uart_tx_str_sync("get capabilities\r\n"); TRACE("get capabilities\r\n");
TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
TU_VERIFY(request->wLength == sizeof(usbtmcd_app_capabilities)); TU_VERIFY(request->wLength == sizeof(usbtmcd_app_capabilities));
TU_VERIFY(tud_control_xfer(rhport, request, (void*)&usbtmcd_app_capabilities, sizeof(usbtmcd_app_capabilities))); TU_VERIFY(tud_control_xfer(rhport, request, (void*)&usbtmcd_app_capabilities, sizeof(usbtmcd_app_capabilities)));
@ -620,7 +767,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
case USBTMC_bREQUEST_INDICATOR_PULSE: // Optional case USBTMC_bREQUEST_INDICATOR_PULSE: // Optional
{ {
uart_tx_str_sync("indicate\r\n"); TRACE("indicate\r\n");
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));
TU_VERIFY(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse); TU_VERIFY(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse);
@ -633,7 +780,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
// USB488 required requests // USB488 required requests
case USBTMC488_bREQUEST_READ_STATUS_BYTE: case USBTMC488_bREQUEST_READ_STATUS_BYTE:
{ {
uart_tx_str_sync("read stb\r\n"); TRACE("read stb\r\n");
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
@ -672,7 +819,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
case USBTMC488_bREQUEST_GO_TO_LOCAL: case USBTMC488_bREQUEST_GO_TO_LOCAL:
case USBTMC488_bREQUEST_LOCAL_LOCKOUT: case USBTMC488_bREQUEST_LOCAL_LOCKOUT:
{ {
uart_tx_str_sync("Unsupported REN/GTL/LLO\r\n"); TRACE("Unsupported REN/GTL/LLO\r\n");
TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
TU_VERIFY(false); TU_VERIFY(false);
return false; return false;
@ -680,7 +827,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
#endif #endif
default: default:
uart_tx_str_sync("Default CTRL handler\r\n"); TRACE("Default CTRL handler\r\n");
TU_VERIFY(false); TU_VERIFY(false);
return false; return false;
} }

6
src/class/usbtmc/usbtmc_device.h
View File

@ -64,9 +64,13 @@ bool usbtmcd_app_msgBulkIn_request(uint8_t rhport, usbtmc_msg_request_dev_dep_in
bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport); bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport);
void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport); // Notice to clear and abort the pending BULK out transfer void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport); // Notice to clear and abort the pending BULK out transfer
bool usbtmcd_app_initiate_abort_bulk_in(uint8_t rhport, uint8_t *tmcResult);
bool usbtmcd_app_initiate_abort_bulk_out(uint8_t rhport, uint8_t *tmcResult);
bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult); bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult);
bool usbtmcd_app_get_clear_status(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp); bool usbtmcd_app_check_abort_bulk_in(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp);
bool usbtmcd_app_check_abort_bulk_out(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp);
bool usbtmcd_app_check_clear(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp);
// Indicator pulse should be 0.5 to 1.0 seconds long // Indicator pulse should be 0.5 to 1.0 seconds long
TU_ATTR_WEAK bool usbtmcd_app_indicator_pluse(uint8_t rhport, tusb_control_request_t const * msg, uint8_t *tmcResult); TU_ATTR_WEAK bool usbtmcd_app_indicator_pluse(uint8_t rhport, tusb_control_request_t const * msg, uint8_t *tmcResult);