/******************************************************************************
* Function: void USBRemoteWakeup(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function should be called by user when the device
* is waken up by an external stimulus other than ACTIVIF.
* Please read the note below to understand the limitations.
*
* Note: The modifiable section in this routine should be changed
* to meet the application needs. Current implementation
* temporary blocks other functions from executing for a
* period of 1-13 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 lest 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
*****************************************************************************/
void USBRemoteWakeup(void)
{
static word delay_count;
if(usb_stat.RemoteWakeup == 1) // Check if RemoteWakeup function
{ // has been enabled by the host.
USBWakeFromSuspend(); // Unsuspend USB modue
UCONbits.RESUME = 1; // Start RESUME signaling
/* Modifiable Section */
delay_count = 1800U; // Set RESUME line for 1-13 ms
do
{
delay_count--;
}while(delay_count);
/* End Modifiable Section */
UCONbits.RESUME = 0;
}//endif
}//end USBRemoteWakeup
/******************************************************************************
* Function: void USBDriverService(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This routine is the heart of this firmware. It manages
* all USB interrupts.
*
* Note: Device state transitions through the following stages:
* DETACHED -> ATTACHED -> POWERED -> DEFAULT ->
* ADDRESS_PENDING -> ADDRESSED -> CONFIGURED -> READY
*****************************************************************************/
void USBDriverService(void)
{
/*
* Pointless to continue servicing if USB cable is not even attached.
*/
if(usb_device_state == DETACHED_STATE) return;
/*
* Task A: Service USB Activity Interrupt
*/
if(UIRbits.ACTVIF && UIEbits.ACTVIE) USBWakeFromSuspend();
/*
* Pointless to continue servicing if the device is in suspend mode.
*/
if(UCONbits.SUSPND==1) return;
/*
* Task B: Service USB Bus Reset Interrupt.
* When bus reset is received during suspend, ACTVIF will be set first,
* once the UCONbits.SUSPND is clear, then the URSTIF bit will be asserted.
* This is why URSTIF is checked after ACTVIF.
*/
if(UIRbits.URSTIF && UIEbits.URSTIE) USBProtocolResetHandler();
/*
* Task C: Service other USB interrupts
*/
if(UIRbits.IDLEIF && UIEbits.IDLEIE) USBSuspend();
if(UIRbits.SOFIF && UIEbits.SOFIE) USB_SOF_Handler();
if(UIRbits.STALLIF && UIEbits.STALLIE) USBStallHandler();
// if(UIRbits.UERRIF && UIEbits.UERRIE) USBErrorHandler();
/*
* Pointless to continue servicing if the host has not sent a bus reset.
* Once bus reset is received, the device transitions into the DEFAULT
* state and is ready for communication.
*/
if(usb_device_state < DEFAULT_STATE) return;
/*
* Task D: Servicing USB Transaction Complete Interrupt
*/
for(bTRNIFCount = 0; bTRNIFCount < 4; bTRNIFCount++)
{
if(UIRbits.TRNIF && UIEbits.TRNIE)
{
/*
* USBCtrlEPService only services transactions over EP0.
* It ignores all other EP transactions.
*/
if(USBCtrlEPService() == 0) // If not an EP0 transaction, then clear TRNIF.
{
/*
* Other EP can be serviced later by responsible device class firmware.
* Each device driver knows when an OUT or IN transaction is ready by
* checking the buffer ownership bit.
* An OUT EP should always be owned by SIE until the data is ready.
* An IN EP should always be owned by CPU until the data is ready.
*
* Because of this logic, it is not necessary to save the USTAT value
* of non-EP0 transactions.
*/
UIRbits.TRNIF = 0;
/*
* At least six Tcy are needed in between clearing UIR<TRNIF>
* and when it becomes reasserted when the USTAT FIFO has more
* than one entry in it.
*
* No Nops are needed here because the number of instruction
* cycles between clearing the TRNIF here to the next flag
* check is longer than the required minimum of six Tcy due
* to the for loop logic of bTRNIFCount. This is true even
* when all optimization options in C18 are enabled.
*/
}
}//end if(UIRbits.TRNIF && UIEbits.TRNIE)
else
break;
}// end for(bTRNIFCount = 0; bTRNIFCount < 4; bTRNIFCount++)
}//end USBDriverService
/******************************************************************************
* Function: void USBDriverService(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This routine is the heart of this firmware. It manages
* all USB interrupts.
*
* Note: Device state transitions through the following stages:
* DETACHED -> ATTACHED -> POWERED -> DEFAULT ->
* ADDRESS_PENDING -> ADDRESSED -> CONFIGURED -> READY
*****************************************************************************/
void USBDriverService(void)
{
/*
* Pointless to continue servicing if USB cable is not even attached.
*/
if(usb_device_state == DETACHED_STATE) return;
/*
* Task A: Service USB Activity Interrupt
*/
if(UIRbits.ACTVIF && UIEbits.ACTVIE) USBWakeFromSuspend();
/*
* Pointless to continue servicing if the device is in suspend mode.
*/
if(UCONbits.SUSPND==1) return;
/*
* Task B: Service USB Bus Reset Interrupt.
* When bus reset is received during suspend, ACTVIF will be set first,
* once the UCONbits.SUSPND is clear, then the URSTIF bit will be asserted.
* This is why URSTIF is checked after ACTVIF.
*/
if(UIRbits.URSTIF && UIEbits.URSTIE) USBProtocolResetHandler();
/*
* Task C: Service other USB interrupts
*/
if(UIRbits.IDLEIF && UIEbits.IDLEIE) USBSuspend();
if(UIRbits.SOFIF && UIEbits.SOFIE) USB_SOF_Handler();
if(UIRbits.STALLIF && UIEbits.STALLIE) USBStallHandler();
if(UIRbits.UERRIF && UIEbits.UERRIE) USBErrorHandler();
/*
* Pointless to continue servicing if the host has not sent a bus reset.
* Once bus reset is received, the device transitions into the DEFAULT
* state and is ready for communication.
*/
if(usb_device_state < DEFAULT_STATE) return;
/*
* Task D: Servicing USB Transaction Complete Interrupt
*/
if(UIRbits.TRNIF && UIEbits.TRNIE)
{
/*
* USBCtrlEPService only services transactions over EP0.
* It ignores all other EP transactions.
*/
USBCtrlEPService();
/*
* Other EP can be serviced later by responsible device class firmware.
* Each device driver knows when an OUT or IN transaction is ready by
* checking the buffer ownership bit.
* An OUT EP should always be owned by SIE until the data is ready.
* An IN EP should always be owned by CPU until the data is ready.
*
* Because of this logic, it is not necessary to save the USTAT value
* of non-EP0 transactions.
*/
UIRbits.TRNIF = 0;
}//end if(UIRbits.TRNIF && UIEbits.TRNIE)
}//end USBDriverService
