kingkevin
/
esp32-s2_dfu
1
0
Fork 0
Code Issues Releases Activity

Rename functions to include tud_ and _cb

This commit is contained in:
Nathan Conrad 2019-09-19 20:08:45 -04:00
parent f3d6d0127b
commit 2a7ca15e2c
5 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -25,7 +25,7 @@
#include <strings.h> #include <strings.h>
#include <stdlib.h> /* atoi */ #include <stdlib.h> /* atoi */
#include "class/usbtmc/usbtmc_device.h" #include "tusb.h"
#include "bsp/board.h" #include "bsp/board.h"
#include "main.h" #include "main.h"
@ -34,7 +34,7 @@ usbtmc_response_capabilities_488_t const
#else #else
usbtmc_response_capabilities_t const usbtmc_response_capabilities_t const
#endif #endif
usbtmcd_app_capabilities = tud_usbtmc_app_capabilities =
{ {
.USBTMC_status = USBTMC_STATUS_SUCCESS, .USBTMC_status = USBTMC_STATUS_SUCCESS,
.bcdUSBTMC = USBTMC_VERSION, .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)rhport;
(void)msg; (void)msg;
// Let trigger set the SRQ // Let trigger set the SRQ
@ -103,7 +103,7 @@ bool usbtmcd_app_msg_trigger(uint8_t rhport, usbtmc_msg_generic_t* msg) {
return true; 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)rhport;
(void)msgHeader; (void)msgHeader;
@ -111,7 +111,7 @@ bool usbtmcd_app_msgBulkOut_start(uint8_t rhport, usbtmc_msg_request_dev_dep_out
return true; 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; (void)rhport;
@ -142,7 +142,7 @@ bool usbtmcd_app_msg_data(uint8_t rhport, void *data, size_t len, bool transfer_
return true; return true;
} }
bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport) bool tud_usbtmc_app_msgBulkIn_complete_cb(uint8_t rhport)
{ {
(void)rhport; (void)rhport;
@ -153,7 +153,7 @@ bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport)
static unsigned int msgReqLen; 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; (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; (void)rhport;
*tmcResult = USBTMC_STATUS_SUCCESS; *tmcResult = USBTMC_STATUS_SUCCESS;
@ -228,7 +228,7 @@ bool usbtmcd_app_initiate_clear(uint8_t rhport, uint8_t *tmcResult)
return true; 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; (void)rhport;
queryState = 0; 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; rsp->bmClear.BulkInFifoBytes = 0u;
return true; 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; (void)rhport;
bulkInStarted = 0; bulkInStarted = 0;
*tmcResult = USBTMC_STATUS_SUCCESS; *tmcResult = USBTMC_STATUS_SUCCESS;
return true; 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)rhport;
(void)rsp; (void)rsp;
return true; 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; (void)rhport;
*tmcResult = USBTMC_STATUS_SUCCESS; *tmcResult = USBTMC_STATUS_SUCCESS;
return true; 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)rhport;
(void)rsp; (void)rsp;
return true; return true;
} }
void usmtmcd_app_bulkIn_clearFeature(uint8_t rhport) void usmtmcd_app_bulkIn_clearFeature_cb(uint8_t rhport)
{ {
(void)rhport; (void)rhport;
} }
void usmtmcd_app_bulkOut_clearFeature(uint8_t rhport) void usmtmcd_app_bulkOut_clearFeature_cb(uint8_t rhport)
{ {
(void)rhport; (void)rhport;
} }
// Return status byte, but put the transfer result status code in the rspResult argument. // 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; (void)rhport;
uint8_t old_status = status; uint8_t old_status = status;
@ -288,7 +288,7 @@ uint8_t usbtmcd_app_get_stb(uint8_t rhport, uint8_t *tmcResult)
return old_status; 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)rhport;
(void)msg; (void)msg;

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

@ -300,7 +300,7 @@ typedef struct TU_ATTR_PACKED
TU_VERIFY_STATIC(sizeof(usbtmc_read_stb_rsp_488_t) == 3u, "struct wrong length"); 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 struct TU_ATTR_PACKED
{ {

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

@ -174,7 +174,7 @@ bool usbtmcd_transmit_dev_msg_data(
TU_ASSERT(len <= usbtmc_state.transfer_size_remaining); TU_ASSERT(len <= usbtmc_state.transfer_size_remaining);
if(usingTermChar) if(usingTermChar)
{ {
TU_ASSERT(usbtmcd_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar); TU_ASSERT(tud_usbtmc_app_capabilities.bmDevCapabilities.canEndBulkInOnTermChar);
TU_ASSERT(termCharRequested); TU_ASSERT(termCharRequested);
TU_ASSERT(((uint8_t*)data)[len-1] == termChar); TU_ASSERT(((uint8_t*)data)[len-1] == termChar);
} }
@ -224,31 +224,31 @@ bool usbtmcd_transmit_dev_msg_data(
return true; return true;
} }
void usbtmcd_init(void) void usbtmcd_init_cb(void)
{ {
#ifndef NDEBUG #ifndef NDEBUG
# if CFG_USBTMC_CFG_ENABLE_488 # if CFG_USBTMC_CFG_ENABLE_488
if(usbtmcd_app_capabilities.bmIntfcCapabilities488.supportsTrigger) if(tud_usbtmc_app_capabilities.bmIntfcCapabilities488.supportsTrigger)
TU_ASSERT(&usbtmcd_app_msg_trigger != NULL,); TU_ASSERT(&tud_usbtmc_app_msg_trigger_cb != NULL,);
// Per USB488 spec: table 8 // Per USB488 spec: table 8
TU_ASSERT(!usbtmcd_app_capabilities.bmIntfcCapabilities.listenOnly,); TU_ASSERT(!tud_usbtmc_app_capabilities.bmIntfcCapabilities.listenOnly,);
TU_ASSERT(!usbtmcd_app_capabilities.bmIntfcCapabilities.talkOnly,); TU_ASSERT(!tud_usbtmc_app_capabilities.bmIntfcCapabilities.talkOnly,);
# endif # endif
if(usbtmcd_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse) if(tud_usbtmc_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse)
TU_ASSERT(&usbtmcd_app_indicator_pluse != NULL,); TU_ASSERT(&tud_usbtmc_app_indicator_pluse_cb != NULL,);
#endif #endif
usbtmcLock = osal_mutex_create(&usbtmcLockBuffer); 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; (void)rhport;
uint8_t const * p_desc; uint8_t const * p_desc;
uint8_t found_endpoints = 0; 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. // Perhaps there are other application specific class drivers, so don't assert here.
if( itf_desc->bInterfaceClass != TUD_USBTMC_APP_CLASS) 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); TU_ASSERT(usbtmc_state.ep_int_in != 0);
} }
#if (USBTMC_CFG_ENABLE_488) #if (USBTMC_CFG_ENABLE_488)
if(usbtmcd_app_capabilities.bmIntfcCapabilities488.is488_2 || if(tud_usbtmc_app_capabilities.bmIntfcCapabilities488.is488_2 ||
usbtmcd_app_capabilities.bmDevCapabilities488.SR1) tud_usbtmc_app_capabilities.bmDevCapabilities488.SR1)
{ {
TU_ASSERT(usbtmc_state.ep_int_in != 0); 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; return true;
} }
void usbtmcd_reset(uint8_t rhport) void usbtmcd_reset_cb(uint8_t rhport)
{ {
// FIXME: Do endpoints need to be closed here? // FIXME: Do endpoints need to be closed here?
usbtmc_state.state = STATE_IDLE; 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. // 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_msg_request_dev_dep_out *msg = (usbtmc_msg_request_dev_dep_out*)data;
usbtmc_state.transfer_size_remaining = msg->TransferSize; 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)); TU_VERIFY(handle_devMsgOut(rhport, (uint8_t*)data + sizeof(*msg), len - sizeof(*msg), len));
return true; return true;
@ -360,7 +360,7 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
atEnd = true; atEnd = true;
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); tud_usbtmc_app_msg_data_cb(rhport,data, len, atEnd);
usbtmc_state.transfer_size_remaining -= len; usbtmc_state.transfer_size_remaining -= len;
usbtmc_state.transfer_size_sent += 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; termChar = msg->TermChar;
if(termCharRequested) 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; 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) #if (CFG_USBTMC_CFG_ENABLE_488)
case USBTMC_MSGID_USB488_TRIGGER: case USBTMC_MSGID_USB488_TRIGGER:
// 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(tud_usbtmc_app_capabilities.bmIntfcCapabilities488.supportsTrigger);
TU_VERIFY(usbtmcd_app_msg_trigger(rhport, msg)); TU_VERIFY(tud_usbtmc_app_msg_trigger_cb(rhport, msg));
break; break;
#endif #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: case STATE_TX_SHORTED:
usbtmc_state.state = STATE_IDLE; usbtmc_state.state = STATE_IDLE;
TU_VERIFY(usbtmcd_app_msgBulkIn_complete(rhport)); TU_VERIFY(tud_usbtmc_app_msgBulkIn_complete_cb(rhport));
break; break;
case STATE_TX_INITIATED: 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; 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; uint8_t tmcStatusCode = USBTMC_STATUS_FAILED;
#if (CFG_USBTMC_CFG_ENABLE_488) #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) 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) 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 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; rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
// Check if we've queued a short packet // Check if we've queued a short packet
usbtmc_state.state = STATE_ABORTING_BULK_OUT; 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); usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
} }
TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp))); 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->bmRequestType == 0xA2); // in,class,EP
TU_VERIFY(request->wLength == sizeof(rsp)); TU_VERIFY(request->wLength == sizeof(rsp));
TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out); TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
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))); TU_VERIFY(usbd_edpt_xfer(rhport, 0u, (void*)&rsp,sizeof(rsp)));
return true; 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)); 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; 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)) 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.... { // 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, .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) switch(usbtmc_state.state)
{ {
case STATE_ABORTING_BULK_IN_ABORTED: 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); usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
usbtmc_state.transfer_size_remaining = 0; usbtmc_state.transfer_size_remaining = 0;
usbtmc_state.state = STATE_CLEARING; 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))); TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
return true; return true;
} }
@ -699,7 +699,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_check_clear(rhport, &clearStatusRsp)); TU_VERIFY(tud_usbtmc_app_check_clear_cb(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;
@ -710,8 +710,8 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
case USBTMC_bREQUEST_GET_CAPABILITIES: case USBTMC_bREQUEST_GET_CAPABILITIES:
{ {
TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
TU_VERIFY(request->wLength == sizeof(usbtmcd_app_capabilities)); TU_VERIFY(request->wLength == sizeof(tud_usbtmc_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*)&tud_usbtmc_app_capabilities, sizeof(tud_usbtmc_app_capabilities)));
return true; return true;
} }
// USBTMC Optional Requests // 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->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(tud_usbtmc_app_capabilities.bmIntfcCapabilities.supportsIndicatorPulse);
TU_VERIFY(usbtmcd_app_indicator_pluse(rhport, request, &tmcStatusCode)); TU_VERIFY(tud_usbtmc_app_indicator_pluse_cb(rhport, request, &tmcStatusCode));
TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode, sizeof(tmcStatusCode))); TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode, sizeof(tmcStatusCode)));
return true; return true;
} }
@ -752,13 +752,13 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
.one = 1, .one = 1,
.bTag = bTag & 0x7Fu, .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)); usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&intMsg,sizeof(intMsg));
} }
else 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))); TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp, sizeof(rsp)));
return true; return true;
@ -781,7 +781,7 @@ bool usbtmcd_control_request(uint8_t rhport, tusb_control_request_t const * requ
TU_VERIFY(false); 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; (void)rhport;
//------------- Class Specific Request -------------// //------------- Class Specific Request -------------//

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

@ -50,35 +50,35 @@
*/ */
#if (CFG_USBTMC_CFG_ENABLE_488) #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 #else
extern usbtmc_response_capabilities_t const usbtmcd_app_capabilities; extern usbtmc_response_capabilities_t const tud_usbtmc_app_capabilities;
#endif #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. // 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); bool tud_usbtmc_app_msg_data_cb(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 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 tud_usbtmc_app_msgBulkIn_request_cb(uint8_t rhport, usbtmc_msg_request_dev_dep_in const * request);
bool usbtmcd_app_msgBulkIn_complete(uint8_t rhport); bool tud_usbtmc_app_msgBulkIn_complete_cb(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_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 tud_usbtmc_app_initiate_abort_bulk_in_cb(uint8_t rhport, uint8_t *tmcResult);
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);
bool usbtmcd_app_initiate_clear(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 tud_usbtmc_app_check_abort_bulk_in_cb(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 tud_usbtmc_app_check_abort_bulk_out_cb(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_clear_cb(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 tud_usbtmc_app_indicator_pluse_cb(uint8_t rhport, tusb_control_request_t const * msg, uint8_t *tmcResult);
#if (CFG_USBTMC_CFG_ENABLE_488) #if (CFG_USBTMC_CFG_ENABLE_488)
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);
TU_ATTR_WEAK bool usbtmcd_app_msg_trigger(uint8_t rhport, usbtmc_msg_generic_t* msg); TU_ATTR_WEAK bool tud_usbtmc_app_msg_trigger_cb(uint8_t rhport, usbtmc_msg_generic_t* msg);
//TU_ATTR_WEAK bool usbtmcd_app_go_to_local(uint8_t rhport); //TU_ATTR_WEAK bool tud_usbtmc_app_go_to_local_cb(uint8_t rhport);
#endif #endif
/******************************************* /*******************************************
@ -96,12 +96,12 @@ bool usbtmcd_transmit_dev_msg_data(
/* "callbacks" from USB device core */ /* "callbacks" from USB device core */
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 usbtmcd_reset(uint8_t rhport); 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_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_request_cb(uint8_t rhport, tusb_control_request_t const * request);
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 usbtmcd_init(void); void usbtmcd_init_cb(void);
/************************************************************ /************************************************************
* USBTMC Descriptor Templates * USBTMC Descriptor Templates

10
src/device/usbd.c
View File

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