Hello,
I'm trying to set up an endpoint, but when I write to the endpoint, I can't read the data from my app or the control center. I'm hoping if I post the code in question, some kind soul can help me figure out what I'm doing wrong.
I've included the function that configures the endpoints and the function that writes log messages to the host machine.
The endpoint in question is 10, and it's an IN endpoint, meaning it goes from the FX3 to the host. It's the last one listed in the descriptor, which means in my list of endpoints it's also the last one. When it isn't clear what value something is, I'll look it up in the debugger and put its value in a comment so you can follow along.
int8_t configureEndpoints()
{
// Wait until descriptor is parsed in another thread
CyU3PMutexGet (&descriptorMutex, CYU3P_WAIT_FOREVER);
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
CyU3PEpConfig_t epCfg;
CyU3PDmaChannelConfig_t dmaCfg;
CyU3PDmaType_t dmaType;
struct ConfigurationDescriptor *config = _getCurrentConfig();
for (uint8_t interfaceIndex = config->firstInterface;
interfaceIndex < config->firstInterface + config->numInterfaces;
++interfaceIndex){
struct InterfaceDescriptor *interface = gInterfaceDesc + interfaceIndex;
// for each interface in a configuration
for (uint8_t endpointIndex = interface->firstEndpoint;
endpointIndex < interface->firstEndpoint + interface->numEndpoints; ++endpointIndex){
struct EndpointDescriptor *endpoint = gEndpointDesc + endpointIndex;
// for each endpoint in an interface
// Configure the corresponding endpoint
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof (epCfg));
epCfg.enable = CyTrue;
epCfg.epType = endpoint->type;// CY_U3P_USB_EP_INTR
epCfg.burstLen = 1;
epCfg.streams = 0;
epCfg.pcktSize = endpoint->packetSize; // 528
apiRetStatus = CyU3PSetEpConfig(endpoint->address, &epCfg); // 0x8a
switch(apiRetStatus){
case CY_U3P_ERROR_NOT_STARTED:
errorLoop();
break;
case CY_U3P_ERROR_NULL_POINTER:
// Should never happen
errorLoop();
break;
case CY_U3P_ERROR_BAD_ARGUMENT:
// We got a bad endpoint number from the descriptor
return USB_INVALID_ADDRESS;
case CY_U3P_ERROR_INVALID_CONFIGURATION:
// bursts of more than 1 are only supported on certain endpoints
// We're hardcoding this to false for now anyway, so this should never happen
errorLoop();
break;
}
// Set up the DMA buffer for the endpoint
uint8_t epLeadsToHost = endpoint->address & IN_Endpoint; // 0x80, but used as a boolean
uint8_t addressNum = endpoint->address & ~IN_Endpoint; // 10
dmaCfg.size = endpoint->packetSize; // 528
dmaCfg.count = DMA_CHANNEL_SIZE / endpoint->packetSize; // 16
if (epLeadsToHost && addressNum == 10){
// Debug endpoint
dmaCfg.notification = 0;
dmaCfg.prodSckId = CY_U3P_CPU_SOCKET_PROD;
dmaCfg.consSckId = CY_U3P_UIB_SOCKET_CONS_0 + addressNum;
dmaType = CY_U3P_DMA_TYPE_MANUAL_OUT;
}
else if (epLeadsToHost) {
// Data goes from the device to the host
// This block isn't used for the endpoint we're talking about
}
else {
//Data goes from the host to the device
// This block isn't used for the endpoint we're talking about either
}
dmaCfg.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaCfg.cb = CyFxDmaCallback; // Not used for this endpoint, but shouldn't be called because it has no notifications
dmaCfg.prodHeader = 0;
dmaCfg.prodFooter = 0;
dmaCfg.consHeader = 0;
dmaCfg.prodAvailCount = 0;
apiRetStatus = CyU3PDmaChannelCreate(&endpoint->dmaHandle, dmaType, &dmaCfg);
switch (apiRetStatus){
case CY_U3P_ERROR_BAD_ARGUMENT:
case CY_U3P_ERROR_NULL_POINTER:
// Shouldn't happen
errorLoop();
break;
case CY_U3P_ERROR_MEMORY_ERROR:
// Could not allocate buffers
errorLoop();
}
if (addressNum == 10){
debugChannel = &endpoint->dmaHandle;
}
// the 0 tells the DMA not to limit the transfers.
apiRetStatus = CyU3PDmaChannelSetXfer(&endpoint->dmaHandle, 0);
switch (apiRetStatus){
case CY_U3P_ERROR_NULL_POINTER:
case CY_U3P_ERROR_NOT_CONFIGURED:
case CY_U3P_ERROR_NOT_SUPPORTED:
// we passed a null pointer, which shouldn't happen
// our configuration was wrong, which shouldn't happen
// no buffer was allocated, which shouldn't happen
errorLoop();
}
if (!epLeadsToHost){
// Configure endpoint watermarks
endpoint->dmaThreadNum = USB_ADDRESS_TO_PIB(addressNum) % 4;
apiRetStatus = CyU3PGpifSocketConfigure(
endpoint->dmaThreadNum,
CY_U3P_PIB_SOCKET_0 + USB_ADDRESS_TO_PIB(addressNum),
0, // buffer contains data if watermark is higher than 0
CyTrue,
0);
if (apiRetStatus != CY_U3P_SUCCESS){
errorLoop();
}
}
// Flush the endpoint
CyU3PUsbFlushEp(endpoint->address);
//Configure the GPIF-II socket
}
}
CyU3PMutexPut (&descriptorMutex);
endpointsAreEnabled = CyTrue;
if (config->isHighSpeed){ // true
// The configuration must be high speed. Sending an interrupt without
// the ready pin asserted indicates that the enumeration was successful,
// but at the wrong speed
setReady(CyTrue);
}
else {
setReady(CyFalse);
}
// report when it's finished starting up
extern uint32_t interruptSentTicks;
interruptSentTicks = CyU3PGetTime();
interrupt8051(); // Does some GPIO stuff to ping another microcontroller
breaksAllowed = CyTrue; // First message has been received from host. Who cares if we time out our connection.
return 0;
}
// We have 16 bytes to work with because the smallest DMA buffer size increments are 16 bytes
#define DEBUG_HEADER_SIZE 15
#define DEBUG_FOOTER_SIZE 1
CyU3PDmaChannel *debugChannel;
void debugLog(int length, unsigned char *data, char endpoint){
#ifdef DEBUG_ENDPOINT10 // is defined
CyU3PReturnStatus_t error;
CyU3PDmaBuffer_t buffer;
// Get a buffer to pass in data
error = CyU3PDmaChannelGetBuffer (
debugChannel, /**< Handle to the DMA channel on which to wait. */
&buffer, /**< Output parameter that will be filled with data about the
buffer that was obtained. */
CYU3P_NO_WAIT /**< Duration to wait before returning a timeout status. */
);
if (error == CY_U3P_ERROR_TIMEOUT || error == CY_U3P_ERROR_MUTEX_FAILURE){ // Usually gets stuck here, failing to get the Mutex
return;
}
else if (error != CY_U3P_SUCCESS){
errorLoop();
}
// Copy data over
int transferLength = length; // should be 8 in this example
char wasClipped = 0;
if (length > buffer.size - (DEBUG_HEADER_SIZE + DEBUG_FOOTER_SIZE)){ // header is 15, footer is 1, buffer size is 528
// Shouldn't happen if my buffer sizes are right, but who knows? Better to be safe
transferLength = buffer.size - (DEBUG_HEADER_SIZE + DEBUG_FOOTER_SIZE);
wasClipped = 1;
}
// An easy pattern to recognize so we know we have the byte order right
buffer.buffer[0] = 0xDE;
buffer.buffer[1] = 0xAD;
buffer.buffer[2] = 0xBE;
buffer.buffer[3] = 0xEF;
// The endpoint this data is associated with, or 0xff is it's a generic log message
buffer.buffer[4] = endpoint; // 0 in this example
// 1 if the message has been clipped. 0 if it has not
buffer.buffer[5] = wasClipped;
// Reserved for more details later
buffer.buffer[6] = 0;
buffer.buffer[7] = 0;
buffer.buffer[8] = 0;
buffer.buffer[9] = 0;
buffer.buffer[10] = 0;
buffer.buffer[11] = 0;
buffer.buffer[12] = 0;
buffer.buffer[13] = 0;
buffer.buffer[14] = 0;
// the rest of the data
memcpy(buffer.buffer + DEBUG_HEADER_SIZE, data, transferLength);
buffer.count = transferLength + DEBUG_HEADER_SIZE + DEBUG_FOOTER_SIZE;
// checksum
unsigned char checksum = 0;
for (int i = 0; i < transferLength + DEBUG_HEADER_SIZE; ++i){
checksum += buffer.buffer[i];
}
buffer.buffer[transferLength + DEBUG_HEADER_SIZE] = checksum;
error = CyU3PDmaChannelCommitBuffer (
debugChannel, /**< Handle to the DMA channel to be modified. */
buffer.count, /**< Size of data in the buffer being committed. The buffer
address is implicit and is fetched from the active descriptor
for the channel. */
0 /**< Current status (end of transfer bit) of the buffer being
committed. The occupied bit will automatically be set by
the API. */
);
if (error != CY_U3P_SUCCESS){
errorLoop();
}
#endif
}
As I said in the comment, at the moment it's failing to get the mutex for some reason I don't understand, but earlier today it was getting farther than that and still nothing went through to the host machine. If you can help me understand what I'm doing wrong, or point out some other things I should check, I'd greatly appreciate it.
