Rename functions to include tud_ and _cb

examples/device/usbtmc/src/usbtmc_app.c

@@ -25,7 +25,7 @@
 
 #include <strings.h>
 #include <stdlib.h>     /* atoi */
-#include "class/usbtmc/usbtmc_device.h"
+#include "tusb.h"
 #include "bsp/board.h"
 #include "main.h"
 
@@ -34,7 +34,7 @@ usbtmc_response_capabilities_488_t const
 #else
 usbtmc_response_capabilities_t const
 #endif
-usbtmcd_app_capabilities  =
+tud_usbtmc_app_capabilities  =
 {
     .USBTMC_status = USBTMC_STATUS_SUCCESS,
     .bcdUSBTMC = USBTMC_VERSION,
@@ -95,7 +95,7 @@ static usbtmc_msg_dev_dep_msg_in_header_t rspMsg = {
     }
 };
 
-bool usbtmcd_app_msg_trigger(uint8_t rhport, usbtmc_msg_generic_t* msg) {
+bool tud_usbtmc_app_msg_trigger_cb(uint8_t rhport, usbtmc_msg_generic_t* msg) {
   (void)rhport;
   (void)msg;
   // Let trigger set the SRQ
@@ -103,7 +103,7 @@ bool usbtmcd_app_msg_trigger(uint8_t rhport, usbtmc_msg_generic_t* msg) {
   return true;
 }
 
-bool usbtmcd_app_msgBulkOut_start(uint8_t rhport, usbtmc_msg_request_dev_dep_out const * msgHeader)
+bool tud_usbtmc_app_msgBulkOut_start_cb(uint8_t rhport, usbtmc_msg_request_dev_dep_out const * msgHeader)
 {
   (void)rhport;
   (void)msgHeader;
@@ -111,7 +111,7 @@ bool usbtmcd_app_msgBulkOut_start(uint8_t rhport, usbtmc_msg_request_dev_dep_out
   return true;
 }
 
-bool usbtmcd_app_msg_data(uint8_t rhport, void *data, size_t len, bool transfer_complete)
+bool tud_usbtmc_app_msg_data_cb(uint8_t rhport, void *data, size_t len, bool transfer_complete)
 {
   (void)rhport;
 
@@ -142,7 +142,7 @@ bool usbtmcd_app_msg_data(uint8_t rhport, void *data, size_t len, bool transfer_
   return true;
 }
 
-bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport)
+bool tud_usbtmc_app_msgBulkIn_complete_cb(uint8_t rhport)
 {
   (void)rhport;
 
@@ -153,7 +153,7 @@ bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport)
 
 static unsigned int msgReqLen;
 
-bool usbtmcd_app_msgBulkIn_request(uint8_t rhport, usbtmc_msg_request_dev_dep_in const * request)
+bool tud_usbtmc_app_msgBulkIn_request_cb(uint8_t rhport, usbtmc_msg_request_dev_dep_in const * request)
 {
   (void)rhport;
 
@@ -218,7 +218,7 @@ void usbtmc_app_task_iter(void) {
   }
 }
 
-bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult)
+bool tud_usbtmc_app_initiate_clear_cb(uint8_t rhport, uint8_t *tmcResult)
 {
   (void)rhport;
   *tmcResult = USBTMC_STATUS_SUCCESS;
@@ -228,7 +228,7 @@ bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult)
   return true;
 }
 
-bool usbtmcd_app_check_clear(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp)
+bool tud_usbtmc_app_check_clear_cb(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp)
 {
   (void)rhport;
   queryState = 0;
@@ -238,45 +238,45 @@ bool usbtmcd_app_check_clear(uint8_t rhport, usbtmc_get_clear_status_rsp_t *rsp)
   rsp->bmClear.BulkInFifoBytes = 0u;
   return true;
 }
-bool usbtmcd_app_initiate_abort_bulk_in(uint8_t rhport, uint8_t *tmcResult)
+bool tud_usbtmc_app_initiate_abort_bulk_in_cb(uint8_t rhport, uint8_t *tmcResult)
 {
   (void)rhport;
   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)
+bool tud_usbtmc_app_check_abort_bulk_in_cb(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp)
 {
   (void)rhport;
   (void)rsp;
   return true;
 }
 
-bool usbtmcd_app_initiate_abort_bulk_out(uint8_t rhport, uint8_t *tmcResult)
+bool tud_usbtmc_app_initiate_abort_bulk_out_cb(uint8_t rhport, uint8_t *tmcResult)
 {
   (void)rhport;
   *tmcResult = USBTMC_STATUS_SUCCESS;
   return true;
 
 }
-bool usbtmcd_app_check_abort_bulk_out(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp)
+bool tud_usbtmc_app_check_abort_bulk_out_cb(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp)
 {
   (void)rhport;
   (void)rsp;
   return true;
 }
 
-void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport)
+void usmtmcd_app_bulkIn_clearFeature_cb(uint8_t rhport)
 {
   (void)rhport;
 }
-void usmtmcd_app_bulkOut_clearFeature(uint8_t rhport)
+void usmtmcd_app_bulkOut_clearFeature_cb(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)
+uint8_t tud_usbtmc_app_get_stb_cb(uint8_t rhport, uint8_t *tmcResult)
 {
   (void)rhport;
   uint8_t old_status = status;
@@ -288,7 +288,7 @@ uint8_t usbtmcd_app_get_stb(uint8_t rhport, uint8_t *tmcResult)
   return old_status;
 }
 
-bool usbtmcd_app_indicator_pluse(uint8_t rhport, tusb_control_request_t const * msg, uint8_t *tmcResult)
+bool tud_usbtmc_app_indicator_pluse_cb(uint8_t rhport, tusb_control_request_t const * msg, uint8_t *tmcResult)
 {
   (void)rhport;
   (void)msg;

src/class/usbtmc/usbtmc.h

@@ -300,7 +300,7 @@ typedef struct TU_ATTR_PACKED
 
 TU_VERIFY_STATIC(sizeof(usbtmc_read_stb_rsp_488_t) == 3u, "struct wrong length");
 
-typedef struct TU_ATTR_PACKET
+typedef struct TU_ATTR_PACKED
 {
   struct TU_ATTR_PACKED
   {

src/class/usbtmc/usbtmc_device.c

@@ -174,7 +174,7 @@ bool usbtmcd_transmit_dev_msg_data(
   TU_ASSERT(len <= usbtmc_state.transfer_size_remaining);
   if(usingTermChar)
   {
-    TU_ASSERT(usbtmcd_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
+    TU_ASSERT(tud_usbtmc_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
     TU_ASSERT(termCharRequested);
     TU_ASSERT(((uint8_t*)data)[len-1] == termChar);
   }
@@ -224,31 +224,31 @@ bool usbtmcd_transmit_dev_msg_data(
   return true;
 }
 
-void usbtmcd_init(void)
+void usbtmcd_init_cb(void)
 {
 #ifndef NDEBUG
 #  if CFG_USBTMC_CFG_ENABLE_488
-  if(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger)
-    TU_ASSERT(&usbtmcd_app_msg_trigger != NULL,);
+  if(tud_usbtmc_app_capabilities.bmIntfcCapabilities488.supportsTrigger)
+    TU_ASSERT(&tud_usbtmc_app_msg_trigger_cb != NULL,);
   // Per USB488 spec: table 8
-  TU_ASSERT(!usbtmcd_app_capabilities.bmIntfcCapabilities.listenOnly,);
-  TU_ASSERT(!usbtmcd_app_capabilities.bmIntfcCapabilities.talkOnly,);
+  TU_ASSERT(!tud_usbtmc_app_capabilities.bmIntfcCapabilities.listenOnly,);
+  TU_ASSERT(!tud_usbtmc_app_capabilities.bmIntfcCapabilities.talkOnly,);
 #  endif
-    if(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse)
-      TU_ASSERT(&usbtmcd_app_indicator_pluse != NULL,);
+    if(tud_usbtmc_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse)
+      TU_ASSERT(&tud_usbtmc_app_indicator_pluse_cb != NULL,);
 #endif
 
     usbtmcLock = osal_mutex_create(&usbtmcLockBuffer);
 }
 
-bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
+bool usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
 {
   (void)rhport;
   uint8_t const * p_desc;
   uint8_t found_endpoints = 0;
 
 
-  usbtmcd_reset(rhport);
+  usbtmcd_reset_cb(rhport);
 
   // Perhaps there are other application specific class drivers, so don't assert here.
   if( itf_desc->bInterfaceClass != TUD_USBTMC_APP_CLASS)
@@ -311,8 +311,8 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
     TU_ASSERT(usbtmc_state.ep_int_in != 0);
   }
 #if (USBTMC_CFG_ENABLE_488)
-  if(usbtmcd_app_capabilities.bmIntfcCapabilities488.is488_2 ||
-      usbtmcd_app_capabilities.bmDevCapabilities488.SR1)
+  if(tud_usbtmc_app_capabilities.bmIntfcCapabilities488.is488_2 ||
+      tud_usbtmc_app_capabilities.bmDevCapabilities488.SR1)
   {
     TU_ASSERT(usbtmc_state.ep_int_in != 0);
   }
@@ -322,7 +322,7 @@ bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
 
   return true;
 }
-void usbtmcd_reset(uint8_t rhport)
+void usbtmcd_reset_cb(uint8_t rhport)
 {
   // FIXME: Do endpoints need to be closed here?
   usbtmc_state.state = STATE_IDLE;
@@ -343,7 +343,7 @@ static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len)
   // must be a header, should have been confirmed before calling here.
   usbtmc_msg_request_dev_dep_out *msg = (usbtmc_msg_request_dev_dep_out*)data;
   usbtmc_state.transfer_size_remaining = msg->TransferSize;
-  TU_VERIFY(usbtmcd_app_msgBulkOut_start(rhport,msg));
+  TU_VERIFY(tud_usbtmc_app_msgBulkOut_start_cb(rhport,msg));
 
   TU_VERIFY(handle_devMsgOut(rhport, (uint8_t*)data + sizeof(*msg), len - sizeof(*msg), len));
   return true;
@@ -360,7 +360,7 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
     atEnd = true;
   if(len > usbtmc_state.transfer_size_remaining)
     len = usbtmc_state.transfer_size_remaining;
-  usbtmcd_app_msg_data(rhport,data, len, atEnd);
+  tud_usbtmc_app_msg_data_cb(rhport,data, len, atEnd);
 
   usbtmc_state.transfer_size_remaining -= len;
   usbtmc_state.transfer_size_sent += len;
@@ -394,9 +394,9 @@ static bool handle_devMsgIn(uint8_t rhport, void *data, size_t len)
   termChar = msg->TermChar;
 
   if(termCharRequested)
-    TU_VERIFY(usbtmcd_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
+    TU_VERIFY(tud_usbtmc_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
 
-  TU_VERIFY(usbtmcd_app_msgBulkIn_request(rhport, msg));
+  TU_VERIFY(tud_usbtmc_app_msgBulkIn_request_cb(rhport, msg));
   return true;
 }
 
@@ -435,8 +435,8 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
 #if (CFG_USBTMC_CFG_ENABLE_488)
       case USBTMC_MSGID_USB488_TRIGGER:
         // 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_msg_trigger(rhport, msg));
+        TU_VERIFY(tud_usbtmc_app_capabilities.bmIntfcCapabilities488.supportsTrigger);
+        TU_VERIFY(tud_usbtmc_app_msg_trigger_cb(rhport, msg));
 
         break;
 #endif
@@ -474,7 +474,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
     case STATE_TX_SHORTED:
 
       usbtmc_state.state = STATE_IDLE;
-      TU_VERIFY(usbtmcd_app_msgBulkIn_complete(rhport));
+      TU_VERIFY(tud_usbtmc_app_msgBulkIn_complete_cb(rhport));
       break;
 
     case STATE_TX_INITIATED:
@@ -522,7 +522,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
   return false;
 }
 
-bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * request) {
+bool usbtmcd_control_request_cb(uint8_t rhport, tusb_control_request_t const * request) {
 
   uint8_t tmcStatusCode = USBTMC_STATUS_FAILED;
 #if (CFG_USBTMC_CFG_ENABLE_488)
@@ -536,11 +536,11 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
   {
     if((request->wIndex) == usbtmc_state.ep_bulk_out)
     {
-      usmtmcd_app_bulkOut_clearFeature(rhport);
+      usmtmcd_app_bulkOut_clearFeature_cb(rhport);
     }
     else if ((request->wIndex) == usbtmc_state.ep_bulk_in)
     {
-      usmtmcd_app_bulkIn_clearFeature(rhport);
+      usmtmcd_app_bulkIn_clearFeature_cb(rhport);
     }
     return false; // We want USBD core to handle sending the status response, and clear the stall condition
   }
@@ -580,7 +580,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
       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)));
+      TU_VERIFY(tud_usbtmc_app_initiate_abort_bulk_out_cb(rhport, &(rsp.USBTMC_status)));
       usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
     }
     TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp)));
@@ -595,7 +595,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 == sizeof(rsp));
     TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
-    TU_VERIFY(usbtmcd_app_check_abort_bulk_out(rhport, &rsp));
+    TU_VERIFY(tud_usbtmc_app_check_abort_bulk_out_cb(rhport, &rsp));
     TU_VERIFY(usbd_edpt_xfer(rhport, 0u, (void*)&rsp,sizeof(rsp)));
     return true;
   }
@@ -623,7 +623,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
         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;
       }
-      TU_VERIFY(usbtmcd_app_initiate_abort_bulk_in(rhport, &(rsp.USBTMC_status)));
+      TU_VERIFY(tud_usbtmc_app_initiate_abort_bulk_in_cb(rhport, &(rsp.USBTMC_status)));
     }
     else if((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED))
     { // FIXME: Unsure how to check  if the OUT endpoint fifo is non-empty....
@@ -651,7 +651,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
         },
         .NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent,
     };
-    TU_VERIFY(usbtmcd_app_check_abort_bulk_in(rhport, &rsp));
+    TU_VERIFY(tud_usbtmc_app_check_abort_bulk_in_cb(rhport, &rsp));
     switch(usbtmc_state.state)
     {
     case STATE_ABORTING_BULK_IN_ABORTED:
@@ -679,7 +679,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
       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_usbtmc_app_initiate_clear_cb(rhport, &tmcStatusCode));
       TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
       return true;
     }
@@ -699,7 +699,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
       else
       {
         // Let app check if it's clear
-        TU_VERIFY(usbtmcd_app_check_clear(rhport, &clearStatusRsp));
+        TU_VERIFY(tud_usbtmc_app_check_clear_cb(rhport, &clearStatusRsp));
       }
       if(clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS)
         usbtmc_state.state = STATE_IDLE;
@@ -710,8 +710,8 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
   case USBTMC_bREQUEST_GET_CAPABILITIES:
     {
       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)));
+      TU_VERIFY(request->wLength == sizeof(tud_usbtmc_app_capabilities));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tud_usbtmc_app_capabilities, sizeof(tud_usbtmc_app_capabilities)));
       return true;
     }
   // USBTMC Optional Requests
@@ -720,8 +720,8 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
     {
       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_usbtmc_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse);
+      TU_VERIFY(tud_usbtmc_app_indicator_pluse_cb(rhport, request, &tmcStatusCode));
       TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode, sizeof(tmcStatusCode)));
       return true;
     }
@@ -752,13 +752,13 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
               .one = 1,
               .bTag = bTag & 0x7Fu,
           },
-          .StatusByte = usbtmcd_app_get_stb(rhport, &(rsp.USBTMC_status))
+          .StatusByte = tud_usbtmc_app_get_stb_cb(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));
+        rsp.statusByte = tud_usbtmc_app_get_stb_cb(rhport, &(rsp.USBTMC_status));
       }
       TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp, sizeof(rsp)));
       return true;
@@ -781,7 +781,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
   TU_VERIFY(false);
 }
 
-bool usbtmcd_control_complete(uint8_t rhport, tusb_control_request_t const * request)
+bool usbtmcd_control_complete_cb(uint8_t rhport, tusb_control_request_t const * request)
 {
   (void)rhport;
   //------------- Class Specific Request -------------//

src/class/usbtmc/usbtmc_device.h

@@ -50,35 +50,35 @@
  */
 
 #if (CFG_USBTMC_CFG_ENABLE_488)
-extern usbtmc_response_capabilities_488_t const usbtmcd_app_capabilities;
+extern usbtmc_response_capabilities_488_t const tud_usbtmc_app_capabilities;
 #else
-extern usbtmc_response_capabilities_t const usbtmcd_app_capabilities;
+extern usbtmc_response_capabilities_t const tud_usbtmc_app_capabilities;
 #endif
 
-bool usbtmcd_app_msgBulkOut_start(uint8_t rhport, usbtmc_msg_request_dev_dep_out const * msgHeader);
+bool tud_usbtmc_app_msgBulkOut_start_cb(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 tud_usbtmc_app_msg_data_cb(uint8_t rhport, void *data, size_t len, bool transfer_complete);
+void usmtmcd_app_bulkOut_clearFeature_cb(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 tud_usbtmc_app_msgBulkIn_request_cb(uint8_t rhport, usbtmc_msg_request_dev_dep_in const * request);
+bool tud_usbtmc_app_msgBulkIn_complete_cb(uint8_t rhport);
+void usmtmcd_app_bulkIn_clearFeature_cb(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 tud_usbtmc_app_initiate_abort_bulk_in_cb(uint8_t rhport, uint8_t *tmcResult);
+bool tud_usbtmc_app_initiate_abort_bulk_out_cb(uint8_t rhport, uint8_t *tmcResult);
+bool tud_usbtmc_app_initiate_clear_cb(uint8_t rhport, uint8_t *tmcResult);
 
-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);
+bool tud_usbtmc_app_check_abort_bulk_in_cb(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp);
+bool tud_usbtmc_app_check_abort_bulk_out_cb(uint8_t rhport, usbtmc_check_abort_bulk_rsp_t *rsp);
+bool tud_usbtmc_app_check_clear_cb(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);
+TU_ATTR_WEAK bool tud_usbtmc_app_indicator_pluse_cb(uint8_t rhport, tusb_control_request_t const * msg, uint8_t *tmcResult);
 
 #if (CFG_USBTMC_CFG_ENABLE_488)
-uint8_t usbtmcd_app_get_stb(uint8_t rhport, uint8_t *tmcResult);
-TU_ATTR_WEAK bool usbtmcd_app_msg_trigger(uint8_t rhport, usbtmc_msg_generic_t* msg);
-//TU_ATTR_WEAK bool usbtmcd_app_go_to_local(uint8_t rhport);
+uint8_t tud_usbtmc_app_get_stb_cb(uint8_t rhport, uint8_t *tmcResult);
+TU_ATTR_WEAK bool tud_usbtmc_app_msg_trigger_cb(uint8_t rhport, usbtmc_msg_generic_t* msg);
+//TU_ATTR_WEAK bool tud_usbtmc_app_go_to_local_cb(uint8_t rhport);
 #endif
 
 /*******************************************
@@ -96,12 +96,12 @@ bool usbtmcd_transmit_dev_msg_data(
 
 /* "callbacks" from USB device core */
 
-bool usbtmcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length);
-void usbtmcd_reset(uint8_t rhport);
+bool usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length);
+void usbtmcd_reset_cb(uint8_t rhport);
 bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
-bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * request);
-bool usbtmcd_control_complete(uint8_t rhport, tusb_control_request_t const * request);
-void usbtmcd_init(void);
+bool usbtmcd_control_request_cb(uint8_t rhport, tusb_control_request_t const * request);
+bool usbtmcd_control_complete_cb(uint8_t rhport, tusb_control_request_t const * request);
+void usbtmcd_init_cb(void);
 
 /************************************************************
  * USBTMC Descriptor Templates

src/device/usbd.c

@@ -153,11 +153,11 @@ static usbd_class_driver_t const usbd_class_drivers[] =
   {
       .class_code       = TUD_USBTMC_APP_CLASS,
     //.subclass_code    = TUD_USBTMC_APP_SUBCLASS
-      .init             = usbtmcd_init,
-      .reset            = usbtmcd_reset,
-      .open             = usbtmcd_open,
-      .control_request  = usbtmcd_control_request,
-      .control_complete = usbtmcd_control_complete,
+      .init             = usbtmcd_init_cb,
+      .reset            = usbtmcd_reset_cb,
+      .open             = usbtmcd_open_cb,
+      .control_request  = usbtmcd_control_request_cb,
+      .control_complete = usbtmcd_control_complete_cb,
       .xfer_cb          = usbtmcd_xfer_cb,
       .sof              = NULL
   },