/***********************************************
* Application USB Device Layer Event Handler.
***********************************************/
void APP_USBDeviceEventHandler ( USB_DEVICE_EVENT event, void * eventData, uintptr_t context )
{
USB_DEVICE_EVENT_DATA_CONFIGURED *configuredEventData;
static bool led;
switch ( event )
{
case USB_DEVICE_EVENT_SOF:
app2Data.sofEventHasOccurred = true;
break;
case USB_DEVICE_EVENT_RESET:
app2Data.isConfigured = false;
break;
case USB_DEVICE_EVENT_CONFIGURED:
/* Set the USBID pin to output (LED control) after configuration is done */
PLIB_PORTS_PinDirectionOutputSet(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_3);
(led) ? PLIB_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_3) : PLIB_PORTS_PinClear(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_3);
/* Check the configuration. We only support configuration 1 */
configuredEventData = (USB_DEVICE_EVENT_DATA_CONFIGURED*)eventData;
if ( configuredEventData->configurationValue == 1)
{
/* Register the CDC Device application event handler here.
* Note how the app2Data object pointer is passed as the
* user data */
USB_DEVICE_CDC_EventHandlerSet(USB_DEVICE_CDC_INDEX_0, APP_USBDeviceCDCEventHandler, (uintptr_t)&app2Data);
/* Mark that the device is now configured */
app2Data.isConfigured = true;
}
break;
case USB_DEVICE_EVENT_POWER_DETECTED:
led = PLIB_PORTS_PinGetLatched(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_3);
/* Set the USBID pin to input (floating) so that it will be configured as DEVICE */
PLIB_PORTS_PinDirectionInputSet(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_3);
/* VBUS was detected. We can attach the device */
USB_DEVICE_Attach(app2Data.deviceHandle);
break;
case USB_DEVICE_EVENT_POWER_REMOVED:
/* VBUS is not available any more. Detach the device. */
USB_DEVICE_Detach(app2Data.deviceHandle);
break;
case USB_DEVICE_EVENT_SUSPENDED:
break;
case USB_DEVICE_EVENT_RESUMED:
case USB_DEVICE_EVENT_ERROR:
default:
break;
}
}
void APP_USBDeviceEventHandler(USB_DEVICE_EVENT event, void * eventData, uintptr_t context)
{
USB_DEVICE_EVENT_DATA_CONFIGURED * configurationValue;
switch(event)
{
case USB_DEVICE_EVENT_SOF:
/* This event is used for switch debounce. This flag is reset
* by the switch process routine. */
appData.sofEventHasOccurred = true;
appData.setIdleTimer++;
break;
case USB_DEVICE_EVENT_RESET:
case USB_DEVICE_EVENT_DECONFIGURED:
/* Device got deconfigured */
appData.isConfigured = false;
appData.isMouseReportSendBusy = false;
appData.state = APP_STATE_WAIT_FOR_CONFIGURATION;
appData.emulateMouse = true;
BSP_LEDOn ( APP_USB_LED_1 );
BSP_LEDOn ( APP_USB_LED_2 );
BSP_LEDOff ( APP_USB_LED_3 );
break;
case USB_DEVICE_EVENT_CONFIGURED:
/* Device is configured */
configurationValue = (USB_DEVICE_EVENT_DATA_CONFIGURED *)eventData;
if(configurationValue->configurationValue == 1)
{
appData.isConfigured = true;
BSP_LEDOff ( APP_USB_LED_1 );
BSP_LEDOff ( APP_USB_LED_2 );
BSP_LEDOn ( APP_USB_LED_3 );
/* Register the Application HID Event Handler. */
USB_DEVICE_HID_EventHandlerSet(appData.hidInstance,
APP_USBDeviceHIDEventHandler, (uintptr_t)&appData);
}
break;
case USB_DEVICE_EVENT_POWER_DETECTED:
/* VBUS was detected. We can attach the device */
USB_DEVICE_Attach(appData.deviceHandle);
break;
case USB_DEVICE_EVENT_POWER_REMOVED:
/* VBUS is not available any more. Detach the device. */
USB_DEVICE_Detach(appData.deviceHandle);
break;
case USB_DEVICE_EVENT_SUSPENDED:
BSP_LEDOff ( APP_USB_LED_1 );
BSP_LEDOn ( APP_USB_LED_2 );
BSP_LEDOn ( APP_USB_LED_3 );
break;
case USB_DEVICE_EVENT_RESUMED:
case USB_DEVICE_EVENT_ERROR:
default:
break;
}
}
void APP_USBDeviceEventHandler(USB_DEVICE_EVENT event, void * eventData, uintptr_t context)
{
switch(event)
{
case USB_DEVICE_EVENT_RESET:
case USB_DEVICE_EVENT_DECONFIGURED:
/* Host has de configured the device or a bus reset has happened.
* Device layer is going to de-initialize all function drivers.
* Hence close handles to all function drivers (Only if they are
* opened previously. */
BSP_LEDOn (APP_USB_LED_1);
BSP_LEDOn (APP_USB_LED_2);
BSP_LEDOff (APP_USB_LED_3);
appData.deviceConfigured = false;
appData.state = APP_STATE_WAIT_FOR_CONFIGURATION;
break;
case USB_DEVICE_EVENT_CONFIGURED:
/* Set the flag indicating device is configured. */
appData.deviceConfigured = true;
/* Save the other details for later use. */
appData.configurationValue = ((USB_DEVICE_EVENT_DATA_CONFIGURED*)eventData)->configurationValue;
/* Register application HID event handler */
USB_DEVICE_HID_EventHandlerSet(USB_DEVICE_HID_INDEX_0, APP_USBDeviceHIDEventHandler, (uintptr_t)&appData);
/* Update the LEDs */
BSP_LEDOff (APP_USB_LED_1);
BSP_LEDOff (APP_USB_LED_2);
BSP_LEDOn (APP_USB_LED_3);
break;
case USB_DEVICE_EVENT_SUSPENDED:
/* Switch on green and orange, switch off red */
BSP_LEDOff (APP_USB_LED_1);
BSP_LEDOn (APP_USB_LED_2);
BSP_LEDOn (APP_USB_LED_3);
break;
case USB_DEVICE_EVENT_POWER_DETECTED:
/* VBUS was detected. We can attach the device */
USB_DEVICE_Attach (appData.usbDevHandle);
break;
case USB_DEVICE_EVENT_POWER_REMOVED:
/* VBUS is not available */
USB_DEVICE_Detach(appData.usbDevHandle);
break;
/* These events are not used in this demo */
case USB_DEVICE_EVENT_RESUMED:
case USB_DEVICE_EVENT_ERROR:
default:
break;
}
}
void APP_USBDeviceEventHandler ( USB_DEVICE_EVENT event, void * eventData, uintptr_t context)
{
uint8_t configurationValue;
switch ( event )
{
case USB_DEVICE_EVENT_RESET:
case USB_DEVICE_EVENT_DECONFIGURED:
/* USB device is reset or device is deconfigured.
* This means that USB device layer is about to deininitialize
* all function drivers. Update LEDs to indicate
* reset/deconfigured state. */
BSP_LEDOn ( APP_USB_LED_1 );
BSP_LEDOn ( APP_USB_LED_2 );
BSP_LEDOff( APP_USB_LED_3 );
appData.isConfigured = false;
break;
case USB_DEVICE_EVENT_CONFIGURED:
/* Check the configuration */
configurationValue = ((USB_DEVICE_EVENT_DATA_CONFIGURED *)eventData)->configurationValue;
if (configurationValue == 1)
{
/* The device is in configured state. Update LED indication */
BSP_LEDOff( APP_USB_LED_1 );
BSP_LEDOff( APP_USB_LED_2 );
BSP_LEDOn( APP_USB_LED_3 );
/* Register the CDC Device application event handler here.
* Note how the appData object pointer is passed as the
* user data */
USB_DEVICE_CDC_EventHandlerSet(USB_DEVICE_CDC_INDEX_0,
APP_USBDeviceCDCEventHandler, (uintptr_t)&appData);
/* mark that set configuration is complete */
appData.isConfigured = true;
}
break;
case USB_DEVICE_EVENT_SUSPENDED:
/* Update LEDs */
BSP_LEDOff ( APP_USB_LED_1 );
BSP_LEDOn ( APP_USB_LED_2 );
BSP_LEDOn( APP_USB_LED_3 );
break;
case USB_DEVICE_EVENT_POWER_DETECTED:
/* VBUS was detected. Connect the device */
USB_DEVICE_Attach (appData.deviceHandle);
break;
case USB_DEVICE_EVENT_POWER_REMOVED:
/* VBUS was removed. Disconnect the device */
USB_DEVICE_Detach(appData.deviceHandle);
break;
/* These events are not used in this demo */
case USB_DEVICE_EVENT_RESUMED:
case USB_DEVICE_EVENT_ERROR:
default:
break;
}
}
void APP_USBDeviceEventHandler
(
USB_DEVICE_EVENT event,
void * eventData,
uintptr_t context
)
{
USB_DEVICE_EVENT_DATA_CONFIGURED* configuredEventData;
switch(event)
{
case USB_DEVICE_EVENT_RESET:
U1TXREG = 'R';
//break;
case USB_DEVICE_EVENT_DECONFIGURED:
{
appData.state = APP_STATE_USB_OPENED;
appData.reading = 0;
appData.audio_play = false;
USB_DEVICE_EndpointDisable(appData.usbDevHandle, AUDIO_EP);
if(appData.tunnel_write_handle != USB_DEVICE_TRANSFER_HANDLE_INVALID)
USB_DEVICE_EndpointTransferCancel(appData.usbDevHandle, TUNNEL_EP_IN, appData.tunnel_write_handle);
USB_DEVICE_EndpointDisable(appData.usbDevHandle, TUNNEL_EP_IN);
USB_DEVICE_EndpointDisable(appData.usbDevHandle, TUNNEL_EP_OUT);
break;
}
case USB_DEVICE_EVENT_CONFIGURED:
U1TXREG = '+';
/* check the configuration */
configuredEventData = (USB_DEVICE_EVENT_DATA_CONFIGURED *)eventData;
if(configuredEventData->configurationValue == 1)
{
}
USB_DEVICE_EndpointEnable(appData.usbDevHandle, AUDIO_STREAMING_INTERFACE_ID, AUDIO_EP, USB_TRANSFER_TYPE_ISOCHRONOUS, PACKET_SIZE);
USB_DEVICE_EndpointEnable(appData.usbDevHandle, TUNER_CONTROL_INTERFACE_ID, TUNNEL_EP_IN, USB_TRANSFER_TYPE_BULK, 32);
USB_DEVICE_EndpointEnable(appData.usbDevHandle, TUNER_CONTROL_INTERFACE_ID, TUNNEL_EP_OUT, USB_TRANSFER_TYPE_BULK, 32);
appData.state = APP_STATE_CONFIGURED;
break;
case USB_DEVICE_EVENT_SUSPENDED:
U1TXREG = 'S';
//appData.suspended = true;
break;
case USB_DEVICE_EVENT_RESUMED:
U1TXREG = 's';
appData.suspended = false;
break;
case USB_DEVICE_EVENT_POWER_DETECTED:
#ifndef NO_USB_ATTACH
USB_DEVICE_Attach (appData.usbDevHandle);
#else
#warning "USB ATTACH DISABLED"
#endif
break;
case USB_DEVICE_EVENT_POWER_REMOVED:
USB_DEVICE_Detach (appData.usbDevHandle);
break;
case USB_DEVICE_EVENT_ERROR:
U1TXREG = 'E';
break;
case USB_DEVICE_EVENT_CONTROL_TRANSFER_SETUP_REQUEST:
{
USB_SETUP_PACKET * sp = eventData;
if(sp->bRequest == 0x0b && sp->wIndex == 0x0001) //set interace on if 1
{
//USB_DEVICE_ControlReceive(appData.usbDevHandle, &controlData, sizeof(controlData));
if(sp->wValue == 0)
{
int i;
appData.audio_play = false;
USB_DEVICE_ControlStatus(appData.usbDevHandle, USB_DEVICE_CONTROL_STATUS_OK);
U1TXREG = 'C';
}
else if(sp->wValue == 1)
{
appData.audio_play = true;
USB_DEVICE_ControlStatus(appData.usbDevHandle, USB_DEVICE_CONTROL_STATUS_OK);
appData.noAudioData = 1;
U1TXREG = 'p';
}
else
USB_DEVICE_ControlStatus(appData.usbDevHandle, USB_DEVICE_CONTROL_STATUS_ERROR);
}
else
USB_DEVICE_ControlStatus(appData.usbDevHandle, USB_DEVICE_CONTROL_STATUS_ERROR);
break;
}
case USB_DEVICE_EVENT_CONTROL_TRANSFER_DATA_RECEIVED:
case USB_DEVICE_EVENT_CONTROL_TRANSFER_ABORTED:
case USB_DEVICE_EVENT_CONTROL_TRANSFER_DATA_SENT:
//debughalt();
break;
case USB_DEVICE_EVENT_ENDPOINT_READ_COMPLETE:
{
appData.tunnel_read_count = ((USB_DEVICE_EVENT_DATA_ENDPOINT_WRITE_COMPLETE*)eventData)->length;
if(appData.tunnel_read_data[0]&TUNNEL_PING_MASK)
appData.pingRequest = 1;
else
appData.tuner_request = 1;
//appData.reading = 0;
U1TXREG = 'I';
break;
}
case USB_DEVICE_EVENT_ENDPOINT_WRITE_COMPLETE:
{
USB_DEVICE_EVENT_DATA_ENDPOINT_WRITE_COMPLETE* ed = (USB_DEVICE_EVENT_DATA_ENDPOINT_WRITE_COMPLETE*)eventData;
if(appData.tunnel_write_handle == ed->transferHandle)
{
appData.tunnel_write_handle = USB_DEVICE_TRANSFER_HANDLE_INVALID;
U1TXREG = 'W';
}
else
{
int i=0;
for(;i<AUDIO_HANDLES;i++)
if(ed->transferHandle == audio_handle[i])
audio_handle[i] = HANDLE_INVALID;
}
break;
}
default:
debughalt();
break;
}
}
