/*******************************************************************
* Function: BOOL USER_USB_CALLBACK_EVENT_HANDLER(
* USB_EVENT event, void *pdata, WORD size)
*
* PreCondition: None
*
* Input: USB_EVENT event - the type of event
* void *pdata - pointer to the event data
* WORD size - size of the event data
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is called from the USB stack to
* notify a user application that a USB event
* occured. This callback is in interrupt context
* when the USB_INTERRUPT option is selected.
*
* Note: None
*******************************************************************/
BOOL USER_USB_CALLBACK_EVENT_HANDLER(USB_EVENT event, void *pdata, WORD size)
{
switch(event)
{
case EVENT_CONFIGURED:
USBCBInitEP();
break;
case EVENT_SET_DESCRIPTOR:
USBCBStdSetDscHandler();
break;
case EVENT_EP0_REQUEST:
USBCBCheckOtherReq();
break;
case EVENT_SOF:
USBCB_SOF_Handler();
break;
case EVENT_SUSPEND:
USBCBSuspend();
break;
case EVENT_RESUME:
USBCBWakeFromSuspend();
break;
case EVENT_BUS_ERROR:
USBCBErrorHandler();
break;
case EVENT_TRANSFER:
Nop();
break;
default:
break;
}
return TRUE;
}
void USBCBSendResume() {
static uint16_t delay_count;
if (USBGetRemoteWakeupStatus() == true) {
//Verify that the USB bus is in fact suspended, before we send
//remote wakeup signalling.
if (USBIsBusSuspended() == true) {
USBMaskInterrupts();
//Clock switch to settings consistent with normal USB operation.
USBCBWakeFromSuspend();
USBSuspendControl = 0;
USBBusIsSuspended = false; //So we don't execute this code again,
//until a new suspend condition is detected.
delay_count = 3600U;
do {
delay_count--;
} while (delay_count);
//Now drive the resume K-state signalling onto the USB bus.
USBResumeControl = 1; // Start RESUME signaling
delay_count = 1800U; // Set RESUME line for 1-13 ms
do {
delay_count--;
} while (delay_count);
USBResumeControl = 0; //Finished driving resume signalling
USBUnmaskInterrupts();
}
}
}
BOOL USER_USB_CALLBACK_EVENT_HANDLER(USB_EVENT event, void *pdata, WORD size){
switch(event){
case EVENT_TRANSFER:
//Add application specific callback task or callback function here if desired.
break;
case EVENT_SOF:
USBCB_SOF_Handler();
break;
case EVENT_SUSPEND:
USBCBSuspend();
break;
case EVENT_RESUME:
USBCBWakeFromSuspend();
break;
case EVENT_CONFIGURED:
USBCBInitEP();
break;
case EVENT_SET_DESCRIPTOR:
USBCBStdSetDscHandler();
break;
case EVENT_EP0_REQUEST:
USBCBCheckOtherReq();
break;
case EVENT_BUS_ERROR:
USBCBErrorHandler();
break;
case EVENT_TRANSFER_TERMINATED:
break;
default:
break;
}
return TRUE;
}
void USBCBSendResume(void){
static WORD delay_count;
//should be checked).
if(USBGetRemoteWakeupStatus() == TRUE){
if(USBIsBusSuspended() == TRUE){
USBMaskInterrupts();
//Clock switch to settings consistent with normal USB operation.
USBCBWakeFromSuspend();
USBSuspendControl = 0;
USBBusIsSuspended = FALSE;
delay_count = 3600U;
do{
delay_count--;
}while(delay_count);
//Now drive the resume K-state signalling onto the USB bus.
USBResumeControl = 1; // Start RESUME signaling
delay_count = 1800U; // Set RESUME line for 1-13 ms
do{
delay_count--;
}while(delay_count);
USBResumeControl = 0; //Finished driving resume signalling
USBUnmaskInterrupts();
}
}
}
BOOL USER_USB_CALLBACK_EVENT_HANDLER( USB_EVENT event, void * pdata, WORD size )
{
switch ( event )
{
case EVENT_TRANSFER: {
// Add application specific callback task or callback function here if desired.
break;
}
case EVENT_SOF: {
USBCB_SOF_Handler();
break;
}
case EVENT_SUSPEND: {
USBCBSuspend();
break;
}
case EVENT_RESUME: {
USBCBWakeFromSuspend();
break;
}
case EVENT_CONFIGURED: {
USBCBInitEP();
break;
}
case EVENT_SET_DESCRIPTOR: {
USBCBStdSetDscHandler();
break;
}
case EVENT_EP0_REQUEST: {
USBCBCheckOtherReq();
break;
}
case EVENT_BUS_ERROR: {
USBCBErrorHandler();
break;
}
case EVENT_TRANSFER_TERMINATED: {
/*
* Add application specific callback task or callback function here if desired.
* The EVENT_TRANSFER_TERMINATED event occurs when the host performs a CLEAR
* FEATURE (endpoint halt) request on an application endpoint which was
* previously armed (UOWN was = 1). Here would be a good place to:
* 1. Determine which endpoint the transaction that just got terminated was
* on, by checking the handle value in the *pdata.
* 2. Re-arm the endpoint if desired (typically would be the case for OUT
* endpoints).
*/
break;
}
default: {
break;
}
}
return TRUE;
}
/********************************************************************
* Function: void USBCBSendResume(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: The USB specifications allow some types of USB
* peripheral devices to wake up a host PC (such
* as if it is in a low power suspend to RAM state).
* This can be a very useful feature in some
* USB applications, such as an Infrared remote
* control receiver. If a user presses the "power"
* button on a remote control, it is nice that the
* IR receiver can detect this signalling, and then
* send a USB "command" to the PC to wake up.
*
* The USBCBSendResume() "callback" function is used
* to send this special USB signalling which wakes
* up the PC. This function may be called by
* application firmware to wake up the PC. This
* function will only be able to wake up the host if
* all of the below are true:
*
* 1. The USB driver used on the host PC supports
* the remote wakeup capability.
* 2. The USB configuration descriptor indicates
* the device is remote wakeup capable in the
* bmAttributes field.
* 3. The USB host PC is currently sleeping,
* and has previously sent your device a SET
* FEATURE setup packet which "armed" the
* remote wakeup capability.
*
* If the host has not armed the device to perform remote wakeup,
* then this function will return without actually performing a
* remote wakeup sequence. This is the required behavior,
* as a USB device that has not been armed to perform remote
* wakeup must not drive remote wakeup signalling onto the bus;
* doing so will cause USB compliance testing failure.
*
* This callback should send a RESUME signal that
* has the period of 1-15ms.
*
* Note: This function does nothing and returns quickly, if the USB
* bus and host are not in a suspended condition, or are
* otherwise not in a remote wakeup ready state. Therefore, it
* is safe to optionally call this function regularly, ex:
* anytime application stimulus occurs, as the function will
* have no effect, until the bus really is in a state ready
* to accept remote wakeup.
*
* When this function executes, it may perform clock switching,
* depending upon the application specific code in
* USBCBWakeFromSuspend(). This is needed, since the USB
* bus will no longer be suspended by the time this function
* returns. Therefore, the USB module will need to be ready
* to receive traffic from the host.
*
* The modifiable section in this routine may be changed
* to meet the application needs. Current implementation
* temporary blocks other functions from executing for a
* period of ~3-15 ms depending on the core frequency.
*
* According to USB 2.0 specification section 7.1.7.7,
* "The remote wakeup device must hold the resume signaling
* for at least 1 ms but for no more than 15 ms."
* The idea here is to use a delay counter loop, using a
* common value that would work over a wide range of core
* frequencies.
* That value selected is 1800. See table below:
* ==========================================================
* Core Freq(MHz) MIP RESUME Signal Period (ms)
* ==========================================================
* 48 12 1.05
* 4 1 12.6
* ==========================================================
* * These timing could be incorrect when using code
* optimization or extended instruction mode,
* or when having other interrupts enabled.
* Make sure to verify using the MPLAB SIM's Stopwatch
* and verify the actual signal on an oscilloscope.
*******************************************************************/
void USBCBSendResume(void)
{
static WORD delay_count;
//First verify that the host has armed us to perform remote wakeup.
//It does this by sending a SET_FEATURE request to enable remote wakeup,
//usually just before the host goes to standby mode (note: it will only
//send this SET_FEATURE request if the configuration descriptor declares
//the device as remote wakeup capable, AND, if the feature is enabled
//on the host (ex: on Windows based hosts, in the device manager
//properties page for the USB device, power management tab, the
//"Allow this device to bring the computer out of standby." checkbox
//should be checked).
if(USBGetRemoteWakeupStatus() == TRUE)
{
//Verify that the USB bus is in fact suspended, before we send
//remote wakeup signalling.
if(USBIsBusSuspended() == TRUE)
{
USBMaskInterrupts();
//Clock switch to settings consistent with normal USB operation.
USBCBWakeFromSuspend();
USBSuspendControl = 0;
USBBusIsSuspended = FALSE; //So we don't execute this code again,
//until a new suspend condition is detected.
//Section 7.1.7.7 of the USB 2.0 specifications indicates a USB
//device must continuously see 5ms+ of idle on the bus, before it sends
//remote wakeup signalling. One way to be certain that this parameter
//gets met, is to add a 2ms+ blocking delay here (2ms plus at
//least 3ms from bus idle to USBIsBusSuspended() == TRUE, yeilds
//5ms+ total delay since start of idle).
delay_count = 3600U;
do
{
delay_count--;
}while(delay_count);
//Now drive the resume K-state signalling onto the USB bus.
USBResumeControl = 1; // Start RESUME signaling
delay_count = 1800U; // Set RESUME line for 1-13 ms
do
{
delay_count--;
}while(delay_count);
USBResumeControl = 0; //Finished driving resume signalling
USBUnmaskInterrupts();
}
}
}
BOOL USER_USB_CALLBACK_EVENT_HANDLER(int event, void* pdata, WORD size) {
switch (event) {
case EVENT_TRANSFER:
// Add application specific callback task or callback function here if
// desired.
break;
case EVENT_SOF:
break;
case EVENT_SUSPEND:
USBCBSuspend();
break;
case EVENT_RESUME:
USBCBWakeFromSuspend();
break;
case EVENT_CONFIGURED:
USBCBInitEP();
break;
case EVENT_SET_DESCRIPTOR:
break;
case EVENT_EP0_REQUEST:
USBCBCheckOtherReq();
break;
case EVENT_BUS_ERROR:
mLED_1_On();
mLED_2_Off();
break;
case EVENT_TRANSFER_TERMINATED:
// Add application specific callback task or callback function here if
// desired.
// The EVENT_TRANSFER_TERMINATED event occurs when the host performs a
// CLEAR
// FEATURE (endpoint halt) request on an application endpoint which was
// previously armed (UOWN was = 1). Here would be a good place to:
// 1. Determine which endpoint the transaction that just got terminated
// was
// on, by checking the handle value in the *pdata.
// 2. Re-arm the endpoint if desired (typically would be the case for OUT
// endpoints).
break;
default:
break;
}
return TRUE;
}
// Send resume call-back
void USBCBSendResume(void)
{
static WORD delay_count;
// Verify that the host has armed us to perform remote wakeup.
if(USBGetRemoteWakeupStatus() == FLAG_TRUE)
{
// Verify that the USB bus is suspended (before we send remote wakeup signalling).
if(USBIsBusSuspended() == FLAG_TRUE)
{
USBMaskInterrupts();
// Bring the clock speed up to normal running state
USBCBWakeFromSuspend();
USBSuspendControl = 0;
USBBusIsSuspended = FLAG_FALSE;
// Section 7.1.7.7 of the USB 2.0 specifications indicates a USB
// device must continuously see 5ms+ of idle on the bus, before it sends
// remote wakeup signalling. One way to be certain that this parameter
// gets met, is to add a 2ms+ blocking delay here (2ms plus at
// least 3ms from bus idle to USBIsBusSuspended() == FLAG_TRUE, yeilds
// 5ms+ total delay since start of idle).
delay_count = 3600U;
do
{
delay_count--;
} while(delay_count);
// Start RESUME signaling for 1-13 ms
USBResumeControl = 1;
delay_count = 1800U;
do
{
delay_count--;
} while(delay_count);
USBResumeControl = 0;
USBUnmaskInterrupts();
}
}
}
bool USER_USB_CALLBACK_EVENT_HANDLER(USB_EVENT event, void *pdata, uint16_t size) {
switch (event) {
case EVENT_TRANSFER:
//Add application specific callback task or callback function here if desired.
break;
case EVENT_SOF:
USBCB_SOF_Handler();
break;
case EVENT_SUSPEND:
USBCBSuspend();
break;
case EVENT_RESUME:
USBCBWakeFromSuspend();
break;
case EVENT_CONFIGURED:
// enable the HID endpoint
USBEnableEndpoint(HID_EP_SNES, USB_IN_ENABLED | USB_HANDSHAKE_ENABLED | USB_DISALLOW_SETUP);
USBEnableEndpoint(HID_EP_CFG, USB_OUT_ENABLED | USB_IN_ENABLED | USB_HANDSHAKE_ENABLED | USB_DISALLOW_SETUP);
USBOutHandleCfg = HIDRxPacket(HID_EP_CFG, usbOutBuffer, sizeof (usbOutBuffer));
break;
case EVENT_SET_DESCRIPTOR:
USBCBStdSetDscHandler();
break;
case EVENT_EP0_REQUEST:
USBCheckHIDRequest();
break;
case EVENT_BUS_ERROR:
USBCBErrorHandler();
break;
case EVENT_TRANSFER_TERMINATED:
break;
default:
break;
}
return true;
}
/*******************************************************************
* Function: BOOL USER_USB_CALLBACK_EVENT_HANDLER(
* USB_EVENT event, void *pdata, WORD size)
*
* PreCondition: None
*
* Input: USB_EVENT event - the type of event
* void *pdata - pointer to the event data
* WORD size - size of the event data
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is called from the USB stack to
* notify a user application that a USB event
* occured. This callback is in interrupt context
* when the USB_INTERRUPT option is selected.
*
* Note: None
*******************************************************************/
BOOL USER_USB_CALLBACK_EVENT_HANDLER(USB_EVENT event, void *pdata, WORD size)
{
switch ((INT)event)
{
case EVENT_TRANSFER:
//Add application specific callback task or callback function here if desired.
break;
case EVENT_SOF:
USBCB_SOF_Handler();
break;
case EVENT_SUSPEND:
USBCBSuspend();
break;
case EVENT_RESUME:
USBCBWakeFromSuspend();
break;
case EVENT_CONFIGURED:
USBCBInitEP();
break;
case EVENT_SET_DESCRIPTOR:
USBCBStdSetDscHandler();
break;
case EVENT_EP0_REQUEST:
USBCBCheckOtherReq();
break;
case EVENT_BUS_ERROR:
USBCBErrorHandler();
break;
case EVENT_TRANSFER_TERMINATED:
// Add application specific callback task or callback function here if desired.
// The EVENT_TRANSFER_TERMINATED event occurs when the host performs a CLEAR
// FEATURE (endpoint halt) request on an application endpoint which was
// previously armed (UOWN was = 1). Here would be a good place to:
// 1. Determine which endpoint the transaction that just got terminated was
// on, by checking the handle value in the *pdata.
// 2. Re-arm the endpoint if desired (typically would be the case for OUT
// endpoints).
// Check if the host recently did a clear endpoint halt on the MSD OUT endpoint.
// In this case, we want to re-arm the MSD OUT endpoint, so we are prepared
// to receive the next CBW that the host might want to send.
// Note: If however the STALL was due to a CBW not valid condition,
// then we are required to have a persistent STALL, where it cannot
// be cleared (until MSD reset recovery takes place). See MSD BOT
// specs v1.0, section 6.6.1.
if (MSDWasLastCBWValid() == FALSE)
{
// Need to re-stall the endpoints, for persistent STALL behavior.
USBStallEndpoint(MSD_DATA_IN_EP, IN_TO_HOST);
USBStallEndpoint(MSD_DATA_OUT_EP, OUT_FROM_HOST);
}
else
{
// Check if the host cleared halt on the bulk out endpoint. In this
// case, we should re-arm the endpoint, so we can receive the next CBW.
if ((USB_HANDLE)pdata == USBGetNextHandle(MSD_DATA_OUT_EP, OUT_FROM_HOST))
{
USBMSDOutHandle = USBRxOnePacket(MSD_DATA_OUT_EP, (BYTE*)&msd_cbw, MSD_OUT_EP_SIZE);
}
}
break;
default:
break;
}
return TRUE;
}
