This is an updated version of the USB HID module supplied with the compiler. This version allows the use of the USB module on the new Microchip PIC18F87J50 3.3v part.
The example program shown here is a modification of the basic HID example supplied with the Compiler Help File. It will interact with the HID example program available from here & was developed for the Microchip PIC18F87J50 Full Speed USB Plug-In Module (Part Number: MA180021). The use of the new Mircochip USB HID bootloader is a highly recommended (updated 17/11/08 to correct Bootloader Descriptor Strings issue).
You can download the modified files from here (plus they are listed below for safety). You will need to place them into your UserLibrary Folder to ensure they are used by the compiler, and to ensure they are not overwritten in an update.
Although the 18F87J50 has 4096 bytes of RAM; due to the part having its USB buffers in RAM BANK 4 for compatibility, Swordfish can only allocate 1024 bytes of RAM automatically (and will report as such on compile).
You can however safely utilize memory above RAM BANK 7 ($0800 hex address and above, up to $0EFF) by directly allocating the memory yourself.
DIM BigBuffer(1000) as byte absolute $0800 DIM SecondBuffer(100) as byte absolute $0BE8
The limitation of this is that you need to keep track of the size of each variable to calculate the correct address for the next one. So probably the best use for this RAM is for large arrays or structures.
Big thanks to Nigle for pointing out how to use the high RAM area & a work around for UCFG. Thanks to richardb and Huge thanks to David Barker for this great compiler and for getting the ICD working - without it I was just thrashing around in the dark.
{ ***************************************************************************** * Name : 18F87J50HIDExample.BAS * * Author : Nathan Herbert * * Notice : Copyright (c) 2008 Nathan (Rangerbob) * * : All Rights Reserved * * Date : 17/11/2008 * * Version : 1.1 * * Notes : Modified USB HID example from the Swordfish Help file * * : To show support for 18F87J50 part * * : Use with Mechanique HIDExample.exe & 18F87J50 PIM * * : 1.1 - Fix for bootloader Descriptor strings issue * ***************************************************************************** } // device and clock... Device = 18F87J50 Clock = 48 // 12Mhz crystal on 18F87J50 Board Config xinst = off, stvren = on, PLLDIV = 3, wdten = off, cp0 = off, CPUDIV = OSC1, ieso = off, fcmen = off, FOSC = HSPLL, wdtps = 32768, msspmsk = msk5, ccp2mx = default, wait = off, bw = 16, mode = mm, eashft = off, pmpmx = default, eccpmx = default // Enable this option to use with the Microchip USB HID bootloader '#option org_reset = $1000 // Fix for Bootloader Descriptor Strings Issue - Ensure this is first include Include "ClearRegisters.bas" // import the HID module... Include "usbhid.bas" // TX report... Structure TTXReport Time As Word Message As String End Structure Dim TXReport As TTXReport Absolute TXReportRAM // RX report... Structure TRXReport LED0 As Bit LED1 As Bit End Structure Dim RXReport As TRXReport Absolute RXReportRAM // alias port pins to LEDs... // Porte.0 & Porte.1 available as LEDs on 18F87J50 PIM module Dim LED0 As PORTE.0, LED1 As PORTE.1 // initialise... // Set all digital //Configure all I/O pins to use digital input buffers. The PIC18F87J50 Family devices //use the ANCONx registers to control this, which is different from other devices which //use the ADCON1 register for this purpose. WDTCON.4 = 1 // selcet alternate sfr locations ANCON0 = $FF ANCON1 = $FF WDTCON.4 = 0 // select normal sfr locations TXReport.Time = 0 Low(LED0) Low(LED1) // connect to USB... Repeat Until Attached // main program loop... While true // if we have data, set port values, update message // and then reset time counter... If DataAvailable Then ReadReport LED0 = RXReport.LED0 LED1 = RXReport.LED1 TXReport.Message = "PORT CHANGED" WriteReport TXReport.Time = 0 DelayMS(100) // no data, set waiting message... Else TXReport.Message = "WAITING..." WriteReport Inc(TXReport.Time) EndIf Wend
{ ***************************************************************************** * Name : ClearRegisters.BAS * * Author : Nathan Herbert * * Notice : * * : All Rights Reserved * * Date : 17/11/2008 * * Version : 1.0 * * Notes : Use with Microchip HID bootloader to ensure correct operation * * : of main program * ***************************************************************************** } Module ClearRegisters #if _device = 18F87J50 TBLPTR = %00000000 TABLAT = %00000000 INTCON = %00000000 INTCON2 = %11111111 INTCON3 = %11000000 TMR0H = %00000000 T0CON = %11111111 CM1CON = %00011111 CM2CON = %00011111 ODCON1 = %00000000 ODCON2 = %00000000 T1CON = %00000000 ODCON3 = %00000000 TMR2 = %00000000 T2CON = %00000000 IPR3 = %11111111 PIR3 = %00000000 PIE3 = %00000000 IPR2 = %11111111 PIR2 = %00000000 PIE2 = %00000000 IPR1 = %11111111 PIR1 = %00000000 PIE1 = %00000000 UCON = %00000000 UEIR = %00000000 UIR = %00000000 UCFG = %00000000 UEIE = %00000000 UIE = %00000000 #endif
{ ***************************************************************************** * Name : USBHID.bas * * Author : David John Barker * * Notice : Copyright (c) 2007 Mecanique * * : All Rights Reserved * * Date : 15/09/2008 * * Version : 1.1a Branch by Nathan(RangerBob) for 18F87J50 Support * * : 1.1 ISR now uses USB interrupts * * : Renamed 'Connected' to 'Attached' * * : 1.0 Release * * Notes : This HID module provides a simple way for you to transfer * * : blocks of data to and from your PC using the USB HID class. * ***************************************************************************** } Module HID // import USB modules... #option USB_USE_HID = true Include USB_DESCRIPTOR Include "usbsfr.bas" Include "usbdefs.bas" Include "usbsystem.bas" Include "system.bas" // interrupt driven service fired every 1 millisecond... Const PriorityLevel = USB_SERVICE_PRIORITY // ISR priority // Public buffers - these are just mapped onto USB RAM space, thus saving // program RAM. You can use a large 256 byte buffer, which can be useful // for trasnferring large blocks of data using ReadArray() and WriteArray(). // The RX and TX buffers match the HID report size, and are typically use with // ReaReport() and WriteReport(). However, they can also be used with ReadArray() // and WriteArray(). Note that these buffers are only available for USB devices // that have extended dual port USB RAM... #if USB_EXTENDED_RAM Public Const BufferRAM = $600, TXReportRAM = BufferRAM, RXReportRAM = BufferRAM + HIDReportBytesIn Public Dim Buffer(256) As Byte Absolute BufferRAM, TXReport(HIDReportBytesIn) As Byte Absolute TXReportRAM, RXReport(HIDReportBytesOut) As Byte Absolute RXReportRAM #endif Public Dim Attached As USBSystem.Attached { **************************************************************************** * Name : Service * * Purpose : Service a USB connection. You need to call this routine * * : periodically from your main program to maintain a connection * * : (every 1 ms or so). You DO NOT need to call this routine if * * : you have enabled the OnService() interrupt handler (it is on * * : by default) * **************************************************************************** } Public Inline Sub Service() USBCheckBusStatus USBDriverService ClrWDT End Sub { **************************************************************************** * Name : NoISRService * * Purpose : Private service helper routine for maintain USB connection * * : for some blocking calls * **************************************************************************** } Inline Sub NoISRService() #if Not USB_SERVICE Service #endif End Sub { **************************************************************************** * Name : OnService (PRIVATE) * * Purpose : USB service event handler * **************************************************************************** } #if USB_SERVICE Interrupt OnService(PriorityLevel) PIR2Bits.USBIF = 0 Save(FSR0, FSR1, Service) Service Restore End Interrupt #endif { **************************************************************************** * Name : EnableISR * * Purpose : Enable the ISR to service USB connection * **************************************************************************** } Public Inline Sub EnableISR() #if USB_SERVICE Enable(OnService) #endif End Sub { **************************************************************************** * Name : DisableISR * * Purpose : Disable the ISR that services the USB connection * **************************************************************************** } Public Inline Sub DisableISR() #if USB_SERVICE Disable(OnService) #endif End Sub { **************************************************************************** * Name : WaitForTX (PRIVATE) * * Purpose : Blocks processing until USB TX buffer is available * **************************************************************************** } Sub WaitForTX() While mHIDTxIsBusy <> 0 And Attached Service Wend End Sub { **************************************************************************** * Name : DataAvailable * * Purpose : Returns true if RX data is available, false otherwise * **************************************************************************** } Public Function DataAvailable() As Boolean DisableISR Result = (mHIDRxIsBusy = 0) EnableISR End Function { **************************************************************************** * Name : ReadReport * * Purpose : Read a HID report into RXReport buffer * **************************************************************************** } #if USB_EXTENDED_RAM Public Sub ReadReport() DisableISR While mHIDRxIsBusy <> 0 And Attached Service Wend HIDRxReport(@RXReport, HIDReportBytesOut) NoISRService EnableISR End Sub { **************************************************************************** * Name : WriteReport * * Purpose : Write the TXReport buffer * **************************************************************************** } Public Sub WriteReport() DisableISR WaitForTX HIDTxReport(@TXReport, HIDReportBytesIn) NoISRService EnableISR End Sub #endif { **************************************************************************** * Name : ReadArray * * Purpose : Read an array of bytes - pCount is an optional number of bytes * * : to read. If pCount is not given, the size of the array is used * **************************************************************************** } Public Sub ReadArray(ByRef pBuffer() As Byte, pCount As Word = 0) Dim BytesRead As Byte Dim Buffer As Word Buffer = @pBuffer If pCount = 0 Then pCount = Bound(pBuffer) + 1 EndIf DisableISR While pCount > 0 And Attached // wait for data If mHIDRxIsBusy = 0 Then // pCount > max report size If pCount > HIDReportBytesOut Then BytesRead = HIDRxReport(Buffer, HIDReportBytesOut) Dec(pCount, BytesRead) Inc(Buffer, BytesRead) // pCount <= max report size Else BytesRead = HIDRxReport(Buffer, pCount.Byte0) Dec(pCount.Byte0, BytesRead) Inc(Buffer, BytesRead) EndIf EndIf Service Wend EnableISR End Sub { **************************************************************************** * Name : WriteArray * * Purpose : Write an array of bytes - pCount is an optional number of * * : to write. If pCount is not given, the array size is used * * : Bytes are transfered in HIDReportBytesIn sized packets - 8, 16 * * : 32 or 64 bytes. If you pass an array which is only dimensioned * * : 4 bytes (for example, DIM Array(4) AS BYTE then a * * : 'HIDReportBytesIn' sized data packet is still transferred. * * : This isn't really a problem, as the host application should * * : know what to do with the data anyway. * **************************************************************************** } Public Sub WriteArray(ByRef pBuffer() As Byte, pLength As Word = 0) Dim Buffer As Word Buffer = @pBuffer If pLength = 0 Then pLength = Bound(pBuffer) + 1 EndIf DisableISR While (pLength > HIDReportBytesIn) And Attached WaitForTX HIDTxReport(Buffer, HIDReportBytesIn) Dec(pLength, HIDReportBytesIn) Inc(Buffer, HIDReportBytesIn) Service Wend If pLength.Byte0 > 0 Then WaitForTX HIDTxReport(Buffer, HIDReportBytesIn) Service EndIf EnableISR End Sub { **************************************************************************** * Name : Initialize * * Purpose : Initialize the USB module * **************************************************************************** } Sub Initialize() #if _device = 18F87J50 //On the PIC18F87J50 Family of USB microcontrollers, the PLL will not power up and be enabled //by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL). //This allows the device to power up at a lower initial operating frequency, which can be //advantageous when powered from a source which is not gauranteed to be adequate for 48MHz //operation. On these devices, user firmware needs to manually set the OSCTUNE<PLLEN> bit to //power up the PLL. //Enable the PLL and wait 2+ms until the PLL locks before enabling USB module OSCTUNE.6 = 1 DelayMS(2) #endif mInitializeUSBDriver() #if USB_SERVICE #if USB_SERVICE_PRIORITY = ipLow #if _device = 18F87J50 IPR2.4 = 0 #else IPR2.5 = 0 #endif #endif PIR2Bits.USBIF = 0 // clear USBIF PIE2Bits.USBIE = 1 // enable USB Int Service UIE = $7F // Enable all interrupts UEIE = $9F // Unmask all USB error interrupts Enable(OnService) #endif End Sub // initialize the module... Initialize
{ ***************************************************************************** * Name : USBSFR.bas * * Author : David John Barker * * Notice : Copyright (c) 2007 Mecanique * * : All Rights Reserved * * Date : 15/09/2008 * * Version : 1.0a Branch by Nathan(RangerBob) for 18F87J50 Support * * : 1.0 * * Notes : This module implements SFRs as structures, which allows you to * * : refer to bits using their respective datasheet names. For * * : example, you can use something like UIRBits.STALLIF = 0. Note * * : that if you want to access as a complete byte, you should use * * : UIRBits._byte = $00 - this is because the compiler sees the * * : variables as structures and not bytes * ***************************************************************************** } Module USBSFR // UFRML Structure TUFRML _byte As Byte FRM0 As _byte.0 FRM1 As _byte.1 FRM2 As _byte.2 FRM3 As _byte.3 FRM4 As _byte.4 FRM5 As _byte.5 FRM6 As _byte.6 FRM7 As _byte.7 End Structure // UFRMH Structure TUFRMH _byte As Byte FRM8 As _byte.0 FRM9 As _byte.1 FRM10 As _byte.2 End Structure // UIR Structure TUIR _byte As Byte URSTIF As _byte.0 UERRIF As _byte.1 ACTVIF As _byte.2 TRNIF As _byte.3 IDLEIF As _byte.4 STALLIF As _byte.5 SOFIF As _byte.6 End Structure // UIE Structure TUIE _byte As Byte URSTIE As _byte.0 UERRIE As _byte.1 ACTVIE As _byte.2 TRNIE As _byte.3 IDLEIE As _byte.4 STALLIE As _byte.5 SOFIE As _byte.6 End Structure // UEIR Structure TUEIR _byte As Byte PIDEF As _byte.0 CRC5EF As _byte.1 CRC16EF As _byte.2 DFN8EF As _byte.3 BTOEF As _byte.4 BTSEF As _byte.7 End Structure // UEIE Structure TUEIE _byte As Byte PIDEE As _byte.0 CRC5EE As _byte.1 CRC16EE As _byte.2 DFN8EE As _byte.3 BTOEE As _byte.4 BTSEE As _byte.7 End Structure // USTAT Structure TUSTAT _byte As Byte PPBI As _byte.1 DIR As _byte.2 ENDP0 As _byte.3 ENDP1 As _byte.4 ENDP2 As _byte.5 ENDP3 As _byte.6 End Structure // UCON Structure TUCON _byte As Byte SUSPND As _byte.1 RESUME As _byte.2 USBEN As _byte.3 PKTDIS As _byte.4 SE0 As _byte.5 PPBRST As _byte.6 End Structure // UADDR Structure TUADDR _byte As Byte ADDR0 As _byte.0 ADDR1 As _byte.1 ADDR2 As _byte.2 ADDR3 As _byte.3 ADDR4 As _byte.4 ADDR5 As _byte.5 ADDR6 As _byte.6 End Structure // UCFG Structure TUCFG _byte As Byte PPB0 As _byte.0 PPB1 As _byte.1 FSEN As _byte.2 UTRDIS As _byte.3 UPUEN As _byte.4 ' UOEMON As _byte.6 UTEYE As _byte.7 End Structure // UEP Structure TUEP _byte As Byte EPSTALL As _byte.0 EPINEN As _byte.1 EPOUTEN As _byte.2 EPCONDIS As _byte.3 EPHSHK As _byte.4 End Structure #if _device = 18F87J50 // PIR2 Structure TPIR2 _byte As Byte CCP2IF As _byte.0 TMR3IF As _byte.1 LVDIF As _byte.2 BCLIF As _byte.3 USBIF As _byte.4 CMIF As _byte.5 OSCFIF As _byte.7 HLVDIF As _byte.2 End Structure #else // PIR2 Structure TPIR2 _byte As Byte CCP2IF As _byte.0 TMR3IF As _byte.1 LVDIF As _byte.2 BCLIF As _byte.3 EEIF As _byte.4 USBIF As _byte.5 CMIF As _byte.6 OSCFIF As _byte.7 HLVDIF As _byte.2 End Structure #endif // INTCON Structure TINTCON _byte As Byte RBIF As _byte.0 INT0IF As _byte.1 TMR0IF As _byte.2 RBIE As _byte.3 INT0IE As _byte.4 TMR0IE As _byte.5 PEIE As _byte.6 GIE As _byte.7 INT0F As _byte.1 T0IF As _byte.2 INT0E As _byte.4 T0IE As _byte.5 GIEL As _byte.6 GIEH As _byte.7 End Structure #if _device = 18F87J50 // PIE2 Structure TPIE2 _byte As Byte CCP2IE As _byte.0 TMR3IE As _byte.1 LVDIE As _byte.2 BCLIE As _byte.3 USBIE As _byte.4 CMIE As _byte.5 OSCFIE As _byte.7 HLVDIE As _byte.2 End Structure #else // PIE2 Structure TPIE2 _byte As Byte CCP2IE As _byte.0 TMR3IE As _byte.1 LVDIE As _byte.2 BCLIE As _byte.3 EEIE As _byte.4 USBIE As _byte.5 CMIE As _byte.6 OSCFIE As _byte.7 HLVDIE As _byte.2 End Structure #endif // public aliases... #if _device = 18F87J50 Public Dim UFRMLBits As TUFRML Absolute $0F60, UFRMHBits As TUFRMH Absolute $0F61, UIRBits As TUIR Absolute $0F62, UIEBits As TUIE Absolute $0F5C, UEIRBits As TUEIR Absolute $0F63, UEIEBits As TUEIE Absolute $0F5D, USTATBits As TUSTAT Absolute $0F64, UCONBits As TUCON Absolute $0F65, UADDRBits As TUADDR Absolute $0F5E, UCFGBits As TUCFG Absolute $0F5F, UEP0Bits As TUEP Absolute $0F4C, UEP1Bits As TUEP Absolute $0F4D, UEP2Bits As TUEP Absolute $0F4E, UEP3Bits As TUEP Absolute $0F4F, UEP4Bits As TUEP Absolute $0F50, UEP5Bits As TUEP Absolute $0F51, UEP6Bits As TUEP Absolute $0F52, UEP7Bits As TUEP Absolute $0F53, UEP8Bits As TUEP Absolute $0F54, UEP9Bits As TUEP Absolute $0F55, UEP10Bits As TUEP Absolute $0F56, UEP11Bits As TUEP Absolute $0F57, UEP12Bits As TUEP Absolute $0F58, UEP13Bits As TUEP Absolute $0F59, UEP14Bits As TUEP Absolute $0F5A, UEP15Bits As TUEP Absolute $0F5B, PIE2Bits As TPIE2 Absolute $0FA0, PIR2Bits As TPIR2 Absolute $0FA1, INTCONBits As TINTCON Absolute $0FF2 #else Public Dim UFRMLBits As TUFRML Absolute $0F66, UFRMHBits As TUFRMH Absolute $0F67, UIRBits As TUIR Absolute $0F68, UIEBits As TUIE Absolute $0F69, UEIRBits As TUEIR Absolute $0F6A, UEIEBits As TUEIE Absolute $0F6B, USTATBits As TUSTAT Absolute $0F6C, UCONBits As TUCON Absolute $0F6D, UADDRBits As TUADDR Absolute $0F6E, UCFGBits As TUCFG Absolute $0F6F, UEP0Bits As TUEP Absolute $0F70, UEP1Bits As TUEP Absolute $0F71, UEP2Bits As TUEP Absolute $0F72, UEP3Bits As TUEP Absolute $0F73, UEP4Bits As TUEP Absolute $0F74, UEP5Bits As TUEP Absolute $0F75, UEP6Bits As TUEP Absolute $0F76, UEP7Bits As TUEP Absolute $0F77, UEP8Bits As TUEP Absolute $0F78, UEP9Bits As TUEP Absolute $0F79, UEP10Bits As TUEP Absolute $0F7A, UEP11Bits As TUEP Absolute $0F7B, UEP12Bits As TUEP Absolute $0F7C, UEP13Bits As TUEP Absolute $0F7D, UEP14Bits As TUEP Absolute $0F7E, UEP15Bits As TUEP Absolute $0F7F, PIE2Bits As TPIE2 Absolute $0FA0, PIR2Bits As TPIR2 Absolute $0FA1, INTCONBits As TINTCON Absolute $0FF2 #endif
{ ***************************************************************************** * Name : USBSystem.Bas * * Author : David John Barker * * Notice : Copyright (c) 2007 Mecanique * * : All Rights Reserved * * Date : 15/09/2008 * * Version : 1.2a Branch by Nathan(RangerBob) for 18F87J50 Support * * : 1.2 Added GetPID() to correctly mask BD_STAT PID * * : Added string index check in USBStdGetDscHandler() * * : Added 'Attached' flag * * : 1.1 Fixed RAM allocation for smaller USB devices * * : 1.0 Release * * Notes : This module is based on the Microchip USB C18 Firmware Version * * : 1.0 by Rawin Rojvanit. Whilst many of the routines could be * * : optimised for the Swordfish compiler, it was felt that * * : maintaining the code as close to possible to the original C * * : version would make it much easier to make changes and update * * : the firmware. In addition, all the documentation relating to * * : the original version can be easily mapped to this module * * : -------------------------------------------------------------- * * : IT IS STRONGLY advised you do not make changes to this module * * : unless you are familiar with USB or the original Microchip * * : firmware * ***************************************************************************** } Module USBSystem // import modules... Include "USBConfig.bas" // configurations Include "USBSFR.bas" // USB Special Function Registers (SFR) Include "USBDefs.bas" // constants, structures etc Include USB_DESCRIPTOR // descriptor file // general module variables... Dim 'usbmap.c usb_device_state As Byte, // Device States: DETACHED, ATTACHED, ... usb_stat As USB_DEVICE_STATUS, // Global USB flags usb_active_cfg As Byte, // Value of current configuration usb_alt_intf(MAX_NUM_INT) As Byte, // Array to keep track of the current alternate setting for each interface ID usb_Attached As Boolean // device attached flag // public... Public Dim Attached As usb_Attached // USB device attached flag // fixed location variables // Cannot Modify MAXRAM or USB_RAM_EP as 18F87J50 uses bank 4 for USB buffers - to look at #if _device = 18F87J50 #if USB_EXTENDED_RAM #variable _maxram = $0400 #else #variable _maxram = $0200 #endif #define EP_SIZE = 4 // endpoint size (byte) #define USB_RAM_EP = $400 // USB RAM start location #else #if USB_EXTENDED_RAM #variable _maxram = $0400 #else #variable _maxram = $0200 #endif #define EP_SIZE = 4 // endpoint size (byte) #define USB_RAM_EP = $400 // USB RAM start location #endif // endpoint 0, OUT and IN #if(0 <= MAX_EP_NUMBER) Dim 'usbmap.c ep0Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 0), ep0Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 1) #endif // endpoint 1, OUT and IN #if(1 <= MAX_EP_NUMBER) Dim 'usbmap.c ep1Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 2), ep1Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 3) #endif // endpoint 2, OUT and IN #if(2 <= MAX_EP_NUMBER) Dim 'usbmap.c ep2Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 4), ep2Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 5) #endif // endpoint 3, OUT and IN #if(3 <= MAX_EP_NUMBER) Dim 'usbmap.c ep3Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 6), ep3Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 7) #endif // endpoint 4, OUT and IN #if(4 <= MAX_EP_NUMBER) Dim 'usbmap.c ep4Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 8), ep4Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 9) #endif // endpoint 5, OUT and IN #if(5 <= MAX_EP_NUMBER) Dim 'usbmap.c ep5Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 10), ep5Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 11) #endif // endpoint 6, OUT and IN #if(6 <= MAX_EP_NUMBER) Dim 'usbmap.c ep6Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 12), ep6Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 13) #endif // endpoint 7, OUT and IN #if(7 <= MAX_EP_NUMBER) Dim 'usbmap.c ep7Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 14), ep7Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 15) #endif // endpoint 8, OUT and IN #if(8 <= MAX_EP_NUMBER) Dim 'usbmap.c ep8Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 16), ep8Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 17) #endif // endpoint 9, OUT and IN #if(9 <= MAX_EP_NUMBER) Dim 'usbmap.c ep9Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 18), ep9Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 19) #endif // endpoint 10, OUT and IN #if(10 <= MAX_EP_NUMBER) Dim 'usbmap.c ep10Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 20), ep10Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 21) #endif // endpoint 11, OUT and IN #if(11 <= MAX_EP_NUMBER) Dim 'usbmap.c ep11Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 22), ep11Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 23) #endif // endpoint 12, OUT and IN #if(12 <= MAX_EP_NUMBER) Dim 'usbmap.c ep12Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 24), ep12Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 25) #endif // endpoint 13, OUT and IN #if(13 <= MAX_EP_NUMBER) Public Dim 'usbmap.c ep13Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 26), ep13Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 27) #endif // endpoint 14, OUT and IN #if(14 <= MAX_EP_NUMBER) Dim 'usbmap.c ep14Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 28), ep14Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 29) #endif // endpoint 15, OUT and IN #if(15 <= MAX_EP_NUMBER) Dim 'usbmap.c ep15Bo As BDT Absolute (USB_RAM_EP + EP_SIZE * 30), ep15Bi As BDT Absolute (USB_RAM_EP + EP_SIZE * 31) #endif // located after enpoints... #define USB_RAM_BUFF = USB_RAM_EP + EP_SIZE * (MAX_EP_NUMBER + 1) * 2 Dim 'usbmap.c SetupPkt As CTRL_TRF_SETUP Absolute USB_RAM_BUFF, CtrlTrfData As CTRL_TRF_DATA Absolute (USB_RAM_BUFF + USB_EP0_BUFF_SIZE) // HID - located after endpoint buffers... #if USB_USE_HID #define USB_RAM_HID = USB_RAM_BUFF + USB_EP0_BUFF_SIZE * 2 Dim 'usbmap.c hid_report_out(HID_INT_OUT_EP_SIZE) As Byte Absolute USB_RAM_HID, hid_report_in(HID_INT_IN_EP_SIZE) As Byte Absolute (USB_RAM_HID + HID_INT_OUT_EP_SIZE), hid_report_feature(USB_EP0_BUFF_SIZE) As Byte Absolute (USB_RAM_HID + HID_INT_OUT_EP_SIZE + HID_INT_IN_EP_SIZE) Dim 'usbcfg.h HID_UEP As UEP1, HID_BD_OUT As ep1Bo, HID_BD_IN As ep1Bi #endif // USB_USE_HID // CDC - located after endpoint buffers... #if USB_USE_CDC #define USB_RAM_CDC = USB_RAM_BUFF + USB_EP0_BUFF_SIZE * 2 Dim 'usbmap.c cdc_notice(CDC_INT_EP_SIZE) As Byte Absolute USB_RAM_CDC, cdc_data_rx(CDC_BULK_OUT_EP_SIZE) As Byte Absolute (USB_RAM_CDC + CDC_INT_EP_SIZE), cdc_data_tx(CDC_BULK_IN_EP_SIZE) As Byte Absolute (USB_RAM_CDC + CDC_INT_EP_SIZE + CDC_BULK_OUT_EP_SIZE) Dim CDC_COMM_UEP As UEP2, 'usbcfg.h CDC_INT_BD_IN As ep2Bi, CDC_DATA_UEP As UEP3, CDC_BULK_BD_OUT As ep3Bo, CDC_BULK_BD_IN As ep3Bi #endif // USB_USE_CDC Dim 'usbctrltr.h and usbctrltr.c ctrl_trf_state As Byte, // control transfer state ctrl_trf_session_owner As Byte, // session owner pSrc As POINTER, // source pointer pDst As POINTER, // destination pointer wCount As Word // originally coded in ROM, we have to use RAM in Swordfish... Dim 'usbdsc.c USB_CD_Ptr(2) As Word, // {&cfg01,&cfg01}; #if USB_HAVE_SERIAL_STRING USB_SD_Ptr(4) As Word // {&sd000,&sd001,&sd002,&sd003}; #else USB_SD_Ptr(3) As Word // {&sd000,&sd001,&sd002}; #endif { **************************************************************************** * Name : SetRAMPtr * * Purpose : Helper routine for setting RAM * **************************************************************************** } Inline Sub SetRAMPtr(pAddress As FSR0, pValue As POSTINC0) End Sub { **************************************************************************** * Name : GetRAMPtr * * Purpose : Helper routine for getting RAM byte * **************************************************************************** } Inline Function GetRAMPtr(pAddress As FSR1) As POSTINC1 End Function { **************************************************************************** * Name : ReadROM * * Purpose : Helper routine for getting ROM byte * **************************************************************************** } Inline Function ReadROM() As TABLAT ASM- TBLRD *+ End ASM End Function { **************************************************************************** * Name :GetROMPtr * * Purpose : Helper routine for getting ROM byte * **************************************************************************** } Inline Function GetROMPtr(pAddress As TABLEPTR) As TABLAT ReadROM End Function { **************************************************************************** * Name : GetRequestType * * Purpose : Helper routine to obtain USB request type * **************************************************************************** } Function GetRequestType() As Byte result = (SetupPkt.RequestType_f2 >> 5) And %00000011 End Function { **************************************************************************** * Name : GetRecipient * * Purpose : Helper routine to get USB recipient * **************************************************************************** } Function GetRecipient() As Byte result = SetupPkt.Recipient_f5 And $1F End Function { **************************************************************************** * Name : GetEPNum * * Purpose : Helper routineto get USB EP number * **************************************************************************** } Function GetEPNum() As Byte result = SetupPkt.EPNum_f4 And $0F End Function { **************************************************************************** * Name : GetPID (version 1.2) * * Purpose : Helper routineto get USB PID * **************************************************************************** } Function GetPID() As Byte result = (ep0Bo.Stat.PID >> 2) And $0F End Function { **************************************************************************** * Name : mInitializeUSBDriver * * Purpose : Configures the USB module * * : This register determines: USB Speed, On-chip pull-up resistor * * : selection, On-chip tranceiver selection, bus eye pattern * * : generation mode, Ping-pong buffering mode selection * **************************************************************************** } Public Sub mInitializeUSBDriver() 'usbdrv.h #if _device = 18F87J50 ASM MOVLW 20 MOVLB 15 MOVWF UCFG End ASM #else UCFG = UCFG_VAL #endif usb_device_state = DETACHED_STATE usb_stat._byte = $00 usb_active_cfg = $00 End Sub { **************************************************************************** * Name : mDisableEP1to15 * * Purpose : This macro disables all endpoints except EP0. This macro * * : should be called when the host sends a RESET signal or a * * : SET_CONFIGURATION request. * **************************************************************************** } Sub mDisableEP1to15() 'usbdrv.h UEP1 = $00 UEP2 = $00 UEP3 = $00 UEP4 = $00 UEP5 = $00 UEP6 = $00 UEP7 = $00 UEP8 = $00 UEP9 = $00 UEP10 = $00 UEP11 = $00 UEP12 = $00 UEP13 = $00 UEP14 = $00 UEP15 = $00 End Sub { **************************************************************************** * Name : mUSBBufferReady * * Require : IN Endpoint: Buffer is loaded and ready to be sent. * * : OUT Endpoint: Buffer is free to be written to by SIE. * * Input : buffer_dsc: Root name of the buffer descriptor group. i.e. * * : ep0Bo, ep1Bi, ... Declared IN usbmmap.c. Names can be * * : remapped for readability, see examples in usbcfg.h * * Purpose : This macro should be called each time after: * * : 1. A non-EP0 IN endpoint buffer is populated with data * * : 2. A non-EP0 OUT endpoint buffer is read. * * : This macro turns the buffer ownership to SIE for * * : servicing. It also toggles the DTS bit for * * : synchronization. * **************************************************************************** } Sub mUSBBufferReady(ByRef buffer_dsc As BDT) 'usbdrv.h buffer_dsc.Stat._byte = buffer_dsc.Stat._byte And _DTSMASK // Save only DTS bit buffer_dsc.Stat.DTS = Not buffer_dsc.Stat.DTS // Toggle DTS bit buffer_dsc.Stat._byte = buffer_dsc.Stat._byte Or _USIE Or _DTSEN // Turn ownership to SIE End Sub { **************************************************************************** * Name : mUSBCheckAdrPendingState * * Purpose : Specialized checking routine, it checks if the device is in * * : the ADDRESS PENDING STATE and services it if it is. * **************************************************************************** } Sub mUSBCheckAdrPendingState() 'usb9.h If usb_device_state = ADR_PENDING_STATE Then UADDR = SetupPkt.bDevADR If (UADDR > 0) Then usb_device_state = ADDRESS_STATE Else usb_device_state = DEFAULT_STATE EndIf EndIf End Sub // ============================ HID CLASS ============================ #if USB_USE_HID Dim hid_rpt_rx_len As Byte // make public for CDC module... Public Dim HIDRXBytesAvailable As HID_BD_OUT.Cnt { **************************************************************************** * Name : mUSBGetHIDDscAdr * * Purpose : Get HID descriptor address * **************************************************************************** } Sub mUSBGetHIDDscAdr() 'usbcfg.h If usb_active_cfg = 1 Then pSrc.bRom = USB_CD_Ptr(1) // @cfg01.hid_i00a00 Inc(pSrc.bRom,18) EndIf End Sub { **************************************************************************** * Name : mUSBGetHIDRptDscAdr * * Purpose : Get HID descriptor report address * **************************************************************************** } Sub mUSBGetHIDRptDscAdr() 'usbcfg.h If usb_active_cfg = 1 Then pSrc.bRom = @hid_rpt01 EndIf End Sub { **************************************************************************** * Name : mUSBGetHIDRptDscSize * * Purpose : Get HID report descriptor size * **************************************************************************** } Sub mUSBGetHIDRptDscSize() 'usbcfg.h If usb_active_cfg = 1 Then wCount = SizeOf(hid_rpt01) EndIf End Sub { **************************************************************************** * Name : mHIDRxIsBusy * * Purpose : This macro is used to check if HID OUT endpoint is busy (owned * * : by SIE) or not. * **************************************************************************** } Public Dim mHIDRxIsBusy As HID_BD_OUT.Stat.UOWN 'hid.h { **************************************************************************** * Name : mHIDTxIsBusy * * Purpose : This macro is used to check if HID IN endpoint is busy (owned * * : by SIE) or not. * **************************************************************************** } Public Dim mHIDTxIsBusy As HID_BD_IN.Stat.UOWN 'hid.h { **************************************************************************** * Name : HandleControlOutReport * * Purpose : Checks to see if an output or Feature report has arrived on * * : the control pipe. if yes, extracts and uses the data. * **************************************************************************** } Sub HandleControlOutReport() 'user_generic_hid.c Dim count As Byte // Find out if an Output or Feature report has arrived on the control pipe. // Get the report type from the Setup packet. Select SetupPkt.W_Value.Byte1 Case 0x02: // Output report // Get the report ID from the Setup packet. Select SetupPkt.W_Value.Byte0 Case 0: // Report ID 0 // This example application copies the Output report data // to hid_report_in. // (Assumes Input and Output reports are the same length.) // A "real" application would do something more useful with the data. // wCount holds the number of bytes read in the Data stage. // This example assumes the report fits in one transaction. count = 0 While count < HID_OUTPUT_REPORT_BYTES hid_report_in(count) = hid_report_out(count) Inc(count) Wend // The number of bytes in the report (from usbcfg.h). End Select Case 0x03: // Feature report // Get the report ID from the Setup packet. Select SetupPkt.W_Value.Byte0 Case 0: // Report ID 0 // The Feature report data is in hid_report_feature. // This example application just sends the data back in the next // Get_Report request for a Feature report. // wCount holds the number of bytes read in the Data stage. // This example assumes the report fits in one transaction. End Select End Select End Sub { **************************************************************************** * Name : HIDGetReportHandler * * Purpose : Called on receiving a Setup packet with a GET_REPORT request. * * : Extracts the report type and the report ID of the report the * * : device will send in the Data stage of the transfer. Calls a * * : function to provide the data. * **************************************************************************** } Sub HIDGetReportHandler() 'hid.c // The report type is in the high byte of the setup packet's Value field. // 3 = Feature; 1 = Input. Select SetupPkt.W_Value.Byte1 // Input report Case 1: // Find out which report ID was specified. // The report ID is in the low byte (LSB) of the Value field. // This example supports Report ID 0. Select SetupPkt.W_Value.Byte0 Case 0: // Report ID 0 // HID will handle the request. ctrl_trf_session_owner = MUID_HID // Provide the data to send. pSrc.bRam = @hid_report_in wCount.Byte0 = HID_INPUT_REPORT_BYTES // The number of bytes in the report Case 1: // Report ID 1 // Place similar code to handle Report ID 1 here. End Select // Feature report Case 3: // The report ID is in the low byte of the Setup packet's Value field. // This example supports Report ID 0. Select SetupPkt.W_Value.Byte0 Case 0: // Report ID 0 // The HID class code will handle the request. ctrl_trf_session_owner = MUID_HID // Provide the data to send. pSrc.bRam = @hid_report_feature wCount.Byte0 = HID_FEATURE_REPORT_BYTES // The number of bytes in the report End Select End Select // The data is in RAM. usb_stat.ctrl_trf_mem = _RAM // Set memory type End Sub { **************************************************************************** * Name : HIDSetReportHandler * * Purpose : Called on receiving a Setup packet with a SET_REPORT request. * * : Extracts the report type and the report ID of the report the * * : host will send IN the Data stage of the transfer. Places the * * : report type and report ID IN out_report_status. * **************************************************************************** } Sub HIDSetReportHandler() 'hid.c // The report type is in the high byte of the Setup packet's Value field. // 3 = Feature; 2 = Output. Select SetupPkt.W_Value.Byte1 Case 2: // Output report // The report ID is in the low byte of the Setup packet's Value field. // This example supports Report ID 0. Select SetupPkt.W_Value.Byte0 Case 0: // Report ID 0 // HID will handle the request. ctrl_trf_session_owner = MUID_HID // Save the report type and report ID in out_report_status. //out_report_status = SetOutReportStatus // (MSB(SetupPkt.W_Value), // LSB(SetupPkt.W_Value)); // When the report arrives in the data stage, the data will be // stored in hid_report_out (defined in usbmmap.c). pDst.bRam = @hid_report_out End Select Case 3: // Feature report // Find out which report ID was specified. // The report ID is in the low byte (LSB) of the Value field. // This example supports Report ID 0. Select SetupPkt.W_Value.Byte0 Case 0: // Report ID 0 // HID will handle the request. ctrl_trf_session_owner = MUID_HID // Save the report type and report ID in out_report_status. //out_report_status = SetOutReportStatus // (MSB(SetupPkt.W_Value), // LSB(SetupPkt.W_Value)); // When the report arrives in the data stage, the data will be // stored in hid_report_feature (defined in usbmmap.c). pDst.bRam = @hid_report_feature End Select End Select End Sub { **************************************************************************** * Name : USBCheckHIDRequest * * Purpose : This routine checks the setup data packet to see if it knows * * : how to handle it * **************************************************************************** } // variables - used in USBCheckHIDRequest 'hid.c Dim idle_rate As Byte Dim active_protocol As Byte // [0] Boot Protocol [1] Report Protocol Sub USBCheckHIDRequest() 'hid.c // The packet must be directed to an interface with the same ID as the // device's HID interface. If GetRecipient <> RCPT_INTF Then Exit EndIf If SetupPkt.bIntfID <> HID_INTF_ID Then Exit EndIf // There are two standard requests that hid.c may support. // 1. GET_DSC(DSC_HID,DSC_RPT,DSC_PHY); // 2. SET_DSC(DSC_HID,DSC_RPT,DSC_PHY); If SetupPkt.bRequest = GET_DSC Then // Request for a descriptor. Select SetupPkt.bDscType // HID descriptor. Case DSC_HID: ctrl_trf_session_owner = MUID_HID mUSBGetHIDDscAdr() // See usbcfg.h wCount = SizeOf(USB_HID_DSC) // Report descriptor. Case DSC_RPT: ctrl_trf_session_owner = MUID_HID mUSBGetHIDRptDscAdr() // See usbcfg.h mUSBGetHIDRptDscSize() // See usbcfg.h // Physical descriptor. Case DSC_PHY: // ctrl_trf_session_owner = MUID_HID End Select usb_stat.ctrl_trf_mem = _ROM EndIf If GetRequestType <> CLASS Then Exit EndIf // HID-specific requests. Select SetupPkt.bRequest // required for all HID tranfers Case GET_REPORT: HIDGetReportHandler() // optional - needed for control transfers only Case SET_REPORT: HIDSetReportHandler() // optional Case GET_IDLE: ctrl_trf_session_owner = MUID_HID pSrc.bRam = @idle_rate // Set source usb_stat.ctrl_trf_mem = _RAM // Set memory type wCount.Byte0 = 1 // Set data count // optional - except for keyboards using the boot protocol Case SET_IDLE: ctrl_trf_session_owner = MUID_HID idle_rate = SetupPkt.W_Value.Byte1 // required for HIDs that support the boot protocol Case GET_PROTOCOL: ctrl_trf_session_owner = MUID_HID pSrc.bRam = @active_protocol // Set source usb_stat.ctrl_trf_mem = _RAM // Set memory type wCount.Byte0 = 1 // Set data count // required for HIDs that support the boot protocol Case SET_PROTOCOL: ctrl_trf_session_owner = MUID_HID active_protocol = SetupPkt.W_Value.Byte0 End Select End Sub { **************************************************************************** * Name : HIDInitEP * * Purpose : HIDInitEP initializes HID endpoints, buffer descriptors, * * : internal state-machine, and variables. It should be called * * : after the USB host has sent OUT a SET_CONFIGURATION request. * **************************************************************************** } Sub HIDInitEP() 'hid.c hid_rpt_rx_len =0 HID_UEP = EP_OUT_IN Or HSHK_EN // Enable 2 data pipes HID_BD_OUT.Cnt = SizeOf(hid_report_out) // Set buffer size HID_BD_OUT.ADR = @hid_report_out // Set buffer address HID_BD_OUT.Stat._byte = _USIE Or _DAT0 Or _DTSEN // Set status (* Do not have to init Cnt of IN pipes here. Reason: Number of bytes to send to the host varies from one transaction to another. Cnt should equal the exact number of bytes to transmit for a given IN transaction. This number of bytes will only be known right before the data is sent. *) HID_BD_IN.ADR = @hid_report_in // Set buffer address HID_BD_IN.Stat._byte = _UCPU Or _DAT1 // Set status End Sub { **************************************************************************** * Name : HIDTxReport * * Require : mHIDTxIsBusy() must return false. Value of 'len' must be equal * * : to or smaller than HID_INT_IN_EP_SIZE for an interrupt * * : endpoint, the largest buffer size is 64 bytes. * * Input: : buffer : POINTER to the starting location of data bytes * * : len : Number of bytes to be transferred * * Purpose : Use this macro to transfer data located in data memory. * * : NOTE : mHIDTxIsBusy() must return false before user can call * * : this function. Unexpected behavior will occur if this function * * : when mHIDTxIsBusy * **************************************************************************** } Public Sub HIDTxReport(Buffer As FSR1, len As Byte) 'hid.c Dim i As Byte If len > HID_INT_IN_EP_SIZE Then len = HID_INT_IN_EP_SIZE EndIf // Copy data from user's buffer to dual-ram buffer FSR0 = @hid_report_in i = 0 While i < len POSTINC0 = POSTINC1 Inc(i) Wend HID_BD_IN.Cnt = len mUSBBufferReady(HID_BD_IN) End Sub { **************************************************************************** * Name : HIDRxReport * * Require : Value of input argument 'len' should be smaller than the * * : maximum endpoint size responsible for receiving report data * * : from USB host for HID CLASS. Input argument 'buffer' should * * : point to a buffer area that is bigger or equal to the size * * : specified by 'len'. * * Input : buffer : POINTER to where received bytes are to be stored * * : len : The number of bytes expected. * * Output : The number of bytes copied to buffer. Publicly accessible * * : variable hid_rpt_rx_len is updated with the number of bytes * * : copied to buffer. Once HIDRxReport is called, subsequent * * : retrieval of hid_rpt_rx_len can be done by calling macro * * : mHIDGetRptRxLength(). * * Purpose:: HIDRxReport copies a string of bytes received through * * : USB HID OUT endpoint to a user's specified location. It is a * * : non-blocking function. It does not wait for data if there is * * : no data available. Instead it returns '0' to notify the * * : caller that there is no data available. If the actual number * * : of bytes received is larger than the number of bytes expected * * : (len), only the expected number of bytes specified will be * * : copied to buffer. If the actual number of bytes received is * * : smaller than the number of bytes expected (len), only the * * : actual number of bytes received will be copied to buffer. * **************************************************************************** } Public Function HIDRxReport(Buffer As FSR0, len As Byte) As Byte 'hid.c hid_rpt_rx_len = 0 If mHIDRxIsBusy = 0 Then // Adjust the expected number of bytes to equal // the actual number of bytes received. If len > HID_BD_OUT.Cnt Then len = HID_BD_OUT.Cnt EndIf // Copy data from dual-ram buffer to user's buffer FSR1 = @hid_report_out hid_rpt_rx_len = 0 While hid_rpt_rx_len < len POSTINC0 = POSTINC1 Inc(hid_rpt_rx_len) Wend // Prepare dual-ram buffer for next OUT transaction HID_BD_OUT.Cnt = SizeOf(hid_report_out) mUSBBufferReady(HID_BD_OUT) EndIf result = hid_rpt_rx_len End Function #endif // USB_USE_HID // ========================== END HID CLASS ========================== // ============================ CDC CLASS ============================ #if USB_USE_CDC Dim 'cdc.c cdc_trf_state As Byte, // States are defined cdc.h pCDCSrc As POINTER, // Dedicated source pointer pCDCDst As POINTER, // Dedicated destination pointer cdc_tx_len As Word, // total tx length cdc_mem_type As Byte, // _ROM, _RAM line_coding As CDC_LINE_CODING, // Buffer to store line coding information control_signal_bitmap As CDC_CONTROL_SIGNAL_BITMAP // make public for CDC module... Public Dim CDCControlSignal As control_signal_bitmap, CDCDataRX As cdc_data_rx, CDCDataTX As cdc_data_tx, CDCRXBytesAvailable As CDC_BULK_BD_OUT.Cnt // SEND_ENCAPSULATED_COMMAND and GET_ENCAPSULATED_RESPONSE are required // requests according to the CDC specification. // However, it is not really being used here, therefore a dummy buffer is // used for conformance. Const dummy_length = $08 Dim dummy_encapsulated_cmd_response(dummy_length) As Byte { **************************************************************************** * Name : mUSBUSARTIsTxTrfReady * * Purpose : This macro is used to check if the CDC CLASS is ready to send * * : more data. * **************************************************************************** } Public Function mUSBUSARTIsTxTrfReady() As Boolean 'cdc.h result = (cdc_trf_state = CDC_TX_READY) End Function { **************************************************************************** * Name : mCDCUsartRxIsBusy * * Purpose : This macro is used to check if CDC bulk OUT endpoint is busy * * : (owned by SIE) or not. * **************************************************************************** } Public Dim mCDCUsartRxIsBusy As CDC_BULK_BD_OUT.Stat.UOWN 'cdc.h { **************************************************************************** * Name : mCDCUsartTxIsBusy * * Purpose : This macro is used to check if CDC bulk IN endpoint is busy * * : (owned by SIE) or not. * **************************************************************************** } Public Dim mCDCUsartTxIsBusy As CDC_BULK_BD_IN.Stat.UOWN 'cdc.h { **************************************************************************** * Name : mUSBUSARTTxRam * * Require : cdc_trf_state must be IN the CDC_TX_READY state. * * Purpose : Use this macro to transfer data located IN data memory. Use * * : this macro when: * * : 1. Data stream is not null-terminated * * : 2. Transfer length is known * * : Remember: cdc_trf_state must == CDC_TX_READY. The actual * * : transfer is handled by CDCTxService(). * **************************************************************************** } Public Sub mUSBUSARTTxRam(pData As Word,len As Word) 'cdc.h pCDCSrc.bRam = pData cdc_tx_len = len cdc_mem_type = _RAM cdc_trf_state = CDC_TX_BUSY End Sub { **************************************************************************** * Name : mUSBUSARTTxRom * * Require : cdc_trf_state must be IN the CDC_TX_READY state. * * Purpose : Use this macro to transfer data located IN data memory. Use * * : this macro when: * * : 1. Data stream is not null-terminated * * : 2. Transfer length is known * * : Remember: cdc_trf_state must == CDC_TX_READY. The actual * * : transfer is handled by CDCTxService(). * **************************************************************************** } Public Sub mUSBUSARTTxRom(pData As Word,len As Word) 'cdc.h pCDCSrc.bRom = pData cdc_tx_len = len cdc_mem_type = _ROM cdc_trf_state = CDC_TX_BUSY End Sub { **************************************************************************** * Name : USBCheckCDCRequest * * Purpose : This routine checks the setup data packet to see if it knows * * : how to use it * **************************************************************************** } Sub USBCheckCDCRequest() 'cdc.c // If request recipient is not an interface then return If GetRecipient <> RCPT_INTF Then Exit EndIf // If request type is not class-specific then return If GetRequestType <> CLASS Then Exit EndIf // Interface ID must match interface numbers associated with // CDC class, else return If (SetupPkt.bIntfID <> CDC_COMM_INTF_ID) And (SetupPkt.bIntfID <> CDC_DATA_INTF_ID) Then Exit EndIf Select SetupPkt.bRequest Case SEND_ENCAPSULATED_COMMAND: ctrl_trf_session_owner = MUID_CDC pSrc.bRam = @dummy_encapsulated_cmd_response usb_stat.ctrl_trf_mem = _RAM wCount.Byte0 = dummy_length Case GET_ENCAPSULATED_RESPONSE: ctrl_trf_session_owner = MUID_CDC // Populate dummy_encapsulated_cmd_response first. pDst.bRam = @dummy_encapsulated_cmd_response ' case SET_COMM_FEATURE: // Optional ' case GET_COMM_FEATURE: // Optional ' case CLEAR_COMM_FEATURE: // Optional Case SET_LINE_CODING: ctrl_trf_session_owner = MUID_CDC pDst.bRam = @LINE_CODING // Set destination Case GET_LINE_CODING: ctrl_trf_session_owner = MUID_CDC pSrc.bRam = @LINE_CODING // Set source usb_stat.ctrl_trf_mem = _RAM // Set memory type wCount.Byte0 = LINE_CODING_LENGTH // Set data count Case SET_CONTROL_LINE_STATE: ctrl_trf_session_owner = MUID_CDC control_signal_bitmap._byte = SetupPkt.W_Value.Byte0 ' case SEND_BREAK: // Optional End Select End Sub { **************************************************************************** * Name : CDCInitEP * * Purpose : CDCInitEP initializes CDC endpoints, buffer descriptors, * * : internal state-machine, and variables. It should be called * * : after the USB host has sent OUT a SET_CONFIGURATION request. * **************************************************************************** } Sub CDCInitEP() 'cdc.c // abstract line coding information LINE_CODING.dwDTERate = 115200 // baud rate LINE_CODING.bCharFormat = $00 // 1 stop bit LINE_CODING.bParityType = $00 // None LINE_CODING.bDataBits = $08 // 5,6,7,8, or 16 cdc_trf_state = CDC_TX_READY CDC_COMM_UEP = EP_IN Or HSHK_EN // Enable 1 Comm pipe CDC_DATA_UEP = EP_OUT_IN Or HSHK_EN // Enable 2 data pipes (* Do not have to init Cnt of IN pipes here. Reason: Number of bytes to send to the host varies from one transaction to another. Cnt should equal the exact number of bytes to transmit for a given IN transaction. This number of bytes will only be known right before the data is sent. *) CDC_INT_BD_IN.ADR = @cdc_notice // Set buffer address CDC_INT_BD_IN.Stat._byte = _UCPU Or _DAT1 // Set status CDC_BULK_BD_OUT.Cnt = SizeOf(cdc_data_rx) // Set buffer size CDC_BULK_BD_OUT.ADR = @cdc_data_rx // Set buffer address CDC_BULK_BD_OUT.Stat._byte = _USIE Or _DAT0 Or _DTSEN // Set status CDC_BULK_BD_IN.ADR = @cdc_data_tx // Set buffer address CDC_BULK_BD_IN.Stat._byte = _UCPU Or _DAT1 // Set status End Sub { **************************************************************************** * Name : CDCRXPrepareForNext * * Purpose : Prepare for next CDC transmission * **************************************************************************** } Public Sub CDCRXPrepareForNext() CDC_BULK_BD_OUT.Cnt = SizeOf(cdc_data_rx) mUSBBufferReady(CDC_BULK_BD_OUT) End Sub { **************************************************************************** * Name : CDCTxService * * Purpose : CDCTxService handles device-to-host transaction(s). This * * : function should be called once per Main program loop. * **************************************************************************** } Public Sub CDCTxService() 'cdc.c Dim byte_to_send As Byte If mCDCUsartTxIsBusy <> 0 Then Exit EndIf // Completing stage is necessary while [ mCDCUSartTxIsBusy()==1 ]. // By having this stage, user can always check cdc_trf_state, // and not having to call mCDCUsartTxIsBusy() directly. If cdc_trf_state = CDC_TX_COMPLETING Then cdc_trf_state = CDC_TX_READY EndIf // If CDC_TX_READY state, nothing to do, just return. If cdc_trf_state = CDC_TX_READY Then Exit EndIf // If CDC_TX_BUSY_ZLP state, send zero length packet If cdc_trf_state = CDC_TX_BUSY_ZLP Then CDC_BULK_BD_IN.Cnt = 0 cdc_trf_state = CDC_TX_COMPLETING Else If cdc_trf_state = CDC_TX_BUSY Then // First, have to figure out how many byte of data to send. If cdc_tx_len > SizeOf(cdc_data_tx) Then byte_to_send = SizeOf(cdc_data_tx) Else byte_to_send = cdc_tx_len EndIf // Next, load the number of bytes to send to Cnt in buffer descriptor CDC_BULK_BD_IN.Cnt = byte_to_send // Subtract the number of bytes just about to be sent from the total. cdc_tx_len = cdc_tx_len - byte_to_send pCDCDst.bRam = @cdc_data_tx // Set destination pointer If cdc_mem_type = _ROM Then // Determine type of memory source TABLEPTR = pCDCSrc.bRom FSR0 = pCDCDst.bRam Inc(pCDCDst.bRam, byte_to_send) Inc(pCDCSrc.bRam, byte_to_send) While byte_to_send > 0 POSTINC0 = ReadROM Dec(byte_to_send) Wend (* while byte_to_send > 0 SetRAMPtr(pCDCDst.bRam,GetROMPtr(pCDCSrc.bRom)) inc(pCDCDst.bRam) inc(pCDCSrc.bRom) dec(byte_to_send) wend *) Else // _RAM - optimised... FSR0 = pCDCDst.bRam FSR1 = pCDCSrc.bRam Inc(pCDCDst.bRam, byte_to_send) Inc(pCDCSrc.bRam, byte_to_send) While byte_to_send > 0 POSTINC0 = POSTINC1 Dec(byte_to_send) Wend EndIf // Lastly, determine if a zero length packet state is necessary. // See explanation in USB Specification 2.0: Section 5.8.3 If cdc_tx_len = 0 Then If CDC_BULK_BD_IN.Cnt = SizeOf(cdc_data_tx) Then cdc_trf_state = CDC_TX_BUSY_ZLP Else cdc_trf_state = CDC_TX_COMPLETING EndIf EndIf EndIf EndIf // Both CDC_TX_BUSY and CDC_TX_BUSY_ZLP states use the following macro mUSBBufferReady(CDC_BULK_BD_IN) End Sub (* ========================== END CDC CLASS ========================== *) #endif //USB_USE_CDC { **************************************************************************** * Name : USBStdGetDscHandler * * Purpose : This routine handles the STANDARD GET_DESCRIPTOR request. It * * : utilizes tables dynamically looks up descriptor size. This * * : routine should never have to be modified if the tables in * * : usbdsc.c are declared correctly. * **************************************************************************** } Sub USBStdGetDscHandler() 'usb9.c If SetupPkt.bmRequestType = $80 Then Select SetupPkt.bDscType Case DSC_DEV: ctrl_trf_session_owner = MUID_USB9 pSrc.bRom = @device_dsc // djb USB_DD_Ptr // @device_dsc wCount = SizeOf(device_dsc) // djb USB_DD_Size // sizeof(device_dsc) Case DSC_CFG: ctrl_trf_session_owner = MUID_USB9 pSrc.bRom = USB_CD_Ptr(SetupPkt.bDscIndex) wCount = GetROMPtr(pSrc.wRom + 2) // Set data count Case DSC_STR: ctrl_trf_session_owner = MUID_USB9 // ensure we have a valid string index - version 1.2... If SetupPkt.bDscIndex > Bound(USB_SD_Ptr) Then wCount = 0 Else pSrc.bRom = USB_SD_Ptr(SetupPkt.bDscIndex) wCount = GetROMPtr(pSrc.bRom) // Set data count EndIf End Select usb_stat.ctrl_trf_mem = _ROM // Set memory type EndIf End Sub { **************************************************************************** * Name : USBStdSetCfgHandler * * Purpose : This routine first disables all endpoints by clearing UEP * * : registers. It then configures (initializes) endpoints specified* * : in the modifiable section. * **************************************************************************** } Sub USBStdSetCfgHandler() 'usb9.c ctrl_trf_session_owner = MUID_USB9 mDisableEP1to15() Clear(usb_alt_intf) usb_active_cfg = SetupPkt.bCfgValue If SetupPkt.bCfgValue = 0 Then usb_device_state = ADDRESS_STATE Else usb_device_state = CONFIGURED_STATE // Modifiable Section #if USB_USE_HID HIDInitEP() #endif #if USB_USE_CDC CDCInitEP() #endif // End modifiable section EndIf End Sub { **************************************************************************** * Name : USBStdGetStatusHandler * * Purpose : This routine handles the STANDARD GET_STATUS request * **************************************************************************** } Sub USBStdGetStatusHandler() 'usb9.c CtrlTrfData._byte0 = 0 // Initialize content CtrlTrfData._byte1 = 0 Select GetRecipient Case RCPT_DEV: ctrl_trf_session_owner = MUID_USB9 // _byte0: bit0: Self-Powered Status [0] Bus-Powered [1] Self-Powered // bit1: RemoteWakeup [0] Disabled [1] Enabled If self_power = 1 Then // self_power defined in io_cfg.h CtrlTrfData._byte0 = CtrlTrfData._byte0 Or %000000001 // Set bit0 If usb_stat.RemoteWakeup = 1 Then // usb_stat defined in usbmmap.c CtrlTrfData._byte0 = CtrlTrfData._byte0 Or $00000010 // Set bit1 EndIf EndIf Case RCPT_INTF: ctrl_trf_session_owner = MUID_USB9 // No data to update Case RCPT_EP: ctrl_trf_session_owner = MUID_USB9 // _byte0: bit0: Halt Status [0] Not Halted [1] Halted pDst.bRam = @ep0Bo + (GetEPNum * 8) + (SetupPkt.EPDir * 4) If (GetRAMPtr(pDst.bRam) And _BSTALL) <> 0 Then // Use _BSTALL as a bit mask CtrlTrfData._byte0 = $01// Set bit0 EndIf End Select If ctrl_trf_session_owner = MUID_USB9 Then pSrc.bRam = @CtrlTrfData // Set Source usb_stat.ctrl_trf_mem = _RAM // Set memory type wCount.Byte0 = 2 // Set data count EndIf End Sub { **************************************************************************** * Name : USBStdFeatureReqHandler * * Purpose : This routine handles the STANDARD SET & clear FEATURES requests* **************************************************************************** } Sub USBStdFeatureReqHandler() 'usb9.c If (SetupPkt.bFeature = DEVICE_REMOTE_WAKEUP) And (GetRecipient = RCPT_DEV) Then ctrl_trf_session_owner = MUID_USB9 If SetupPkt.bRequest = SET_FEATURE Then usb_stat.RemoteWakeup = 1 Else usb_stat.RemoteWakeup = 0 EndIf EndIf If (SetupPkt.bFeature = ENDPOINT_HALT) And (GetRecipient = RCPT_EP) And (GetEPNum <> 0) Then ctrl_trf_session_owner = MUID_USB9 // Must do address calculation here pDst.bRam = @ep0Bo + (GetEPNum * 8) + (SetupPkt.EPDir * 4) If SetupPkt.bRequest = SET_FEATURE Then SetRAMPtr(pDst.bRam, _USIE Or _BSTALL) Else If SetupPkt.EPDir = 1 Then// IN SetRAMPtr(pDst.bRam, _UCPU) Else SetRAMPtr(pDst.bRam, _USIE Or _DAT0 Or _DTSEN) EndIf EndIf EndIf End Sub { **************************************************************************** * Name : USBCheckStdRequest * * Purpose : This routine checks the setup data packet to see if it knows * * : how to handle it * **************************************************************************** } Sub USBCheckStdRequest() 'usb9.c If GetRequestType <> STANDARD Then Exit EndIf Select SetupPkt.bRequest Case SET_ADR: ctrl_trf_session_owner = MUID_USB9 usb_device_state = ADR_PENDING_STATE // Update state only // See USBCtrlTrfInHandler() in usbctrltrf.c for the next step Case GET_DSC: USBStdGetDscHandler() Case SET_CFG: USBStdSetCfgHandler() Case GET_CFG: ctrl_trf_session_owner = MUID_USB9 pSrc.bRam = @usb_active_cfg // Set Source usb_stat.ctrl_trf_mem = _RAM // Set memory type wCount.Byte0 = 1 // Set data count Case GET_STATUS: USBStdGetStatusHandler() Case CLR_FEATURE: USBStdFeatureReqHandler() Case CLR_FEATURE USBStdFeatureReqHandler() Case GET_INTF: ctrl_trf_session_owner = MUID_USB9 pSrc.bRam = @usb_alt_intf + SetupPkt.bIntfID // Set source usb_stat.ctrl_trf_mem = _RAM // Set memory type wCount.Byte0 = 1 // Set data count Case SET_INTF: ctrl_trf_session_owner = MUID_USB9 usb_alt_intf(SetupPkt.bIntfID) = SetupPkt.bAltID Case SET_DSC: Case SYNCH_FRAME: End Select End Sub { **************************************************************************** * Name : USBCtrlTrfTxService * * Require : pSrc, wCount, and usb_stat.ctrl_trf_mem are setup properly. * * Purpose : This routine should be called from only two places. One from * * : USBCtrlEPServiceComplete() and one from USBCtrlTrfInHandler(). * * : It takes care of managing a transfer over multiple USB * * : transactions. This routine works with isochronous endpoint * * : larger than 256 bytes and is shown here as an example of how to* * : deal with BC9 and BC8. IN reality, a control endpoint can never* * : be larger than 64 bytes. * **************************************************************************** } Sub USBCtrlTrfTxService() 'usbctrltr.c // This code executes in the Data stage of a Control Read transfer. Dim byte_to_send As Word // First, have to figure out how many byte of data to send. If wCount < EP0BufferSize Then byte_to_send = wCount Else byte_to_send = EP0BufferSize EndIf // Next, load the number of bytes to send to BC9..0 in buffer descriptor ep0Bi.Stat.BC9 = 0 ep0Bi.Stat.BC8 = 0 ep0Bi.Stat._byte = ep0Bi.Stat._byte Or byte_to_send.Byte1 ep0Bi.Cnt = byte_to_send.Byte0 // Subtract the number of bytes just about to be sent from the total. wCount = wCount - byte_to_send pDst.bRam = @CtrlTrfData // Set destination pointer If usb_stat.ctrl_trf_mem = _ROM Then // Determine type of memory source TABLEPTR = pSrc.bRom FSR0 = pDst.bRam Inc(pSrc.bRom,byte_to_send) While byte_to_send > 0 POSTINC0 = ReadROM Dec(byte_to_send) Wend Else // RAM FSR1 = pSrc.bRam FSR0 = pDst.bRam Inc(pSrc.bRam,byte_to_send) While byte_to_send > 0 POSTINC0 = POSTINC1 Dec(byte_to_send) Wend EndIf End Sub { **************************************************************************** * Name : USBCtrlEPServiceComplete * * Purpose : This routine wrap up the ramaining tasks IN servicing a Setup * * : Request. Its main task is to set the endpoint controls * * : appropriately for a given situation. See code below. * * : There are three main scenarios: * * : a) There was no handler for the Request, IN this case a STALL* * : should be sent OUT. * * : b) The host has requested a read control transfer, endpoints * * : are required to be setup IN a specific way. * * : c) The host has requested a write control transfer, or a * * : control data stage is not required, endpoints are required* * : to be setup IN a specific way. * * : Packet processing is resumed by clearing PKTDIS bit. * **************************************************************************** } Sub USBCtrlEPServiceComplete() 'usbctrltr.c // PKTDIS bit is set when a Setup Transaction is received. // Clear before modifying ep0Bi.Stat or ep0Bo.Stat. UCONBits.PKTDIS = 0 If ctrl_trf_session_owner = MUID_NULL Then // If no one knows how to service this request then stall. // Must also prepare EP0 to receive the next SETUP transaction. ep0Bo.Cnt = EP0BufferSize ep0Bo.ADR = @SetupPkt ep0Bo.Stat._byte = _USIE Or _BSTALL ep0Bi.Stat._byte = _USIE Or _BSTALL // A module has claimed ownership of the control transfer session. Else If SetupPkt.DataDir = DEV_TO_HOST Then If SetupPkt.wLength < wCount Then wCount = SetupPkt.wLength EndIf USBCtrlTrfTxService() ctrl_trf_state = CTRL_TRF_TX // Control Read: // <SETUP[0]><IN[1]><IN[0]>...<OUT[1]> | <SETUP[0]> // 1. Prepare OUT EP to respond to early termination // NOTE: // If something went wrong during the control transfer, // the last status stage may not be sent by the host. // When this happens, two different things could happen // depending on the host. // a) The host could send out a RESET. // b) The host could send out a new SETUP transaction // without sending a RESET first. // To properly handle case (b), the OUT EP must be setup // to receive either a zero length OUT transaction, or a // new SETUP transaction. // Since the SETUP transaction requires the DTS bit to be // DAT0 while the zero length OUT status requires the DTS // bit to be DAT1, the DTS bit check by the hardware should // be disabled. This way the SIE could accept either of // the two transactions. // Furthermore, the Cnt byte should be set to prepare for // the SETUP data (8-byte or more), and the buffer address // should be pointed to SetupPkt. ep0Bo.Cnt = EP0BufferSize ep0Bo.ADR = @SetupPkt ep0Bo.Stat._byte = _USIE // Note: DTSEN is 0! // 2. Prepare IN EP to transfer data, Cnt should have // been initialized by responsible request owner. ep0Bi.ADR = @CtrlTrfData ep0Bi.Stat._byte = _USIE Or _DAT1 Or _DTSEN // (SetupPkt.DataDir == HOST_TO_DEV) Else ctrl_trf_state = CTRL_TRF_RX // Control Write: // <SETUP[0]><OUT[1]><OUT[0]>...<IN[1]> | <SETUP[0]> // 1. Prepare IN EP to respond to early termination // This is the same as a Zero Length Packet Response // for control transfer without a data stage ep0Bi.Cnt = 0 ep0Bi.Stat._byte = _USIE Or _DAT1 Or _DTSEN // Prepare OUT EP to receive data. ep0Bo.Cnt = EP0BufferSize ep0Bo.ADR = @CtrlTrfData ep0Bo.Stat._byte = _USIE Or _DAT1 Or _DTSEN EndIf EndIf End Sub { **************************************************************************** * Name : USBCtrlTrfSetupHandler * * Require : SetupPkt buffer is loaded with valid USB Setup Data * * Purpose : This routine is a task dispatcher and has 3 stages. * * : 1. It initializes the control transfer state machine. * * : 2. It calls on each of the module that may know how to * * : service the Setup Request from the host. * * : module Example: USB9, HID, CDC, MSD, ... * * : as new classes are added, ClassReqHandler table IN * * : usbdsc.c should be updated to call all available * * : CLASS handlers. * * : 3. Once each of the modules has had a chance to check if * * : it is responsible for servicing the request, stage 3 * * : then checks direction of the transfer to determine how * * : to prepare EP0 for the control transfer. * * : Refer to USBCtrlEPServiceComplete() for more details. * * Note : Microchip USB Firmware has three different states for the * * : control transfer state machine: * * : 1. WAIT_SETUP * * : 2. CTRL_TRF_TX * * : 3. CTRL_TRF_RX * * : A Control Transfer is composed of many USB transactions. When * * : transferring data over multiple transactions, it is important * * : to keep track of data source, data destination, and data count * * : These three parameters are stored IN pSrc,pDst, and wCount. A * * : flag is used to note if the data source is from ROM or RAM. * **************************************************************************** } Sub USBCtrlTrfSetupHandler() 'usbctrltr.c // Stage 1 ctrl_trf_state = WAIT_SETUP ctrl_trf_session_owner = MUID_NULL // Set owner to NULL wCount = 0 // Stage 2 */ USBCheckStdRequest() // See system\usb9\usb9.c // Modifiable Section #if USB_USE_HID USBCheckHIDRequest #endif #if USB_USE_CDC USBCheckCDCRequest #endif // End Modifiable Section // Stage 3 USBCtrlEPServiceComplete() End Sub { **************************************************************************** * Name : USBCtrlTrfRxService * * Require : pDst and wCount are setup properly. pSrc is always &CtrlTrfData* * : usb_stat.ctrl_trf_mem is always _RAM. wCount should be set to * * : 0 at the start of each control transfer. * * Purpose : This routine is only partially complete. Check for new version * * : of the firmware. * **************************************************************************** } Sub USBCtrlTrfRxService() 'usbctrltr.c // This code executes in the Data stage of a Control Write transfer. Dim byte_to_read As Word byte_to_read.Byte1 = $03 And ep0Bo.Stat._byte // Filter out last 2 bits byte_to_read.Byte0 = ep0Bo.Cnt // Accumulate total number of bytes read wCount = wCount + byte_to_read pSrc.bRam = @CtrlTrfData While byte_to_read > 0 SetRAMPtr(pDst.bRam,GetRAMPtr(pSrc.bRam)) Inc(pDst.bRam) Inc(pSrc.bRam) Dec(byte_to_read) Wend End Sub { **************************************************************************** * Name : USBPrepareForNextSetupTrf * * Purpose : The routine forces EP0 OUT to be ready for a new Setup * * : transaction, and forces EP0 IN to be owned by CPU. * **************************************************************************** } Sub USBPrepareForNextSetupTrf() 'usbctrltr.c ctrl_trf_state = WAIT_SETUP // See usbctrltrf.h ep0Bo.Cnt = EP0BufferSize // Defined in usbcfg.h ep0Bo.ADR = @SetupPkt ep0Bo.Stat._byte = _USIE Or _DAT0 Or _DTSEN // EP0 buff dsc init, see usbmmap.h ep0Bi.Stat._byte = _UCPU // EP0 IN buffer initialization End Sub { **************************************************************************** * Name : USBCtrlTrfOutHandler * * Purpose : This routine handles an OUT transaction according to which * * : control transfer state is currently active. Note that if the * * : the control transfer was from host to device, the session owner* * : should be notified at the end of each OUT transaction to * * : service the received data. * **************************************************************************** } Sub USBCtrlTrfOutHandler() 'usbctrltr.c // Direction of data packet: host to device. If ctrl_trf_state = CTRL_TRF_RX Then // It's the Data stage of a Control Write transfer. USBCtrlTrfRxService() // for control transfers only ' if ctrl_trf_session_owner = MUID_HID then ' // The only HID-class request with a host-to-device Data stage ' // is Set_Report. ' HandleControlOutReport() ' endif // Don't have to worry about overwriting _KEEP bit // because if _KEEP was set, TRNIF would not have been // generated in the first place. If ep0Bo.Stat.DTS = 0 Then ep0Bo.Stat._byte = _USIE Or _DAT1 Or _DTSEN Else ep0Bo.Stat._byte = _USIE Or _DAT0 Or _DTSEN EndIf Else // It's the Status stage of a Control Read transfer. USBPrepareForNextSetupTrf() EndIf End Sub { **************************************************************************** * Name : USBCtrlTrfInHandler * * Purpose : This routine handles an IN transaction according to which * * : control transfer state is currently active. A Set Address * * : Request must not change the acutal address of the device until * * : the completion of the control transfer. The end of the control * * : transfer for Set Address. Request is an in transaction. * * : Therefore it is necessary to service this unique situation when* * : the condition is right. Macro mUSBCheckAdrPendingState is * * : defined in usb9.h and its function is to specifically service * * : this event. * **************************************************************************** } Sub USBCtrlTrfInHandler() 'usbctrltr.c // Direction of data packet: device to host. mUSBCheckAdrPendingState() // Must check if in ADR_PENDING_STATE If ctrl_trf_state = CTRL_TRF_TX Then // It's the Data stage of a Control Read transfer. USBCtrlTrfTxService() If ep0Bi.Stat.DTS = 0 Then ep0Bi.Stat._byte = _USIE Or _DAT1 Or _DTSEN Else ep0Bi.Stat._byte = _USIE Or _DAT0 Or _DTSEN EndIf Else // CTRL_TRF_RX // It's the Status stage of a Control Write transfer. USBPrepareForNextSetupTrf() EndIf End Sub { **************************************************************************** * Name : USBCtrlEPService * * Require : USTAT is loaded with a valid endpoint address * * Purpose : USBCtrlEPService checks for three transaction types that it * * : knows how to service and services them. * * : 1. EP0 SETUP * * : 2. EP0 OUT * * : 3. EP0 IN * * : It ignores all other types (i.e. EP1, EP2, etc.) * **************************************************************************** } Sub USBCtrlEPService() 'usbctrltr.c If USTAT = EP00_OUT Then If GetPID = SETUP_TOKEN Then // EP0 SETUP USBCtrlTrfSetupHandler() Else // EP0 OUT USBCtrlTrfOutHandler() EndIf ElseIf USTAT = EP00_IN Then // EP0 IN USBCtrlTrfInHandler() EndIf End Sub { **************************************************************************** * Name : USBModuleEnable * * Purpose : 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(). * **************************************************************************** } Sub USBModuleEnable() 'usbdrv.c 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 Sub { **************************************************************************** * Name : USBModuleDisable * * Purpose : 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(). * **************************************************************************** } Sub USBModuleDisable() 'usbdrv.c UCON = 0 // Disable module & detach from bus UIE = 0 // Mask all USB interrupts usb_device_state = DETACHED_STATE // Defined in usbmmap.c & .h End Sub { **************************************************************************** * Name : USBCheckBusStatus * * Purpose : This routine enables/disables the USB module by monitoring the * * : USB power signal. * **************************************************************************** } Public Sub USBCheckBusStatus() 'usbdrv.c // Bus Attachment & Detachment Detection // usb_bus_sense is an i/o pin defined in io_cfg.h Const USB_BUS_ATTACHED = 1, USB_BUS_DETACHED = 0 If usb_bus_sense = USB_BUS_ATTACHED Then // Is USB bus attached? If UCONBits.USBEN = 0 Then // Is the module off? USBModuleEnable() // Is off, enable it EndIf Else If UCONBits.USBEN = 1 Then // Is the module on? USBModuleDisable() // Is on, disable it EndIf EndIf // 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 Then If UCONBits.SE0 = 0 Then 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 EndIf // else wait until SE0 is cleared EndIf End Sub { **************************************************************************** * Name : USBSoftDetach * * Purpose : The device will have to be re-enumerated to function again * * : 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. * **************************************************************************** } Sub USBSoftDetach() 'usbdrv.c USBModuleDisable() End Sub { **************************************************************************** * Name : USBWakeFromSuspend * * Purpose : * **************************************************************************** } Sub USBWakeFromSuspend() 'usbdrv.c // If using clock switching, this is the place to restore the // original clock frequency. UCONBits.SUSPND = 0 UIEBits.ACTVIE = 0 UIRBits.ACTVIF = 0 End Sub { **************************************************************************** * Name : USBProtocolResetHandler * * Require : A USB bus reset is received from the host * * Purpose : Currently, this routine flushes any pending USB transactions. * * : It empties OUT the USTAT FIFO. This action might not be * * : desirable in some applications. * * : 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. * **************************************************************************** } Sub USBProtocolResetHandler() 'usbdrv.bas UEIR = 0 // Clear all USB error flags UIR = 0 // Clears all USB interrupts UEIE = %10011111 // Unmask all USB error interrupts UIE = %01111011 // Enable all interrupts except ACTVIE UADDR = $00 // Reset to default address mDisableEP1to15() // Reset all non-EP0 UEPn registers UEP0 = EP_CTRL Or HSHK_EN // Init EP0 as a Ctrl EP, see usbdrv.h While UIRBits.TRNIF = 1 // Flush any pending transactions UIRBits.TRNIF = 0 Wend 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 Sub { **************************************************************************** * Name : USBRemoteWakeup * * Purpose : 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. * * : 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. * * : ========================================================== * * : 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 * **************************************************************************** } Sub USBRemoteWakeup() 'usbdrv.c If usb_stat.RemoteWakeup = 1 Then // Check if RemoteWakeup function // has been enabled by the host. USBWakeFromSuspend() // Unsuspend USB modue UCONBits.RESUME = 1 // Start RESUME signaling // Modifiable Section // Set RESUME line for 1-13 ms // End Modifiable Section UCONBits.RESUME = 0 EndIf End Sub { **************************************************************************** * Name : USBSuspend * * Purpose : * **************************************************************************** } Sub USBSuspend() 'usbdrv.c // 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 ' INTCONBits.RBIF = 0 ' PIE2Bits.USBIE = 1 // Set USB wakeup source ' INTCONBits.RBIE = 1 // Set sw2,3 wakeup source ' asm- // Goto sleep ' sleep ' end asm ' if INTCONBits.RBIF = 1 then // Check if external stimulus ' USBRemoteWakeup() // If yes, attempt RWU ' endif ' PIE2Bits.USBIE = 0 ' INTCONBits.RBIE = 0 // End Modifiable Section End Sub { **************************************************************************** * Name : USB_SOF_Handler * * Purpose : 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. * **************************************************************************** } Sub USB_SOF_Handler() 'usbdrv.c UIRBits.SOFIF = 0 usb_Attached = (usb_device_state = CONFIGURED_STATE) End Sub { **************************************************************************** * Name : USBStallHandler * * Require : A STALL packet is sent to the host by the SIE. * * Purpose : 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 * * : accept 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. * * : UEPn.EPSTALL can be scanned to see which endpoint causes the * * : stall event. * **************************************************************************** } Sub USBStallHandler() 'usbdrv.c // 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 Then USBPrepareForNextSetupTrf() // Firmware work-around UEP0Bits.EPSTALL = 0 EndIf UIRBits.STALLIF = 0 End Sub { **************************************************************************** * Name : USBErrorHandler * * Purpose : The purpose of this interrupt is mainly for debugging during * * : development. Check UEIR to see which error causes the interrupt* **************************************************************************** } Sub USBErrorHandler() 'usbdrv.c UIRBits.UERRIF = 0 End Sub { **************************************************************************** * Name : USBDriverService * * Purpose : This routine is the heart of this firmware. It manages all USB * * : interrupts. Device state transitions through the following * * : stages: DETACHED -> ATTACHED -> POWERED -> DEFAULT -> * * : ADDRESS_PENDING -> ADDRESSED -> CONFIGURED -> READY * **************************************************************************** } Public Sub USBDriverService() 'usbdrv.c // Pointless to continue servicing if USB cable is not even attached. If usb_device_state = DETACHED_STATE Then Exit EndIf // Task A: Service USB Activity Interrupt If (UIRBits.ACTVIF <> 0) And (UIEBits.ACTVIE <> 0) Then USBWakeFromSuspend() EndIf // Pointless to continue servicing if the device is in suspend mode. If UCONBits.SUSPND = 1 Then usb_Attached = false Exit EndIf // 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. // The USB reset flag is masked when the USB state is in // DETACHED_STATE or ATTACHED_STATE, and therefore cannot // cause a USB reset event during these two states. If (UIRBits.URSTIF <> 0) And (UIEBits.URSTIE <> 0) Then USBProtocolResetHandler() EndIf // Task C: Service other USB interrupts If (UIRBits.IDLEIF <> 0) And (UIEBits.IDLEIE <> 0) Then USBSuspend() EndIf If (UIRBits.SOFIF <> 0) And (UIEBits.SOFIE <> 0) Then USB_SOF_Handler() EndIf If (UIRBits.STALLIF <> 0) And (UIEBits.STALLIE <> 0) Then USBStallHandler() EndIf If (UIRBits.UERRIF <> 0) And (UIEBits.UERRIE <> 0) Then USBErrorHandler() EndIf // 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 Then Exit EndIf // Task D: Servicing USB Transaction Complete Interrupt If (UIRBits.TRNIF <> 0) And (UIEBits.TRNIE <> 0) Then // 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 EndIf End Sub // version 1.2 usb_Attached = false // initialise descriptor pointers... USB_CD_Ptr(0) = @cfg01 USB_CD_Ptr(1) = @cfg01 // configuration USB_SD_Ptr(0) = @sd000 // language string USB_SD_Ptr(1) = @sd001 // manufacturer string USB_SD_Ptr(2) = @sd002 // product string #if USB_HAVE_SERIAL_STRING USB_SD_Ptr(3) = @sd003 // serial number string #endif // HID defaults... #if USB_USE_HID idle_rate = 0 active_protocol = 0 #endif // CDC defaults... #if USB_USE_CDC cdc_tx_len = 0 cdc_mem_type = _RAM cdc_trf_state = CDC_TX_READY #endif // USB_USE_CDC
{ ***************************************************************************** * Name : USBConfig.bas * * Author : David John Barker * * Notice : Copyright (c) 2007 Mecanique * * : All Rights Reserved * * Date : 15/09/2008 * * Version : 1.1a Branch by Nathan(RangerBob) for 18F87J50 Support * * : 1.1 Removed USB_SERVICE_US as ISR now uses USB interrupts * * : 1.0 Release * * Notes : USB configuration options * * : ==================== DO NOT EDIT THIS FILE =================== * * : Change the options FROM YOU MAIN PROGRAM. For example, * * : #option USB_VID = $1234 * * : This will AUTOMATICALLY override these default values. DONT * * : FORGET to add options BEFORE any include files!! * ***************************************************************************** } Module USBConfig // *************************************************************************** // device version (device_dsc) // *************************************************************************** #option USB_DEVICE_VERSION = $0110 // (BCD) #if Not (USB_DEVICE_VERSION in (0 to 65535)) #error USB_DEVICE_VERSION, "Invalid option. USB_DEVICE_VERSION must be between 0 and 65535." #endif // *************************************************************************** // descriptor string index (device_desc) // *************************************************************************** #define USB_MANUFACTURER_INDEX = 1 #define USB_PRODUCT_INDEX = 2 #variable USB_SERIAL_INDEX = 0 #option USB_HAVE_SERIAL_STRING = false #if Not (USB_HAVE_SERIAL_STRING in (true, false)) #error USB_HAVE_SERIAL_STRING, "Invalid option. USB_HAVE_SERIAL_STRING must be TRUE or FALSE." #endif #if USB_HAVE_SERIAL_STRING #variable USB_SERIAL_INDEX = 3 #endif // *************************************************************************** // bus power (cfg01) // *************************************************************************** #option USB_BUS_POWER = 50 // x2 #if Not (USB_BUS_POWER in (50 to 250)) #error USB_BUS_POWER, "Invalid option. USB_BUS_POWER must be between 50 and 250." #endif // *************************************************************************** // link in HID code option... // *************************************************************************** #option USB_USE_HID = false #if Not (USB_USE_HID in (true, false)) #error USB_USE_HID, "Invalid option. USB_USE_HID must be TRUE or FALSE." #endif // *************************************************************************** // link in CDC code option... // *************************************************************************** #option USB_USE_CDC = false #if Not (USB_USE_CDC in (true, false)) #error USB_USE_CDC, "Invalid option. USB_USE_CDC must be TRUE or FALSE." #endif // *************************************************************************** // default option for CDC... // *************************************************************************** #if USB_USE_CDC #option USB_DESCRIPTOR = "CDCDescriptor.bas" // name of descriptor file #option USB_VID = $1781 // VID - 6017 is Mecanique #option USB_PID = $07D1 // PID - 2001 #define MAX_EP_NUMBER = 3 // UEP1 minimum, up to 16 'usbcfg.h // *************************************************************************** // default options for HID... // *************************************************************************** #else #option USB_DESCRIPTOR = "HIDDescriptor.bas" // name of descriptor file #option USB_VID = $1781 // VID - 6017 is Mecanique #option USB_PID = $07D0 // PID - 2000 #define MAX_EP_NUMBER = 1 // UEP1 minimum, up to 16 'usbcfg.h #endif // *************************************************************************** // verify VID... // *************************************************************************** #if Not (USB_VID in (0 to 65535)) #error USB_VID, "Invalid option. USB_VID must be between 0 and 65535." #endif // *************************************************************************** // verify PID... // *************************************************************************** #if Not (USB_PID in (0 to 65535)) #error USB_PID, "Invalid option. USB_PID must be between 0 and 65535." #endif // *************************************************************************** // CDC options // *************************************************************************** #option CDC_RX_SIZE = 64 // CDCDataRX #if Not (CDC_RX_SIZE in (8, 16, 32, 64)) #error CDC_RX_SIZE, "Invalid option. CDC_RX_SIZE must be 8, 16, 32 or 64." #endif #option CDC_TX_SIZE = 64 // CDCDataTX #if Not (CDC_TX_SIZE in (8, 16, 32, 64)) #error CDC_TX_SIZE, "Invalid option. CDC_TX_SIZE must be 8, 16, 32 or 64." #endif // *************************************************************************** // HID buffer size // *************************************************************************** #option HID_BUFFER_SIZE = 64 // HID EP1 can be 8, 16, 32 or 64 #if Not (HID_BUFFER_SIZE in (8, 16, 32, 64)) #error HID_BUFFER_SIZE, "Invalid option. HID_BUFFER_SIZE must be 8, 16, 32 or 64." #endif // will equal HID_BUFFER_SIZE unless overridden in main program... #option HID_REPORT_BYTES_IN = HID_BUFFER_SIZE // HID Report bytes in #if Not (HID_REPORT_BYTES_IN in (8, 16, 32, 64)) #error HID_REPORT_BYTES_IN, "Invalid option. HID_REPORT_BYTES_IN must be 8, 16, 32 or 64." #endif // will equal HID_BUFFER_SIZE unless overridden in main program... #option HID_REPORT_BYTES_OUT = HID_BUFFER_SIZE // HID_Report bytes out #if Not (HID_REPORT_BYTES_OUT in (8, 16, 32, 64)) #error HID_REPORT_BYTES_OUT, "Invalid option. HID_REPORT_BYTES_OUT must be 8, 16, 32 or 64." #endif // *************************************************************************** // HID EP Polling // *************************************************************************** #option HID_EP_OUT_POLLING_MS = 1 // HID - EP01 - 1ms (EP01Out) #if Not (HID_EP_OUT_POLLING_MS in (1 to 10)) #error HID_EP_OUT_POLLING_MS, "Invalid option. HID_EP_OUT_POLLING_MS must be between 1 and 10." #endif #option HID_EP_IN_POLLING_MS = 1 // HID - EP01 - 1ms (EP01In) #if Not (HID_EP_IN_POLLING_MS in (1 to 10)) #error HID_EP_IN_POLLING_MS, "Invalid option. HID_EP_IN_POLLING_MS must be between 1 and 10." #endif // *************************************************************************** // self power sensing... // *************************************************************************** #option USB_POWER_SENSE_IO = false 'usbcfg.h #option USB_POWER_SENSE_PIN = PORTA.2 #if IsOption(USB_POWER_SENSE_PIN) And Not IsValidPortPin(USB_POWER_SENSE_PIN) #error USB_POWER_SENSE_PIN, "Invalid option. USB_POWER_SENSE_PIN must be a valid port pin." #endif #if USB_POWER_SENSE_IO 'io_cfg.h Public Dim self_power As USB_POWER_SENSE_PIN.USB_POWER_SENSE_PIN@ #else Public Const self_power = 1 #endif // *************************************************************************** // bus sense... // *************************************************************************** #option USB_BUS_SENSE_IO = false 'usbcfg.h #option USB_BUS_SENSE_PIN = PORTA.1 #if IsOption(USB_BUS_SENSE_PIN) And Not IsValidPortPin(USB_BUS_SENSE_PIN) #error USB_BUS_SENSE_PIN, "Invalid option. USB_BUS_SENSE_PIN must be a valid port pin." #endif #if USB_BUS_SENSE_IO 'io_cfg.h Public Dim usb_bus_sense As USB_BUS_SENSE_PIN.USB_BUS_SENSE_PIN@ #else Public Const usb_bus_sense = 1 #endif // *************************************************************************** // Use interrupt polling... // *************************************************************************** #option USB_SERVICE = true #if Not (USB_SERVICE in (true, false)) #error USB_SERVICE, "Invalid option. USB_SERVICE must be TRUE or FALSE." #endif #option USB_SERVICE_PRIORITY = ipHigh // set interrupt priority level... #if IsOption(USB_SERVICE_PRIORITY) And Not (USB_SERVICE_PRIORITY in (ipLow, ipHigh)) #error USB_SERVICE_PRIORITY, "Invalid option. Priority must be ipHigh or ipLow." #endif // *************************************************************************** // Timeout between CONFIGURED_STATE and setting 'USBSystem.Connected' // *************************************************************************** #option USB_CONNECT_MS = 1200 #if Not (USB_CONNECT_MS in (0 to 5000)) #error USB_CONNECT_MS, "Invalid option. USB_CONNECT_MS must be between 0 and 5000 ms." #endif // *************************************************************************** // does device support extended dual port RAM // *************************************************************************** #if _device in (18F2455, 18F2550, 18F4455, 18F4550, 18F87J50) #define USB_EXTENDED_RAM = true #else #define USB_EXTENDED_RAM = false #endif