BOOL HIDUSB_ApplicationEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size )
{
switch( event) {
case EVENT_HID_RPT_DESC_PARSED:
#ifdef APPL_COLLECT_PARSED_DATA
return (APPL_COLLECT_PARSED_DATA());
#else
return TRUE;
#endif
break;
default:
break;
}
return FALSE;
}
BOOL USB_ApplicationEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size)
{
BYTE currentEndpoint;
#if defined(USB_USE_MIDI)
ENDPOINT_DIRECTION direction;
#endif
// Handle specific events.
switch ((INT)event)
{
case EVENT_VBUS_REQUEST_POWER:
if (((USB_VBUS_POWER_EVENT_DATA*)data)->current <= (MAX_ALLOWED_CURRENT / 2))
{
return TRUE;
}
break;
case EVENT_VBUS_RELEASE_POWER:
case EVENT_HUB_ATTACH:
case EVENT_UNSUPPORTED_DEVICE:
case EVENT_CANNOT_ENUMERATE:
case EVENT_CLIENT_INIT_ERROR:
case EVENT_OUT_OF_MEMORY:
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
case EVENT_SUSPEND:
case EVENT_DETACH:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
return TRUE;
break;
#if defined(USB_USE_HID)
case EVENT_HID_RPT_DESC_PARSED:
#ifdef APPL_COLLECT_PARSED_DATA
return(APPL_COLLECT_PARSED_DATA());
#else
return TRUE;
#endif
break;
#endif
#if defined(USB_USE_CDC)
case EVENT_CDC_NONE:
case EVENT_CDC_ATTACH:
case EVENT_CDC_COMM_READ_DONE:
case EVENT_CDC_COMM_WRITE_DONE:
case EVENT_CDC_DATA_READ_DONE:
case EVENT_CDC_DATA_WRITE_DONE:
case EVENT_CDC_RESET:
return TRUE;
break;
case EVENT_CDC_NAK_TIMEOUT:
APPL_CDC_State = READY_TO_TX_RX;
return TRUE;
break;
#endif
#if defined(USB_USE_MIDI)
case EVENT_MIDI_ATTACH:
deviceHandle = data;
ProcState = STATE_READY;
rcvMidiPacket = malloc(sizeof(HOST_MIDI_PACKET) * USBHostMIDINumberOfEndpoints(deviceHandle));
endpointBuffers = malloc(sizeof(ENDPOINT_BUFFER) * USBHostMIDINumberOfEndpoints(deviceHandle));
for( currentEndpoint = 0; currentEndpoint < USBHostMIDINumberOfEndpoints(deviceHandle); currentEndpoint++ )
{
rcvMidiPacket[currentEndpoint].rcvFlag = FALSE;
direction = USBHostMIDIEndpointDirection(deviceHandle, currentEndpoint);
// For OUT endpoints
if(direction == OUT)
{
// We only want to send NUM_MIDI_PKTS_IN_USB_PKT MIDI packet per USB packet
endpointBuffers[currentEndpoint].numOfMIDIPackets = NUM_MIDI_PKTS_IN_USB_PKT;
// And we want to start it off transmitting data
endpointBuffers[currentEndpoint].TransferState = TX_DATA;
}
// For IN endpoints
else if (direction == IN)
{
// We will accept however many will fit inside the maximum USB packet size
endpointBuffers[currentEndpoint].numOfMIDIPackets = USBHostMIDISizeOfEndpoint(deviceHandle, currentEndpoint) / sizeof(USB_AUDIO_MIDI_PACKET);
// And we want to start it off trying to read data
endpointBuffers[currentEndpoint].TransferState = RX_DATA;
}
else
{
continue;
}
// Allocate the 2D buffer, and keep track of the write and read locations
endpointBuffers[currentEndpoint].bufferStart = malloc( sizeof(USB_AUDIO_MIDI_PACKET) * endpointBuffers[currentEndpoint].numOfMIDIPackets * MIDI_USB_BUFFER_SIZE );
endpointBuffers[currentEndpoint].pBufReadLocation = endpointBuffers[currentEndpoint].bufferStart;
endpointBuffers[currentEndpoint].pBufWriteLocation = endpointBuffers[currentEndpoint].bufferStart;
}
return TRUE;
break;
case EVENT_MIDI_DETACH:
for( currentEndpoint = 0; currentEndpoint < USBHostMIDINumberOfEndpoints(deviceHandle); currentEndpoint++ )
{
free(endpointBuffers[currentEndpoint].bufferStart);
endpointBuffers[currentEndpoint].bufferStart = NULL;
endpointBuffers[currentEndpoint].pBufReadLocation = NULL;
endpointBuffers[currentEndpoint].pBufWriteLocation = NULL;
}
free(rcvMidiPacket);
rcvMidiPacket = NULL;
free(endpointBuffers);
endpointBuffers = NULL;
deviceHandle = NULL;
ProcState = STATE_INITIALIZE;
return TRUE;
break;
case EVENT_MIDI_TRANSFER_DONE: // The main state machine will poll the driver.
return TRUE;
break;
#endif
default:
break;
}
return FALSE;
} // USB_ApplicationEventHandler
//******************************************************************************
//******************************************************************************
// USB Support Functions
//******************************************************************************
//******************************************************************************
BOOL USB_ApplicationEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size )
{
switch ( (INT) event )
{
case EVENT_VBUS_REQUEST_POWER:
// The data pointer points to a byte that represents the amount of power
// requested in mA, divided by two. If the device wants too much power,
// we reject it.
if (((USB_VBUS_POWER_EVENT_DATA*) data)->current <= (MAX_ALLOWED_CURRENT / 2))
{
return TRUE;
}
else
{
DBPRINTF( "\r\n***** USB Error - device requires too much current *****\r\n" );
}
break;
case EVENT_VBUS_RELEASE_POWER:
// Turn off Vbus power.
// The PIC24F with the Explorer 16 cannot turn off Vbus through software.
return TRUE;
break;
case EVENT_HUB_ATTACH:
DBPRINTF( "\r\n***** USB Error - hubs are not supported *****\r\n" );
return TRUE;
break;
case EVENT_UNSUPPORTED_DEVICE:
DBPRINTF( "\r\n***** USB Error - device is not supported *****\r\n" );
return TRUE;
break;
case EVENT_CANNOT_ENUMERATE:
DBPRINTF( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
return TRUE;
break;
case EVENT_CLIENT_INIT_ERROR:
DBPRINTF( "\r\n***** USB Error - client driver initialization error *****\r\n" );
return TRUE;
break;
case EVENT_OUT_OF_MEMORY:
DBPRINTF( "\r\n***** USB Error - out of heap memory *****\r\n" );
return TRUE;
break;
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
DBPRINTF( "\r\n***** USB Error - unspecified *****\r\n" );
return TRUE;
break;
case EVENT_HID_RPT_DESC_PARSED:
#ifdef APPL_COLLECT_PARSED_DATA
return (APPL_COLLECT_PARSED_DATA());
#else
return TRUE;
#endif
break;
default:
break;
}
return FALSE;
}
