From c755aee7d0c1e2486055e02ac353878d8da3ba59 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Sat, 14 Sep 2019 22:55:42 -0400
Subject: Clear

---
 src/class/usbtmc/usbtmc.h        |  94 +++++++++++++++++----------
 src/class/usbtmc/usbtmc_device.c | 137 +++++++++++++++++++++++++--------------
 src/class/usbtmc/usbtmc_device.h |   4 ++
 3 files changed, 153 insertions(+), 82 deletions(-)

(limited to 'src')

diff --git a/src/class/usbtmc/usbtmc.h b/src/class/usbtmc/usbtmc.h
index ecc16a315..d24a72cb6 100644
--- a/src/class/usbtmc/usbtmc.h
+++ b/src/class/usbtmc/usbtmc.h
@@ -73,53 +73,67 @@ typedef struct TU_ATTR_PACKED
 typedef struct TU_ATTR_PACKED {
 	usbtmc_msg_header_t header ; ///< Header
 	uint32_t TransferSize      ; ///< Transfer size; LSB first
-	struct {
-      uint8_t EOM  : 1         ; ///< EOM set on last byte
+	struct TU_ATTR_PACKED
+	{
+	  unsigned int EOM  : 1         ; ///< EOM set on last byte
   } bmTransferAttributes;
   uint8_t _reserved[3];
 } usbtmc_msg_request_dev_dep_out;
 
+TU_VERIFY_STATIC(sizeof(usbtmc_msg_request_dev_dep_out) == 12u, "struct wrong length");
+
 // Next 8 bytes are message-specific
-typedef struct TU_ATTR_PACKED {
+typedef struct TU_ATTR_PACKED
+{
   usbtmc_msg_header_t header ; ///< Header
   uint32_t TransferSize      ; ///< Transfer size; LSB first
-  struct {
-      uint8_t : 0;
-      uint8_t TermCharEnabled  : 1 ; ///< "The Bulk-IN transfer must terminate on the specified TermChar."; CAPABILITIES must list TermChar
+  struct TU_ATTR_PACKED
+  {
+    unsigned int TermCharEnabled  : 1 ; ///< "The Bulk-IN transfer must terminate on the specified TermChar."; CAPABILITIES must list TermChar
   } bmTransferAttributes;
   uint8_t TermChar;
   uint8_t _reserved[2];
 } usbtmc_msg_request_dev_dep_in;
 
+TU_VERIFY_STATIC(sizeof(usbtmc_msg_request_dev_dep_in) == 12u, "struct wrong length");
+
 /* Bulk-in headers */
 
 typedef struct TU_ATTR_PACKED
 {
   usbtmc_msg_header_t header;
   uint32_t TransferSize;
-  struct {
+  struct TU_ATTR_PACKED
+  {
     uint8_t EOM: 1;           ///< Last byte of transfer is the end of the message
     uint8_t UsingTermChar: 1; ///< Support TermChar && Request.TermCharEnabled && last char in transfer is TermChar
   } bmTransferAttributes;
   uint8_t _reserved[3];
 } usbtmc_msg_dev_dep_msg_in_header_t;
 
+TU_VERIFY_STATIC(sizeof(usbtmc_msg_dev_dep_msg_in_header_t) == 12u, "struct wrong length");
 
 /* Unsupported vendor things.... Are these ever used?*/
 
-typedef struct TU_ATTR_PACKED {
+typedef struct TU_ATTR_PACKED
+{
   usbtmc_msg_header_t header ; ///< Header
   uint32_t TransferSize      ; ///< Transfer size; LSB first
   uint8_t _reserved[4];
 } usbtmc_msg_request_vendor_specific_out;
 
 
-typedef struct TU_ATTR_PACKED {
+TU_VERIFY_STATIC(sizeof(usbtmc_msg_request_vendor_specific_out) == 12u, "struct wrong length");
+
+typedef struct TU_ATTR_PACKED
+{
   usbtmc_msg_header_t header ; ///< Header
   uint32_t TransferSize      ; ///< Transfer size; LSB first
   uint8_t _reserved[4];
 } usbtmc_msg_request_vendor_specific_in;
 
+TU_VERIFY_STATIC(sizeof(usbtmc_msg_request_vendor_specific_in) == 12u, "struct wrong length");
+
 // Control request type should use tusb_control_request_t
 
 /*
@@ -187,13 +201,15 @@ typedef struct TU_ATTR_PACKED {
   uint8_t _reserved;
   uint16_t bcdUSBTMC;                    ///< USBTMC_VERSION
 
-  struct {
-    uint8_t listenOnly :1;
-    uint8_t talkOnly :1;
-    uint8_t supportsIndicatorPulse :1;
+  struct TU_ATTR_PACKED
+  {
+    unsigned int listenOnly :1;
+    unsigned int talkOnly :1;
+    unsigned int supportsIndicatorPulse :1;
   } bmIntfcCapabilities;
-  struct {
-    uint8_t canEndBulkInOnTermChar :1;
+  struct TU_ATTR_PACKED
+  {
+    unsigned int canEndBulkInOnTermChar :1;
   } bmDevCapabilities;
   uint8_t _reserved2[6];
   uint8_t _reserved3[12];
@@ -201,40 +217,51 @@ typedef struct TU_ATTR_PACKED {
 
 TU_VERIFY_STATIC(sizeof(usbtmc_response_capabilities_t) == 0x18, "struct wrong length");
 
+typedef struct TU_ATTR_PACKED
+{
+  uint8_t USBTMC_status;
+  struct TU_ATTR_PACKED
+  {
+    unsigned int BulkInFifoBytes :1;
+  } bmClear;
+} usbtmc_get_clear_status_rsp_t;
+
+TU_VERIFY_STATIC(sizeof(usbtmc_get_clear_status_rsp_t) == 2u, "struct wrong length");
+
 typedef struct TU_ATTR_PACKED
 {
   uint8_t USBTMC_status;                 ///< usbtmc_status_enum
   uint8_t _reserved;
   uint16_t bcdUSBTMC;                    ///< USBTMC_VERSION
 
-  struct
+  struct TU_ATTR_PACKED
   {
-    uint8_t listenOnly :1;
-    uint8_t talkOnly :1;
-    uint8_t supportsIndicatorPulse :1;
+    unsigned int listenOnly :1;
+    unsigned int talkOnly :1;
+    unsigned int supportsIndicatorPulse :1;
   } bmIntfcCapabilities;
 
-  struct
+  struct TU_ATTR_PACKED
   {
-    uint8_t canEndBulkInOnTermChar :1;
+    unsigned int canEndBulkInOnTermChar :1;
   } bmDevCapabilities;
 
   uint8_t _reserved2[6];
   uint16_t bcdUSB488;
 
-  struct
+  struct TU_ATTR_PACKED
   {
-    uint8_t is488_2 :1;
-    uint8_t supportsREN_GTL_LLO :1;
-    uint8_t supportsTrigger :1;
+    unsigned int is488_2 :1;
+    unsigned int supportsREN_GTL_LLO :1;
+    unsigned int supportsTrigger :1;
   } bmIntfcCapabilities488;
 
-  struct
+  struct TU_ATTR_PACKED
   {
-    uint8_t SCPI :1;
-    uint8_t SR1 :1;
-    uint8_t RL1 :1;
-    uint8_t DT1 :1;
+    unsigned int SCPI :1;
+    unsigned int SR1 :1;
+    unsigned int RL1 :1;
+    unsigned int DT1 :1;
   } bmDevCapabilities488;
   uint8_t _reserved3[8];
 } usbtmc_response_capabilities_488_t;
@@ -253,14 +280,15 @@ TU_VERIFY_STATIC(sizeof(usbtmc_read_stb_rsp_488_t) == 3u, "struct wrong length")
 typedef struct TU_ATTR_PACKET
 {
   union {
-    struct {
-      uint8_t bTag : 7;
-      uint8_t one  : 1;
+    struct TU_ATTR_PACKED {
+      unsigned int bTag : 7;
+      unsigned int one  : 1;
     } bNotify1Struct;
     uint8_t bNotify1;
   };
   uint8_t StatusByte;
 } usbtmc_read_stb_interrupt_488_t;
+
 TU_VERIFY_STATIC(sizeof(usbtmc_read_stb_interrupt_488_t) == 2u, "struct wrong length");
 
 #endif
diff --git a/src/class/usbtmc/usbtmc_device.c b/src/class/usbtmc/usbtmc_device.c
index db0c95a32..7264125bb 100644
--- a/src/class/usbtmc/usbtmc_device.c
+++ b/src/class/usbtmc/usbtmc_device.c
@@ -170,6 +170,9 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
   uint8_t const * p_desc;
   uint8_t found_endpoints = 0;
 
+
+  usbtmcd_reset(rhport);
+
   // Perhaps there are other application specific class drivers, so don't assert here.
   if( itf_desc->bInterfaceClass != USBTMC_APP_CLASS)
     return false;
@@ -232,6 +235,12 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
 void usbtmcd_reset(uint8_t rhport)
 {
   // FIXME: Do endpoints need to be closed here?
+  usbtmc_state.state = STATE_IDLE;
+  usbtmc_state.itf_id = 0xFF;
+  usbtmc_state.ep_bulk_in = 0;
+  usbtmc_state.ep_bulk_out = 0;
+  usbtmc_state.ep_int_in = 0;
+
   (void)rhport;
 }
 
@@ -376,15 +385,19 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
 
 bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * request) {
 
+  uint8_t tmcStatusCode = USBTMC_STATUS_FAILED;
 #if (USBTMC_CFG_ENABLE_488)
   ushort bTag;
 #endif
   // We only handle class requests, IN direction.
+  // (for now)
   if(request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS)
   {
     return false;
   }
 
+  // Verification that we own the interface is unneeded since it's been routed to us specifically.
+
   switch(request->bRequest)
   {
   // USBTMC required requests
@@ -392,74 +405,100 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
   case USBTMC_bREQUEST_CHECK_ABORT_BULK_OUT_STATUS:
   case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN:
   case USBTMC_bREQUEST_CHECK_ABORT_BULK_IN_STATUS:
-    TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
-    TU_VERIFY(false);
-    break;
+    {
+      TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
+      TU_VERIFY(request->wLength == 1u);
+      tmcStatusCode = USBTMC_STATUS_FAILED;
+      usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&tmcStatusCode,sizeof(tmcStatusCode));
+      return true;
+    }
 
   case USBTMC_bREQUEST_INITIATE_CLEAR:
+    {
+      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
+      // After receiving an INITIATE_CLEAR request, the device must Halt the Bulk-OUT endpoint, queue the
+      // control endpoint response shown in Table 31, and clear all input buffers and output buffers.
+      usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
+      TU_VERIFY(usbtmcd_app_initiate_clear(rhport, &tmcStatusCode));
+      TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
+      return true;
+    }
+
   case USBTMC_bREQUEST_CHECK_CLEAR_STATUS:
-    TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
-    TU_VERIFY(false);
-    break;
+    {
+      usbtmc_get_clear_status_rsp_t clearStatusRsp = {0};
+      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      TU_VERIFY(request->wLength == sizeof(clearStatusRsp));
+      TU_VERIFY(usbtmcd_app_get_clear_status(rhport, &clearStatusRsp));
+
+      TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&clearStatusRsp,sizeof(clearStatusRsp)));
+      return true;
+    }
 
   case USBTMC_bREQUEST_GET_CAPABILITIES:
-    TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
-    TU_VERIFY(request->wValue == 0x0000);
-    TU_VERIFY(request->wIndex == usbtmc_state.itf_id);
-    TU_VERIFY(request->wLength == sizeof(usbtmcd_app_capabilities));
-    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&usbtmcd_app_capabilities, sizeof(usbtmcd_app_capabilities)));
-    return true;
+    {
+      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      TU_VERIFY(request->wLength == sizeof(usbtmcd_app_capabilities));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&usbtmcd_app_capabilities, sizeof(usbtmcd_app_capabilities)));
+      return true;
+    }
   // USBTMC Optional Requests
 
   case USBTMC_bREQUEST_INDICATOR_PULSE: // Optional
-    TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
-    TU_VERIFY(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse);
-    uint8_t tmcResult;
-    TU_VERIFY(usbtmcd_app_indicator_pluse(rhport, request, &tmcResult));
-    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcResult, sizeof(tmcResult)));
-
-    return true;
-
+    {
+      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
+      TU_VERIFY(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse);
+      TU_VERIFY(usbtmcd_app_indicator_pluse(rhport, request, &tmcStatusCode));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode, sizeof(tmcStatusCode)));
+      return true;
+    }
 #if (USBTMC_CFG_ENABLE_488)
+
     // USB488 required requests
   case USBTMC488_bREQUEST_READ_STATUS_BYTE:
-    TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
-
-    bTag = request->wValue & 0x7F;
-    TU_VERIFY(request->bmRequestType == 0xA1);
-    TU_VERIFY((request->wValue & (~0x7F)) == 0u); // Other bits are required to be zero
-    TU_VERIFY(bTag >= 0x02 && bTag <= 127);
-    TU_VERIFY(request->wIndex == usbtmc_state.itf_id);
-    TU_VERIFY(request->wLength == 0x0003);
-    usbtmc_read_stb_rsp_488_t rsp;
-    rsp.bTag = (uint8_t)bTag;
-    if(usbtmc_state.ep_int_in != 0)
     {
-      rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
-      rsp.statusByte = 0x00; // Use interrupt endpoint, instead.
-
-      usbtmc_read_stb_interrupt_488_t intMsg =
+      usbtmc_read_stb_rsp_488_t rsp;
+      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      TU_VERIFY(request->wLength == sizeof(rsp)); // in,class,interface
+
+      bTag = request->wValue & 0x7F;
+      TU_VERIFY(request->bmRequestType == 0xA1);
+      TU_VERIFY((request->wValue & (~0x7F)) == 0u); // Other bits are required to be zero
+      TU_VERIFY(bTag >= 0x02 && bTag <= 127);
+      TU_VERIFY(request->wIndex == usbtmc_state.itf_id);
+      TU_VERIFY(request->wLength == 0x0003);
+      rsp.bTag = (uint8_t)bTag;
+      if(usbtmc_state.ep_int_in != 0)
       {
-          .bNotify1   = (uint8_t)(0x80 | bTag),
-          .StatusByte = usbtmcd_app_get_stb(rhport, &(rsp.USBTMC_status))
-      };
-      usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&intMsg,sizeof(intMsg));
+        rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
+        rsp.statusByte = 0x00; // Use interrupt endpoint, instead.
 
-    }
-    else
-    {
-      rsp.statusByte = usbtmcd_app_get_stb(rhport, &(rsp.USBTMC_status));
-    }
-    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp, sizeof(rsp)));
-    return true;
+        usbtmc_read_stb_interrupt_488_t intMsg =
+        {
+            .bNotify1   = (uint8_t)(0x80 | bTag),
+            .StatusByte = usbtmcd_app_get_stb(rhport, &(rsp.USBTMC_status))
+        };
+        usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&intMsg,sizeof(intMsg));
 
+      }
+      else
+      {
+        rsp.statusByte = usbtmcd_app_get_stb(rhport, &(rsp.USBTMC_status));
+      }
+      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp, sizeof(rsp)));
+      return true;
+    }
     // USB488 optional requests
   case USBTMC488_bREQUEST_REN_CONTROL:
   case USBTMC488_bREQUEST_GO_TO_LOCAL:
   case USBTMC488_bREQUEST_LOCAL_LOCKOUT:
-    TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
-    TU_VERIFY(false);
-    return false;
+    {
+      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      TU_VERIFY(false);
+      return false;
+    }
 #endif
 
   default:
diff --git a/src/class/usbtmc/usbtmc_device.h b/src/class/usbtmc/usbtmc_device.h
index 84640b136..702f595e6 100644
--- a/src/class/usbtmc/usbtmc_device.h
+++ b/src/class/usbtmc/usbtmc_device.h
@@ -64,6 +64,10 @@ 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_initiate_clear(uint8_t rhport, uint8_t *tmcResult);
+
+bool usbtmcd_app_get_clear_status(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp);
+
 // 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);
 
-- 
cgit v1.3.1


From e234998c6c8eeedd3ae2e28a3015afd6e910952d Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Sun, 15 Sep 2019 14:57:02 -0400
Subject: More proper handling of clear.

---
 examples/device/usbtmc/src/usbtmc_app.c | 23 +++++++++++--
 src/class/usbtmc/usbtmc.h               |  8 ++---
 src/class/usbtmc/usbtmc_device.c        | 58 ++++++++++++++++++++++++---------
 src/class/usbtmc/usbtmc_device.h        | 10 +++---
 4 files changed, 71 insertions(+), 28 deletions(-)

(limited to 'src')

diff --git a/examples/device/usbtmc/src/usbtmc_app.c b/examples/device/usbtmc/src/usbtmc_app.c
index a41d911d2..7328b6598 100644
--- a/examples/device/usbtmc/src/usbtmc_app.c
+++ b/examples/device/usbtmc/src/usbtmc_app.c
@@ -117,6 +117,7 @@ bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport)
 
 bool usbtmcd_app_msgBulkIn_request(uint8_t rhport, usbtmc_msg_request_dev_dep_in const * request)
 {
+  (void)rhport;
   rspMsg.header.MsgID = request->header.MsgID,
   rspMsg.header.bTag = request->header.bTag,
   rspMsg.header.bTagInverse = request->header.bTagInverse;
@@ -135,6 +136,8 @@ void usbtmc_app_task_iter(void) {
   uint8_t const rhport = 0;
 
   switch(queryState) {
+  case 0:
+    break;
   case 1:
     queryDelayStart = board_millis();
     queryState = 2;
@@ -166,18 +169,34 @@ void usbtmc_app_task_iter(void) {
   }
 }
 
-bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult) {
+bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult)
+{
   (void)rhport;
   *tmcResult = USBTMC_STATUS_SUCCESS;
+  queryState = 0;
+  bulkInStarted = false;
+  status = 0;
   return true;
 }
 
-bool usbtmcd_app_get_clear_status(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp) {
+bool usbtmcd_app_get_clear_status(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp)
+{
   (void)rhport;
+  queryState = 0;
+  bulkInStarted = false;
+  status = 0;
   rsp->USBTMC_status = USBTMC_STATUS_SUCCESS;
   rsp->bmClear.BulkInFifoBytes = 0u;
   return true;
 }
+void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport)
+{
+  (void)rhport;
+}
+void usmtmcd_app_bulkOut_clearFeature(uint8_t rhport)
+{
+  (void)rhport;
+}
 
 // Return status byte, but put the transfer result status code in the rspResult argument.
 uint8_t usbtmcd_app_get_stb(uint8_t rhport, uint8_t *tmcResult)
diff --git a/src/class/usbtmc/usbtmc.h b/src/class/usbtmc/usbtmc.h
index d24a72cb6..2e4999c2d 100644
--- a/src/class/usbtmc/usbtmc.h
+++ b/src/class/usbtmc/usbtmc.h
@@ -279,13 +279,11 @@ TU_VERIFY_STATIC(sizeof(usbtmc_read_stb_rsp_488_t) == 3u, "struct wrong length")
 
 typedef struct TU_ATTR_PACKET
 {
-  union {
-    struct TU_ATTR_PACKED {
+  struct TU_ATTR_PACKED
+  {
       unsigned int bTag : 7;
       unsigned int one  : 1;
-    } bNotify1Struct;
-    uint8_t bNotify1;
-  };
+  } bNotify1;
   uint8_t StatusByte;
 } usbtmc_read_stb_interrupt_488_t;
 
diff --git a/src/class/usbtmc/usbtmc_device.c b/src/class/usbtmc/usbtmc_device.c
index 7264125bb..cf8a5069a 100644
--- a/src/class/usbtmc/usbtmc_device.c
+++ b/src/class/usbtmc/usbtmc_device.c
@@ -115,18 +115,19 @@ bool usbtmcd_transmit_dev_msg_data(
     const void *data)
 {
   TU_ASSERT(usbtmc_state.state == STATE_TX_REQUESTED);
+#ifndef NDEBUG
   TU_ASSERT(hdr->TransferSize > 0u);
-
   if(hdr->bmTransferAttributes.UsingTermChar)
   {
     TU_ASSERT(usbtmcd_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
     TU_ASSERT(termCharRequested);
     TU_ASSERT(((uint8_t*)data)[hdr->TransferSize-1] == termChar);
   }
+#endif
 
   // Copy in the header
   memcpy(usbtmc_state.ep_bulk_in_buf, hdr, sizeof(*hdr));
-  uint packetLen = sizeof(*hdr);
+  size_t packetLen = sizeof(*hdr);
   // Single-packet transfer
   if((packetLen + hdr->TransferSize) <= USBTMCD_MAX_PACKET_SIZE)
   {
@@ -155,13 +156,14 @@ bool usbtmcd_transmit_dev_msg_data(
 
 void usbtmcd_init(void)
 {
-#if USBTMC_CFG_ENABLE_488
-  if(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger)
-    TU_ASSERT(&usbtmcd_app_msg_trigger != NULL,);
+#ifndef NDEBUG
+#  if USBTMC_CFG_ENABLE_488
+    if(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger)
+      TU_ASSERT(&usbtmcd_app_msg_trigger != NULL,);
+#  endif
+    if(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse)
+      TU_ASSERT(&usbtmcd_app_indicator_pluse != NULL,);
 #endif
-  if(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse)
-    TU_ASSERT(&usbtmcd_app_indicator_pluse != NULL,);
-
 }
 
 bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
@@ -204,8 +206,10 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
 
           break;
         case TUSB_XFER_INTERRUPT:
+#ifndef NDEBUG
           TU_ASSERT(tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN);
           TU_ASSERT(usbtmc_state.ep_int_in == 0);
+#endif
           usbtmc_state.ep_int_in = ep_desc->bEndpointAddress;
           break;
         default:
@@ -219,6 +223,7 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
   }
 
   // bulk endpoints are required, but interrupt IN is optional
+#ifndef NDEBUG
   TU_ASSERT(usbtmc_state.ep_bulk_in != 0);
   TU_ASSERT(usbtmc_state.ep_bulk_out != 0);
   if (itf_desc->bNumEndpoints == 2) {
@@ -228,6 +233,7 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
   {
     TU_ASSERT(usbtmc_state.ep_int_in != 0);
   }
+#endif
   TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_out, usbtmc_state.ep_bulk_out_buf, 64));
 
   return true;
@@ -363,7 +369,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
     }
     else // short packet
     {
-      uint packetLen = usbtmc_state.transfer_size_remaining;
+      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)
       {
@@ -387,8 +393,25 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
 
   uint8_t tmcStatusCode = USBTMC_STATUS_FAILED;
 #if (USBTMC_CFG_ENABLE_488)
-  ushort bTag;
+  uint8_t bTag;
 #endif
+
+  if((request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD) &&
+      (request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_ENDPOINT) &&
+      (request->bRequest == TUSB_REQ_CLEAR_FEATURE) &&
+      (request->wValue == TUSB_REQ_FEATURE_EDPT_HALT))
+  {
+    if((request->wIndex) == usbtmc_state.ep_bulk_out)
+    {
+      usmtmcd_app_bulkOut_clearFeature(rhport);
+    }
+    else if ((request->wIndex) == usbtmc_state.ep_bulk_in)
+    {
+      usmtmcd_app_bulkIn_clearFeature(rhport);
+    }
+    return false; // We want USBD core to handle sending the status response, and clear the stall condition
+  }
+
   // We only handle class requests, IN direction.
   // (for now)
   if(request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS)
@@ -409,7 +432,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
       TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
       TU_VERIFY(request->wLength == 1u);
       tmcStatusCode = USBTMC_STATUS_FAILED;
-      usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&tmcStatusCode,sizeof(tmcStatusCode));
+      usbd_edpt_xfer(rhport, 0u, (void*)&tmcStatusCode,sizeof(tmcStatusCode));
       return true;
     }
 
@@ -421,7 +444,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
       // control endpoint response shown in Table 31, and clear all input buffers and output buffers.
       usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
       TU_VERIFY(usbtmcd_app_initiate_clear(rhport, &tmcStatusCode));
-      TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
       return true;
     }
 
@@ -432,7 +455,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
       TU_VERIFY(request->wLength == sizeof(clearStatusRsp));
       TU_VERIFY(usbtmcd_app_get_clear_status(rhport, &clearStatusRsp));
 
-      TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&clearStatusRsp,sizeof(clearStatusRsp)));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&clearStatusRsp,sizeof(clearStatusRsp)));
       return true;
     }
 
@@ -477,11 +500,13 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
 
         usbtmc_read_stb_interrupt_488_t intMsg =
         {
-            .bNotify1   = (uint8_t)(0x80 | bTag),
-            .StatusByte = usbtmcd_app_get_stb(rhport, &(rsp.USBTMC_status))
+          .bNotify1 = {
+              .one = 1,
+              .bTag = bTag & 0x7Fu,
+          },
+          .StatusByte = usbtmcd_app_get_stb(rhport, &(rsp.USBTMC_status))
         };
         usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&intMsg,sizeof(intMsg));
-
       }
       else
       {
@@ -503,6 +528,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
 
   default:
     TU_VERIFY(false);
+    return false;
   }
   TU_VERIFY(false);
 }
diff --git a/src/class/usbtmc/usbtmc_device.h b/src/class/usbtmc/usbtmc_device.h
index 702f595e6..35d4da438 100644
--- a/src/class/usbtmc/usbtmc_device.h
+++ b/src/class/usbtmc/usbtmc_device.h
@@ -56,13 +56,13 @@ extern usbtmc_response_capabilities_t const usbtmcd_app_capabilities;
 #endif
 
 bool usbtmcd_app_msgBulkOut_start(uint8_t rhport, usbtmc_msg_request_dev_dep_out const * msgHeader);
-
 // transfer_complete does not imply that a message is complete.
 bool usbtmcd_app_msg_data(uint8_t rhport, void *data, size_t len, bool transfer_complete);
+void usmtmcd_app_bulkOut_clearFeature(uint8_t rhport); // Notice to clear and abort the pending BULK out transfer
 
 bool usbtmcd_app_msgBulkIn_request(uint8_t rhport, usbtmc_msg_request_dev_dep_in const * request);
-
 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
 
 bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult);
 
@@ -104,10 +104,10 @@ void usbtmcd_init(void);
  *************************************************************/
 
 #define USBTMC_APP_CLASS    TUSB_CLASS_APPLICATION_SPECIFIC
-#define USBTMC_APP_SUBCLASS 0x03
+#define USBTMC_APP_SUBCLASS 0x03u
 
-#define USBTMC_PROTOCOL_STD    0x00
-#define USBTMC_PROTOCOL_USB488 0x01
+#define USBTMC_PROTOCOL_STD    0x00u
+#define USBTMC_PROTOCOL_USB488 0x01u
 
 //   Interface number, number of endpoints, EP string index, USB_TMC_PROTOCOL*, bulk-out endpoint ID,
 //   bulk-in endpoint ID
-- 
cgit v1.3.1


From 45871001e6d18503f05733ae770538e622313584 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Tue, 17 Sep 2019 13:24:43 -0400
Subject: Changes1...

---
 src/class/usbtmc/usbtmc.h        |   9 ++
 src/class/usbtmc/usbtmc_device.c | 268 ++++++++++++++++++++++++++++++---------
 2 files changed, 220 insertions(+), 57 deletions(-)

(limited to 'src')

diff --git a/src/class/usbtmc/usbtmc.h b/src/class/usbtmc/usbtmc.h
index 2e4999c2d..6893c3743 100644
--- a/src/class/usbtmc/usbtmc.h
+++ b/src/class/usbtmc/usbtmc.h
@@ -228,6 +228,15 @@ typedef struct TU_ATTR_PACKED
 
 TU_VERIFY_STATIC(sizeof(usbtmc_get_clear_status_rsp_t) == 2u, "struct wrong length");
 
+// Used for both abort bulk IN and bulk OUT
+typedef struct TU_ATTR_PACKED
+{
+  uint8_t USBTMC_status;
+  uint8_t bTag;
+} usbtmc_initiate_abort_rsp_t;
+
+TU_VERIFY_STATIC(sizeof(usbtmc_get_clear_status_rsp_t) == 2u, "struct wrong length");
+
 typedef struct TU_ATTR_PACKED
 {
   uint8_t USBTMC_status;                 ///< usbtmc_status_enum
diff --git a/src/class/usbtmc/usbtmc_device.c b/src/class/usbtmc/usbtmc_device.c
index cf8a5069a..6d562641e 100644
--- a/src/class/usbtmc/usbtmc_device.c
+++ b/src/class/usbtmc/usbtmc_device.c
@@ -8,7 +8,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2019 N Conrad
+ * Copyright (c) 2019 Nathan Conrad
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -33,31 +33,53 @@
 
 #include "tusb_option.h"
 
-// We don't do any cross-task anything here (everything is in tud or interrupt context).
-// You must ensure thread safety in your own app.
+// Synchronization is needed in some spots.
+// These functions should NOT be called from interrupts.
+
+/* The library is designed that its functions can be called by any user task, with need for
+ * additional locking. In the case of "no OS", this task is never preempted other than by
+ * interrupts, and the USBTMC code isn't called by interrupts, so all is OK. In the case
+ * of an OS, this class driver uses the OSAL to perform locking. The code uses a single lock
+ * and does not call outside of this class with a lock held, so deadlocks won't happen.
+ *
+ * This module's application-facing functions are not reentrant. The application must
+ * only call them from a single thread (or implement its own locking).
+ */
 
 
-//Limitations (not planned to be implemented):
-// "vendor-specific" commands are not handled
+//Limitations:
+// "vendor-specific" commands are not handled.
 // Dealing with "termchar" must be handled by the application layer,
 //    though additional error checking is does in this module.
+// talkOnly and listenOnly are NOT supported. They're no permitted
+// in USB488, anyway.
+
+/* Supported:
+ *
+ * Notification pulse
+ * Trigger
+ * Read status byte (both by interrupt endpoint and control message)
+ *
+ */
+
 
 // TODO:
 // USBTMC 3.2.2 error conditions not strictly followed
 // No local lock-out, REN, or GTL.
 // Cannot handle clear.
-// Not all "capabilities" supported
 // Clear message available status byte at the correct time? (488 4.3.1.3)
-// Split transfers
+// Abort bulk in/out
 // No CLEAR_FEATURE/HALT no EP (yet)
-// No aborting transfers.
 
 #if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_USBTMC)
 
+#include <string.h>
 #include "usbtmc.h"
 #include "usbtmc_device.h"
 #include "device/dcd.h"
 #include "device/usbd.h"
+#include "uart_util.h"
+static char logMsg[150];
 
 // FIXME: I shouldn't need to include _pvt headers.
 #include "device/usbd_pvt.h"
@@ -70,21 +92,31 @@ typedef enum
   STATE_IDLE,
   STATE_RCV,
   STATE_TX_REQUESTED,
-  STATE_TX_INITIATED
+  STATE_TX_INITIATED,
+  STATE_CLEARING,
+  STATE_ABORTING_BULK_IN,
+  STATE_ABORTING_BULK_OUT,
+  STATE_NUM_STATES
 } usbtmcd_state_enum;
 
 typedef struct
 {
-  usbtmcd_state_enum state;
+  volatile usbtmcd_state_enum state;
+
   uint8_t itf_id;
   uint8_t ep_bulk_in;
   uint8_t ep_bulk_out;
   uint8_t ep_int_in;
-  uint8_t ep_bulk_in_buf[64];
-  uint8_t ep_bulk_out_buf[64];
-  uint8_t lastTag;
+  // IN buffer is only used for first packet, not the remainder
+  // in order to deal with prepending header
+  uint8_t ep_bulk_in_buf[USBTMCD_MAX_PACKET_SIZE];
+  // OUT buffer receives one packet at a time
+  uint8_t ep_bulk_out_buf[USBTMCD_MAX_PACKET_SIZE];
+  uint32_t transfer_size_remaining; // also used for requested length for bulk IN.
+
+  uint8_t lastBulkOutTag; // used for aborts (mostly)
+  uint8_t lastBulkInTag; // used for aborts (mostly)
 
-  uint32_t transfer_size_remaining;
   uint8_t const * devInBuffer;
 } usbtmc_interface_state_t;
 
@@ -97,39 +129,63 @@ static usbtmc_interface_state_t usbtmc_state =
     .ep_int_in = 0
 };
 
-// We want everything to fit nicely in a single packet, so lets require EP size >32
-// I'm not sure if this is really necessary, though.
+// 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(
+    (sizeof(usbtmc_state.ep_bulk_in_buf) % USBTMCD_MAX_PACKET_SIZE) == 0,
+    "packet buffer must be a multiple of the packet size");
 
 static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len);
 static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t packetLen);
 
+
+osal_mutex_def_t usbtmcLockBuffer;
+static osal_mutex_t usbtmcLock;
+
+// Our own private lock, mostly for the state variable.
+#define criticalEnter() do {osal_mutex_lock(usbtmcLock,OSAL_TIMEOUT_WAIT_FOREVER); } while (0)
+#define criticalLeave() do {osal_mutex_unlock(usbtmcLock); } while (0)
+
 // called from app
 // We keep a reference to the buffer, so it MUST not change until the app is
 // notified that the transfer is complete.
 // length of data is specified in the hdr.
+
+// We can't just send the whole thing at once because we need to concatanate the
+// header with the data.
 bool usbtmcd_transmit_dev_msg_data(
     uint8_t rhport,
-    usbtmc_msg_dev_dep_msg_in_header_t const * hdr,
-    const void *data)
+    const void * data, size_t len,
+    bool usingTermChar)
 {
-  TU_ASSERT(usbtmc_state.state == STATE_TX_REQUESTED);
+  const unsigned int txBufLen = sizeof(usbtmc_state.ep_bulk_in_buf);
+
 #ifndef NDEBUG
-  TU_ASSERT(hdr->TransferSize > 0u);
-  if(hdr->bmTransferAttributes.UsingTermChar)
+  TU_ASSERT(len > 0u);
+  TU_ASSERT(len <= usbtmc_state.transfer_size_remaining);
+  if(usingTermChar)
   {
     TU_ASSERT(usbtmcd_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
     TU_ASSERT(termCharRequested);
-    TU_ASSERT(((uint8_t*)data)[hdr->TransferSize-1] == termChar);
+    TU_ASSERT(((uint8_t*)data)[len-1] == termChar);
   }
 #endif
 
+  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_state.ep_bulk_in_buf;
+  memset(hdr, 0x00, sizeof(*hdr));
+  hdr->header.MsgID = USBTMC_MSGID_DEV_DEP_MSG_IN;
+  hdr->header.bTag = usbtmc_state.lastBulkInTag;
+  hdr->header.bTagInverse = (uint8_t)~(usbtmc_state.lastBulkInTag);
+  hdr->TransferSize = len;
+  hdr->bmTransferAttributes.EOM = 1u;
+  hdr->bmTransferAttributes.UsingTermChar = usingTermChar;
+
   // Copy in the header
-  memcpy(usbtmc_state.ep_bulk_in_buf, hdr, sizeof(*hdr));
   size_t packetLen = sizeof(*hdr);
-  // Single-packet transfer
-  if((packetLen + hdr->TransferSize) <= USBTMCD_MAX_PACKET_SIZE)
+
+  // If it fits in a single trasnmission:
+  if((packetLen + hdr->TransferSize) <= txBufLen)
   {
     memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + packetLen, data, hdr->TransferSize);
     packetLen = (uint16_t)(packetLen+ hdr->TransferSize);
@@ -142,15 +198,23 @@ bool usbtmcd_transmit_dev_msg_data(
     usbtmc_state.transfer_size_remaining = 0;
     usbtmc_state.devInBuffer = NULL;
   }
-  else
+  else /* partial packet */
   {
-    memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + packetLen, data, USBTMCD_MAX_PACKET_SIZE - packetLen);
-    usbtmc_state.transfer_size_remaining = hdr->TransferSize - (USBTMCD_MAX_PACKET_SIZE - packetLen);
-    usbtmc_state.devInBuffer += (USBTMCD_MAX_PACKET_SIZE - packetLen);
-    packetLen = USBTMCD_MAX_PACKET_SIZE;
+    memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + packetLen, data, txBufLen - packetLen);
+    usbtmc_state.devInBuffer += txBufLen - packetLen;
+    usbtmc_state.transfer_size_remaining = hdr->TransferSize - (txBufLen - packetLen);
+    packetLen = txBufLen;
   }
-  usbtmc_state.state = STATE_TX_INITIATED;
-  TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,(uint16_t)packetLen));
+
+
+  criticalEnter();
+  {
+    TU_VERIFY(usbtmc_state.state == STATE_TX_REQUESTED);
+    usbtmc_state.state = STATE_TX_INITIATED;
+  }
+  criticalLeave();
+
+  TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf, (uint16_t)packetLen));
   return true;
 }
 
@@ -158,12 +222,17 @@ void usbtmcd_init(void)
 {
 #ifndef NDEBUG
 #  if USBTMC_CFG_ENABLE_488
-    if(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger)
-      TU_ASSERT(&usbtmcd_app_msg_trigger != NULL,);
+  if(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger)
+    TU_ASSERT(&usbtmcd_app_msg_trigger != NULL,);
+  // Per USB488 spec: table 8
+  TU_ASSERT(!usbtmcd_app_capabilities.bmIntfcCapabilities.listenOnly,);
+  TU_ASSERT(!usbtmcd_app_capabilities.bmIntfcCapabilities.talkOnly,);
 #  endif
     if(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse)
       TU_ASSERT(&usbtmcd_app_indicator_pluse != NULL,);
 #endif
+
+    usbtmcLock = osal_mutex_create(&usbtmcLockBuffer);
 }
 
 bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
@@ -226,10 +295,17 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
 #ifndef NDEBUG
   TU_ASSERT(usbtmc_state.ep_bulk_in != 0);
   TU_ASSERT(usbtmc_state.ep_bulk_out != 0);
-  if (itf_desc->bNumEndpoints == 2) {
+  if (itf_desc->bNumEndpoints == 2)
+  {
     TU_ASSERT(usbtmc_state.ep_int_in == 0);
   }
-  else if (itf_desc->bNumEndpoints == 2)
+  else if (itf_desc->bNumEndpoints == 3)
+  {
+    TU_ASSERT(usbtmc_state.ep_int_in != 0);
+  }
+
+  if(usbtmcd_app_capabilities.bmIntfcCapabilities488.is488_2 ||
+      usbtmcd_app_capabilities.bmDevCapabilities488.SR1)
   {
     TU_ASSERT(usbtmc_state.ep_int_in != 0);
   }
@@ -286,12 +362,22 @@ static bool handle_devMsgIn(uint8_t rhport, void *data, size_t len)
 {
   TU_VERIFY(len == sizeof(usbtmc_msg_request_dev_dep_in));
   usbtmc_msg_request_dev_dep_in *msg = (usbtmc_msg_request_dev_dep_in*)data;
-  TU_VERIFY(usbtmc_state.state == STATE_IDLE);
-  usbtmc_state.state = STATE_TX_REQUESTED;
-  usbtmc_state.transfer_size_remaining = msg->TransferSize;
+
+  sprintf(logMsg," handle_devMsgIn len=%ul\r\n",len);
+  uart_tx_str_sync(logMsg);
+
+  criticalEnter();
+  {
+    TU_VERIFY(usbtmc_state.state == STATE_IDLE);
+    usbtmc_state.state = STATE_TX_REQUESTED;
+    usbtmc_state.lastBulkInTag = msg->header.bTag;
+    usbtmc_state.transfer_size_remaining = msg->TransferSize;
+  }
+  criticalLeave();
 
   termCharRequested = msg->bmTransferAttributes.TermCharEnabled;
   termChar = msg->TermChar;
+
   if(termCharRequested)
     TU_VERIFY(usbtmcd_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
 
@@ -302,8 +388,17 @@ 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)
 {
   TU_VERIFY(result == XFER_RESULT_SUCCESS);
+  uart_tx_str_sync("USBTMC Xfer CB" );
+  sprintf(logMsg," STATE=%lu ", (uint32_t)usbtmc_state.state);
+  uart_tx_str_sync(logMsg);
+
+  if(usbtmc_state.state == STATE_CLEARING) {
+    return true; /* I think we can ignore everything here */
+  }
+
   if(ep_addr == usbtmc_state.ep_bulk_out)
   {
+    uart_tx_str_sync("OUT");
     switch(usbtmc_state.state)
     {
     case STATE_IDLE:
@@ -312,15 +407,19 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
       uint8_t invInvTag = (uint8_t)~(msg->header.bTagInverse);
       TU_VERIFY(msg->header.bTag == invInvTag);
       TU_VERIFY(msg->header.bTag != 0x00);
-      usbtmc_state.lastTag = msg->header.bTag;
+
+      sprintf(logMsg," type=%lu\r\n",(uint32_t)msg->header.MsgID);
+      uart_tx_str_sync(logMsg);
 
       switch(msg->header.MsgID) {
       case USBTMC_MSGID_DEV_DEP_MSG_OUT:
         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;
         break;
 
       case USBTMC_MSGID_DEV_DEP_MSG_IN:
+        uart_tx_sync("Handling msg in req\r\n", 21);
         TU_VERIFY(handle_devMsgIn(rhport, msg, xferred_bytes));
         break;
 
@@ -336,6 +435,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
       case USBTMC_MSGID_VENDOR_SPECIFIC_MSG_OUT:
       case USBTMC_MSGID_VENDOR_SPECIFIC_IN:
       default:
+
         TU_VERIFY(false);
         return false;
       }
@@ -347,12 +447,22 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
 
     case STATE_TX_REQUESTED:
     case STATE_TX_INITIATED:
+    case STATE_ABORTING_BULK_IN:
+    case STATE_ABORTING_BULK_OUT:
     default:
+      if(msg == NULL)
+        sprintf(logMsg," Unknown received control?\r\n ");
+      else {
+        sprintf(logMsg," msg=%lu\r\n ", (uint32_t)msg->header.MsgID);
+      }
+      uart_tx_str_sync(logMsg);
       TU_VERIFY(false);
     }
   }
   else if(ep_addr == usbtmc_state.ep_bulk_in)
   {
+    sprintf(logMsg,"IN\r\n");
+    uart_tx_str_sync(logMsg);
     TU_ASSERT(usbtmc_state.state == STATE_TX_INITIATED);
     if(usbtmc_state.transfer_size_remaining == 0)
     {
@@ -360,14 +470,14 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
       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));
     }
-    else if(usbtmc_state.transfer_size_remaining >= USBTMCD_MAX_PACKET_SIZE)
+    else if(usbtmc_state.transfer_size_remaining > sizeof(usbtmc_state.devInBuffer))
     {
-      memcpy(usbtmc_state.ep_bulk_in_buf, usbtmc_state.devInBuffer, USBTMCD_MAX_PACKET_SIZE);
-      usbtmc_state.devInBuffer += USBTMCD_MAX_PACKET_SIZE;
-      usbtmc_state.transfer_size_remaining -= USBTMCD_MAX_PACKET_SIZE;
-      TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,USBTMCD_MAX_PACKET_SIZE));
+      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 // short packet
+    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);
@@ -401,6 +511,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
       (request->bRequest == TUSB_REQ_CLEAR_FEATURE) &&
       (request->wValue == TUSB_REQ_FEATURE_EDPT_HALT))
   {
+    uart_tx_str_sync("feature clear\r\n");
     if((request->wIndex) == usbtmc_state.ep_bulk_out)
     {
       usmtmcd_app_bulkOut_clearFeature(rhport);
@@ -426,23 +537,48 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
   // USBTMC required requests
   case USBTMC_bREQUEST_INITIATE_ABORT_BULK_OUT:
   case USBTMC_bREQUEST_CHECK_ABORT_BULK_OUT_STATUS:
-  case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN:
+  {
+    TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
+    TU_VERIFY(request->wLength == 1u);
+    tmcStatusCode = USBTMC_STATUS_FAILED;
+    usbd_edpt_xfer(rhport, 0u, (void*)&tmcStatusCode,sizeof(tmcStatusCode));
+    return true;
+  }
   case USBTMC_bREQUEST_CHECK_ABORT_BULK_IN_STATUS:
-    {
-      TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
-      TU_VERIFY(request->wLength == 1u);
-      tmcStatusCode = USBTMC_STATUS_FAILED;
-      usbd_edpt_xfer(rhport, 0u, (void*)&tmcStatusCode,sizeof(tmcStatusCode));
-      return true;
-    }
+  {
+    TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
+    TU_VERIFY(request->wLength == 1u);
+    usbtmc_get_clear_status_rsp_t clearStatusRsp = {0};
+    tmcStatusCode = USBTMC_STATUS_FAILED;
+    usbd_edpt_xfer(rhport, 0u, (void*)&tmcStatusCode,sizeof(tmcStatusCode));
+    return true;
+  }
+
+  case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN:
+  {
+    usbtmc_initiate_abort_rsp_t rsp = {0};
+    uart_tx_str_sync("init abort bulk in\r\n");
+    TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+    TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
+    TU_VERIFY(request->wIndex == usbtmc_state.ep_int_in);
+    // wValue is the requested bTag to abort
+    usbtmc_state.transfer_size_remaining = 0;
+    usbtmc_state.state = STATE_ABORTING_BULK_IN;
+    TU_VERIFY(usbtmcd_app_initiate_clear(rhport, &tmcStatusCode));
+    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
+    return true;
+  }
 
   case USBTMC_bREQUEST_INITIATE_CLEAR:
     {
+      uart_tx_str_sync("init clear\r\n");
       TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
       TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
       // After receiving an INITIATE_CLEAR request, the device must Halt the Bulk-OUT endpoint, queue the
       // control endpoint response shown in Table 31, and clear all input buffers and output buffers.
       usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
+      usbtmc_state.transfer_size_remaining = 0;
+      usbtmc_state.state = STATE_CLEARING;
       TU_VERIFY(usbtmcd_app_initiate_clear(rhport, &tmcStatusCode));
       TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
       return true;
@@ -450,17 +586,31 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
 
   case USBTMC_bREQUEST_CHECK_CLEAR_STATUS:
     {
-      usbtmc_get_clear_status_rsp_t clearStatusRsp = {0};
+      uart_tx_str_sync("check clear\r\n");
       TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      usbtmc_get_clear_status_rsp_t clearStatusRsp = {0};
       TU_VERIFY(request->wLength == sizeof(clearStatusRsp));
-      TU_VERIFY(usbtmcd_app_get_clear_status(rhport, &clearStatusRsp));
 
+      if(usbd_edpt_busy(rhport, usbtmc_state.ep_bulk_in))
+      {
+        // Stuff stuck in TX buffer?
+        clearStatusRsp.bmClear.BulkInFifoBytes = 1;
+        clearStatusRsp.USBTMC_status = USBTMC_STATUS_PENDING;
+      }
+      else
+      {
+        // Let app check if it's clear
+        TU_VERIFY(usbtmcd_app_get_clear_status(rhport, &clearStatusRsp));
+      }
+      if(clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS)
+        usbtmc_state.state = STATE_IDLE;
       TU_VERIFY(tud_control_xfer(rhport, request, (void*)&clearStatusRsp,sizeof(clearStatusRsp)));
       return true;
     }
 
   case USBTMC_bREQUEST_GET_CAPABILITIES:
     {
+      uart_tx_str_sync("get capabilities\r\n");
       TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
       TU_VERIFY(request->wLength == sizeof(usbtmcd_app_capabilities));
       TU_VERIFY(tud_control_xfer(rhport, request, (void*)&usbtmcd_app_capabilities, sizeof(usbtmcd_app_capabilities)));
@@ -470,6 +620,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
 
   case USBTMC_bREQUEST_INDICATOR_PULSE: // Optional
     {
+      uart_tx_str_sync("indicate\r\n");
       TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
       TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
       TU_VERIFY(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse);
@@ -482,6 +633,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
     // USB488 required requests
   case USBTMC488_bREQUEST_READ_STATUS_BYTE:
     {
+      uart_tx_str_sync("read stb\r\n");
       usbtmc_read_stb_rsp_488_t rsp;
       TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
       TU_VERIFY(request->wLength == sizeof(rsp)); // in,class,interface
@@ -520,6 +672,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
   case USBTMC488_bREQUEST_GO_TO_LOCAL:
   case USBTMC488_bREQUEST_LOCAL_LOCKOUT:
     {
+      uart_tx_str_sync("Unsupported REN/GTL/LLO\r\n");
       TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
       TU_VERIFY(false);
       return false;
@@ -527,6 +680,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
 #endif
 
   default:
+    uart_tx_str_sync("Default CTRL handler\r\n");
     TU_VERIFY(false);
     return false;
   }
-- 
cgit v1.3.1


From 91cd247c97a7376133638d960b6c650c0f71d376 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Tue, 17 Sep 2019 13:26:10 -0400
Subject: changes 2

---
 examples/device/usbtmc/src/usb_descriptors.c | 10 ++++------
 examples/device/usbtmc/src/usbtmc_app.c      | 23 +++++++++++++++++------
 src/class/usbtmc/usbtmc_device.h             |  4 ++--
 3 files changed, 23 insertions(+), 14 deletions(-)

(limited to 'src')

diff --git a/examples/device/usbtmc/src/usb_descriptors.c b/examples/device/usbtmc/src/usb_descriptors.c
index 9567bcab5..792fff87c 100644
--- a/examples/device/usbtmc/src/usb_descriptors.c
+++ b/examples/device/usbtmc/src/usb_descriptors.c
@@ -106,7 +106,7 @@ uint8_t const * tud_hid_descriptor_report_cb(void)
 #if defined(CFG_TUD_USBTMC)
 
 #  define USBTMC_DESC_MAIN(_itfnum,_bNumEndpoints) \
-     USBTMC_IF_DESCRIPTOR(_itfnum, _bNumEndpoints,  /*_stridx = */ 7u, USBTMC_PROTOCOL_USB488), \
+     USBTMC_IF_DESCRIPTOR(_itfnum, _bNumEndpoints,  /*_stridx = */ 4u, USBTMC_PROTOCOL_USB488), \
      USBTMC_BULK_DESCRIPTORS(/* OUT = */0x03, /* IN = */ 0x83)
 
 #if defined(CFG_TUD_USBTMC_ENABLE_INT_EP)
@@ -209,10 +209,7 @@ char const* string_desc_arr [] =
   "TinyUSB",                     // 1: Manufacturer
   "TinyUSB Device",              // 2: Product
   "123456",                      // 3: Serials, should use chip ID
-  "TinyUSB CDC",                 // 4: CDC Interface
-  "TinyUSB MSC",                 // 5: MSC Interface
-  "TinyUSB HID",                 // 6: HID
-  "TinyUSB USBTMC",              // 7: USBTMC
+  "TinyUSB USBTMC",              // 4: USBTMC
 };
 
 static uint16_t _desc_str[32];
@@ -227,7 +224,8 @@ uint16_t const* tud_descriptor_string_cb(uint8_t index)
   {
     memcpy(&_desc_str[1], string_desc_arr[0], 2);
     chr_count = 1;
-  }else
+  }
+  else
   {
     // Convert ASCII string into UTF-16
 
diff --git a/examples/device/usbtmc/src/usbtmc_app.c b/examples/device/usbtmc/src/usbtmc_app.c
index 7328b6598..e21c3ca22 100644
--- a/examples/device/usbtmc/src/usbtmc_app.c
+++ b/examples/device/usbtmc/src/usbtmc_app.c
@@ -64,8 +64,8 @@ usbtmcd_app_capabilities  =
     }
 #endif
 };
-
-static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer\n";
+//static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer";
+static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer and a bunch of other text to make it longer than a packet, perhaps?\n";
 static volatile uint8_t status;
 
 // 0=not query, 1=queried, 2=delay,set(MAV), 3=delay 4=ready?
@@ -86,6 +86,7 @@ bool usbtmcd_app_msgBulkOut_start(uint8_t rhport, usbtmc_msg_request_dev_dep_out
 {
   (void)rhport;
   (void)msgHeader;
+  uart_tx_str_sync("MSG_OUT_DATA: start\r\n");
   return true;
 }
 bool usbtmcd_app_msg_trigger(uint8_t rhport, usbtmc_msg_generic_t* msg) {
@@ -99,6 +100,11 @@ bool usbtmcd_app_msg_data(uint8_t rhport, void *data, size_t len, bool transfer_
   (void)rhport;
 
   // If transfer isn't finished, we just ignore it (for now)
+  uart_tx_str_sync("MSG_OUT_DATA: <<<");
+  uart_tx_sync(data,len);
+  uart_tx_str_sync(">>>\r\n");
+  if(transfer_complete)
+    uart_tx_str_sync("MSG_OUT_DATA: Complete\r\n");
 
   if(transfer_complete && (len >=4) && !strncasecmp("*idn?",data,4)) {
     queryState = 1;
@@ -115,13 +121,18 @@ bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport)
   return true;
 }
 
+static unsigned int msgReqLen;
+
 bool usbtmcd_app_msgBulkIn_request(uint8_t rhport, usbtmc_msg_request_dev_dep_in const * request)
 {
   (void)rhport;
+
   rspMsg.header.MsgID = request->header.MsgID,
   rspMsg.header.bTag = request->header.bTag,
   rspMsg.header.bTagInverse = request->header.bTagInverse;
+  msgReqLen = request->TransferSize;
 
+  uart_tx_str_sync("MSG_IN_DATA: Requested!\r\n");
   TU_ASSERT(bulkInStarted == 0);
   bulkInStarted = 1;
 
@@ -143,14 +154,14 @@ void usbtmc_app_task_iter(void) {
     queryState = 2;
     break;
   case 2:
-    if( (board_millis() - queryDelayStart) > 1000u) {
+    if( (board_millis() - queryDelayStart) > 5u) {
       queryDelayStart = board_millis();
       queryState=3;
       status |= 0x10u; // MAV
     }
     break;
   case 3:
-    if( (board_millis() - queryDelayStart) > 1000u) {
+    if( (board_millis() - queryDelayStart) > 10u) {
       queryState = 4;
     }
     break;
@@ -158,8 +169,7 @@ void usbtmc_app_task_iter(void) {
     if(bulkInStarted) {
       queryState = 0;
       bulkInStarted = 0;
-      rspMsg.TransferSize = sizeof(idn)-1;
-      usbtmcd_transmit_dev_msg_data(rhport, &rspMsg, idn);
+      usbtmcd_transmit_dev_msg_data(rhport, idn,  tu_min32(sizeof(idn)-1,msgReqLen),false);
       // MAV is cleared in the transfer complete callback.
     }
     break;
@@ -189,6 +199,7 @@ bool usbtmcd_app_get_clear_status(uint8_t rhport, usbtmc_get_clear_status_rsp_t
   rsp->bmClear.BulkInFifoBytes = 0u;
   return true;
 }
+
 void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport)
 {
   (void)rhport;
diff --git a/src/class/usbtmc/usbtmc_device.h b/src/class/usbtmc/usbtmc_device.h
index 35d4da438..a0ba82e30 100644
--- a/src/class/usbtmc/usbtmc_device.h
+++ b/src/class/usbtmc/usbtmc_device.h
@@ -86,8 +86,8 @@ TU_ATTR_WEAK bool usbtmcd_app_msg_trigger(uint8_t rhport, usbtmc_msg_generic_t*
 
 bool usbtmcd_transmit_dev_msg_data(
     uint8_t rhport,
-    usbtmc_msg_dev_dep_msg_in_header_t const * hdr,
-    const void *data);
+    const void * data, size_t len,
+    bool usingTermChar);
 
 
 /* "callbacks" from USB device core */
-- 
cgit v1.3.1


From a0b6b8187c036b386f09188a9017301f730096b8 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Fri, 13 Sep 2019 20:28:26 -0400
Subject: TI compiler quirks, and le byte swapping functions.

---
 src/common/tusb_compiler.h | 83 ++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 73 insertions(+), 10 deletions(-)

(limited to 'src')

diff --git a/src/common/tusb_compiler.h b/src/common/tusb_compiler.h
index 09768ef88..ca294c20f 100644
--- a/src/common/tusb_compiler.h
+++ b/src/common/tusb_compiler.h
@@ -53,6 +53,9 @@
 // for declaration of reserved field, make use of _TU_COUNTER_
 #define TU_RESERVED           TU_XSTRCAT(reserved, _TU_COUNTER_)
 
+#define TU_LITTLE_ENDIAN (0x12u)
+#define TU_BIG_ENDIAN (0x21u)
+
 //--------------------------------------------------------------------+
 // Compiler porting with Attribute and Endian
 //--------------------------------------------------------------------+
@@ -67,20 +70,80 @@
 
   // Endian conversion use well-known host to network (big endian) naming
   #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    #define tu_htonl(u32)  __builtin_bswap32(u32)
-    #define tu_ntohl(u32)  __builtin_bswap32(u32)
-
-    #define tu_htons(u16)  __builtin_bswap16(u16)
-    #define tu_ntohs(u16)  __builtin_bswap16(u16)
+    #define TU_BYTE_ORDER TU_LITTLE_ENDIAN
   #else
-    #define tu_htonl(u32)  (u32)
-    #define tu_ntohl(u32)  (u32)
+    #define TU_BYTE_ORDER TU_BIG_ENDIAN
+  #endif
+
+  static inline uint16_t tu_bswap16(uint16_t u16)
+  {
+    return __builtin_bswap16(u16);
+  }
+
+  static inline uint16_t tu_bswap32(uint16_t u32)
+  {
+    return __builtin_bswap32(u32);
+  }
+
+  #define TU_BSWAP16
+
+#elif defined(__TI_COMPILER_VERSION__)
+  #define TU_ATTR_ALIGNED(Bytes)        __attribute__ ((aligned(Bytes)))
+  #define TU_ATTR_SECTION(sec_name)     __attribute__ ((section(#sec_name)))
+  #define TU_ATTR_PACKED                __attribute__ ((packed))
+  #define TU_ATTR_PREPACKED
+  #define TU_ATTR_WEAK                  __attribute__ ((weak))
+  #define TU_ATTR_DEPRECATED(mess)      __attribute__ ((deprecated(mess))) // warn if function with this attribute is used
+  #define TU_ATTR_UNUSED                __attribute__ ((unused))           // Function/Variable is meant to be possibly unused
 
-    #define tu_htons(u16)  (u16)
-    #define tu_ntohs(u16)  (u16)
+  // __BYTE_ORDER is defined in the TI ARM compiler, but not MSP430 (which is little endian)
+  #if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__)) || defined(__MSP430__)
+    #define TU_BYTE_ORDER TU_LITTLE_ENDIAN
+  #else
+    #define TU_BYTE_ORDER TU_BIG_ENDIAN
   #endif
+
+  static inline uint16_t tu_bswap16(uint16_t u16)
+  {
+    return __builtin_bswap16(u16);
+  }
+
+  static inline uint16_t tu_bswap32(uint16_t u32)
+  {
+    return __builtin_bswap32(u32);
+  }
+#else
+  #error "Compiler attribute porting is required"
+#endif
+
+#if (TU_BYTE_ORDER == TU_LITTLE_ENDIAN)
+  #define tu_htonl(u32)  tu_bswap32(u32)
+  #define tu_ntohl(u32)  tu_bswap32(u32)
+
+  #define tu_htons(u16)  tu_bswap16(u16)
+  #define tu_ntohs(u16)  tu_bswap16(u16)
+
+  #define tu_htole16(x) (x)
+  #define tu_le16toh(x) (x)
+
+  #define tu_htole32(x) (x)
+  #define tu_le32toh(x) (x)
+
+#elif (TU_BYTE_ORDER == TU_BIG_ENDIAN)
+  #define tu_htonl(u32)  (x)
+  #define tu_ntohl(u32)  (x)
+
+  #define tu_htons(u16)  (x)
+  #define tu_ntohs(u16)  (x)
+
+  #define tu_htole16(x) tu_bswap16(u32)
+  #define tu_le16toh(x) tu_bswap16(u32)
+
+  #define tu_htole32(x) tu_bswap32(u32)
+  #define tu_le32toh(x) tu_bswap32(u32)
+
 #else
-  #error "Compiler attribute porting are required"
+  #error Byte order is undefined
 #endif
 
 #endif /* _TUSB_COMPILER_H_ */
-- 
cgit v1.3.1


From 41e8b8752e421ccb63a48eec316f353854abc8a0 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Sun, 15 Sep 2019 15:20:01 -0400
Subject: Massive copy&paste typo of mine in the 32-bit byte swapping
 function....

---
 src/common/tusb_compiler.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/common/tusb_compiler.h b/src/common/tusb_compiler.h
index ca294c20f..df0326afd 100644
--- a/src/common/tusb_compiler.h
+++ b/src/common/tusb_compiler.h
@@ -80,7 +80,7 @@
     return __builtin_bswap16(u16);
   }
 
-  static inline uint16_t tu_bswap32(uint16_t u32)
+  static inline uint32_t tu_bswap32(uint32_t u32)
   {
     return __builtin_bswap32(u32);
   }
@@ -108,7 +108,7 @@
     return __builtin_bswap16(u16);
   }
 
-  static inline uint16_t tu_bswap32(uint16_t u32)
+  static inline uint32_t tu_bswap32(uint32_t u32)
   {
     return __builtin_bswap32(u32);
   }
-- 
cgit v1.3.1


From 8d05b70a72d8132eb67523c789499cd4cdf5d562 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Fri, 13 Sep 2019 23:37:47 -0400
Subject: Off-by-one error in Synopsys assertions. (and move some braces to
 their own lines.

---
 src/portable/st/synopsys/dcd_synopsys.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

(limited to 'src')

diff --git a/src/portable/st/synopsys/dcd_synopsys.c b/src/portable/st/synopsys/dcd_synopsys.c
index b0e7e04bd..2daa16a26 100644
--- a/src/portable/st/synopsys/dcd_synopsys.c
+++ b/src/portable/st/synopsys/dcd_synopsys.c
@@ -268,21 +268,22 @@ bool dcd_edpt_open (uint8_t rhport, tusb_desc_endpoint_t const * desc_edpt)
 
   uint8_t const epnum = tu_edpt_number(desc_edpt->bEndpointAddress);
   uint8_t const dir   = tu_edpt_dir(desc_edpt->bEndpointAddress);
-
-  // Unsupported endpoint numbers/size.
-  if((desc_edpt->wMaxPacketSize.size > 64) || (epnum > EP_MAX)) {
-    return false;
-  }
-
+  
+  TU_ASSERT((desc_edpt->wMaxPacketSize.size <= 64);
+  TU_ASSERT(epnum < EP_MAX);
+  
   xfer_ctl_t * xfer = XFER_CTL_BASE(epnum, dir);
   xfer->max_size = desc_edpt->wMaxPacketSize.size;
 
-  if(dir == TUSB_DIR_OUT) {
+  if(dir == TUSB_DIR_OUT)
+  {
     out_ep[epnum].DOEPCTL |= (1 << USB_OTG_DOEPCTL_USBAEP_Pos) | \
       desc_edpt->bmAttributes.xfer << USB_OTG_DOEPCTL_EPTYP_Pos | \
       desc_edpt->wMaxPacketSize.size << USB_OTG_DOEPCTL_MPSIZ_Pos;
     dev->DAINTMSK |= (1 << (USB_OTG_DAINTMSK_OEPM_Pos + epnum));
-  } else {
+  }
+  else
+  {
     // "USB Data FIFOs" section in reference manual
     // Peripheral FIFO architecture
     //
-- 
cgit v1.3.1


From 1ceeab2702c6f5407c00dab8deeade338d176a45 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Fri, 13 Sep 2019 23:52:43 -0400
Subject: This demonstrates that I don't pre-build things before committing
 them... oops.

---
 src/portable/st/synopsys/dcd_synopsys.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/portable/st/synopsys/dcd_synopsys.c b/src/portable/st/synopsys/dcd_synopsys.c
index 2daa16a26..f15b92edc 100644
--- a/src/portable/st/synopsys/dcd_synopsys.c
+++ b/src/portable/st/synopsys/dcd_synopsys.c
@@ -269,7 +269,7 @@ bool dcd_edpt_open (uint8_t rhport, tusb_desc_endpoint_t const * desc_edpt)
   uint8_t const epnum = tu_edpt_number(desc_edpt->bEndpointAddress);
   uint8_t const dir   = tu_edpt_dir(desc_edpt->bEndpointAddress);
   
-  TU_ASSERT((desc_edpt->wMaxPacketSize.size <= 64);
+  TU_ASSERT(desc_edpt->wMaxPacketSize.size <= 64);
   TU_ASSERT(epnum < EP_MAX);
   
   xfer_ctl_t * xfer = XFER_CTL_BASE(epnum, dir);
-- 
cgit v1.3.1


From 8e17fb49106eeb291a36ff5f82ead624e867e6b0 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Mon, 16 Sep 2019 11:13:17 +0700
Subject: follow up to suggestion to pr 155

---
 src/common/tusb_types.h |  3 ++-
 src/device/usbd.c       | 19 +++++++++++++------
 2 files changed, 15 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/common/tusb_types.h b/src/common/tusb_types.h
index a50e89934..ad42baad7 100644
--- a/src/common/tusb_types.h
+++ b/src/common/tusb_types.h
@@ -125,7 +125,8 @@ typedef enum
 {
   TUSB_REQ_TYPE_STANDARD = 0,
   TUSB_REQ_TYPE_CLASS,
-  TUSB_REQ_TYPE_VENDOR
+  TUSB_REQ_TYPE_VENDOR,
+  TUSB_REQ_TYPE_INVALID
 } tusb_request_type_t;
 
 typedef enum
diff --git a/src/device/usbd.c b/src/device/usbd.c
index 572708f7d..2f8967fae 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -62,7 +62,7 @@ typedef struct {
 static usbd_device_t _usbd_dev = { 0 };
 
 // Invalid driver ID in itf2drv[] ep2drv[][] mapping
-enum { DRVID_INVALID = 0xff };
+enum { DRVID_INVALID = 0xFFu };
 
 //--------------------------------------------------------------------+
 // Class Driver
@@ -365,6 +365,8 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
 {
   usbd_control_set_complete_callback(NULL);
 
+  TU_ASSERT(p_request->bmRequestType_bit.type < TUSB_REQ_TYPE_INVALID);
+
   // Vendor request
   if ( p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_VENDOR )
   {
@@ -486,7 +488,8 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
             // GET HID REPORT DESCRIPTOR falls into this case
             // stall control endpoint if driver return false
             usbd_control_set_complete_callback(usbd_class_drivers[drvid].control_complete);
-            TU_ASSERT(usbd_class_drivers[drvid].control_request(rhport, p_request));
+            TU_ASSERT(usbd_class_drivers[drvid].control_request != NULL &&
+                      usbd_class_drivers[drvid].control_request(rhport, p_request));
           break;
         }
       }else
@@ -494,7 +497,8 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
         // forward to class driver: "non-STD request to Interface"
         // stall control endpoint if driver return false
         usbd_control_set_complete_callback(usbd_class_drivers[drvid].control_complete);
-        TU_ASSERT(usbd_class_drivers[drvid].control_request(rhport, p_request));
+        TU_ASSERT(usbd_class_drivers[drvid].control_request != NULL &&
+                  usbd_class_drivers[drvid].control_request(rhport, p_request));
       }
     }
     break;
@@ -515,7 +519,7 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
       // We will forward all request targeted endpoint to its class driver
       // - For non-standard request: driver can ACK or Stall the request by return true/false
       // - For standard request: usbd decide the ACK stage regardless of driver return value
-      bool ret;
+      bool ret = false;
 
       if ( TUSB_REQ_TYPE_STANDARD != p_request->bmRequestType_bit.type )
       {
@@ -523,8 +527,11 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
         usbd_control_set_complete_callback(usbd_class_drivers[drv_id].control_complete);
       }
 
-      // Invoke class driver first
-      ret = usbd_class_drivers[drv_id].control_request(rhport, p_request);
+      // Invoke class driver first if available
+      if ( usbd_class_drivers[drv_id].control_request )
+      {
+        ret = usbd_class_drivers[drv_id].control_request(rhport, p_request);
+      }
 
       // Then handle if it is standard request
       if ( TUSB_REQ_TYPE_STANDARD == p_request->bmRequestType_bit.type )
-- 
cgit v1.3.1


From 5a2e510af73e84284343420fd76388369e70f7f5 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Sat, 14 Sep 2019 09:02:21 -0400
Subject: Interpretation of assert vs verify.

---
 src/common/tusb_verify.h | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/common/tusb_verify.h b/src/common/tusb_verify.h
index 2727ce043..fae0c88ae 100644
--- a/src/common/tusb_verify.h
+++ b/src/common/tusb_verify.h
@@ -36,10 +36,34 @@
  * as C++ for the sake of code simplicity. Beware of a headache macro
  * manipulation that you are told to stay away.
  *
- * e.g
  *
- * - TU_VERIFY( cond ) will return false if cond is false
- * - TU_VERIFY( cond, err) will return err instead if cond is false
+ * This contains macros for both VERIFY and ASSERT:
+ * 
+ *   VERIFY: Used when there is an error condition which is not the
+ *           fault of the MCU. For example, bounds checking on data
+ *           sent to the micro over USB should use this function.
+ *           Another example is checking for buffer overflows, where
+ *           returning from the active function causes a NAK.
+ * 
+ *   ASSERT: Used for error conditions that are caused by MCU firmware
+ *           bugs. This is used to discover bugs in the code more
+ *           quickly. One example would be adding assertions in library
+ *           function calls to confirm a function's (untainted)
+ *           parameters are valid.
+ *
+ * 
+ * The difference in behaviour is that ASSERT triggers a breakpoint while
+ * verify does not.
+ *
+ *   #define TU_VERIFY(cond)                  if(cond) return false;
+ *   #define TU_VERIFY(cond,ret)              if(cond) return ret;
+ *   
+ *   #define TU_VERIFY_HDLR(cond,handler)     if(cond) {handler; return false;}
+ *   #define TU_VERIFY_HDLR(cond,ret,handler) if(cond) {handler; return ret;}
+ *
+ *   #define TU_ASSERT(cond)                  if(cond) {_MESS_FAILED(); TU_BREAKPOINT(), return false;}
+ *   #define TU_ASSERT(cond,ret)              if(cond) {_MESS_FAILED(); TU_BREAKPOINT(), return ret;}
+ *  
  *------------------------------------------------------------------*/
 
 #ifdef __cplusplus
-- 
cgit v1.3.1


From 237c32b976d605087dd0b2c5013f7f2ae4bae46f Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Mon, 16 Sep 2019 13:32:47 +0700
Subject: fix #143

---
 src/portable/nxp/lpc17_40/dcd_lpc17_40.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/portable/nxp/lpc17_40/dcd_lpc17_40.c b/src/portable/nxp/lpc17_40/dcd_lpc17_40.c
index 2b49f52e9..d5f90d2a7 100644
--- a/src/portable/nxp/lpc17_40/dcd_lpc17_40.c
+++ b/src/portable/nxp/lpc17_40/dcd_lpc17_40.c
@@ -293,7 +293,7 @@ bool dcd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const * p_endpoint_desc)
       break;
 
     case TUSB_XFER_ISOCHRONOUS:
-      TU_ASSERT((epnum % 3) == 3 && (epnum != 15));
+      TU_ASSERT((epnum % 3) == 0 && (epnum != 0) && (epnum != 15));
       break;
 
     default:
-- 
cgit v1.3.1


From 6dd2296cfc1b2cd871e577c42de96ee444d4a1d3 Mon Sep 17 00:00:00 2001
From: Nathan Conrad <pigrew@gmail.com>
Date: Mon, 16 Sep 2019 11:27:05 -0400
Subject: Change inline functions to macros, and make all parameter names
 uniform.

---
 src/common/tusb_compiler.h | 58 ++++++++++++++++++----------------------------
 1 file changed, 23 insertions(+), 35 deletions(-)

(limited to 'src')

diff --git a/src/common/tusb_compiler.h b/src/common/tusb_compiler.h
index df0326afd..58732b871 100644
--- a/src/common/tusb_compiler.h
+++ b/src/common/tusb_compiler.h
@@ -75,17 +75,8 @@
     #define TU_BYTE_ORDER TU_BIG_ENDIAN
   #endif
 
-  static inline uint16_t tu_bswap16(uint16_t u16)
-  {
-    return __builtin_bswap16(u16);
-  }
-
-  static inline uint32_t tu_bswap32(uint32_t u32)
-  {
-    return __builtin_bswap32(u32);
-  }
-
-  #define TU_BSWAP16
+#define TU_BSWAP16(u16) (__builtin_bswap16(u16))
+#define TU_BSWAP32(u32) (__builtin_bswap32(u32))
 
 #elif defined(__TI_COMPILER_VERSION__)
   #define TU_ATTR_ALIGNED(Bytes)        __attribute__ ((aligned(Bytes)))
@@ -103,44 +94,41 @@
     #define TU_BYTE_ORDER TU_BIG_ENDIAN
   #endif
 
-  static inline uint16_t tu_bswap16(uint16_t u16)
-  {
-    return __builtin_bswap16(u16);
-  }
+  #define TU_BSWAP16(u16) (__builtin_bswap16(u16))
+  #define TU_BSWAP32(u32) (__builtin_bswap32(u32))
 
-  static inline uint32_t tu_bswap32(uint32_t u32)
-  {
-    return __builtin_bswap32(u32);
-  }
 #else
   #error "Compiler attribute porting is required"
 #endif
 
 #if (TU_BYTE_ORDER == TU_LITTLE_ENDIAN)
-  #define tu_htonl(u32)  tu_bswap32(u32)
-  #define tu_ntohl(u32)  tu_bswap32(u32)
 
-  #define tu_htons(u16)  tu_bswap16(u16)
-  #define tu_ntohs(u16)  tu_bswap16(u16)
+  #define tu_htons(u16)  (TU_BSWAP16(u16))
+  #define tu_ntohs(u16)  (TU_BSWAP16(u16))
+
+  #define tu_htonl(u32)  (TU_BSWAP32(u32))
+  #define tu_ntohl(u32)  (TU_BSWAP32(u32))
 
-  #define tu_htole16(x) (x)
-  #define tu_le16toh(x) (x)
+  #define tu_htole16(u16) (u16)
+  #define tu_le16toh(u16) (u16)
 
-  #define tu_htole32(x) (x)
-  #define tu_le32toh(x) (x)
+  #define tu_htole32(u32) (u32)
+  #define tu_le32toh(u32) (u32)
 
 #elif (TU_BYTE_ORDER == TU_BIG_ENDIAN)
-  #define tu_htonl(u32)  (x)
-  #define tu_ntohl(u32)  (x)
 
-  #define tu_htons(u16)  (x)
-  #define tu_ntohs(u16)  (x)
+  #define tu_htons(u16)  (u16)
+  #define tu_ntohs(u16)  (u16)
+
+  #define tu_htonl(u32)  (u32)
+  #define tu_ntohl(u32)  (u32)
+
 
-  #define tu_htole16(x) tu_bswap16(u32)
-  #define tu_le16toh(x) tu_bswap16(u32)
+  #define tu_htole16(u16) (tu_bswap16(u16))
+  #define tu_le16toh(u16) (tu_bswap16(u16))
 
-  #define tu_htole32(x) tu_bswap32(u32)
-  #define tu_le32toh(x) tu_bswap32(u32)
+  #define tu_htole32(u32) (tu_bswap32(u32))
+  #define tu_le32toh(u32) (tu_bswap32(u32))
 
 #else
   #error Byte order is undefined
-- 
cgit v1.3.1