/********************************************************************* * * Microchip USB C18 Firmware Version 1.0 * ********************************************************************* * FileName: usbdrv.c * Dependencies: See INCLUDES section below * Processor: PIC18 * Compiler: C18 2.30.01+ * Company: Microchip Technology, Inc. * * Software License Agreement * * The software supplied herewith by Microchip Technology Incorporated * (the “Company”) for its PICmicro® Microcontroller is intended and * supplied to you, the Company’s customer, for use solely and * exclusively on Microchip PICmicro Microcontroller products. The * software is owned by the Company and/or its supplier, and is * protected under applicable copyright laws. All rights are reserved. * Any use in violation of the foregoing restrictions may subject the * user to criminal sanctions under applicable laws, as well as to * civil liability for the breach of the terms and conditions of this * license. * * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES, * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT, * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. * * Author Date Comment *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rawin Rojvanit 11/19/04 Original. ********************************************************************/ /** I N C L U D E S **********************************************************/ #include #include "system\typedefs.h" #include "system\usb\usb.h" #include "io_cfg.h" // Required for USBCheckBusStatus() /** V A R I A B L E S ********************************************************/ #pragma udata /** P R I V A T E P R O T O T Y P E S ***************************************/ void USBModuleEnable(void); void USBModuleDisable(void); void USBSuspend(void); void USBWakeFromSuspend(void); void USBProtocolResetHandler(void); void USB_SOF_Handler(void); void USBStallHandler(void); void USBErrorHandler(void); /** D E C L A R A T I O N S **************************************************/ #pragma code /****************************************************************************** * Function: void USBCheckBusStatus(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This routine enables/disables the USB module by monitoring * the USB power signal. * * Note: None *****************************************************************************/ void USBCheckBusStatus(void) { /************************************************************************** * Bus Attachment & Detachment Detection * usb_bus_sense is an i/o pin defined in io_cfg.h *************************************************************************/ #define USB_BUS_ATTACHED 1 #define USB_BUS_DETACHED 0 if(usb_bus_sense == USB_BUS_ATTACHED) // Is USB bus attached? { if(UCONbits.USBEN == 0) // Is the module off? USBModuleEnable(); // Is off, enable it } else { if(UCONbits.USBEN == 1) // Is the module on? USBModuleDisable(); // Is on, disable it }//end if(usb_bus_sense...) /* * After enabling the USB module, it takes some time for the voltage * on the D+ or D- line to rise high enough to get out of the SE0 condition. * The USB Reset interrupt should not be unmasked until the SE0 condition is * cleared. This helps preventing the firmware from misinterpreting this * unique event as a USB bus reset from the USB host. */ if(usb_device_state == ATTACHED_STATE) { if(!UCONbits.SE0) { UIR = 0; // Clear all USB interrupts UIE = 0; // Mask all USB interrupts UIEbits.URSTIE = 1; // Unmask RESET interrupt UIEbits.IDLEIE = 1; // Unmask IDLE interrupt usb_device_state = POWERED_STATE; }//end if // else wait until SE0 is cleared }//end if(usb_device_state == ATTACHED_STATE) }//end USBCheckBusStatus /****************************************************************************** * Function: void USBModuleEnable(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This routine enables the USB module. * An end designer should never have to call this routine * manually. This routine should only be called from * USBCheckBusStatus(). * * Note: See USBCheckBusStatus() for more information. *****************************************************************************/ void USBModuleEnable(void) { UCON = 0; UIE = 0; // Mask all USB interrupts UCONbits.USBEN = 1; // Enable module & attach to bus usb_device_state = ATTACHED_STATE; // Defined in usbmmap.c & .h }//end USBModuleEnable /****************************************************************************** * Function: void USBModuleDisable(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This routine disables the USB module. * An end designer should never have to call this routine * manually. This routine should only be called from * USBCheckBusStatus(). * * Note: See USBCheckBusStatus() for more information. *****************************************************************************/ void USBModuleDisable(void) { UCON = 0; // Disable module & detach from bus UIE = 0; // Mask all USB interrupts usb_device_state = DETACHED_STATE; // Defined in usbmmap.c & .h }//end USBModuleDisable /****************************************************************************** * Function: void USBSoftDetach(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: The device will have to be re-enumerated to function again. * * Overview: USBSoftDetach electrically disconnects the device from * the bus. This is done by stop supplying Vusb voltage to * pull-up resistor. The pull-down resistors on the host * side will pull both differential signal lines low and * the host registers the event as a disconnect. * * Since the USB cable is not physically disconnected, the * power supply through the cable can still be sensed by * the device. The next time USBCheckBusStatus() function * is called, it will reconnect the device back to the bus. * * Note: None *****************************************************************************/ void USBSoftDetach(void) { USBModuleDisable(); }//end USBSoftDetach /****************************************************************************** * 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 /****************************************************************************** * Function: void USBSuspend(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: * * Note: None *****************************************************************************/ void USBSuspend(void) { /* * NOTE: Do not clear UIRbits.ACTVIF here! * Reason: * ACTVIF is only generated once an IDLEIF has been generated. * This is a 1:1 ratio interrupt generation. * For every IDLEIF, there will be only one ACTVIF regardless of * the number of subsequent bus transitions. * * If the ACTIF is cleared here, a problem could occur when: * [ IDLE ][bus activity -> * <--- 3 ms -----> ^ * ^ ACTVIF=1 * IDLEIF=1 * # # # # (#=Program polling flags) * ^ * This polling loop will see both * IDLEIF=1 and ACTVIF=1. * However, the program services IDLEIF first * because ACTIVIE=0. * If this routine clears the only ACTIVIF, * then it can never get out of the suspend * mode. */ UIEbits.ACTVIE = 1; // Enable bus activity interrupt UIRbits.IDLEIF = 0; UCONbits.SUSPND = 1; // Put USB module in power conserve // mode, SIE clock inactive /* * At this point the PIC can go into sleep,idle, or * switch to a slower clock, etc. */ /* Modifiable Section */ PIR2bits.USBIF = 0; PIE2bits.USBIE = 1; // Set USB wakeup source Sleep(); // Goto sleep PIE2bits.USBIE = 0; /* End Modifiable Section */ }//end USBSuspend /****************************************************************************** * Function: void USBWakeFromSuspend(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: * * Note: None *****************************************************************************/ void USBWakeFromSuspend(void) { /* * If using clock switching, this is the place to restore the * original clock frequency. */ UCONbits.SUSPND = 0; UIEbits.ACTVIE = 0; UIRbits.ACTVIF = 0; }//end USBWakeFromSuspend /****************************************************************************** * 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 USB_SOF_Handler(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: The USB host sends out a SOF packet to full-speed devices * every 1 ms. This interrupt may be useful for isochronous * pipes. End designers should implement callback routine * as necessary. * * Note: None *****************************************************************************/ void USB_SOF_Handler(void) { /* Callback routine here */ UIRbits.SOFIF = 0; }//end USB_SOF_Handler /****************************************************************************** * Function: void USBStallHandler(void) * * PreCondition: A STALL packet is sent to the host by the SIE. * * Input: None * * Output: None * * Side Effects: None * * Overview: The STALLIF is set anytime the SIE sends out a STALL * packet regardless of which endpoint causes it. * A Setup transaction overrides the STALL function. A stalled * endpoint stops stalling once it receives a setup packet. * In this case, the SIE will accepts the Setup packet and * set the TRNIF flag to notify the firmware. STALL function * for that particular endpoint pipe will be automatically * disabled (direction specific). * * There are a few reasons for an endpoint to be stalled. * 1. When a non-supported USB request is received. * Example: GET_DESCRIPTOR(DEVICE_QUALIFIER) * 2. When an endpoint is currently halted. * 3. When the device class specifies that an endpoint must * stall in response to a specific event. * Example: Mass Storage Device Class * If the CBW is not valid, the device shall * STALL the Bulk-In pipe. * See USB Mass Storage Class Bulk-only Transport * Specification for more details. * * Note: UEPn.EPSTALL can be scanned to see which endpoint causes * the stall event. * If *****************************************************************************/ void USBStallHandler(void) { /* * Does not really have to do anything here, * even for the control endpoint. * All BDs of Endpoint 0 are owned by SIE right now, * but once a Setup Transaction is received, the ownership * for EP0_OUT will be returned to CPU. * When the Setup Transaction is serviced, the ownership * for EP0_IN will then be forced back to CPU by firmware. */ if(UEP0bits.EPSTALL == 1) { USBPrepareForNextSetupTrf(); // Firmware work-around UEP0bits.EPSTALL = 0; } UIRbits.STALLIF = 0; }//end USBStallHandler /****************************************************************************** * Function: void USBErrorHandler(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: The purpose of this interrupt is mainly for debugging * during development. Check UEIR to see which error causes * the interrupt. * * Note: None *****************************************************************************/ void USBErrorHandler(void) { UIRbits.UERRIF = 0; }//end USBErrorHandler /****************************************************************************** * Function: void USBProtocolResetHandler(void) * * PreCondition: A USB bus reset is received from the host. * * Input: None * * Output: None * * Side Effects: Currently, this routine flushes any pending USB * transactions. It empties out the USTAT FIFO. This action * might not be desirable in some applications. * * Overview: Once a USB bus reset is received from the host, this * routine should be called. It resets the device address to * zero, disables all non-EP0 endpoints, initializes EP0 to * be ready for default communication, clears all USB * interrupt flags, unmasks applicable USB interrupts, and * reinitializes internal state-machine variables. * * Note: None *****************************************************************************/ void USBProtocolResetHandler(void) { UEIR = 0; // Clear all USB error flags UIR = 0; // Clears all USB interrupts UEIE = 0b10011111; // Unmask all USB error interrupts UIE = 0b01111011; // Enable all interrupts except ACTVIE UADDR = 0x00; // Reset to default address mDisableEP1to15(); // Reset all non-EP0 UEPn registers UEP0 = EP_CTRL|HSHK_EN; // Init EP0 as a Ctrl EP, see usbdrv.h while(UIRbits.TRNIF == 1) // Flush any pending transactions UIRbits.TRNIF = 0; UCONbits.PKTDIS = 0; // Make sure packet processing is enabled USBPrepareForNextSetupTrf(); // Declared in usbctrltrf.c usb_stat.RemoteWakeup = 0; // Default status flag to disable usb_active_cfg = 0; // Clear active configuration usb_device_state = DEFAULT_STATE; }//end USBProtocolResetHandler /* Auxiliary Function */ void ClearArray(byte* startAdr,byte count) { *startAdr; while(count) { _asm clrf POSTINC0,0 _endasm count--; }//end while }//end ClearArray /** EOF usbdrv.c *************************************************************/