//! \brief Sends a message of 5 bytes to the USBDM device over EP0.
//!
//! An immediate response is expected
//!
//! @param data - Entry \n
//! data[0] = N, the number of bytes to receive from the device \n
//! data[1] = Command byte \n
//! data[2..5] = parameter(s) for OSBDM command \n
//! @note data must be an array of at least 5 bytes even if there are no parameters!
//!
//! @param data - Exit \n
//! data[0] = cmd response from OSBDM\n
//! data[1..N-1] = data response from the device (cleared on error)\n
//!
//! @return \n
//! == BDM_RC_OK (0) => Success, OK response from device\n
//! == BDM_RC_USB_ERROR => USB failure \n
//! == else => Error code from Device
//!
USBDM_ErrorCode bdm_usb_recv_ep0(unsigned char *data, unsigned *actualRxSize) {
unsigned char size = data[0]; // Transfer size is the first byte
unsigned char cmd = data[1]; // OSBDM/TBDML Command byte
int rc;
int retry = 5;
*actualRxSize = 0;
if (usbDeviceHandle == NULL) {
print("bdm_usb_recv_ep0() - ERROR : Device handle NULL!\n");
data[0] = BDM_RC_DEVICE_NOT_OPEN;
return BDM_RC_DEVICE_NOT_OPEN;
}
#ifdef LOG_LOW_LEVEL
print("============================\n");
print("bdm_usb_recv_ep0(%s, size=%d) - \n", getCommandName(cmd), size);
if (data[1] == CMD_USBDM_DEBUG)
print("bdm_usb_recv_ep0() - Debug cmd = %s\n", getDebugCommandName(data[2]));
printDump(data, 6);
#endif // LOG_LOW_LEVEL
do {
rc = libusb_control_transfer(usbDeviceHandle,
LIBUSB_REQUEST_TYPE_VENDOR|EP_CONTROL_IN, // bmRequestType
cmd, // bRequest
data[2]+(data[3]<<8), // wValue
data[4]+(data[5]<<8), // wIndex
(unsigned char*)data, // ptr to data buffer (for Rx)
size, // wLength = size of transfer
5*timeoutValue // timeout
);
if (rc < 0) {
print("bdm_usb_recv_ep0(size=%d) - Transfer error (USB error = %s) - retry %d \n", size, libusb_strerror((libusb_error)rc), retry);
milliSleep(100); // So we don't monopolise the USB
}
} while ((rc < 0) && (--retry>0));
if (rc < 0) {
print("bdm_usb_recv_ep0() - Transfer failed (USB error = %s)\n", libusb_strerror((libusb_error)rc));
data[0] = BDM_RC_USB_ERROR;
*actualRxSize = 0;
}
else {
*actualRxSize = (unsigned) rc;
}
if ((data[0] != BDM_RC_OK) && (data[0] != cmd)) { // Error at BDM?
print("bdm_usb_recv_ep0() - Cmd Failed (%s):\n", getErrorName(data[0]));
printDump(data,*actualRxSize);
memset(&data[1], 0x00, size-1);
return (USBDM_ErrorCode)data[0];
}
#ifdef LOG_LOW_LEVEL
print("bdm_usb_recv_ep0(size = %d, recvd = %d):\n", size, rc);
printDump(data,rc);
#endif // LOG_LOW_LEVEL
return(BDM_RC_OK);
}
/// The exception filter that will display the stack
static LONG WINAPI UnhandledExpFilter(PEXCEPTION_POINTERS pExceptionInfo)
{
/// Handle to the process
HANDLE hProcess;
/// List of the loaded modules
std::list<std::string> loadedModules;
/// List of the elements on the call stack
std::list<std::string> callStack;
/// List of the elements on the file stack
std::list<std::string> fileStack;
SymSetOptions(SYMOPT_UNDNAME|SYMOPT_DEFERRED_LOADS|SYMOPT_LOAD_LINES);
hProcess = GetCurrentProcess();
if(SymInitialize(hProcess, NULL, TRUE))
{
LoadCallStack(pExceptionInfo, hProcess, callStack, fileStack);
::EnumerateLoadedModules64(hProcess, EnumerateLoadedModules, &loadedModules);
::SymCleanup(hProcess);
}
printDump(loadedModules, callStack, fileStack);
return EXCEPTION_CONTINUE_SEARCH;
}
//! \brief Sends a command to the TBDML device over the Out Bulk Endpoint
//!
//! Since the EP transfer is unidirectional, data returned by the
//! device must be read in a separate transfer - this includes any status
//! from extended command execution.
//!
//! @param count = # of bytes to Tx (N)
//!
//! @param data \n
//! OUT \n
//! ======================================= \n
//! data[0] = reserved \n
//! data[1] = command byte \n
//! data[2..N-1] = parameters \n
//! \n
//! IN \n
//! ======================================== \n
//! data[0] = error code (=rc)
//!
//! @return
//! BDM_RC_OK => USB transfer OK \n
//! BDM_RC_USB_ERROR => USB transfer Failed
//!
USBDM_ErrorCode bdm_usb_send_epOut(unsigned int count, const unsigned char *data) {
int rc;
int transferCount;
if (usbDeviceHandle==NULL) {
print("bdm_usb_send_epOut(): device not open\n");
return BDM_RC_DEVICE_NOT_OPEN;
}
#ifdef LOG_LOW_LEVEL
print("============================\n");
if (data[0] == 0) { // Zero as first byte indicates split USBDM command
print("bdm_usb_send_epOut() - USB EP0ut send (SPLIT, size=%d):\n", count);
}
else {
print("bdm_usb_send_epOut() - USB EP0ut send (%s, size=%d):\n", getCommandName(data[1]), count);
if (data[1] == CMD_USBDM_DEBUG)
print("bdm_usb_send_epOut() - Debug cmd = %s\n", getDebugCommandName(data[2]));
}
printDump(data, count);
#endif // LOG_LOW_LEVEL
rc = libusb_bulk_transfer(usbDeviceHandle,
EP_OUT, // Endpoint & direction
(unsigned char *)data, // ptr to Tx data
count, // number of bytes to Tx
&transferCount, // number of bytes actually Tx
timeoutValue // timeout
);
if (rc != LIBUSB_SUCCESS) {
print("bdm_usb_send_epOut() - Transfer failed (USB error = %s, timeout=%d)\n", libusb_strerror((libusb_error)rc), timeoutValue);
return BDM_RC_USB_ERROR;
}
return BDM_RC_OK;
}
void
LogNetDump(struct dump *dumpPtr)
{
struct dump hostDump;
extern buServerConfP globalConfPtr;
dump_ntoh(dumpPtr, &hostDump);
globalConfPtr->log = fopen(AFSDIR_SERVER_BUDBLOG_FILEPATH, "a");
if (globalConfPtr->log != NULL) {
printDump(globalConfPtr->log, &hostDump);
fclose(globalConfPtr->log);
}
}
//*****************************************************************************
//!
//! \brief Sends a message+data to the USBDM device over EP0
//!
//! No response is expected from device.
//!
//! Since the EP0 transfer is unidirectional in this case, data returned by the
//! device must be read in a separate transfer - this includes any status.
//!
//! @param data \n
//! data[0] = N, the number of bytes to send (excluding this byte)\n
//! data[1] = Command byte \n
//! data[2..N] = parameter(s) for command \n
//!
//! @return \n
//! == BDM_RC_OK (0) => Success\n
//! == BDM_RC_USB_ERROR => USB failure
//!
USBDM_ErrorCode bdm_usb_send_ep0( const unsigned char * data ) {
unsigned char setupPkt[] = {0,0,0,0,0,0,0};
unsigned char size = data[0]; // Size is the first byte
int rc;
unsigned index;
if (usbDeviceHandle == NULL) {
print("bdm_usb_send_ep0() - Device handle NULL!\n");
return BDM_RC_DEVICE_NOT_OPEN;
}
#ifdef LOG_LOW_LEVEL
print("============================\n");
print("bdm_usb_send_ep0() - USB EP0 send (%s, size=%d):\n", getCommandName(data[1]), size);
if (data[1] == CMD_USBDM_DEBUG)
print("bdm_usb_send_ep0() - Debug cmd = %s\n", getDebugCommandName(data[2]));
printDump(data, size+1);
#endif // LOG_LOW_LEVEL
// Copy data in case <5 bytes to avoid possible illegal de-referencing
for(index=0; index<(sizeof(setupPkt)/sizeof(setupPkt[0])); index++) {
if (index > size)
break;
setupPkt[index] = data[index];
}
rc=libusb_control_transfer(usbDeviceHandle,
LIBUSB_REQUEST_TYPE_VENDOR|EP_CONTROL_OUT, // requestType=Vendor
setupPkt[1], // request
setupPkt[2]+(setupPkt[3]<<8), // value
setupPkt[4]+(setupPkt[5]<<8), // index
(unsigned char *)((size>5)?data+6:setupPkt), // data bytes
(size>5)?(size-5):0, // size (# of data bytes)
timeoutValue); // how long to wait for reply
if (rc < 0) {
print("bdm_usb_send_ep0() - USB EP0 send: Send failed (USB error = %d)\n", rc);
return(BDM_RC_USB_ERROR);
}
return(BDM_RC_OK);
}
//! \brief Receives a response from the USBDM device over the In Bulk Endpoint
//! Responses are retried to allow for target execution
//!
//! @param count = Maximum number of bytes to receive
//!
//! @param data
//! IN \n
//! ======================================== \n
//! data[0] = error code (= rc) \n
//! data[1..N] = data received \n
//!
//! @param actualCount = Actual number of bytes received
//!
//! @return \n
//! == BDM_RC_OK (0) => Success, OK response from device \n
//! == BDM_RC_USB_ERROR => USB failure \n
//! == else => Error code from Device
//!
USBDM_ErrorCode bdm_usb_recv_epIn(unsigned count, unsigned char *data, unsigned *actualCount) {
int rc;
int retry = 40; // ~4s of retries
int transferCount;
*actualCount = 0; // Assume failure
if (usbDeviceHandle==NULL) {
print("bdm_usb_recv_epIn(): device not open\n");
return BDM_RC_DEVICE_NOT_OPEN;
}
#ifdef LOG_LOW_LEVEL
print("bdm_usb_recv_epIn(%d, ...)\n", count);
#endif // LOG_LOW_LEVEL
#if OLD
do {
rc = libusb_bulk_transfer(usbDeviceHandle,
EP_IN, // Endpoint & direction
(unsigned char *)dummyBuffer, // ptr to Rx data
sizeof(dummyBuffer)-5, // number of bytes to Rx
&transferCount, // number of bytes actually Rx
timeoutValue // timeout
);
if (rc != LIBUSB_SUCCESS) {
print("bdm_usb_recv_epIn(count=%d) - Transfer timeout (USB error = %s, timeout=%d) - retry\n", count, libusb_strerror((libusb_error)rc), timeoutValue);
milliSleep(100); // So we don't monopolise the USB
}
} while ((rc!=LIBUSB_SUCCESS) && (--retry>0));
#else
do {
rc = libusb_bulk_transfer(usbDeviceHandle,
EP_IN, // Endpoint & direction
(unsigned char *)dummyBuffer, // ptr to Rx data
sizeof(dummyBuffer)-5, // number of bytes to Rx
&transferCount, // number of bytes actually Rx
timeoutValue // timeout
);
if ((rc == LIBUSB_SUCCESS) && (dummyBuffer[0] == BDM_RC_BUSY)) {
// The BDM has indicated it's busy for a while - try again in 1/10 second
print("bdm_usb_recv_epIn(retry=%d) - BDM Busy - retry\n", retry);
milliSleep(100); // So we don't monopolise the USB
}
} while ((rc == LIBUSB_SUCCESS) && (dummyBuffer[0] == BDM_RC_BUSY) && (--retry>0));
#endif
if (rc != LIBUSB_SUCCESS) {
print("bdm_usb_recv_epIn(count=%d) - Transfer failed (USB error = %s)\n", count, libusb_strerror((libusb_error)rc));
data[0] = BDM_RC_USB_ERROR;
memset(&data[1], 0x00, count-1);
return BDM_RC_USB_ERROR;
}
memcpy(data, dummyBuffer, transferCount);
rc = data[0]&0x7F;
if (rc != BDM_RC_OK) {
print("bdm_usb_recv_epIn() - Error Return %d (%s):\n", rc, getErrorName(rc));
print("bdm_usb_recv_epIn(size = %d, recvd = %d):\n", count, transferCount);
printDump(data, transferCount);
memset(&data[1], 0x00, count-1);
}
#ifdef LOG_LOW_LEVEL
printDump(data, transferCount);
#endif // LOG_LOW_LEVEL
*actualCount = transferCount;
return (USBDM_ErrorCode)(rc);
}
