Added the scsi2sd-config utility, and updated firmware to suit.
authorMichael McMaster <michael@codesrc.com>
Tue, 29 Oct 2013 11:48:07 +0000 (21:48 +1000)
committerMichael McMaster <michael@codesrc.com>
Tue, 29 Oct 2013 11:48:07 +0000 (21:48 +1000)
49 files changed:
STATUS
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm_aliases.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp_aliases.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_audio.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_audio.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_boot.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.inf [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cls.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_descr.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_drv.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_episr.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_hid.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_hid.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_midi.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_midi.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_pm.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_pvt.h [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_std.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_vnd.c [new file with mode: 0755]
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/cyfitter.h
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/cyfitter_cfg.c
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/cyfittergnu.inc
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/cyfitteriar.inc
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/cyfitterrv.inc
software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/project.h [changed mode: 0644->0755]
software/SCSI2SD/SCSI2SD.cydsn/SCSI2SD.cycdx
software/SCSI2SD/SCSI2SD.cydsn/SCSI2SD.cyfit
software/SCSI2SD/SCSI2SD.cydsn/SCSI2SD.cyprj
software/SCSI2SD/SCSI2SD.cydsn/SCSI2SD.svd
software/SCSI2SD/SCSI2SD.cydsn/TopDesign/TopDesign.cysch
software/SCSI2SD/SCSI2SD.cydsn/config.c
software/SCSI2SD/SCSI2SD.cydsn/config.h
software/SCSI2SD/SCSI2SD.cydsn/main.c
software/SCSI2SD/SCSI2SD.cydsn/scsi.c
software/SCSI2SD/USB_Bootloader.cydsn/USB_Bootloader.cyprj.Micha_000
software/bootloaderhost/.gitignore [new file with mode: 0644]
software/bootloaderhost/Makefile
software/scsi2sd-config/.gitignore [new file with mode: 0644]
software/scsi2sd-config/Makefile [new file with mode: 0644]
software/scsi2sd-config/Makefile.mingw [new file with mode: 0644]
software/scsi2sd-config/main.c [new file with mode: 0644]

diff --git a/STATUS b/STATUS
index 03bc964..6e099b1 100644 (file)
--- a/STATUS
+++ b/STATUS
@@ -1,9 +1,4 @@
-- Configuration options cannot be set via USB. Must use the USB bootloader to
-       load a new firmware instead.
-       - SCSI ID hardcoded to 0
-       - Partity checking is on
-       - Unit Attention Condition is off
-
 - DMA is not used for SPI transfers
+       - Potential for large performance improvement.
 - Parity checking not implemented for the PSoC Datapath implementation
 
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS.c
new file mode 100755 (executable)
index 0000000..081e687
--- /dev/null
@@ -0,0 +1,1335 @@
+/*******************************************************************************\r
+* File Name: USBFS.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  API for USBFS Component.\r
+*\r
+* Note:\r
+*  Many of the functions use endpoint number.  RAM arrays are sized with 9\r
+*  elements so they are indexed directly by epNumber.  The SIE and ARB\r
+*  registers are indexed by variations of epNumber - 1.\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include <CyDmac.h>\r
+#include "USBFS.h"\r
+#include "USBFS_pvt.h"\r
+#include "USBFS_hid.h"\r
+#if(USBFS_DMA1_REMOVE == 0u)\r
+    #include "USBFS_ep1_dma.h"\r
+#endif   /* End USBFS_DMA1_REMOVE */\r
+#if(USBFS_DMA2_REMOVE == 0u)\r
+    #include "USBFS_ep2_dma.h"\r
+#endif   /* End USBFS_DMA2_REMOVE */\r
+#if(USBFS_DMA3_REMOVE == 0u)\r
+    #include "USBFS_ep3_dma.h"\r
+#endif   /* End USBFS_DMA3_REMOVE */\r
+#if(USBFS_DMA4_REMOVE == 0u)\r
+    #include "USBFS_ep4_dma.h"\r
+#endif   /* End USBFS_DMA4_REMOVE */\r
+#if(USBFS_DMA5_REMOVE == 0u)\r
+    #include "USBFS_ep5_dma.h"\r
+#endif   /* End USBFS_DMA5_REMOVE */\r
+#if(USBFS_DMA6_REMOVE == 0u)\r
+    #include "USBFS_ep6_dma.h"\r
+#endif   /* End USBFS_DMA6_REMOVE */\r
+#if(USBFS_DMA7_REMOVE == 0u)\r
+    #include "USBFS_ep7_dma.h"\r
+#endif   /* End USBFS_DMA7_REMOVE */\r
+#if(USBFS_DMA8_REMOVE == 0u)\r
+    #include "USBFS_ep8_dma.h"\r
+#endif   /* End USBFS_DMA8_REMOVE */\r
+\r
+\r
+/***************************************\r
+* Global data allocation\r
+***************************************/\r
+\r
+uint8 USBFS_initVar = 0u;\r
+#if(USBFS_EP_MM != USBFS__EP_MANUAL)\r
+    uint8 USBFS_DmaChan[USBFS_MAX_EP];\r
+    uint8 USBFS_DmaTd[USBFS_MAX_EP];\r
+#endif /* End USBFS_EP_MM */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Start\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This function initialize the USB SIE, arbiter and the\r
+*  endpoint APIs, including setting the D+ Pullup\r
+*\r
+* Parameters:\r
+*  device: Contains the device number of the desired device descriptor.\r
+*          The device number can be found in the Device Descriptor Tab of\r
+*          "Configure" dialog, under the settings of desired Device Descriptor,\r
+*          in the "Device Number" field.\r
+*  mode: The operating voltage. This determines whether the voltage regulator\r
+*        is enabled for 5V operation or if pass through mode is used for 3.3V\r
+*        operation. Symbolic names and their associated values are given in the\r
+*        following table.\r
+*       USBFS_3V_OPERATION - Disable voltage regulator and pass-thru\r
+*                                       Vcc for pull-up\r
+*       USBFS_5V_OPERATION - Enable voltage regulator and use\r
+*                                       regulator for pull-up\r
+*       USBFS_DWR_VDDD_OPERATION - Enable or Disable voltage\r
+*                         regulator depend on Vddd Voltage configuration in DWR.\r
+*\r
+* Return:\r
+*   None.\r
+*\r
+* Global variables:\r
+*  The USBFS_intiVar variable is used to indicate initial\r
+*  configuration of this component. The variable is initialized to zero (0u)\r
+*  and set to one (1u) the first time USBFS_Start() is called.\r
+*  This allows for component Re-Start without unnecessary re-initialization\r
+*  in all subsequent calls to the USBFS_Start() routine.\r
+*  If re-initialization of the component is required the variable should be set\r
+*  to zero before call of UART_Start() routine, or the user may call\r
+*  USBFS_Init() and USBFS_InitComponent() as done\r
+*  in the USBFS_Start() routine.\r
+*\r
+* Side Effects:\r
+*   This function will reset all communication states to default.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_Start(uint8 device, uint8 mode) \r
+{\r
+    /* If not Initialized then initialize all required hardware and software */\r
+    if(USBFS_initVar == 0u)\r
+    {\r
+        USBFS_Init();\r
+        USBFS_initVar = 1u;\r
+    }\r
+    USBFS_InitComponent(device, mode);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Init\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Initialize component's hardware. Usually called in USBFS_Start().\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_Init(void) \r
+{\r
+    uint8 enableInterrupts;\r
+    #if(USBFS_EP_MM != USBFS__EP_MANUAL)\r
+        uint16 i;\r
+    #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */\r
+\r
+    enableInterrupts = CyEnterCriticalSection();\r
+\r
+    /* Enable USB block  */\r
+    USBFS_PM_ACT_CFG_REG |= USBFS_PM_ACT_EN_FSUSB;\r
+    /* Enable USB block for Standby Power Mode */\r
+    USBFS_PM_STBY_CFG_REG |= USBFS_PM_STBY_EN_FSUSB;\r
+\r
+    /* Enable core clock */\r
+    USBFS_USB_CLK_EN_REG = USBFS_USB_CLK_ENABLE;\r
+\r
+    USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK;\r
+\r
+    /* ENABLING USBIO PADS IN USB MODE FROM I/O MODE */\r
+    /* Ensure USB transmit enable is low (USB_USBIO_CR0.ten). - Manual Transmission - Disabled */\r
+    USBFS_USBIO_CR0_REG &= ((uint8)(~USBFS_USBIO_CR0_TEN));\r
+    CyDelayUs(0u);  /*~50ns delay */\r
+    /* Disable the USBIO by asserting PM.USB_CR0.fsusbio_pd_n(Inverted)\r
+    *  high. This will have been set low by the power manger out of reset.\r
+    *  Also confirm USBIO pull-up disabled\r
+    */\r
+    USBFS_PM_USB_CR0_REG &= ((uint8)(~(USBFS_PM_USB_CR0_PD_N |\r
+                                                  USBFS_PM_USB_CR0_PD_PULLUP_N)));\r
+\r
+    /* Select iomode to USB mode*/\r
+    USBFS_USBIO_CR1_REG &= ((uint8)(~USBFS_USBIO_CR1_IOMODE));\r
+\r
+    /* Enable the USBIO reference by setting PM.USB_CR0.fsusbio_ref_en.*/\r
+    USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_REF_EN;\r
+    /* The reference will be available 1 us after the regulator is enabled */\r
+    CyDelayUs(1u);\r
+    /* OR 40us after power restored */\r
+    CyDelayUs(40u);\r
+    /* Ensure the single ended disable bits are low (PRT15.INP_DIS[7:6])(input receiver enabled). */\r
+    USBFS_DM_INP_DIS_REG &= ((uint8)(~USBFS_DM_MASK));\r
+    USBFS_DP_INP_DIS_REG &= ((uint8)(~USBFS_DP_MASK));\r
+\r
+    /* Enable USBIO */\r
+    USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_PD_N;\r
+    CyDelayUs(2u);\r
+    /* Set the USBIO pull-up enable */\r
+    USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_PD_PULLUP_N;\r
+\r
+    /* Write WAx */\r
+    CY_SET_REG8(USBFS_ARB_RW1_WA_PTR,     0u);\r
+    CY_SET_REG8(USBFS_ARB_RW1_WA_MSB_PTR, 0u);\r
+\r
+    #if(USBFS_EP_MM != USBFS__EP_MANUAL)\r
+        /* Init transfer descriptor. This will be used to detect the DMA state - initialized or not. */\r
+        for (i = 0u; i < USBFS_MAX_EP; i++)\r
+        {\r
+            USBFS_DmaTd[i] = DMA_INVALID_TD;\r
+        }\r
+    #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */\r
+\r
+    CyExitCriticalSection(enableInterrupts);\r
+\r
+\r
+    /* Set the bus reset Interrupt. */\r
+    (void) CyIntSetVector(USBFS_BUS_RESET_VECT_NUM,   &USBFS_BUS_RESET_ISR);\r
+    CyIntSetPriority(USBFS_BUS_RESET_VECT_NUM, USBFS_BUS_RESET_PRIOR);\r
+\r
+    /* Set the SOF Interrupt. */\r
+    #if(USBFS_SOF_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_SOF_VECT_NUM,   &USBFS_SOF_ISR);\r
+        CyIntSetPriority(USBFS_SOF_VECT_NUM, USBFS_SOF_PRIOR);\r
+    #endif   /* End USBFS_SOF_ISR_REMOVE */\r
+\r
+    /* Set the Control Endpoint Interrupt. */\r
+    (void) CyIntSetVector(USBFS_EP_0_VECT_NUM,   &USBFS_EP_0_ISR);\r
+    CyIntSetPriority(USBFS_EP_0_VECT_NUM, USBFS_EP_0_PRIOR);\r
+\r
+    /* Set the Data Endpoint 1 Interrupt. */\r
+    #if(USBFS_EP1_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_1_VECT_NUM,   &USBFS_EP_1_ISR);\r
+        CyIntSetPriority(USBFS_EP_1_VECT_NUM, USBFS_EP_1_PRIOR);\r
+    #endif   /* End USBFS_EP1_ISR_REMOVE */\r
+\r
+    /* Set the Data Endpoint 2 Interrupt. */\r
+    #if(USBFS_EP2_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_2_VECT_NUM,   &USBFS_EP_2_ISR);\r
+        CyIntSetPriority(USBFS_EP_2_VECT_NUM, USBFS_EP_2_PRIOR);\r
+    #endif   /* End USBFS_EP2_ISR_REMOVE */\r
+\r
+    /* Set the Data Endpoint 3 Interrupt. */\r
+    #if(USBFS_EP3_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_3_VECT_NUM,   &USBFS_EP_3_ISR);\r
+        CyIntSetPriority(USBFS_EP_3_VECT_NUM, USBFS_EP_3_PRIOR);\r
+    #endif   /* End USBFS_EP3_ISR_REMOVE */\r
+\r
+    /* Set the Data Endpoint 4 Interrupt. */\r
+    #if(USBFS_EP4_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_4_VECT_NUM,   &USBFS_EP_4_ISR);\r
+        CyIntSetPriority(USBFS_EP_4_VECT_NUM, USBFS_EP_4_PRIOR);\r
+    #endif   /* End USBFS_EP4_ISR_REMOVE */\r
+\r
+    /* Set the Data Endpoint 5 Interrupt. */\r
+    #if(USBFS_EP5_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_5_VECT_NUM,   &USBFS_EP_5_ISR);\r
+        CyIntSetPriority(USBFS_EP_5_VECT_NUM, USBFS_EP_5_PRIOR);\r
+    #endif   /* End USBFS_EP5_ISR_REMOVE */\r
+\r
+    /* Set the Data Endpoint 6 Interrupt. */\r
+    #if(USBFS_EP6_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_6_VECT_NUM,   &USBFS_EP_6_ISR);\r
+        CyIntSetPriority(USBFS_EP_6_VECT_NUM, USBFS_EP_6_PRIOR);\r
+    #endif   /* End USBFS_EP6_ISR_REMOVE */\r
+\r
+     /* Set the Data Endpoint 7 Interrupt. */\r
+    #if(USBFS_EP7_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_7_VECT_NUM,   &USBFS_EP_7_ISR);\r
+        CyIntSetPriority(USBFS_EP_7_VECT_NUM, USBFS_EP_7_PRIOR);\r
+    #endif   /* End USBFS_EP7_ISR_REMOVE */\r
+\r
+    /* Set the Data Endpoint 8 Interrupt. */\r
+    #if(USBFS_EP8_ISR_REMOVE == 0u)\r
+        (void) CyIntSetVector(USBFS_EP_8_VECT_NUM,   &USBFS_EP_8_ISR);\r
+        CyIntSetPriority(USBFS_EP_8_VECT_NUM, USBFS_EP_8_PRIOR);\r
+    #endif   /* End USBFS_EP8_ISR_REMOVE */\r
+\r
+    #if((USBFS_EP_MM != USBFS__EP_MANUAL) && (USBFS_ARB_ISR_REMOVE == 0u))\r
+        /* Set the ARB Interrupt. */\r
+        (void) CyIntSetVector(USBFS_ARB_VECT_NUM,   &USBFS_ARB_ISR);\r
+        CyIntSetPriority(USBFS_ARB_VECT_NUM, USBFS_ARB_PRIOR);\r
+    #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */\r
+\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_InitComponent\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Initialize the component, except for the HW which is done one time in\r
+*  the Start function.  This function pulls up D+.\r
+*\r
+* Parameters:\r
+*  device: Contains the device number of the desired device descriptor.\r
+*          The device number can be found in the Device Descriptor Tab of\r
+*          "Configure" dialog, under the settings of desired Device Descriptor,\r
+*          in the "Device Number" field.\r
+*  mode: The operating voltage. This determines whether the voltage regulator\r
+*        is enabled for 5V operation or if pass through mode is used for 3.3V\r
+*        operation. Symbolic names and their associated values are given in the\r
+*        following table.\r
+*       USBFS_3V_OPERATION - Disable voltage regulator and pass-thru\r
+*                                       Vcc for pull-up\r
+*       USBFS_5V_OPERATION - Enable voltage regulator and use\r
+*                                       regulator for pull-up\r
+*       USBFS_DWR_VDDD_OPERATION - Enable or Disable voltage\r
+*                         regulator depend on Vddd Voltage configuration in DWR.\r
+*\r
+* Return:\r
+*   None.\r
+*\r
+* Global variables:\r
+*   USBFS_device: Contains the device number of the desired device\r
+*       descriptor. The device number can be found in the Device Descriptor Tab\r
+*       of "Configure" dialog, under the settings of desired Device Descriptor,\r
+*       in the "Device Number" field.\r
+*   USBFS_transferState: This variable used by the communication\r
+*       functions to handle current transfer state. Initialized to\r
+*       TRANS_STATE_IDLE in this API.\r
+*   USBFS_configuration: Contains current configuration number\r
+*       which is set by the Host using SET_CONFIGURATION request.\r
+*       Initialized to zero in this API.\r
+*   USBFS_deviceAddress: Contains current device address. This\r
+*       variable is initialized to zero in this API. Host starts to communicate\r
+*      to device with address 0 and then set it to whatever value using\r
+*      SET_ADDRESS request.\r
+*   USBFS_deviceStatus: initialized to 0.\r
+*       This is two bit variable which contain power status in first bit\r
+*       (DEVICE_STATUS_BUS_POWERED or DEVICE_STATUS_SELF_POWERED) and remote\r
+*       wakeup status (DEVICE_STATUS_REMOTE_WAKEUP) in second bit.\r
+*   USBFS_lastPacketSize initialized to 0;\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_InitComponent(uint8 device, uint8 mode) \r
+{\r
+    /* Initialize _hidProtocol variable to comply with\r
+    *  HID 7.2.6 Set_Protocol Request:\r
+    *  "When initialized, all devices default to report protocol."\r
+    */\r
+    #if defined(USBFS_ENABLE_HID_CLASS)\r
+        uint8 i;\r
+\r
+        for (i = 0u; i < USBFS_MAX_INTERFACES_NUMBER; i++)\r
+        {\r
+            USBFS_hidProtocol[i] = USBFS_PROTOCOL_REPORT;\r
+        }\r
+    #endif /* USBFS_ENABLE_HID_CLASS */\r
+\r
+    /* Enable Interrupts. */\r
+    CyIntEnable(USBFS_BUS_RESET_VECT_NUM);\r
+    CyIntEnable(USBFS_EP_0_VECT_NUM);\r
+    #if(USBFS_EP1_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_1_VECT_NUM);\r
+    #endif   /* End USBFS_EP1_ISR_REMOVE */\r
+    #if(USBFS_EP2_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_2_VECT_NUM);\r
+    #endif   /* End USBFS_EP2_ISR_REMOVE */\r
+    #if(USBFS_EP3_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_3_VECT_NUM);\r
+    #endif   /* End USBFS_EP3_ISR_REMOVE */\r
+    #if(USBFS_EP4_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_4_VECT_NUM);\r
+    #endif   /* End USBFS_EP4_ISR_REMOVE */\r
+    #if(USBFS_EP5_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_5_VECT_NUM);\r
+    #endif   /* End USBFS_EP5_ISR_REMOVE */\r
+    #if(USBFS_EP6_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_6_VECT_NUM);\r
+    #endif   /* End USBFS_EP6_ISR_REMOVE */\r
+    #if(USBFS_EP7_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_7_VECT_NUM);\r
+    #endif   /* End USBFS_EP7_ISR_REMOVE */\r
+    #if(USBFS_EP8_ISR_REMOVE == 0u)\r
+        CyIntEnable(USBFS_EP_8_VECT_NUM);\r
+    #endif   /* End USBFS_EP8_ISR_REMOVE */\r
+    #if((USBFS_EP_MM != USBFS__EP_MANUAL) && (USBFS_ARB_ISR_REMOVE == 0u))\r
+        /* usb arb interrupt enable */\r
+        USBFS_ARB_INT_EN_REG = USBFS_ARB_INT_MASK;\r
+        CyIntEnable(USBFS_ARB_VECT_NUM);\r
+    #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */\r
+\r
+    /* Arbiter configuration for DMA transfers */\r
+    #if(USBFS_EP_MM != USBFS__EP_MANUAL)\r
+\r
+        #if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)\r
+            USBFS_ARB_CFG_REG = USBFS_ARB_CFG_MANUAL_DMA;\r
+        #endif   /* End USBFS_EP_MM == USBFS__EP_DMAMANUAL */\r
+        #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)\r
+            /*Set cfg cmplt this rises DMA request when the full configuration is done */\r
+            USBFS_ARB_CFG_REG = USBFS_ARB_CFG_AUTO_DMA | USBFS_ARB_CFG_AUTO_MEM;\r
+        #endif   /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */\r
+    #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */\r
+\r
+    USBFS_transferState = USBFS_TRANS_STATE_IDLE;\r
+\r
+    /* USB Locking: Enabled, VRegulator: depend on mode or DWR Voltage configuration*/\r
+    switch(mode)\r
+    {\r
+        case USBFS_3V_OPERATION:\r
+            USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK;\r
+            break;\r
+        case USBFS_5V_OPERATION:\r
+            USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK | USBFS_CR1_REG_ENABLE;\r
+            break;\r
+        default:   /*USBFS_DWR_VDDD_OPERATION */\r
+            #if(USBFS_VDDD_MV < USBFS_3500MV)\r
+                USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK;\r
+            #else\r
+                USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK | USBFS_CR1_REG_ENABLE;\r
+            #endif /* End USBFS_VDDD_MV < USBFS_3500MV */\r
+            break;\r
+    }\r
+\r
+    /* Record the descriptor selection */\r
+    USBFS_device = device;\r
+\r
+    /* Clear all of the component data */\r
+    USBFS_configuration = 0u;\r
+    USBFS_interfaceNumber = 0u;\r
+    USBFS_configurationChanged = 0u;\r
+    USBFS_deviceAddress  = 0u;\r
+    USBFS_deviceStatus = 0u;\r
+\r
+    USBFS_lastPacketSize = 0u;\r
+\r
+    /*  ACK Setup, Stall IN/OUT */\r
+    CY_SET_REG8(USBFS_EP0_CR_PTR, USBFS_MODE_STALL_IN_OUT);\r
+\r
+    /* Enable the SIE with an address 0 */\r
+    CY_SET_REG8(USBFS_CR0_PTR, USBFS_CR0_ENABLE);\r
+\r
+    /* Workaround for PSOC5LP */\r
+    CyDelayCycles(1u);\r
+\r
+    /* Finally, Enable d+ pullup and select iomode to USB mode*/\r
+    CY_SET_REG8(USBFS_USBIO_CR1_PTR, USBFS_USBIO_CR1_USBPUEN);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_ReInitComponent\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This function reinitialize the component configuration and is\r
+*  intend to be called from the Reset interrupt.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*   None.\r
+*\r
+* Global variables:\r
+*   USBFS_device: Contains the device number of the desired device\r
+*        descriptor. The device number can be found in the Device Descriptor Tab\r
+*       of "Configure" dialog, under the settings of desired Device Descriptor,\r
+*       in the "Device Number" field.\r
+*   USBFS_transferState: This variable used by the communication\r
+*       functions to handle current transfer state. Initialized to\r
+*       TRANS_STATE_IDLE in this API.\r
+*   USBFS_configuration: Contains current configuration number\r
+*       which is set by the Host using SET_CONFIGURATION request.\r
+*       Initialized to zero in this API.\r
+*   USBFS_deviceAddress: Contains current device address. This\r
+*       variable is initialized to zero in this API. Host starts to communicate\r
+*      to device with address 0 and then set it to whatever value using\r
+*      SET_ADDRESS request.\r
+*   USBFS_deviceStatus: initialized to 0.\r
+*       This is two bit variable which contain power status in first bit\r
+*       (DEVICE_STATUS_BUS_POWERED or DEVICE_STATUS_SELF_POWERED) and remote\r
+*       wakeup status (DEVICE_STATUS_REMOTE_WAKEUP) in second bit.\r
+*   USBFS_lastPacketSize initialized to 0;\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_ReInitComponent(void) \r
+{\r
+    /* Initialize _hidProtocol variable to comply with HID 7.2.6 Set_Protocol\r
+    *  Request: "When initialized, all devices default to report protocol."\r
+    */\r
+    #if defined(USBFS_ENABLE_HID_CLASS)\r
+        uint8 i;\r
+\r
+        for (i = 0u; i < USBFS_MAX_INTERFACES_NUMBER; i++)\r
+        {\r
+            USBFS_hidProtocol[i] = USBFS_PROTOCOL_REPORT;\r
+        }\r
+    #endif /* USBFS_ENABLE_HID_CLASS */\r
+\r
+    USBFS_transferState = USBFS_TRANS_STATE_IDLE;\r
+\r
+    /* Clear all of the component data */\r
+    USBFS_configuration = 0u;\r
+    USBFS_interfaceNumber = 0u;\r
+    USBFS_configurationChanged = 0u;\r
+    USBFS_deviceAddress  = 0u;\r
+    USBFS_deviceStatus = 0u;\r
+\r
+    USBFS_lastPacketSize = 0u;\r
+\r
+\r
+    /*  ACK Setup, Stall IN/OUT */\r
+    CY_SET_REG8(USBFS_EP0_CR_PTR, USBFS_MODE_STALL_IN_OUT);\r
+\r
+    /* Enable the SIE with an address 0 */\r
+    CY_SET_REG8(USBFS_CR0_PTR, USBFS_CR0_ENABLE);\r
+\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Stop\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This function shuts down the USB function including to release\r
+*  the D+ Pullup and disabling the SIE.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*   USBFS_configuration: Contains current configuration number\r
+*       which is set by the Host using SET_CONFIGURATION request.\r
+*       Initialized to zero in this API.\r
+*   USBFS_deviceAddress: Contains current device address. This\r
+*       variable is initialized to zero in this API. Host starts to communicate\r
+*      to device with address 0 and then set it to whatever value using\r
+*      SET_ADDRESS request.\r
+*   USBFS_deviceStatus: initialized to 0.\r
+*       This is two bit variable which contain power status in first bit\r
+*       (DEVICE_STATUS_BUS_POWERED or DEVICE_STATUS_SELF_POWERED) and remote\r
+*       wakeup status (DEVICE_STATUS_REMOTE_WAKEUP) in second bit.\r
+*   USBFS_configurationChanged: This variable is set to one after\r
+*       SET_CONFIGURATION request and cleared in this function.\r
+*   USBFS_intiVar variable is set to zero\r
+*\r
+*******************************************************************************/\r
+void USBFS_Stop(void) \r
+{\r
+\r
+    #if(USBFS_EP_MM != USBFS__EP_MANUAL)\r
+        USBFS_Stop_DMA(USBFS_MAX_EP);     /* Stop all DMAs */\r
+    #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */\r
+\r
+    /* Disable the SIE */\r
+    USBFS_CR0_REG &= (uint8)(~USBFS_CR0_ENABLE);\r
+    /* Disable the d+ pullup */\r
+    USBFS_USBIO_CR1_REG &= (uint8)(~USBFS_USBIO_CR1_USBPUEN);\r
+    /* Disable USB in ACT PM */\r
+    USBFS_PM_ACT_CFG_REG &= (uint8)(~USBFS_PM_ACT_EN_FSUSB);\r
+    /* Disable USB block for Standby Power Mode */\r
+    USBFS_PM_STBY_CFG_REG &= (uint8)(~USBFS_PM_STBY_EN_FSUSB);\r
+\r
+    /* Disable the reset and EP interrupts */\r
+    CyIntDisable(USBFS_BUS_RESET_VECT_NUM);\r
+    CyIntDisable(USBFS_EP_0_VECT_NUM);\r
+    #if(USBFS_EP1_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_1_VECT_NUM);\r
+    #endif   /* End USBFS_EP1_ISR_REMOVE */\r
+    #if(USBFS_EP2_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_2_VECT_NUM);\r
+    #endif   /* End USBFS_EP2_ISR_REMOVE */\r
+    #if(USBFS_EP3_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_3_VECT_NUM);\r
+    #endif   /* End USBFS_EP3_ISR_REMOVE */\r
+    #if(USBFS_EP4_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_4_VECT_NUM);\r
+    #endif   /* End USBFS_EP4_ISR_REMOVE */\r
+    #if(USBFS_EP5_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_5_VECT_NUM);\r
+    #endif   /* End USBFS_EP5_ISR_REMOVE */\r
+    #if(USBFS_EP6_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_6_VECT_NUM);\r
+    #endif   /* End USBFS_EP6_ISR_REMOVE */\r
+    #if(USBFS_EP7_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_7_VECT_NUM);\r
+    #endif   /* End USBFS_EP7_ISR_REMOVE */\r
+    #if(USBFS_EP8_ISR_REMOVE == 0u)\r
+        CyIntDisable(USBFS_EP_8_VECT_NUM);\r
+    #endif   /* End USBFS_EP8_ISR_REMOVE */\r
+\r
+    /* Clear all of the component data */\r
+    USBFS_configuration = 0u;\r
+    USBFS_interfaceNumber = 0u;\r
+    USBFS_configurationChanged = 0u;\r
+    USBFS_deviceAddress  = 0u;\r
+    USBFS_deviceStatus = 0u;\r
+    USBFS_initVar = 0u;\r
+\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_CheckActivity\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returns the activity status of the bus.  Clears the status hardware to\r
+*  provide fresh activity status on the next call of this routine.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  1 - If bus activity was detected since the last call to this function\r
+*  0 - If bus activity not was detected since the last call to this function\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_CheckActivity(void) \r
+{\r
+    uint8 r;\r
+\r
+    r = CY_GET_REG8(USBFS_CR1_PTR);\r
+    CY_SET_REG8(USBFS_CR1_PTR, (r & ((uint8)(~USBFS_CR1_BUS_ACTIVITY))));\r
+\r
+    return((r & USBFS_CR1_BUS_ACTIVITY) >> USBFS_CR1_BUS_ACTIVITY_SHIFT);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_GetConfiguration\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returns the current configuration setting\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  configuration.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_GetConfiguration(void) \r
+{\r
+    return(USBFS_configuration);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_IsConfigurationChanged\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returns the clear on read configuration state. It is usefull when PC send\r
+*  double SET_CONFIGURATION request with same configuration number.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  Not zero value when new configuration has been changed, otherwise zero is\r
+*  returned.\r
+*\r
+* Global variables:\r
+*   USBFS_configurationChanged: This variable is set to one after\r
+*       SET_CONFIGURATION request and cleared in this function.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_IsConfigurationChanged(void) \r
+{\r
+    uint8 res = 0u;\r
+\r
+    if(USBFS_configurationChanged != 0u)\r
+    {\r
+        res = USBFS_configurationChanged;\r
+        USBFS_configurationChanged = 0u;\r
+    }\r
+\r
+    return(res);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_GetInterfaceSetting\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returns the alternate setting from current interface\r
+*\r
+* Parameters:\r
+*  uint8 interfaceNumber, interface number\r
+*\r
+* Return:\r
+*  Alternate setting.\r
+*\r
+*******************************************************************************/\r
+uint8  USBFS_GetInterfaceSetting(uint8 interfaceNumber)\r
+                                                    \r
+{\r
+    return(USBFS_interfaceSetting[interfaceNumber]);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_GetEPState\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returned the state of the requested endpoint.\r
+*\r
+* Parameters:\r
+*  epNumber: Endpoint Number\r
+*\r
+* Return:\r
+*  State of the requested endpoint.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_GetEPState(uint8 epNumber) \r
+{\r
+    return(USBFS_EP[epNumber].apiEpState);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_GetEPCount\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This function supports Data Endpoints only(EP1-EP8).\r
+*  Returns the transfer count for the requested endpoint.  The value from\r
+*  the count registers includes 2 counts for the two byte checksum of the\r
+*  packet.  This function subtracts the two counts.\r
+*\r
+* Parameters:\r
+*  epNumber: Data Endpoint Number.\r
+*            Valid values are between 1 and 8.\r
+*\r
+* Return:\r
+*  Returns the current byte count from the specified endpoint or 0 for an\r
+*  invalid endpoint.\r
+*\r
+*******************************************************************************/\r
+uint16 USBFS_GetEPCount(uint8 epNumber) \r
+{\r
+    uint8 ri;\r
+    uint16 result = 0u;\r
+\r
+    if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))\r
+    {\r
+        ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);\r
+\r
+        result = (uint8)(CY_GET_REG8((reg8 *)(USBFS_SIE_EP1_CNT0_IND + ri)) &\r
+                          USBFS_EPX_CNT0_MASK);\r
+        result = (result << 8u) | CY_GET_REG8((reg8 *)(USBFS_SIE_EP1_CNT1_IND + ri));\r
+        result -= USBFS_EPX_CNTX_CRC_COUNT;\r
+    }\r
+    return(result);\r
+}\r
+\r
+\r
+#if(USBFS_EP_MM != USBFS__EP_MANUAL)\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_InitEP_DMA\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  This function allocates and initializes a DMA channel to be used by the\r
+    *  USBFS_LoadInEP() or USBFS_ReadOutEP() APIs for data\r
+    *  transfer.\r
+    *\r
+    * Parameters:\r
+    *  epNumber: Contains the data endpoint number.\r
+    *            Valid values are between 1 and 8.\r
+    *  *pData: Pointer to a data array that is related to the EP transfers.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    void USBFS_InitEP_DMA(uint8 epNumber, const uint8 *pData)\r
+                                                                    \r
+    {\r
+        uint16 src;\r
+        uint16 dst;\r
+        #if (CY_PSOC3)                  /* PSoC 3 */\r
+            src = HI16(CYDEV_SRAM_BASE);\r
+            dst = HI16(CYDEV_PERIPH_BASE);\r
+            pData = pData;\r
+        #else                           /* PSoC 5 */\r
+            if((USBFS_EP[epNumber].addr & USBFS_DIR_IN) != 0u )\r
+            {   /* for the IN EP source is the SRAM memory buffer */\r
+                src = HI16(pData);\r
+                dst = HI16(CYDEV_PERIPH_BASE);\r
+            }\r
+            else\r
+            {   /* for the OUT EP source is the SIE register */\r
+                src = HI16(CYDEV_PERIPH_BASE);\r
+                dst = HI16(pData);\r
+            }\r
+        #endif  /* End C51 */\r
+        switch(epNumber)\r
+        {\r
+            case USBFS_EP1:\r
+                #if(USBFS_DMA1_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep1_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA1_REMOVE */\r
+                break;\r
+            case USBFS_EP2:\r
+                #if(USBFS_DMA2_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep2_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA2_REMOVE */\r
+                break;\r
+            case USBFS_EP3:\r
+                #if(USBFS_DMA3_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep3_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA3_REMOVE */\r
+                break;\r
+            case USBFS_EP4:\r
+                #if(USBFS_DMA4_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep4_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA4_REMOVE */\r
+                break;\r
+            case USBFS_EP5:\r
+                #if(USBFS_DMA5_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep5_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA5_REMOVE */\r
+                break;\r
+            case USBFS_EP6:\r
+                #if(USBFS_DMA6_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep6_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA6_REMOVE */\r
+                break;\r
+            case USBFS_EP7:\r
+                #if(USBFS_DMA7_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep7_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA7_REMOVE */\r
+                break;\r
+            case USBFS_EP8:\r
+                #if(USBFS_DMA8_REMOVE == 0u)\r
+                    USBFS_DmaChan[epNumber] = USBFS_ep8_DmaInitialize(\r
+                        USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);\r
+                #endif   /* End USBFS_DMA8_REMOVE */\r
+                break;\r
+            default:\r
+                /* Do not support EP0 DMA transfers */\r
+                break;\r
+        }\r
+        if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))\r
+        {\r
+            USBFS_DmaTd[epNumber] = CyDmaTdAllocate();\r
+        }\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_Stop_DMA\r
+    ********************************************************************************\r
+    *\r
+    * Summary: Stops and free DMA\r
+    *\r
+    * Parameters:\r
+    *  epNumber: Contains the data endpoint number or\r
+    *           USBFS_MAX_EP to stop all DMAs\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    void USBFS_Stop_DMA(uint8 epNumber) \r
+    {\r
+        uint8 i;\r
+        i = (epNumber < USBFS_MAX_EP) ? epNumber : USBFS_EP1;\r
+        do\r
+        {\r
+            if(USBFS_DmaTd[i] != DMA_INVALID_TD)\r
+            {\r
+                (void) CyDmaChDisable(USBFS_DmaChan[i]);\r
+                CyDmaTdFree(USBFS_DmaTd[i]);\r
+                USBFS_DmaTd[i] = DMA_INVALID_TD;\r
+            }\r
+            i++;\r
+        }while((i < USBFS_MAX_EP) && (epNumber == USBFS_MAX_EP));\r
+    }\r
+\r
+#endif /* End USBFS_EP_MM != USBFS__EP_MANUAL */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_LoadInEP\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Loads and enables the specified USB data endpoint for an IN interrupt or bulk\r
+*  transfer.\r
+*\r
+* Parameters:\r
+*  epNumber: Contains the data endpoint number.\r
+*            Valid values are between 1 and 8.\r
+*  *pData: A pointer to a data array from which the data for the endpoint space\r
+*          is loaded.\r
+*  length: The number of bytes to transfer from the array and then send as a\r
+*          result of an IN request. Valid values are between 0 and 512.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_LoadInEP(uint8 epNumber, const uint8 pData[], uint16 length)\r
+                                                                        \r
+{\r
+    uint8 ri;\r
+    reg8 *p;\r
+    #if(USBFS_EP_MM == USBFS__EP_MANUAL)\r
+        uint16 i;\r
+    #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */\r
+\r
+    if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))\r
+    {\r
+        ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);\r
+        p = (reg8 *)(USBFS_ARB_RW1_DR_IND + ri);\r
+\r
+        #if(USBFS_EP_MM != USBFS__EP_DMAAUTO)\r
+            /* Limits length to available buffer space, auto MM could send packets up to 1024 bytes */\r
+            if(length > (USBFS_EPX_DATA_BUF_MAX - USBFS_EP[epNumber].buffOffset))\r
+            {\r
+                length = USBFS_EPX_DATA_BUF_MAX - USBFS_EP[epNumber].buffOffset;\r
+            }\r
+        #endif /* End USBFS_EP_MM != USBFS__EP_DMAAUTO */\r
+\r
+        /* Set the count and data toggle */\r
+        CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CNT0_IND + ri),\r
+                            (length >> 8u) | (USBFS_EP[epNumber].epToggle));\r
+        CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CNT1_IND + ri),  length & 0xFFu);\r
+\r
+        #if(USBFS_EP_MM == USBFS__EP_MANUAL)\r
+            if(pData != NULL)\r
+            {\r
+                /* Copy the data using the arbiter data register */\r
+                for (i = 0u; i < length; i++)\r
+                {\r
+                    CY_SET_REG8(p, pData[i]);\r
+                }\r
+            }\r
+            USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;\r
+            /* Write the Mode register */\r
+            CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);\r
+        #else\r
+            /* Init DMA if it was not initialized */\r
+            if(USBFS_DmaTd[epNumber] == DMA_INVALID_TD)\r
+            {\r
+                USBFS_InitEP_DMA(epNumber, pData);\r
+            }\r
+        #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */\r
+\r
+        #if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)\r
+            USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;\r
+            if((pData != NULL) && (length > 0u))\r
+            {\r
+                /* Enable DMA in mode2 for transferring data */\r
+                (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);\r
+                (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length, CY_DMA_DISABLE_TD,\r
+                                                                                 TD_TERMIN_EN | TD_INC_SRC_ADR);\r
+                (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)pData), LO16((uint32)p));\r
+                /* Enable the DMA */\r
+                (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);\r
+                (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);\r
+                /* Generate DMA request */\r
+                * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) |= USBFS_ARB_EPX_CFG_DMA_REQ;\r
+                * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) &= ((uint8)(~USBFS_ARB_EPX_CFG_DMA_REQ));\r
+                /* Mode register will be written in arb ISR after DMA transfer complete */\r
+            }\r
+            else\r
+            {\r
+                /* When zero-length packet - write the Mode register directly */\r
+                CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);\r
+            }\r
+        #endif /* End USBFS_EP_MM == USBFS__EP_DMAMANUAL */\r
+\r
+        #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)\r
+            if(pData != NULL)\r
+            {\r
+                /* Enable DMA in mode3 for transferring data */\r
+                (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);\r
+                (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length,\r
+                                               USBFS_DmaTd[epNumber], TD_TERMIN_EN | TD_INC_SRC_ADR);\r
+                (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)pData), LO16((uint32)p));\r
+                /* Clear Any potential pending DMA requests before starting the DMA channel to transfer data */\r
+                (void) CyDmaClearPendingDrq(USBFS_DmaChan[epNumber]);\r
+                /* Enable the DMA */\r
+                (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);\r
+                (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);\r
+            }\r
+            else\r
+            {\r
+                USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;\r
+                if(length > 0u)\r
+                {\r
+                    /* Set Data ready status, This will generate DMA request */\r
+                    * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) |= USBFS_ARB_EPX_CFG_IN_DATA_RDY;\r
+                    /* Mode register will be written in arb ISR(In Buffer Full) after first DMA transfer complete */\r
+                }\r
+                else\r
+                {\r
+                    /* When zero-length packet - write the Mode register directly */\r
+                    CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);\r
+                }\r
+            }\r
+        #endif /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */\r
+\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_ReadOutEP\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Read data from an endpoint.  The application must call\r
+*  USBFS_GetEPState to see if an event is pending.\r
+*\r
+* Parameters:\r
+*  epNumber: Contains the data endpoint number.\r
+*            Valid values are between 1 and 8.\r
+*  pData: A pointer to a data array from which the data for the endpoint space\r
+*         is loaded.\r
+*  length: The number of bytes to transfer from the USB Out endpoint and loads\r
+*          it into data array. Valid values are between 0 and 1023. The function\r
+*          moves fewer than the requested number of bytes if the host sends\r
+*          fewer bytes than requested.\r
+*\r
+* Returns:\r
+*  Number of bytes received, 0 for an invalid endpoint.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint16 USBFS_ReadOutEP(uint8 epNumber, uint8 pData[], uint16 length)\r
+                                                                        \r
+{\r
+    uint8 ri;\r
+    reg8 *p;\r
+    #if(USBFS_EP_MM == USBFS__EP_MANUAL)\r
+        uint16 i;\r
+    #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */\r
+    #if(USBFS_EP_MM != USBFS__EP_DMAAUTO)\r
+        uint16 xferCount;\r
+    #endif /* End USBFS_EP_MM != USBFS__EP_DMAAUTO */\r
+\r
+    if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP) && (pData != NULL))\r
+    {\r
+        ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);\r
+        p = (reg8 *)(USBFS_ARB_RW1_DR_IND + ri);\r
+\r
+        #if(USBFS_EP_MM != USBFS__EP_DMAAUTO)\r
+            /* Determine which is smaller the requested data or the available data */\r
+            xferCount = USBFS_GetEPCount(epNumber);\r
+            if (length > xferCount)\r
+            {\r
+                length = xferCount;\r
+            }\r
+        #endif /* End USBFS_EP_MM != USBFS__EP_DMAAUTO */\r
+\r
+        #if(USBFS_EP_MM == USBFS__EP_MANUAL)\r
+            /* Copy the data using the arbiter data register */\r
+            for (i = 0u; i < length; i++)\r
+            {\r
+                pData[i] = CY_GET_REG8(p);\r
+            }\r
+\r
+            /* (re)arming of OUT endpoint */\r
+            USBFS_EnableOutEP(epNumber);\r
+        #else\r
+            /*Init DMA if it was not initialized */\r
+            if(USBFS_DmaTd[epNumber] == DMA_INVALID_TD)\r
+            {\r
+                USBFS_InitEP_DMA(epNumber, pData);\r
+            }\r
+        #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */\r
+\r
+        #if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)\r
+            /* Enable DMA in mode2 for transferring data */\r
+            (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);\r
+            (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length, CY_DMA_DISABLE_TD,\r
+                                                                                TD_TERMIN_EN | TD_INC_DST_ADR);\r
+            (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)p), LO16((uint32)pData));\r
+            /* Enable the DMA */\r
+            (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);\r
+            (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);\r
+\r
+            /* Generate DMA request */\r
+            * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) |= USBFS_ARB_EPX_CFG_DMA_REQ;\r
+            * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) &= ((uint8)(~USBFS_ARB_EPX_CFG_DMA_REQ));\r
+            /* Out EP will be (re)armed in arb ISR after transfer complete */\r
+        #endif /* End USBFS_EP_MM == USBFS__EP_DMAMANUAL */\r
+\r
+        #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)\r
+            /* Enable DMA in mode3 for transferring data */\r
+            (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);\r
+            (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length, USBFS_DmaTd[epNumber],\r
+                                                                                TD_TERMIN_EN | TD_INC_DST_ADR);\r
+            (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)p), LO16((uint32)pData));\r
+\r
+            /* Clear Any potential pending DMA requests before starting the DMA channel to transfer data */\r
+            (void) CyDmaClearPendingDrq(USBFS_DmaChan[epNumber]);\r
+            /* Enable the DMA */\r
+            (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);\r
+            (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);\r
+            /* Out EP will be (re)armed in arb ISR after transfer complete */\r
+        #endif /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */\r
+\r
+    }\r
+    else\r
+    {\r
+        length = 0u;\r
+    }\r
+\r
+    return(length);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_EnableOutEP\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This function enables an OUT endpoint.  It should not be\r
+*  called for an IN endpoint.\r
+*\r
+* Parameters:\r
+*  epNumber: Endpoint Number\r
+*            Valid values are between 1 and 8.\r
+*\r
+* Return:\r
+*   None.\r
+*\r
+* Global variables:\r
+*  USBFS_EP[epNumber].apiEpState - set to NO_EVENT_PENDING\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_EnableOutEP(uint8 epNumber) \r
+{\r
+    uint8 ri;\r
+\r
+    if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))\r
+    {\r
+        ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);\r
+        USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;\r
+        /* Write the Mode register */\r
+        CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_DisableOutEP\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This function disables an OUT endpoint.  It should not be\r
+*  called for an IN endpoint.\r
+*\r
+* Parameters:\r
+*  epNumber: Endpoint Number\r
+*            Valid values are between 1 and 8.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+*******************************************************************************/\r
+void USBFS_DisableOutEP(uint8 epNumber) \r
+{\r
+    uint8 ri ;\r
+\r
+    if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))\r
+    {\r
+        ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);\r
+        /* Write the Mode register */\r
+        CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_MODE_NAK_OUT);\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Force\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Forces the bus state\r
+*\r
+* Parameters:\r
+*  bState\r
+*    USBFS_FORCE_J\r
+*    USBFS_FORCE_K\r
+*    USBFS_FORCE_SE0\r
+*    USBFS_FORCE_NONE\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+*******************************************************************************/\r
+void USBFS_Force(uint8 bState) \r
+{\r
+    CY_SET_REG8(USBFS_USBIO_CR0_PTR, bState);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_GetEPAckState\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returns the ACK of the CR0 Register (ACKD)\r
+*\r
+* Parameters:\r
+*  epNumber: Endpoint Number\r
+*            Valid values are between 1 and 8.\r
+*\r
+* Returns\r
+*  0 if nothing has been ACKD, non-=zero something has been ACKD\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_GetEPAckState(uint8 epNumber) \r
+{\r
+    uint8 ri;\r
+    uint8 cr = 0u;\r
+\r
+    if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))\r
+    {\r
+        ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);\r
+        cr = CY_GET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri)) & USBFS_MODE_ACKD;\r
+    }\r
+\r
+    return(cr);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_SetPowerStatus\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Sets the device power status for reporting in the Get Device Status\r
+*  request\r
+*\r
+* Parameters:\r
+*  powerStatus: USBFS_DEVICE_STATUS_BUS_POWERED(0) - Bus Powered,\r
+*               USBFS_DEVICE_STATUS_SELF_POWERED(1) - Self Powered\r
+*\r
+* Return:\r
+*   None.\r
+*\r
+* Global variables:\r
+*  USBFS_deviceStatus - set power status\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_SetPowerStatus(uint8 powerStatus) \r
+{\r
+    if (powerStatus != USBFS_DEVICE_STATUS_BUS_POWERED)\r
+    {\r
+        USBFS_deviceStatus |=  USBFS_DEVICE_STATUS_SELF_POWERED;\r
+    }\r
+    else\r
+    {\r
+        USBFS_deviceStatus &=  ((uint8)(~USBFS_DEVICE_STATUS_SELF_POWERED));\r
+    }\r
+}\r
+\r
+\r
+#if (USBFS_MON_VBUS == 1u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_VBusPresent\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Determines VBUS presence for Self Powered Devices.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  1 if VBUS is present, otherwise 0.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_VBusPresent(void) \r
+    {\r
+        return((0u != (CY_GET_REG8(USBFS_VBUS_PS_PTR) & USBFS_VBUS_MASK)) ? 1u : 0u);\r
+    }\r
+\r
+#endif /* USBFS_MON_VBUS */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_RWUEnabled\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returns TRUE if Remote Wake Up is enabled, otherwise FALSE\r
+*\r
+* Parameters:\r
+*   None.\r
+*\r
+* Return:\r
+*  TRUE -  Remote Wake Up Enabled\r
+*  FALSE - Remote Wake Up Disabled\r
+*\r
+* Global variables:\r
+*  USBFS_deviceStatus - checked to determine remote status\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_RWUEnabled(void) \r
+{\r
+    uint8 result = USBFS_FALSE;\r
+    if((USBFS_deviceStatus & USBFS_DEVICE_STATUS_REMOTE_WAKEUP) != 0u)\r
+    {\r
+        result = USBFS_TRUE;\r
+    }\r
+\r
+    return(result);\r
+}\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS.h
new file mode 100755 (executable)
index 0000000..e7fd899
--- /dev/null
@@ -0,0 +1,1189 @@
+/*******************************************************************************\r
+* File Name: USBFS.h\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  Header File for the USFS component. Contains prototypes and constant values.\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_USBFS_USBFS_H)\r
+#define CY_USBFS_USBFS_H\r
+\r
+#include "cytypes.h"\r
+#include "cydevice_trm.h"\r
+#include "cyfitter.h"\r
+#include "CyLib.h"\r
+\r
+\r
+/***************************************\r
+* Conditional Compilation Parameters\r
+***************************************/\r
+\r
+/* Check to see if required defines such as CY_PSOC5LP are available */\r
+/* They are defined starting with cy_boot v3.0 */\r
+#if !defined (CY_PSOC5LP)\r
+    #error Component USBFS_v2_60 requires cy_boot v3.0 or later\r
+#endif /* (CY_PSOC5LP) */\r
+\r
+\r
+/***************************************\r
+*  Memory Type Definitions\r
+***************************************/\r
+\r
+/* Renamed Type Definitions for backward compatibility.\r
+*  Should not be used in new designs.\r
+*/\r
+#define USBFS_CODE CYCODE\r
+#define USBFS_FAR CYFAR\r
+#if defined(__C51__) || defined(__CX51__)\r
+    #define USBFS_DATA data\r
+    #define USBFS_XDATA xdata\r
+#else\r
+    #define USBFS_DATA\r
+    #define USBFS_XDATA\r
+#endif /* End __C51__ */\r
+#define USBFS_NULL       NULL\r
+\r
+\r
+/***************************************\r
+* Enumerated Types and Parameters\r
+***************************************/\r
+\r
+#define USBFS__EP_MANUAL 0\r
+#define USBFS__EP_DMAMANUAL 1\r
+#define USBFS__EP_DMAAUTO 2\r
+\r
+#define USBFS__MA_STATIC 0\r
+#define USBFS__MA_DYNAMIC 1\r
+\r
+\r
+\r
+/***************************************\r
+*    Initial Parameter Constants\r
+***************************************/\r
+\r
+#define USBFS_NUM_DEVICES   (1u)\r
+#define USBFS_ENABLE_DESCRIPTOR_STRINGS   \r
+#define USBFS_ENABLE_SN_STRING   \r
+#define USBFS_ENABLE_STRINGS   \r
+#define USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_BUF_SIZE   (65u)\r
+#define USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_NUM_IN_RPTS   (1u)\r
+#define USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_BUF_SIZE   (65u)\r
+#define USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_NUM_OUT_RPTS   (1u)\r
+#define USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_COUNT   (1u)\r
+#define USBFS_ENABLE_HID_CLASS   \r
+#define USBFS_HID_RPT_1_SIZE_LSB   (0x24u)\r
+#define USBFS_HID_RPT_1_SIZE_MSB   (0x00u)\r
+#define USBFS_MAX_REPORTID_NUMBER   (0u)\r
+\r
+#define USBFS_MON_VBUS                       (0u)\r
+#define USBFS_EXTERN_VBUS                    (0u)\r
+#define USBFS_EXTERN_VND                     (0u)\r
+#define USBFS_EXTERN_CLS                     (0u)\r
+#define USBFS_MAX_INTERFACES_NUMBER          (1u)\r
+#define USBFS_EP0_ISR_REMOVE                 (0u)\r
+#define USBFS_EP1_ISR_REMOVE                 (0u)\r
+#define USBFS_EP2_ISR_REMOVE                 (0u)\r
+#define USBFS_EP3_ISR_REMOVE                 (1u)\r
+#define USBFS_EP4_ISR_REMOVE                 (1u)\r
+#define USBFS_EP5_ISR_REMOVE                 (1u)\r
+#define USBFS_EP6_ISR_REMOVE                 (1u)\r
+#define USBFS_EP7_ISR_REMOVE                 (1u)\r
+#define USBFS_EP8_ISR_REMOVE                 (1u)\r
+#define USBFS_EP_MM                          (0u)\r
+#define USBFS_EP_MA                          (0u)\r
+#define USBFS_DMA1_REMOVE                    (1u)\r
+#define USBFS_DMA2_REMOVE                    (1u)\r
+#define USBFS_DMA3_REMOVE                    (1u)\r
+#define USBFS_DMA4_REMOVE                    (1u)\r
+#define USBFS_DMA5_REMOVE                    (1u)\r
+#define USBFS_DMA6_REMOVE                    (1u)\r
+#define USBFS_DMA7_REMOVE                    (1u)\r
+#define USBFS_DMA8_REMOVE                    (1u)\r
+#define USBFS_SOF_ISR_REMOVE                 (0u)\r
+#define USBFS_ARB_ISR_REMOVE                 (0u)\r
+#define USBFS_DP_ISR_REMOVE                  (0u)\r
+#define USBFS_ENABLE_CDC_CLASS_API           (1u)\r
+#define USBFS_ENABLE_MIDI_API                (1u)\r
+#define USBFS_MIDI_EXT_MODE                  (0u)\r
+\r
+\r
+/***************************************\r
+*    Data Struct Definition\r
+***************************************/\r
+\r
+typedef struct\r
+{\r
+    uint8  attrib;\r
+    uint8  apiEpState;\r
+    uint8  hwEpState;\r
+    uint8  epToggle;\r
+    uint8  addr;\r
+    uint8  epMode;\r
+    uint16 buffOffset;\r
+    uint16 bufferSize;\r
+    uint8  interface;\r
+} T_USBFS_EP_CTL_BLOCK;\r
+\r
+typedef struct\r
+{\r
+    uint8  interface;\r
+    uint8  altSetting;\r
+    uint8  addr;\r
+    uint8  attributes;\r
+    uint16 bufferSize;\r
+    uint8  bMisc;\r
+} T_USBFS_EP_SETTINGS_BLOCK;\r
+\r
+typedef struct\r
+{\r
+    uint8  status;\r
+    uint16 length;\r
+} T_USBFS_XFER_STATUS_BLOCK;\r
+\r
+typedef struct\r
+{\r
+    uint16  count;\r
+    volatile uint8 *pData;\r
+    T_USBFS_XFER_STATUS_BLOCK *pStatusBlock;\r
+} T_USBFS_TD;\r
+\r
+\r
+typedef struct\r
+{\r
+    uint8   c;\r
+    const void *p_list;\r
+} T_USBFS_LUT;\r
+\r
+/* Resume/Suspend API Support */\r
+typedef struct\r
+{\r
+    uint8 enableState;\r
+    uint8 mode;\r
+} USBFS_BACKUP_STRUCT;\r
+\r
+\r
+/* Renamed structure fields for backward compatibility.\r
+*  Should not be used in new designs.\r
+*/\r
+#define wBuffOffset         buffOffset\r
+#define wBufferSize         bufferSize\r
+#define bStatus             status\r
+#define wLength             length\r
+#define wCount              count\r
+\r
+/* Renamed global variable for backward compatibility.\r
+*  Should not be used in new designs.\r
+*/\r
+#define CurrentTD           USBFS_currentTD\r
+\r
+\r
+/***************************************\r
+*       Function Prototypes\r
+***************************************/\r
+\r
+void   USBFS_Start(uint8 device, uint8 mode) ;\r
+void   USBFS_Init(void) ;\r
+void   USBFS_InitComponent(uint8 device, uint8 mode) ;\r
+void   USBFS_Stop(void) ;\r
+uint8  USBFS_CheckActivity(void) ;\r
+uint8  USBFS_GetConfiguration(void) ;\r
+uint8  USBFS_IsConfigurationChanged(void) ;\r
+uint8  USBFS_GetInterfaceSetting(uint8 interfaceNumber)\r
+                                                        ;\r
+uint8  USBFS_GetEPState(uint8 epNumber) ;\r
+uint16 USBFS_GetEPCount(uint8 epNumber) ;\r
+void   USBFS_LoadInEP(uint8 epNumber, const uint8 pData[], uint16 length)\r
+                                                                    ;\r
+uint16 USBFS_ReadOutEP(uint8 epNumber, uint8 pData[], uint16 length)\r
+                                                                    ;\r
+void   USBFS_EnableOutEP(uint8 epNumber) ;\r
+void   USBFS_DisableOutEP(uint8 epNumber) ;\r
+void   USBFS_Force(uint8 bState) ;\r
+uint8  USBFS_GetEPAckState(uint8 epNumber) ;\r
+void   USBFS_SetPowerStatus(uint8 powerStatus) ;\r
+uint8  USBFS_RWUEnabled(void) ;\r
+void   USBFS_TerminateEP(uint8 ep) ;\r
+\r
+void   USBFS_Suspend(void) ;\r
+void   USBFS_Resume(void) ;\r
+\r
+#if defined(USBFS_ENABLE_FWSN_STRING)\r
+    void   USBFS_SerialNumString(uint8 snString[]) ;\r
+#endif  /* USBFS_ENABLE_FWSN_STRING */\r
+#if (USBFS_MON_VBUS == 1u)\r
+    uint8  USBFS_VBusPresent(void) ;\r
+#endif /* End USBFS_MON_VBUS */\r
+\r
+#if defined(CYDEV_BOOTLOADER_IO_COMP) && ((CYDEV_BOOTLOADER_IO_COMP == CyBtldr_USBFS) || \\r
+                                          (CYDEV_BOOTLOADER_IO_COMP == CyBtldr_Custom_Interface))\r
+\r
+    void USBFS_CyBtldrCommStart(void) ;\r
+    void USBFS_CyBtldrCommStop(void) ;\r
+    void USBFS_CyBtldrCommReset(void) ;\r
+    cystatus USBFS_CyBtldrCommWrite(uint8 *pData, uint16 size, uint16 *count, uint8 timeOut) CYSMALL\r
+                                                        ;\r
+    cystatus USBFS_CyBtldrCommRead( uint8 *pData, uint16 size, uint16 *count, uint8 timeOut) CYSMALL\r
+                                                        ;\r
+\r
+    #define USBFS_BTLDR_SIZEOF_WRITE_BUFFER      (64u)    /* EP 1 OUT */\r
+    #define USBFS_BTLDR_SIZEOF_READ_BUFFER       (64u)    /* EP 2 IN */\r
+    #define USBFS_BTLDR_MAX_PACKET_SIZE          USBFS_BTLDR_SIZEOF_WRITE_BUFFER\r
+\r
+    /* These defines active if used USBFS interface as an\r
+    *  IO Component for bootloading. When Custom_Interface selected\r
+    *  in Bootloder configuration as the IO Component, user must\r
+    *  provide these functions\r
+    */\r
+    #if (CYDEV_BOOTLOADER_IO_COMP == CyBtldr_USBFS)\r
+        #define CyBtldrCommStart        USBFS_CyBtldrCommStart\r
+        #define CyBtldrCommStop         USBFS_CyBtldrCommStop\r
+        #define CyBtldrCommReset        USBFS_CyBtldrCommReset\r
+        #define CyBtldrCommWrite        USBFS_CyBtldrCommWrite\r
+        #define CyBtldrCommRead         USBFS_CyBtldrCommRead\r
+    #endif  /*End   CYDEV_BOOTLOADER_IO_COMP == CyBtldr_USBFS */\r
+\r
+#endif /* End CYDEV_BOOTLOADER_IO_COMP  */\r
+\r
+#if(USBFS_EP_MM != USBFS__EP_MANUAL)\r
+    void USBFS_InitEP_DMA(uint8 epNumber, const uint8 *pData)\r
+                                                    ;\r
+    void USBFS_Stop_DMA(uint8 epNumber) ;\r
+#endif /* End USBFS_EP_MM != USBFS__EP_MANUAL) */\r
+\r
+#if defined(USBFS_ENABLE_MIDI_STREAMING) && (USBFS_ENABLE_MIDI_API != 0u)\r
+    void USBFS_MIDI_EP_Init(void) ;\r
+\r
+    #if (USBFS_MIDI_IN_BUFF_SIZE > 0)\r
+        void USBFS_MIDI_IN_Service(void) ;\r
+        uint8 USBFS_PutUsbMidiIn(uint8 ic, const uint8 midiMsg[], uint8 cable)\r
+                                                                ;\r
+    #endif /* USBFS_MIDI_IN_BUFF_SIZE > 0 */\r
+\r
+    #if (USBFS_MIDI_OUT_BUFF_SIZE > 0)\r
+        void USBFS_MIDI_OUT_EP_Service(void) ;\r
+    #endif /* USBFS_MIDI_OUT_BUFF_SIZE > 0 */\r
+\r
+#endif /* End USBFS_ENABLE_MIDI_API != 0u */\r
+\r
+/* Renamed Functions for backward compatibility.\r
+*  Should not be used in new designs.\r
+*/\r
+\r
+#define USBFS_bCheckActivity             USBFS_CheckActivity\r
+#define USBFS_bGetConfiguration          USBFS_GetConfiguration\r
+#define USBFS_bGetInterfaceSetting       USBFS_GetInterfaceSetting\r
+#define USBFS_bGetEPState                USBFS_GetEPState\r
+#define USBFS_wGetEPCount                USBFS_GetEPCount\r
+#define USBFS_bGetEPAckState             USBFS_GetEPAckState\r
+#define USBFS_bRWUEnabled                USBFS_RWUEnabled\r
+#define USBFS_bVBusPresent               USBFS_VBusPresent\r
+\r
+#define USBFS_bConfiguration             USBFS_configuration\r
+#define USBFS_bInterfaceSetting          USBFS_interfaceSetting\r
+#define USBFS_bDeviceAddress             USBFS_deviceAddress\r
+#define USBFS_bDeviceStatus              USBFS_deviceStatus\r
+#define USBFS_bDevice                    USBFS_device\r
+#define USBFS_bTransferState             USBFS_transferState\r
+#define USBFS_bLastPacketSize            USBFS_lastPacketSize\r
+\r
+#define USBFS_LoadEP                     USBFS_LoadInEP\r
+#define USBFS_LoadInISOCEP               USBFS_LoadInEP\r
+#define USBFS_EnableOutISOCEP            USBFS_EnableOutEP\r
+\r
+#define USBFS_SetVector                  CyIntSetVector\r
+#define USBFS_SetPriority                CyIntSetPriority\r
+#define USBFS_EnableInt                  CyIntEnable\r
+\r
+\r
+/***************************************\r
+*          API Constants\r
+***************************************/\r
+\r
+#define USBFS_EP0                        (0u)\r
+#define USBFS_EP1                        (1u)\r
+#define USBFS_EP2                        (2u)\r
+#define USBFS_EP3                        (3u)\r
+#define USBFS_EP4                        (4u)\r
+#define USBFS_EP5                        (5u)\r
+#define USBFS_EP6                        (6u)\r
+#define USBFS_EP7                        (7u)\r
+#define USBFS_EP8                        (8u)\r
+#define USBFS_MAX_EP                     (9u)\r
+\r
+#define USBFS_TRUE                       (1u)\r
+#define USBFS_FALSE                      (0u)\r
+\r
+#define USBFS_NO_EVENT_ALLOWED           (2u)\r
+#define USBFS_EVENT_PENDING              (1u)\r
+#define USBFS_NO_EVENT_PENDING           (0u)\r
+\r
+#define USBFS_IN_BUFFER_FULL             USBFS_NO_EVENT_PENDING\r
+#define USBFS_IN_BUFFER_EMPTY            USBFS_EVENT_PENDING\r
+#define USBFS_OUT_BUFFER_FULL            USBFS_EVENT_PENDING\r
+#define USBFS_OUT_BUFFER_EMPTY           USBFS_NO_EVENT_PENDING\r
+\r
+#define USBFS_FORCE_J                    (0xA0u)\r
+#define USBFS_FORCE_K                    (0x80u)\r
+#define USBFS_FORCE_SE0                  (0xC0u)\r
+#define USBFS_FORCE_NONE                 (0x00u)\r
+\r
+#define USBFS_IDLE_TIMER_RUNNING         (0x02u)\r
+#define USBFS_IDLE_TIMER_EXPIRED         (0x01u)\r
+#define USBFS_IDLE_TIMER_INDEFINITE      (0x00u)\r
+\r
+#define USBFS_DEVICE_STATUS_BUS_POWERED  (0x00u)\r
+#define USBFS_DEVICE_STATUS_SELF_POWERED (0x01u)\r
+\r
+#define USBFS_3V_OPERATION               (0x00u)\r
+#define USBFS_5V_OPERATION               (0x01u)\r
+#define USBFS_DWR_VDDD_OPERATION         (0x02u)\r
+\r
+#define USBFS_MODE_DISABLE               (0x00u)\r
+#define USBFS_MODE_NAK_IN_OUT            (0x01u)\r
+#define USBFS_MODE_STATUS_OUT_ONLY       (0x02u)\r
+#define USBFS_MODE_STALL_IN_OUT          (0x03u)\r
+#define USBFS_MODE_RESERVED_0100         (0x04u)\r
+#define USBFS_MODE_ISO_OUT               (0x05u)\r
+#define USBFS_MODE_STATUS_IN_ONLY        (0x06u)\r
+#define USBFS_MODE_ISO_IN                (0x07u)\r
+#define USBFS_MODE_NAK_OUT               (0x08u)\r
+#define USBFS_MODE_ACK_OUT               (0x09u)\r
+#define USBFS_MODE_RESERVED_1010         (0x0Au)\r
+#define USBFS_MODE_ACK_OUT_STATUS_IN     (0x0Bu)\r
+#define USBFS_MODE_NAK_IN                (0x0Cu)\r
+#define USBFS_MODE_ACK_IN                (0x0Du)\r
+#define USBFS_MODE_RESERVED_1110         (0x0Eu)\r
+#define USBFS_MODE_ACK_IN_STATUS_OUT     (0x0Fu)\r
+#define USBFS_MODE_MASK                  (0x0Fu)\r
+#define USBFS_MODE_STALL_DATA_EP         (0x80u)\r
+\r
+#define USBFS_MODE_ACKD                  (0x10u)\r
+#define USBFS_MODE_OUT_RCVD              (0x20u)\r
+#define USBFS_MODE_IN_RCVD               (0x40u)\r
+#define USBFS_MODE_SETUP_RCVD            (0x80u)\r
+\r
+#define USBFS_RQST_TYPE_MASK             (0x60u)\r
+#define USBFS_RQST_TYPE_STD              (0x00u)\r
+#define USBFS_RQST_TYPE_CLS              (0x20u)\r
+#define USBFS_RQST_TYPE_VND              (0x40u)\r
+#define USBFS_RQST_DIR_MASK              (0x80u)\r
+#define USBFS_RQST_DIR_D2H               (0x80u)\r
+#define USBFS_RQST_DIR_H2D               (0x00u)\r
+#define USBFS_RQST_RCPT_MASK             (0x03u)\r
+#define USBFS_RQST_RCPT_DEV              (0x00u)\r
+#define USBFS_RQST_RCPT_IFC              (0x01u)\r
+#define USBFS_RQST_RCPT_EP               (0x02u)\r
+#define USBFS_RQST_RCPT_OTHER            (0x03u)\r
+\r
+/* USB Class Codes */\r
+#define USBFS_CLASS_DEVICE               (0x00u)     /* Use class code info from Interface Descriptors */\r
+#define USBFS_CLASS_AUDIO                (0x01u)     /* Audio device */\r
+#define USBFS_CLASS_CDC                  (0x02u)     /* Communication device class */\r
+#define USBFS_CLASS_HID                  (0x03u)     /* Human Interface Device */\r
+#define USBFS_CLASS_PDC                  (0x05u)     /* Physical device class */\r
+#define USBFS_CLASS_IMAGE                (0x06u)     /* Still Imaging device */\r
+#define USBFS_CLASS_PRINTER              (0x07u)     /* Printer device  */\r
+#define USBFS_CLASS_MSD                  (0x08u)     /* Mass Storage device  */\r
+#define USBFS_CLASS_HUB                  (0x09u)     /* Full/Hi speed Hub */\r
+#define USBFS_CLASS_CDC_DATA             (0x0Au)     /* CDC data device */\r
+#define USBFS_CLASS_SMART_CARD           (0x0Bu)     /* Smart Card device */\r
+#define USBFS_CLASS_CSD                  (0x0Du)     /* Content Security device */\r
+#define USBFS_CLASS_VIDEO                (0x0Eu)     /* Video device */\r
+#define USBFS_CLASS_PHD                  (0x0Fu)     /* Personal Healthcare device */\r
+#define USBFS_CLASS_WIRELESSD            (0xDCu)     /* Wireless Controller */\r
+#define USBFS_CLASS_MIS                  (0xE0u)     /* Miscellaneous */\r
+#define USBFS_CLASS_APP                  (0xEFu)     /* Application Specific */\r
+#define USBFS_CLASS_VENDOR               (0xFFu)     /* Vendor specific */\r
+\r
+\r
+/* Standard Request Types (Table 9-4) */\r
+#define USBFS_GET_STATUS                 (0x00u)\r
+#define USBFS_CLEAR_FEATURE              (0x01u)\r
+#define USBFS_SET_FEATURE                (0x03u)\r
+#define USBFS_SET_ADDRESS                (0x05u)\r
+#define USBFS_GET_DESCRIPTOR             (0x06u)\r
+#define USBFS_SET_DESCRIPTOR             (0x07u)\r
+#define USBFS_GET_CONFIGURATION          (0x08u)\r
+#define USBFS_SET_CONFIGURATION          (0x09u)\r
+#define USBFS_GET_INTERFACE              (0x0Au)\r
+#define USBFS_SET_INTERFACE              (0x0Bu)\r
+#define USBFS_SYNCH_FRAME                (0x0Cu)\r
+\r
+/* Vendor Specific Request Types */\r
+/* Request for Microsoft OS String Descriptor */\r
+#define USBFS_GET_EXTENDED_CONFIG_DESCRIPTOR (0x01u)\r
+\r
+/* Descriptor Types (Table 9-5) */\r
+#define USBFS_DESCR_DEVICE                   (1u)\r
+#define USBFS_DESCR_CONFIG                   (2u)\r
+#define USBFS_DESCR_STRING                   (3u)\r
+#define USBFS_DESCR_INTERFACE                (4u)\r
+#define USBFS_DESCR_ENDPOINT                 (5u)\r
+#define USBFS_DESCR_DEVICE_QUALIFIER         (6u)\r
+#define USBFS_DESCR_OTHER_SPEED              (7u)\r
+#define USBFS_DESCR_INTERFACE_POWER          (8u)\r
+\r
+/* Device Descriptor Defines */\r
+#define USBFS_DEVICE_DESCR_LENGTH            (18u)\r
+#define USBFS_DEVICE_DESCR_SN_SHIFT          (16u)\r
+\r
+/* Config Descriptor Shifts and Masks */\r
+#define USBFS_CONFIG_DESCR_LENGTH                (0u)\r
+#define USBFS_CONFIG_DESCR_TYPE                  (1u)\r
+#define USBFS_CONFIG_DESCR_TOTAL_LENGTH_LOW      (2u)\r
+#define USBFS_CONFIG_DESCR_TOTAL_LENGTH_HI       (3u)\r
+#define USBFS_CONFIG_DESCR_NUM_INTERFACES        (4u)\r
+#define USBFS_CONFIG_DESCR_CONFIG_VALUE          (5u)\r
+#define USBFS_CONFIG_DESCR_CONFIGURATION         (6u)\r
+#define USBFS_CONFIG_DESCR_ATTRIB                (7u)\r
+#define USBFS_CONFIG_DESCR_ATTRIB_SELF_POWERED   (0x40u)\r
+#define USBFS_CONFIG_DESCR_ATTRIB_RWU_EN         (0x20u)\r
+\r
+/* Feature Selectors (Table 9-6) */\r
+#define USBFS_DEVICE_REMOTE_WAKEUP           (0x01u)\r
+#define USBFS_ENDPOINT_HALT                  (0x00u)\r
+#define USBFS_TEST_MODE                      (0x02u)\r
+\r
+/* USB Device Status (Figure 9-4) */\r
+#define USBFS_DEVICE_STATUS_BUS_POWERED      (0x00u)\r
+#define USBFS_DEVICE_STATUS_SELF_POWERED     (0x01u)\r
+#define USBFS_DEVICE_STATUS_REMOTE_WAKEUP    (0x02u)\r
+\r
+/* USB Endpoint Status (Figure 9-4) */\r
+#define USBFS_ENDPOINT_STATUS_HALT           (0x01u)\r
+\r
+/* USB Endpoint Directions */\r
+#define USBFS_DIR_IN                         (0x80u)\r
+#define USBFS_DIR_OUT                        (0x00u)\r
+#define USBFS_DIR_UNUSED                     (0x7Fu)\r
+\r
+/* USB Endpoint Attributes */\r
+#define USBFS_EP_TYPE_CTRL                   (0x00u)\r
+#define USBFS_EP_TYPE_ISOC                   (0x01u)\r
+#define USBFS_EP_TYPE_BULK                   (0x02u)\r
+#define USBFS_EP_TYPE_INT                    (0x03u)\r
+#define USBFS_EP_TYPE_MASK                   (0x03u)\r
+\r
+#define USBFS_EP_SYNC_TYPE_NO_SYNC           (0x00u)\r
+#define USBFS_EP_SYNC_TYPE_ASYNC             (0x04u)\r
+#define USBFS_EP_SYNC_TYPE_ADAPTIVE          (0x08u)\r
+#define USBFS_EP_SYNC_TYPE_SYNCHRONOUS       (0x0Cu)\r
+#define USBFS_EP_SYNC_TYPE_MASK              (0x0Cu)\r
+\r
+#define USBFS_EP_USAGE_TYPE_DATA             (0x00u)\r
+#define USBFS_EP_USAGE_TYPE_FEEDBACK         (0x10u)\r
+#define USBFS_EP_USAGE_TYPE_IMPLICIT         (0x20u)\r
+#define USBFS_EP_USAGE_TYPE_RESERVED         (0x30u)\r
+#define USBFS_EP_USAGE_TYPE_MASK             (0x30u)\r
+\r
+/* Endpoint Status defines */\r
+#define USBFS_EP_STATUS_LENGTH               (0x02u)\r
+\r
+/* Endpoint Device defines */\r
+#define USBFS_DEVICE_STATUS_LENGTH           (0x02u)\r
+\r
+#define USBFS_STATUS_LENGTH_MAX \\r
+                 ( (USBFS_EP_STATUS_LENGTH > USBFS_DEVICE_STATUS_LENGTH) ? \\r
+                    USBFS_EP_STATUS_LENGTH : USBFS_DEVICE_STATUS_LENGTH )\r
+/* Transfer Completion Notification */\r
+#define USBFS_XFER_IDLE                      (0x00u)\r
+#define USBFS_XFER_STATUS_ACK                (0x01u)\r
+#define USBFS_XFER_PREMATURE                 (0x02u)\r
+#define USBFS_XFER_ERROR                     (0x03u)\r
+\r
+/* Driver State defines */\r
+#define USBFS_TRANS_STATE_IDLE               (0x00u)\r
+#define USBFS_TRANS_STATE_CONTROL_READ       (0x02u)\r
+#define USBFS_TRANS_STATE_CONTROL_WRITE      (0x04u)\r
+#define USBFS_TRANS_STATE_NO_DATA_CONTROL    (0x06u)\r
+\r
+/* String Descriptor defines */\r
+#define USBFS_STRING_MSOS                    (0xEEu)\r
+#define USBFS_MSOS_DESCRIPTOR_LENGTH         (18u)\r
+#define USBFS_MSOS_CONF_DESCR_LENGTH         (40u)\r
+\r
+#if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)\r
+    /* DMA manual mode defines */\r
+    #define USBFS_DMA_BYTES_PER_BURST        (0u)\r
+    #define USBFS_DMA_REQUEST_PER_BURST      (0u)\r
+#endif /* End USBFS_EP_MM == USBFS__EP_DMAMANUAL */\r
+#if(USBFS_EP_MM == USBFS__EP_DMAAUTO)\r
+    /* DMA automatic mode defines */\r
+    #define USBFS_DMA_BYTES_PER_BURST        (32u)\r
+    /* BUF_SIZE-BYTES_PER_BURST examples: 55-32 bytes  44-16 bytes 33-8 bytes 22-4 bytes 11-2 bytes */\r
+    #define USBFS_DMA_BUF_SIZE               (0x55u)\r
+    #define USBFS_DMA_REQUEST_PER_BURST      (1u)\r
+#endif /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */\r
+\r
+/* DIE ID string descriptor defines */\r
+#if defined(USBFS_ENABLE_IDSN_STRING)\r
+    #define USBFS_IDSN_DESCR_LENGTH          (0x22u)\r
+#endif /* USBFS_ENABLE_IDSN_STRING */\r
+\r
+\r
+/***************************************\r
+* External data references\r
+***************************************/\r
+\r
+extern uint8 USBFS_initVar;\r
+extern volatile uint8 USBFS_device;\r
+extern volatile uint8 USBFS_transferState;\r
+extern volatile uint8 USBFS_configuration;\r
+extern volatile uint8 USBFS_configurationChanged;\r
+extern volatile uint8 USBFS_deviceStatus;\r
+\r
+/* HID Variables */\r
+#if defined(USBFS_ENABLE_HID_CLASS)\r
+    extern volatile uint8 USBFS_hidProtocol[USBFS_MAX_INTERFACES_NUMBER];\r
+    extern volatile uint8 USBFS_hidIdleRate[USBFS_MAX_INTERFACES_NUMBER];\r
+    extern volatile uint8 USBFS_hidIdleTimer[USBFS_MAX_INTERFACES_NUMBER];\r
+#endif /* USBFS_ENABLE_HID_CLASS */\r
+\r
+\r
+/***************************************\r
+*              Registers\r
+***************************************/\r
+\r
+#define USBFS_ARB_CFG_PTR        (  (reg8 *) USBFS_USB__ARB_CFG)\r
+#define USBFS_ARB_CFG_REG        (* (reg8 *) USBFS_USB__ARB_CFG)\r
+\r
+#define USBFS_ARB_EP1_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP1_CFG)\r
+#define USBFS_ARB_EP1_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP1_CFG)\r
+#define USBFS_ARB_EP1_CFG_IND    USBFS_USB__ARB_EP1_CFG\r
+#define USBFS_ARB_EP1_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP1_INT_EN)\r
+#define USBFS_ARB_EP1_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP1_INT_EN)\r
+#define USBFS_ARB_EP1_INT_EN_IND USBFS_USB__ARB_EP1_INT_EN\r
+#define USBFS_ARB_EP1_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP1_SR)\r
+#define USBFS_ARB_EP1_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP1_SR)\r
+#define USBFS_ARB_EP1_SR_IND     USBFS_USB__ARB_EP1_SR\r
+\r
+#define USBFS_ARB_EP2_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP2_CFG)\r
+#define USBFS_ARB_EP2_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP2_CFG)\r
+#define USBFS_ARB_EP2_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP2_INT_EN)\r
+#define USBFS_ARB_EP2_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP2_INT_EN)\r
+#define USBFS_ARB_EP2_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP2_SR)\r
+#define USBFS_ARB_EP2_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP2_SR)\r
+\r
+#define USBFS_ARB_EP3_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP3_CFG)\r
+#define USBFS_ARB_EP3_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP3_CFG)\r
+#define USBFS_ARB_EP3_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP3_INT_EN)\r
+#define USBFS_ARB_EP3_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP3_INT_EN)\r
+#define USBFS_ARB_EP3_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP3_SR)\r
+#define USBFS_ARB_EP3_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP3_SR)\r
+\r
+#define USBFS_ARB_EP4_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP4_CFG)\r
+#define USBFS_ARB_EP4_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP4_CFG)\r
+#define USBFS_ARB_EP4_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP4_INT_EN)\r
+#define USBFS_ARB_EP4_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP4_INT_EN)\r
+#define USBFS_ARB_EP4_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP4_SR)\r
+#define USBFS_ARB_EP4_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP4_SR)\r
+\r
+#define USBFS_ARB_EP5_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP5_CFG)\r
+#define USBFS_ARB_EP5_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP5_CFG)\r
+#define USBFS_ARB_EP5_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP5_INT_EN)\r
+#define USBFS_ARB_EP5_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP5_INT_EN)\r
+#define USBFS_ARB_EP5_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP5_SR)\r
+#define USBFS_ARB_EP5_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP5_SR)\r
+\r
+#define USBFS_ARB_EP6_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP6_CFG)\r
+#define USBFS_ARB_EP6_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP6_CFG)\r
+#define USBFS_ARB_EP6_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP6_INT_EN)\r
+#define USBFS_ARB_EP6_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP6_INT_EN)\r
+#define USBFS_ARB_EP6_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP6_SR)\r
+#define USBFS_ARB_EP6_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP6_SR)\r
+\r
+#define USBFS_ARB_EP7_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP7_CFG)\r
+#define USBFS_ARB_EP7_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP7_CFG)\r
+#define USBFS_ARB_EP7_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP7_INT_EN)\r
+#define USBFS_ARB_EP7_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP7_INT_EN)\r
+#define USBFS_ARB_EP7_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP7_SR)\r
+#define USBFS_ARB_EP7_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP7_SR)\r
+\r
+#define USBFS_ARB_EP8_CFG_PTR    (  (reg8 *) USBFS_USB__ARB_EP8_CFG)\r
+#define USBFS_ARB_EP8_CFG_REG    (* (reg8 *) USBFS_USB__ARB_EP8_CFG)\r
+#define USBFS_ARB_EP8_INT_EN_PTR (  (reg8 *) USBFS_USB__ARB_EP8_INT_EN)\r
+#define USBFS_ARB_EP8_INT_EN_REG (* (reg8 *) USBFS_USB__ARB_EP8_INT_EN)\r
+#define USBFS_ARB_EP8_SR_PTR     (  (reg8 *) USBFS_USB__ARB_EP8_SR)\r
+#define USBFS_ARB_EP8_SR_REG     (* (reg8 *) USBFS_USB__ARB_EP8_SR)\r
+\r
+#define USBFS_ARB_INT_EN_PTR     (  (reg8 *) USBFS_USB__ARB_INT_EN)\r
+#define USBFS_ARB_INT_EN_REG     (* (reg8 *) USBFS_USB__ARB_INT_EN)\r
+#define USBFS_ARB_INT_SR_PTR     (  (reg8 *) USBFS_USB__ARB_INT_SR)\r
+#define USBFS_ARB_INT_SR_REG     (* (reg8 *) USBFS_USB__ARB_INT_SR)\r
+\r
+#define USBFS_ARB_RW1_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW1_DR)\r
+#define USBFS_ARB_RW1_DR_IND     USBFS_USB__ARB_RW1_DR\r
+#define USBFS_ARB_RW1_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW1_RA)\r
+#define USBFS_ARB_RW1_RA_IND     USBFS_USB__ARB_RW1_RA\r
+#define USBFS_ARB_RW1_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW1_RA_MSB)\r
+#define USBFS_ARB_RW1_RA_MSB_IND USBFS_USB__ARB_RW1_RA_MSB\r
+#define USBFS_ARB_RW1_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW1_WA)\r
+#define USBFS_ARB_RW1_WA_IND     USBFS_USB__ARB_RW1_WA\r
+#define USBFS_ARB_RW1_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW1_WA_MSB)\r
+#define USBFS_ARB_RW1_WA_MSB_IND USBFS_USB__ARB_RW1_WA_MSB\r
+\r
+#define USBFS_ARB_RW2_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW2_DR)\r
+#define USBFS_ARB_RW2_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW2_RA)\r
+#define USBFS_ARB_RW2_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW2_RA_MSB)\r
+#define USBFS_ARB_RW2_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW2_WA)\r
+#define USBFS_ARB_RW2_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW2_WA_MSB)\r
+\r
+#define USBFS_ARB_RW3_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW3_DR)\r
+#define USBFS_ARB_RW3_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW3_RA)\r
+#define USBFS_ARB_RW3_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW3_RA_MSB)\r
+#define USBFS_ARB_RW3_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW3_WA)\r
+#define USBFS_ARB_RW3_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW3_WA_MSB)\r
+\r
+#define USBFS_ARB_RW4_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW4_DR)\r
+#define USBFS_ARB_RW4_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW4_RA)\r
+#define USBFS_ARB_RW4_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW4_RA_MSB)\r
+#define USBFS_ARB_RW4_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW4_WA)\r
+#define USBFS_ARB_RW4_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW4_WA_MSB)\r
+\r
+#define USBFS_ARB_RW5_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW5_DR)\r
+#define USBFS_ARB_RW5_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW5_RA)\r
+#define USBFS_ARB_RW5_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW5_RA_MSB)\r
+#define USBFS_ARB_RW5_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW5_WA)\r
+#define USBFS_ARB_RW5_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW5_WA_MSB)\r
+\r
+#define USBFS_ARB_RW6_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW6_DR)\r
+#define USBFS_ARB_RW6_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW6_RA)\r
+#define USBFS_ARB_RW6_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW6_RA_MSB)\r
+#define USBFS_ARB_RW6_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW6_WA)\r
+#define USBFS_ARB_RW6_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW6_WA_MSB)\r
+\r
+#define USBFS_ARB_RW7_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW7_DR)\r
+#define USBFS_ARB_RW7_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW7_RA)\r
+#define USBFS_ARB_RW7_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW7_RA_MSB)\r
+#define USBFS_ARB_RW7_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW7_WA)\r
+#define USBFS_ARB_RW7_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW7_WA_MSB)\r
+\r
+#define USBFS_ARB_RW8_DR_PTR     ((reg8 *) USBFS_USB__ARB_RW8_DR)\r
+#define USBFS_ARB_RW8_RA_PTR     ((reg8 *) USBFS_USB__ARB_RW8_RA)\r
+#define USBFS_ARB_RW8_RA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW8_RA_MSB)\r
+#define USBFS_ARB_RW8_WA_PTR     ((reg8 *) USBFS_USB__ARB_RW8_WA)\r
+#define USBFS_ARB_RW8_WA_MSB_PTR ((reg8 *) USBFS_USB__ARB_RW8_WA_MSB)\r
+\r
+#define USBFS_BUF_SIZE_PTR       (  (reg8 *) USBFS_USB__BUF_SIZE)\r
+#define USBFS_BUF_SIZE_REG       (* (reg8 *) USBFS_USB__BUF_SIZE)\r
+#define USBFS_BUS_RST_CNT_PTR    (  (reg8 *) USBFS_USB__BUS_RST_CNT)\r
+#define USBFS_BUS_RST_CNT_REG    (* (reg8 *) USBFS_USB__BUS_RST_CNT)\r
+#define USBFS_CWA_PTR            (  (reg8 *) USBFS_USB__CWA)\r
+#define USBFS_CWA_REG            (* (reg8 *) USBFS_USB__CWA)\r
+#define USBFS_CWA_MSB_PTR        (  (reg8 *) USBFS_USB__CWA_MSB)\r
+#define USBFS_CWA_MSB_REG        (* (reg8 *) USBFS_USB__CWA_MSB)\r
+#define USBFS_CR0_PTR            (  (reg8 *) USBFS_USB__CR0)\r
+#define USBFS_CR0_REG            (* (reg8 *) USBFS_USB__CR0)\r
+#define USBFS_CR1_PTR            (  (reg8 *) USBFS_USB__CR1)\r
+#define USBFS_CR1_REG            (* (reg8 *) USBFS_USB__CR1)\r
+\r
+#define USBFS_DMA_THRES_PTR      (  (reg8 *) USBFS_USB__DMA_THRES)\r
+#define USBFS_DMA_THRES_REG      (* (reg8 *) USBFS_USB__DMA_THRES)\r
+#define USBFS_DMA_THRES_MSB_PTR  (  (reg8 *) USBFS_USB__DMA_THRES_MSB)\r
+#define USBFS_DMA_THRES_MSB_REG  (* (reg8 *) USBFS_USB__DMA_THRES_MSB)\r
+\r
+#define USBFS_EP_ACTIVE_PTR      (  (reg8 *) USBFS_USB__EP_ACTIVE)\r
+#define USBFS_EP_ACTIVE_REG      (* (reg8 *) USBFS_USB__EP_ACTIVE)\r
+#define USBFS_EP_TYPE_PTR        (  (reg8 *) USBFS_USB__EP_TYPE)\r
+#define USBFS_EP_TYPE_REG        (* (reg8 *) USBFS_USB__EP_TYPE)\r
+\r
+#define USBFS_EP0_CNT_PTR        (  (reg8 *) USBFS_USB__EP0_CNT)\r
+#define USBFS_EP0_CNT_REG        (* (reg8 *) USBFS_USB__EP0_CNT)\r
+#define USBFS_EP0_CR_PTR         (  (reg8 *) USBFS_USB__EP0_CR)\r
+#define USBFS_EP0_CR_REG         (* (reg8 *) USBFS_USB__EP0_CR)\r
+#define USBFS_EP0_DR0_PTR        (  (reg8 *) USBFS_USB__EP0_DR0)\r
+#define USBFS_EP0_DR0_REG        (* (reg8 *) USBFS_USB__EP0_DR0)\r
+#define USBFS_EP0_DR0_IND        USBFS_USB__EP0_DR0\r
+#define USBFS_EP0_DR1_PTR        (  (reg8 *) USBFS_USB__EP0_DR1)\r
+#define USBFS_EP0_DR1_REG        (* (reg8 *) USBFS_USB__EP0_DR1)\r
+#define USBFS_EP0_DR2_PTR        (  (reg8 *) USBFS_USB__EP0_DR2)\r
+#define USBFS_EP0_DR2_REG        (* (reg8 *) USBFS_USB__EP0_DR2)\r
+#define USBFS_EP0_DR3_PTR        (  (reg8 *) USBFS_USB__EP0_DR3)\r
+#define USBFS_EP0_DR3_REG        (* (reg8 *) USBFS_USB__EP0_DR3)\r
+#define USBFS_EP0_DR4_PTR        (  (reg8 *) USBFS_USB__EP0_DR4)\r
+#define USBFS_EP0_DR4_REG        (* (reg8 *) USBFS_USB__EP0_DR4)\r
+#define USBFS_EP0_DR5_PTR        (  (reg8 *) USBFS_USB__EP0_DR5)\r
+#define USBFS_EP0_DR5_REG        (* (reg8 *) USBFS_USB__EP0_DR5)\r
+#define USBFS_EP0_DR6_PTR        (  (reg8 *) USBFS_USB__EP0_DR6)\r
+#define USBFS_EP0_DR6_REG        (* (reg8 *) USBFS_USB__EP0_DR6)\r
+#define USBFS_EP0_DR7_PTR        (  (reg8 *) USBFS_USB__EP0_DR7)\r
+#define USBFS_EP0_DR7_REG        (* (reg8 *) USBFS_USB__EP0_DR7)\r
+\r
+#define USBFS_OSCLK_DR0_PTR      (  (reg8 *) USBFS_USB__OSCLK_DR0)\r
+#define USBFS_OSCLK_DR0_REG      (* (reg8 *) USBFS_USB__OSCLK_DR0)\r
+#define USBFS_OSCLK_DR1_PTR      (  (reg8 *) USBFS_USB__OSCLK_DR1)\r
+#define USBFS_OSCLK_DR1_REG      (* (reg8 *) USBFS_USB__OSCLK_DR1)\r
+\r
+#define USBFS_PM_ACT_CFG_PTR     (  (reg8 *) USBFS_USB__PM_ACT_CFG)\r
+#define USBFS_PM_ACT_CFG_REG     (* (reg8 *) USBFS_USB__PM_ACT_CFG)\r
+#define USBFS_PM_STBY_CFG_PTR    (  (reg8 *) USBFS_USB__PM_STBY_CFG)\r
+#define USBFS_PM_STBY_CFG_REG    (* (reg8 *) USBFS_USB__PM_STBY_CFG)\r
+\r
+#define USBFS_SIE_EP_INT_EN_PTR  (  (reg8 *) USBFS_USB__SIE_EP_INT_EN)\r
+#define USBFS_SIE_EP_INT_EN_REG  (* (reg8 *) USBFS_USB__SIE_EP_INT_EN)\r
+#define USBFS_SIE_EP_INT_SR_PTR  (  (reg8 *) USBFS_USB__SIE_EP_INT_SR)\r
+#define USBFS_SIE_EP_INT_SR_REG  (* (reg8 *) USBFS_USB__SIE_EP_INT_SR)\r
+\r
+#define USBFS_SIE_EP1_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP1_CNT0)\r
+#define USBFS_SIE_EP1_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP1_CNT0)\r
+#define USBFS_SIE_EP1_CNT0_IND   USBFS_USB__SIE_EP1_CNT0\r
+#define USBFS_SIE_EP1_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP1_CNT1)\r
+#define USBFS_SIE_EP1_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP1_CNT1)\r
+#define USBFS_SIE_EP1_CNT1_IND   USBFS_USB__SIE_EP1_CNT1\r
+#define USBFS_SIE_EP1_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP1_CR0)\r
+#define USBFS_SIE_EP1_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP1_CR0)\r
+#define USBFS_SIE_EP1_CR0_IND    USBFS_USB__SIE_EP1_CR0\r
+\r
+#define USBFS_SIE_EP2_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP2_CNT0)\r
+#define USBFS_SIE_EP2_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP2_CNT0)\r
+#define USBFS_SIE_EP2_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP2_CNT1)\r
+#define USBFS_SIE_EP2_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP2_CNT1)\r
+#define USBFS_SIE_EP2_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP2_CR0)\r
+#define USBFS_SIE_EP2_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP2_CR0)\r
+\r
+#define USBFS_SIE_EP3_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP3_CNT0)\r
+#define USBFS_SIE_EP3_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP3_CNT0)\r
+#define USBFS_SIE_EP3_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP3_CNT1)\r
+#define USBFS_SIE_EP3_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP3_CNT1)\r
+#define USBFS_SIE_EP3_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP3_CR0)\r
+#define USBFS_SIE_EP3_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP3_CR0)\r
+\r
+#define USBFS_SIE_EP4_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP4_CNT0)\r
+#define USBFS_SIE_EP4_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP4_CNT0)\r
+#define USBFS_SIE_EP4_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP4_CNT1)\r
+#define USBFS_SIE_EP4_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP4_CNT1)\r
+#define USBFS_SIE_EP4_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP4_CR0)\r
+#define USBFS_SIE_EP4_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP4_CR0)\r
+\r
+#define USBFS_SIE_EP5_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP5_CNT0)\r
+#define USBFS_SIE_EP5_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP5_CNT0)\r
+#define USBFS_SIE_EP5_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP5_CNT1)\r
+#define USBFS_SIE_EP5_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP5_CNT1)\r
+#define USBFS_SIE_EP5_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP5_CR0)\r
+#define USBFS_SIE_EP5_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP5_CR0)\r
+\r
+#define USBFS_SIE_EP6_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP6_CNT0)\r
+#define USBFS_SIE_EP6_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP6_CNT0)\r
+#define USBFS_SIE_EP6_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP6_CNT1)\r
+#define USBFS_SIE_EP6_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP6_CNT1)\r
+#define USBFS_SIE_EP6_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP6_CR0)\r
+#define USBFS_SIE_EP6_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP6_CR0)\r
+\r
+#define USBFS_SIE_EP7_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP7_CNT0)\r
+#define USBFS_SIE_EP7_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP7_CNT0)\r
+#define USBFS_SIE_EP7_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP7_CNT1)\r
+#define USBFS_SIE_EP7_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP7_CNT1)\r
+#define USBFS_SIE_EP7_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP7_CR0)\r
+#define USBFS_SIE_EP7_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP7_CR0)\r
+\r
+#define USBFS_SIE_EP8_CNT0_PTR   (  (reg8 *) USBFS_USB__SIE_EP8_CNT0)\r
+#define USBFS_SIE_EP8_CNT0_REG   (* (reg8 *) USBFS_USB__SIE_EP8_CNT0)\r
+#define USBFS_SIE_EP8_CNT1_PTR   (  (reg8 *) USBFS_USB__SIE_EP8_CNT1)\r
+#define USBFS_SIE_EP8_CNT1_REG   (* (reg8 *) USBFS_USB__SIE_EP8_CNT1)\r
+#define USBFS_SIE_EP8_CR0_PTR    (  (reg8 *) USBFS_USB__SIE_EP8_CR0)\r
+#define USBFS_SIE_EP8_CR0_REG    (* (reg8 *) USBFS_USB__SIE_EP8_CR0)\r
+\r
+#define USBFS_SOF0_PTR           (  (reg8 *) USBFS_USB__SOF0)\r
+#define USBFS_SOF0_REG           (* (reg8 *) USBFS_USB__SOF0)\r
+#define USBFS_SOF1_PTR           (  (reg8 *) USBFS_USB__SOF1)\r
+#define USBFS_SOF1_REG           (* (reg8 *) USBFS_USB__SOF1)\r
+\r
+#define USBFS_USB_CLK_EN_PTR     (  (reg8 *) USBFS_USB__USB_CLK_EN)\r
+#define USBFS_USB_CLK_EN_REG     (* (reg8 *) USBFS_USB__USB_CLK_EN)\r
+\r
+#define USBFS_USBIO_CR0_PTR      (  (reg8 *) USBFS_USB__USBIO_CR0)\r
+#define USBFS_USBIO_CR0_REG      (* (reg8 *) USBFS_USB__USBIO_CR0)\r
+#define USBFS_USBIO_CR1_PTR      (  (reg8 *) USBFS_USB__USBIO_CR1)\r
+#define USBFS_USBIO_CR1_REG      (* (reg8 *) USBFS_USB__USBIO_CR1)\r
+#if(!CY_PSOC5LP)\r
+    #define USBFS_USBIO_CR2_PTR      (  (reg8 *) USBFS_USB__USBIO_CR2)\r
+    #define USBFS_USBIO_CR2_REG      (* (reg8 *) USBFS_USB__USBIO_CR2)\r
+#endif /* End CY_PSOC5LP */\r
+\r
+#define USBFS_DIE_ID             CYDEV_FLSHID_CUST_TABLES_BASE\r
+\r
+#define USBFS_PM_USB_CR0_PTR     (  (reg8 *) CYREG_PM_USB_CR0)\r
+#define USBFS_PM_USB_CR0_REG     (* (reg8 *) CYREG_PM_USB_CR0)\r
+#define USBFS_DYN_RECONFIG_PTR   (  (reg8 *) USBFS_USB__DYN_RECONFIG)\r
+#define USBFS_DYN_RECONFIG_REG   (* (reg8 *) USBFS_USB__DYN_RECONFIG)\r
+\r
+#define USBFS_DM_INP_DIS_PTR     (  (reg8 *) USBFS_Dm__INP_DIS)\r
+#define USBFS_DM_INP_DIS_REG     (* (reg8 *) USBFS_Dm__INP_DIS)\r
+#define USBFS_DP_INP_DIS_PTR     (  (reg8 *) USBFS_Dp__INP_DIS)\r
+#define USBFS_DP_INP_DIS_REG     (* (reg8 *) USBFS_Dp__INP_DIS)\r
+#define USBFS_DP_INTSTAT_PTR     (  (reg8 *) USBFS_Dp__INTSTAT)\r
+#define USBFS_DP_INTSTAT_REG     (* (reg8 *) USBFS_Dp__INTSTAT)\r
+\r
+#if (USBFS_MON_VBUS == 1u)\r
+    #if (USBFS_EXTERN_VBUS == 0u)\r
+        #define USBFS_VBUS_DR_PTR        (  (reg8 *) USBFS_VBUS__DR)\r
+        #define USBFS_VBUS_DR_REG        (* (reg8 *) USBFS_VBUS__DR)\r
+        #define USBFS_VBUS_PS_PTR        (  (reg8 *) USBFS_VBUS__PS)\r
+        #define USBFS_VBUS_PS_REG        (* (reg8 *) USBFS_VBUS__PS)\r
+        #define USBFS_VBUS_MASK          USBFS_VBUS__MASK\r
+    #else\r
+        #define USBFS_VBUS_PS_PTR        (  (reg8 *) USBFS_Vbus_ps_sts_sts_reg__STATUS_REG )\r
+        #define USBFS_VBUS_MASK          (0x01u)\r
+    #endif /* End USBFS_EXTERN_VBUS == 0u */\r
+#endif /* End USBFS_MON_VBUS */\r
+\r
+/* Renamed Registers for backward compatibility.\r
+*  Should not be used in new designs.\r
+*/\r
+#define USBFS_ARB_CFG        USBFS_ARB_CFG_PTR\r
+\r
+#define USBFS_ARB_EP1_CFG    USBFS_ARB_EP1_CFG_PTR\r
+#define USBFS_ARB_EP1_INT_EN USBFS_ARB_EP1_INT_EN_PTR\r
+#define USBFS_ARB_EP1_SR     USBFS_ARB_EP1_SR_PTR\r
+\r
+#define USBFS_ARB_EP2_CFG    USBFS_ARB_EP2_CFG_PTR\r
+#define USBFS_ARB_EP2_INT_EN USBFS_ARB_EP2_INT_EN_PTR\r
+#define USBFS_ARB_EP2_SR     USBFS_ARB_EP2_SR_PTR\r
+\r
+#define USBFS_ARB_EP3_CFG    USBFS_ARB_EP3_CFG_PTR\r
+#define USBFS_ARB_EP3_INT_EN USBFS_ARB_EP3_INT_EN_PTR\r
+#define USBFS_ARB_EP3_SR     USBFS_ARB_EP3_SR_PTR\r
+\r
+#define USBFS_ARB_EP4_CFG    USBFS_ARB_EP4_CFG_PTR\r
+#define USBFS_ARB_EP4_INT_EN USBFS_ARB_EP4_INT_EN_PTR\r
+#define USBFS_ARB_EP4_SR     USBFS_ARB_EP4_SR_PTR\r
+\r
+#define USBFS_ARB_EP5_CFG    USBFS_ARB_EP5_CFG_PTR\r
+#define USBFS_ARB_EP5_INT_EN USBFS_ARB_EP5_INT_EN_PTR\r
+#define USBFS_ARB_EP5_SR     USBFS_ARB_EP5_SR_PTR\r
+\r
+#define USBFS_ARB_EP6_CFG    USBFS_ARB_EP6_CFG_PTR\r
+#define USBFS_ARB_EP6_INT_EN USBFS_ARB_EP6_INT_EN_PTR\r
+#define USBFS_ARB_EP6_SR     USBFS_ARB_EP6_SR_PTR\r
+\r
+#define USBFS_ARB_EP7_CFG    USBFS_ARB_EP7_CFG_PTR\r
+#define USBFS_ARB_EP7_INT_EN USBFS_ARB_EP7_INT_EN_PTR\r
+#define USBFS_ARB_EP7_SR     USBFS_ARB_EP7_SR_PTR\r
+\r
+#define USBFS_ARB_EP8_CFG    USBFS_ARB_EP8_CFG_PTR\r
+#define USBFS_ARB_EP8_INT_EN USBFS_ARB_EP8_INT_EN_PTR\r
+#define USBFS_ARB_EP8_SR     USBFS_ARB_EP8_SR_PTR\r
+\r
+#define USBFS_ARB_INT_EN     USBFS_ARB_INT_EN_PTR\r
+#define USBFS_ARB_INT_SR     USBFS_ARB_INT_SR_PTR\r
+\r
+#define USBFS_ARB_RW1_DR     USBFS_ARB_RW1_DR_PTR\r
+#define USBFS_ARB_RW1_RA     USBFS_ARB_RW1_RA_PTR\r
+#define USBFS_ARB_RW1_RA_MSB USBFS_ARB_RW1_RA_MSB_PTR\r
+#define USBFS_ARB_RW1_WA     USBFS_ARB_RW1_WA_PTR\r
+#define USBFS_ARB_RW1_WA_MSB USBFS_ARB_RW1_WA_MSB_PTR\r
+\r
+#define USBFS_ARB_RW2_DR     USBFS_ARB_RW2_DR_PTR\r
+#define USBFS_ARB_RW2_RA     USBFS_ARB_RW2_RA_PTR\r
+#define USBFS_ARB_RW2_RA_MSB USBFS_ARB_RW2_RA_MSB_PTR\r
+#define USBFS_ARB_RW2_WA     USBFS_ARB_RW2_WA_PTR\r
+#define USBFS_ARB_RW2_WA_MSB USBFS_ARB_RW2_WA_MSB_PTR\r
+\r
+#define USBFS_ARB_RW3_DR     USBFS_ARB_RW3_DR_PTR\r
+#define USBFS_ARB_RW3_RA     USBFS_ARB_RW3_RA_PTR\r
+#define USBFS_ARB_RW3_RA_MSB USBFS_ARB_RW3_RA_MSB_PTR\r
+#define USBFS_ARB_RW3_WA     USBFS_ARB_RW3_WA_PTR\r
+#define USBFS_ARB_RW3_WA_MSB USBFS_ARB_RW3_WA_MSB_PTR\r
+\r
+#define USBFS_ARB_RW4_DR     USBFS_ARB_RW4_DR_PTR\r
+#define USBFS_ARB_RW4_RA     USBFS_ARB_RW4_RA_PTR\r
+#define USBFS_ARB_RW4_RA_MSB USBFS_ARB_RW4_RA_MSB_PTR\r
+#define USBFS_ARB_RW4_WA     USBFS_ARB_RW4_WA_PTR\r
+#define USBFS_ARB_RW4_WA_MSB USBFS_ARB_RW4_WA_MSB_PTR\r
+\r
+#define USBFS_ARB_RW5_DR     USBFS_ARB_RW5_DR_PTR\r
+#define USBFS_ARB_RW5_RA     USBFS_ARB_RW5_RA_PTR\r
+#define USBFS_ARB_RW5_RA_MSB USBFS_ARB_RW5_RA_MSB_PTR\r
+#define USBFS_ARB_RW5_WA     USBFS_ARB_RW5_WA_PTR\r
+#define USBFS_ARB_RW5_WA_MSB USBFS_ARB_RW5_WA_MSB_PTR\r
+\r
+#define USBFS_ARB_RW6_DR     USBFS_ARB_RW6_DR_PTR\r
+#define USBFS_ARB_RW6_RA     USBFS_ARB_RW6_RA_PTR\r
+#define USBFS_ARB_RW6_RA_MSB USBFS_ARB_RW6_RA_MSB_PTR\r
+#define USBFS_ARB_RW6_WA     USBFS_ARB_RW6_WA_PTR\r
+#define USBFS_ARB_RW6_WA_MSB USBFS_ARB_RW6_WA_MSB_PTR\r
+\r
+#define USBFS_ARB_RW7_DR     USBFS_ARB_RW7_DR_PTR\r
+#define USBFS_ARB_RW7_RA     USBFS_ARB_RW7_RA_PTR\r
+#define USBFS_ARB_RW7_RA_MSB USBFS_ARB_RW7_RA_MSB_PTR\r
+#define USBFS_ARB_RW7_WA     USBFS_ARB_RW7_WA_PTR\r
+#define USBFS_ARB_RW7_WA_MSB USBFS_ARB_RW7_WA_MSB_PTR\r
+\r
+#define USBFS_ARB_RW8_DR     USBFS_ARB_RW8_DR_PTR\r
+#define USBFS_ARB_RW8_RA     USBFS_ARB_RW8_RA_PTR\r
+#define USBFS_ARB_RW8_RA_MSB USBFS_ARB_RW8_RA_MSB_PTR\r
+#define USBFS_ARB_RW8_WA     USBFS_ARB_RW8_WA_PTR\r
+#define USBFS_ARB_RW8_WA_MSB USBFS_ARB_RW8_WA_MSB_PTR\r
+\r
+#define USBFS_BUF_SIZE       USBFS_BUF_SIZE_PTR\r
+#define USBFS_BUS_RST_CNT    USBFS_BUS_RST_CNT_PTR\r
+#define USBFS_CR0            USBFS_CR0_PTR\r
+#define USBFS_CR1            USBFS_CR1_PTR\r
+#define USBFS_CWA            USBFS_CWA_PTR\r
+#define USBFS_CWA_MSB        USBFS_CWA_MSB_PTR\r
+\r
+#define USBFS_DMA_THRES      USBFS_DMA_THRES_PTR\r
+#define USBFS_DMA_THRES_MSB  USBFS_DMA_THRES_MSB_PTR\r
+\r
+#define USBFS_EP_ACTIVE      USBFS_EP_ACTIVE_PTR\r
+#define USBFS_EP_TYPE        USBFS_EP_TYPE_PTR\r
+\r
+#define USBFS_EP0_CNT        USBFS_EP0_CNT_PTR\r
+#define USBFS_EP0_CR         USBFS_EP0_CR_PTR\r
+#define USBFS_EP0_DR0        USBFS_EP0_DR0_PTR\r
+#define USBFS_EP0_DR1        USBFS_EP0_DR1_PTR\r
+#define USBFS_EP0_DR2        USBFS_EP0_DR2_PTR\r
+#define USBFS_EP0_DR3        USBFS_EP0_DR3_PTR\r
+#define USBFS_EP0_DR4        USBFS_EP0_DR4_PTR\r
+#define USBFS_EP0_DR5        USBFS_EP0_DR5_PTR\r
+#define USBFS_EP0_DR6        USBFS_EP0_DR6_PTR\r
+#define USBFS_EP0_DR7        USBFS_EP0_DR7_PTR\r
+\r
+#define USBFS_OSCLK_DR0      USBFS_OSCLK_DR0_PTR\r
+#define USBFS_OSCLK_DR1      USBFS_OSCLK_DR1_PTR\r
+\r
+#define USBFS_PM_ACT_CFG     USBFS_PM_ACT_CFG_PTR\r
+#define USBFS_PM_STBY_CFG    USBFS_PM_STBY_CFG_PTR\r
+\r
+#define USBFS_SIE_EP_INT_EN  USBFS_SIE_EP_INT_EN_PTR\r
+#define USBFS_SIE_EP_INT_SR  USBFS_SIE_EP_INT_SR_PTR\r
+\r
+#define USBFS_SIE_EP1_CNT0   USBFS_SIE_EP1_CNT0_PTR\r
+#define USBFS_SIE_EP1_CNT1   USBFS_SIE_EP1_CNT1_PTR\r
+#define USBFS_SIE_EP1_CR0    USBFS_SIE_EP1_CR0_PTR\r
+\r
+#define USBFS_SIE_EP2_CNT0   USBFS_SIE_EP2_CNT0_PTR\r
+#define USBFS_SIE_EP2_CNT1   USBFS_SIE_EP2_CNT1_PTR\r
+#define USBFS_SIE_EP2_CR0    USBFS_SIE_EP2_CR0_PTR\r
+\r
+#define USBFS_SIE_EP3_CNT0   USBFS_SIE_EP3_CNT0_PTR\r
+#define USBFS_SIE_EP3_CNT1   USBFS_SIE_EP3_CNT1_PTR\r
+#define USBFS_SIE_EP3_CR0    USBFS_SIE_EP3_CR0_PTR\r
+\r
+#define USBFS_SIE_EP4_CNT0   USBFS_SIE_EP4_CNT0_PTR\r
+#define USBFS_SIE_EP4_CNT1   USBFS_SIE_EP4_CNT1_PTR\r
+#define USBFS_SIE_EP4_CR0    USBFS_SIE_EP4_CR0_PTR\r
+\r
+#define USBFS_SIE_EP5_CNT0   USBFS_SIE_EP5_CNT0_PTR\r
+#define USBFS_SIE_EP5_CNT1   USBFS_SIE_EP5_CNT1_PTR\r
+#define USBFS_SIE_EP5_CR0    USBFS_SIE_EP5_CR0_PTR\r
+\r
+#define USBFS_SIE_EP6_CNT0   USBFS_SIE_EP6_CNT0_PTR\r
+#define USBFS_SIE_EP6_CNT1   USBFS_SIE_EP6_CNT1_PTR\r
+#define USBFS_SIE_EP6_CR0    USBFS_SIE_EP6_CR0_PTR\r
+\r
+#define USBFS_SIE_EP7_CNT0   USBFS_SIE_EP7_CNT0_PTR\r
+#define USBFS_SIE_EP7_CNT1   USBFS_SIE_EP7_CNT1_PTR\r
+#define USBFS_SIE_EP7_CR0    USBFS_SIE_EP7_CR0_PTR\r
+\r
+#define USBFS_SIE_EP8_CNT0   USBFS_SIE_EP8_CNT0_PTR\r
+#define USBFS_SIE_EP8_CNT1   USBFS_SIE_EP8_CNT1_PTR\r
+#define USBFS_SIE_EP8_CR0    USBFS_SIE_EP8_CR0_PTR\r
+\r
+#define USBFS_SOF0           USBFS_SOF0_PTR\r
+#define USBFS_SOF1           USBFS_SOF1_PTR\r
+\r
+#define USBFS_USB_CLK_EN     USBFS_USB_CLK_EN_PTR\r
+\r
+#define USBFS_USBIO_CR0      USBFS_USBIO_CR0_PTR\r
+#define USBFS_USBIO_CR1      USBFS_USBIO_CR1_PTR\r
+#define USBFS_USBIO_CR2      USBFS_USBIO_CR2_PTR\r
+\r
+#define USBFS_USB_MEM        ((reg8 *) CYDEV_USB_MEM_BASE)\r
+\r
+#if(CYDEV_CHIP_DIE_EXPECT == CYDEV_CHIP_DIE_LEOPARD)\r
+    /* PSoC3 interrupt registers*/\r
+    #define USBFS_USB_ISR_PRIOR  ((reg8 *) CYDEV_INTC_PRIOR0)\r
+    #define USBFS_USB_ISR_SET_EN ((reg8 *) CYDEV_INTC_SET_EN0)\r
+    #define USBFS_USB_ISR_CLR_EN ((reg8 *) CYDEV_INTC_CLR_EN0)\r
+    #define USBFS_USB_ISR_VECT   ((cyisraddress *) CYDEV_INTC_VECT_MBASE)\r
+#elif(CYDEV_CHIP_DIE_EXPECT == CYDEV_CHIP_DIE_PANTHER)\r
+    /* PSoC5 interrupt registers*/\r
+    #define USBFS_USB_ISR_PRIOR  ((reg8 *) CYDEV_NVIC_PRI_0)\r
+    #define USBFS_USB_ISR_SET_EN ((reg8 *) CYDEV_NVIC_SETENA0)\r
+    #define USBFS_USB_ISR_CLR_EN ((reg8 *) CYDEV_NVIC_CLRENA0)\r
+    #define USBFS_USB_ISR_VECT   ((cyisraddress *) CYDEV_NVIC_VECT_OFFSET)\r
+#endif /* End CYDEV_CHIP_DIE_EXPECT */\r
+\r
+\r
+/***************************************\r
+* Interrupt vectors, masks and priorities\r
+***************************************/\r
+\r
+#define USBFS_BUS_RESET_PRIOR    USBFS_bus_reset__INTC_PRIOR_NUM\r
+#define USBFS_BUS_RESET_MASK     USBFS_bus_reset__INTC_MASK\r
+#define USBFS_BUS_RESET_VECT_NUM USBFS_bus_reset__INTC_NUMBER\r
+\r
+#define USBFS_SOF_PRIOR          USBFS_sof_int__INTC_PRIOR_NUM\r
+#define USBFS_SOF_MASK           USBFS_sof_int__INTC_MASK\r
+#define USBFS_SOF_VECT_NUM       USBFS_sof_int__INTC_NUMBER\r
+\r
+#define USBFS_EP_0_PRIOR         USBFS_ep_0__INTC_PRIOR_NUM\r
+#define USBFS_EP_0_MASK          USBFS_ep_0__INTC_MASK\r
+#define USBFS_EP_0_VECT_NUM      USBFS_ep_0__INTC_NUMBER\r
+\r
+#define USBFS_EP_1_PRIOR         USBFS_ep_1__INTC_PRIOR_NUM\r
+#define USBFS_EP_1_MASK          USBFS_ep_1__INTC_MASK\r
+#define USBFS_EP_1_VECT_NUM      USBFS_ep_1__INTC_NUMBER\r
+\r
+#define USBFS_EP_2_PRIOR         USBFS_ep_2__INTC_PRIOR_NUM\r
+#define USBFS_EP_2_MASK          USBFS_ep_2__INTC_MASK\r
+#define USBFS_EP_2_VECT_NUM      USBFS_ep_2__INTC_NUMBER\r
+\r
+#define USBFS_EP_3_PRIOR         USBFS_ep_3__INTC_PRIOR_NUM\r
+#define USBFS_EP_3_MASK          USBFS_ep_3__INTC_MASK\r
+#define USBFS_EP_3_VECT_NUM      USBFS_ep_3__INTC_NUMBER\r
+\r
+#define USBFS_EP_4_PRIOR         USBFS_ep_4__INTC_PRIOR_NUM\r
+#define USBFS_EP_4_MASK          USBFS_ep_4__INTC_MASK\r
+#define USBFS_EP_4_VECT_NUM      USBFS_ep_4__INTC_NUMBER\r
+\r
+#define USBFS_EP_5_PRIOR         USBFS_ep_5__INTC_PRIOR_NUM\r
+#define USBFS_EP_5_MASK          USBFS_ep_5__INTC_MASK\r
+#define USBFS_EP_5_VECT_NUM      USBFS_ep_5__INTC_NUMBER\r
+\r
+#define USBFS_EP_6_PRIOR         USBFS_ep_6__INTC_PRIOR_NUM\r
+#define USBFS_EP_6_MASK          USBFS_ep_6__INTC_MASK\r
+#define USBFS_EP_6_VECT_NUM      USBFS_ep_6__INTC_NUMBER\r
+\r
+#define USBFS_EP_7_PRIOR         USBFS_ep_7__INTC_PRIOR_NUM\r
+#define USBFS_EP_7_MASK          USBFS_ep_7__INTC_MASK\r
+#define USBFS_EP_7_VECT_NUM      USBFS_ep_7__INTC_NUMBER\r
+\r
+#define USBFS_EP_8_PRIOR         USBFS_ep_8__INTC_PRIOR_NUM\r
+#define USBFS_EP_8_MASK          USBFS_ep_8__INTC_MASK\r
+#define USBFS_EP_8_VECT_NUM      USBFS_ep_8__INTC_NUMBER\r
+\r
+#define USBFS_DP_INTC_PRIOR      USBFS_dp_int__INTC_PRIOR_NUM\r
+#define USBFS_DP_INTC_MASK       USBFS_dp_int__INTC_MASK\r
+#define USBFS_DP_INTC_VECT_NUM   USBFS_dp_int__INTC_NUMBER\r
+\r
+/* ARB ISR should have higher priority from EP_X ISR, therefore it is defined to highest (0) */\r
+#define USBFS_ARB_PRIOR          (0u)\r
+#define USBFS_ARB_MASK           USBFS_arb_int__INTC_MASK\r
+#define USBFS_ARB_VECT_NUM       USBFS_arb_int__INTC_NUMBER\r
+\r
+/***************************************\r
+ *  Endpoint 0 offsets (Table 9-2)\r
+ **************************************/\r
+\r
+#define USBFS_bmRequestType      USBFS_EP0_DR0_PTR\r
+#define USBFS_bRequest           USBFS_EP0_DR1_PTR\r
+#define USBFS_wValue             USBFS_EP0_DR2_PTR\r
+#define USBFS_wValueHi           USBFS_EP0_DR3_PTR\r
+#define USBFS_wValueLo           USBFS_EP0_DR2_PTR\r
+#define USBFS_wIndex             USBFS_EP0_DR4_PTR\r
+#define USBFS_wIndexHi           USBFS_EP0_DR5_PTR\r
+#define USBFS_wIndexLo           USBFS_EP0_DR4_PTR\r
+#define USBFS_length             USBFS_EP0_DR6_PTR\r
+#define USBFS_lengthHi           USBFS_EP0_DR7_PTR\r
+#define USBFS_lengthLo           USBFS_EP0_DR6_PTR\r
+\r
+\r
+/***************************************\r
+*       Register Constants\r
+***************************************/\r
+#define USBFS_VDDD_MV                    CYDEV_VDDD_MV\r
+#define USBFS_3500MV                     (3500u)\r
+\r
+#define USBFS_CR1_REG_ENABLE             (0x01u)\r
+#define USBFS_CR1_ENABLE_LOCK            (0x02u)\r
+#define USBFS_CR1_BUS_ACTIVITY_SHIFT     (0x02u)\r
+#define USBFS_CR1_BUS_ACTIVITY           ((uint8)(0x01u << USBFS_CR1_BUS_ACTIVITY_SHIFT))\r
+#define USBFS_CR1_TRIM_MSB_EN            (0x08u)\r
+\r
+#define USBFS_EP0_CNT_DATA_TOGGLE        (0x80u)\r
+#define USBFS_EPX_CNT_DATA_TOGGLE        (0x80u)\r
+#define USBFS_EPX_CNT0_MASK              (0x0Fu)\r
+#define USBFS_EPX_CNTX_MSB_MASK          (0x07u)\r
+#define USBFS_EPX_CNTX_ADDR_SHIFT        (0x04u)\r
+#define USBFS_EPX_CNTX_ADDR_OFFSET       (0x10u)\r
+#define USBFS_EPX_CNTX_CRC_COUNT         (0x02u)\r
+#define USBFS_EPX_DATA_BUF_MAX           (512u)\r
+\r
+#define USBFS_CR0_ENABLE                 (0x80u)\r
+\r
+/* A 100 KHz clock is used for BUS reset count. Recommended is to count 10 pulses */\r
+#define USBFS_BUS_RST_COUNT              (0x0au)\r
+\r
+#define USBFS_USBIO_CR1_IOMODE           (0x20u)\r
+#define USBFS_USBIO_CR1_USBPUEN          (0x04u)\r
+#define USBFS_USBIO_CR1_DP0              (0x02u)\r
+#define USBFS_USBIO_CR1_DM0              (0x01u)\r
+\r
+#define USBFS_USBIO_CR0_TEN              (0x80u)\r
+#define USBFS_USBIO_CR0_TSE0             (0x40u)\r
+#define USBFS_USBIO_CR0_TD               (0x20u)\r
+#define USBFS_USBIO_CR0_RD               (0x01u)\r
+\r
+#define USBFS_FASTCLK_IMO_CR_USBCLK_ON   (0x40u)\r
+#define USBFS_FASTCLK_IMO_CR_XCLKEN      (0x20u)\r
+#define USBFS_FASTCLK_IMO_CR_FX2ON       (0x10u)\r
+\r
+#define USBFS_ARB_EPX_CFG_RESET          (0x08u)\r
+#define USBFS_ARB_EPX_CFG_CRC_BYPASS     (0x04u)\r
+#define USBFS_ARB_EPX_CFG_DMA_REQ        (0x02u)\r
+#define USBFS_ARB_EPX_CFG_IN_DATA_RDY    (0x01u)\r
+\r
+#define USBFS_ARB_EPX_SR_IN_BUF_FULL     (0x01u)\r
+#define USBFS_ARB_EPX_SR_DMA_GNT         (0x02u)\r
+#define USBFS_ARB_EPX_SR_BUF_OVER        (0x04u)\r
+#define USBFS_ARB_EPX_SR_BUF_UNDER       (0x08u)\r
+\r
+#define USBFS_ARB_CFG_AUTO_MEM           (0x10u)\r
+#define USBFS_ARB_CFG_MANUAL_DMA         (0x20u)\r
+#define USBFS_ARB_CFG_AUTO_DMA           (0x40u)\r
+#define USBFS_ARB_CFG_CFG_CPM            (0x80u)\r
+\r
+#if(USBFS_EP_MM == USBFS__EP_DMAAUTO)\r
+    #define USBFS_ARB_EPX_INT_MASK           (0x1Du)\r
+#else\r
+    #define USBFS_ARB_EPX_INT_MASK           (0x1Fu)\r
+#endif /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */\r
+#define USBFS_ARB_INT_MASK       (uint8)((USBFS_DMA1_REMOVE ^ 1u) | \\r
+                                            (uint8)((USBFS_DMA2_REMOVE ^ 1u) << 1u) | \\r
+                                            (uint8)((USBFS_DMA3_REMOVE ^ 1u) << 2u) | \\r
+                                            (uint8)((USBFS_DMA4_REMOVE ^ 1u) << 3u) | \\r
+                                            (uint8)((USBFS_DMA5_REMOVE ^ 1u) << 4u) | \\r
+                                            (uint8)((USBFS_DMA6_REMOVE ^ 1u) << 5u) | \\r
+                                            (uint8)((USBFS_DMA7_REMOVE ^ 1u) << 6u) | \\r
+                                            (uint8)((USBFS_DMA8_REMOVE ^ 1u) << 7u) )\r
+\r
+#define USBFS_SIE_EP_INT_EP1_MASK        (0x01u)\r
+#define USBFS_SIE_EP_INT_EP2_MASK        (0x02u)\r
+#define USBFS_SIE_EP_INT_EP3_MASK        (0x04u)\r
+#define USBFS_SIE_EP_INT_EP4_MASK        (0x08u)\r
+#define USBFS_SIE_EP_INT_EP5_MASK        (0x10u)\r
+#define USBFS_SIE_EP_INT_EP6_MASK        (0x20u)\r
+#define USBFS_SIE_EP_INT_EP7_MASK        (0x40u)\r
+#define USBFS_SIE_EP_INT_EP8_MASK        (0x80u)\r
+\r
+#define USBFS_PM_ACT_EN_FSUSB            USBFS_USB__PM_ACT_MSK\r
+#define USBFS_PM_STBY_EN_FSUSB           USBFS_USB__PM_STBY_MSK\r
+#define USBFS_PM_AVAIL_EN_FSUSBIO        (0x10u)\r
+\r
+#define USBFS_PM_USB_CR0_REF_EN          (0x01u)\r
+#define USBFS_PM_USB_CR0_PD_N            (0x02u)\r
+#define USBFS_PM_USB_CR0_PD_PULLUP_N     (0x04u)\r
+\r
+#define USBFS_USB_CLK_ENABLE             (0x01u)\r
+\r
+#define USBFS_DM_MASK                    USBFS_Dm__0__MASK\r
+#define USBFS_DP_MASK                    USBFS_Dp__0__MASK\r
+\r
+#define USBFS_DYN_RECONFIG_ENABLE        (0x01u)\r
+#define USBFS_DYN_RECONFIG_EP_SHIFT      (0x01u)\r
+#define USBFS_DYN_RECONFIG_RDY_STS       (0x10u)\r
+\r
+\r
+#endif /* End CY_USBFS_USBFS_H */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm.c
new file mode 100755 (executable)
index 0000000..afae8fa
--- /dev/null
@@ -0,0 +1,137 @@
+/*******************************************************************************\r
+* File Name: USBFS_Dm.c  \r
+* Version 1.90\r
+*\r
+* Description:\r
+*  This file contains API to enable firmware control of a Pins component.\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions, \r
+* disclaimers, and limitations in the end user license agreement accompanying \r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "cytypes.h"\r
+#include "USBFS_Dm.h"\r
+\r
+/* APIs are not generated for P15[7:6] on PSoC 5 */\r
+#if !(CY_PSOC5A &&\\r
+        USBFS_Dm__PORT == 15 && ((USBFS_Dm__MASK & 0xC0) != 0))\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dm_Write\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Assign a new value to the digital port's data output register.  \r
+*\r
+* Parameters:  \r
+*  prtValue:  The value to be assigned to the Digital Port. \r
+*\r
+* Return: \r
+*  None\r
+*  \r
+*******************************************************************************/\r
+void USBFS_Dm_Write(uint8 value) \r
+{\r
+    uint8 staticBits = (USBFS_Dm_DR & (uint8)(~USBFS_Dm_MASK));\r
+    USBFS_Dm_DR = staticBits | ((uint8)(value << USBFS_Dm_SHIFT) & USBFS_Dm_MASK);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dm_SetDriveMode\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Change the drive mode on the pins of the port.\r
+* \r
+* Parameters:  \r
+*  mode:  Change the pins to this drive mode.\r
+*\r
+* Return: \r
+*  None\r
+*\r
+*******************************************************************************/\r
+void USBFS_Dm_SetDriveMode(uint8 mode) \r
+{\r
+       CyPins_SetPinDriveMode(USBFS_Dm_0, mode);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dm_Read\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Read the current value on the pins of the Digital Port in right justified \r
+*  form.\r
+*\r
+* Parameters:  \r
+*  None\r
+*\r
+* Return: \r
+*  Returns the current value of the Digital Port as a right justified number\r
+*  \r
+* Note:\r
+*  Macro USBFS_Dm_ReadPS calls this function. \r
+*  \r
+*******************************************************************************/\r
+uint8 USBFS_Dm_Read(void) \r
+{\r
+    return (USBFS_Dm_PS & USBFS_Dm_MASK) >> USBFS_Dm_SHIFT;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dm_ReadDataReg\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Read the current value assigned to a Digital Port's data output register\r
+*\r
+* Parameters:  \r
+*  None \r
+*\r
+* Return: \r
+*  Returns the current value assigned to the Digital Port's data output register\r
+*  \r
+*******************************************************************************/\r
+uint8 USBFS_Dm_ReadDataReg(void) \r
+{\r
+    return (USBFS_Dm_DR & USBFS_Dm_MASK) >> USBFS_Dm_SHIFT;\r
+}\r
+\r
+\r
+/* If Interrupts Are Enabled for this Pins component */ \r
+#if defined(USBFS_Dm_INTSTAT) \r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_Dm_ClearInterrupt\r
+    ********************************************************************************\r
+    * Summary:\r
+    *  Clears any active interrupts attached to port and returns the value of the \r
+    *  interrupt status register.\r
+    *\r
+    * Parameters:  \r
+    *  None \r
+    *\r
+    * Return: \r
+    *  Returns the value of the interrupt status register\r
+    *  \r
+    *******************************************************************************/\r
+    uint8 USBFS_Dm_ClearInterrupt(void) \r
+    {\r
+        return (USBFS_Dm_INTSTAT & USBFS_Dm_MASK) >> USBFS_Dm_SHIFT;\r
+    }\r
+\r
+#endif /* If Interrupts Are Enabled for this Pins component */ \r
+\r
+#endif /* CY_PSOC5A... */\r
+\r
+    \r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm.h
new file mode 100755 (executable)
index 0000000..c1aa9b9
--- /dev/null
@@ -0,0 +1,130 @@
+/*******************************************************************************\r
+* File Name: USBFS_Dm.h  \r
+* Version 1.90\r
+*\r
+* Description:\r
+*  This file containts Control Register function prototypes and register defines\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions, \r
+* disclaimers, and limitations in the end user license agreement accompanying \r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_PINS_USBFS_Dm_H) /* Pins USBFS_Dm_H */\r
+#define CY_PINS_USBFS_Dm_H\r
+\r
+#include "cytypes.h"\r
+#include "cyfitter.h"\r
+#include "cypins.h"\r
+#include "USBFS_Dm_aliases.h"\r
+\r
+/* Check to see if required defines such as CY_PSOC5A are available */\r
+/* They are defined starting with cy_boot v3.0 */\r
+#if !defined (CY_PSOC5A)\r
+    #error Component cy_pins_v1_90 requires cy_boot v3.0 or later\r
+#endif /* (CY_PSOC5A) */\r
+\r
+/* APIs are not generated for P15[7:6] */\r
+#if !(CY_PSOC5A &&\\r
+        USBFS_Dm__PORT == 15 && ((USBFS_Dm__MASK & 0xC0) != 0))\r
+\r
+\r
+/***************************************\r
+*        Function Prototypes             \r
+***************************************/    \r
+\r
+void    USBFS_Dm_Write(uint8 value) ;\r
+void    USBFS_Dm_SetDriveMode(uint8 mode) ;\r
+uint8   USBFS_Dm_ReadDataReg(void) ;\r
+uint8   USBFS_Dm_Read(void) ;\r
+uint8   USBFS_Dm_ClearInterrupt(void) ;\r
+\r
+\r
+/***************************************\r
+*           API Constants        \r
+***************************************/\r
+\r
+/* Drive Modes */\r
+#define USBFS_Dm_DM_ALG_HIZ         PIN_DM_ALG_HIZ\r
+#define USBFS_Dm_DM_DIG_HIZ         PIN_DM_DIG_HIZ\r
+#define USBFS_Dm_DM_RES_UP          PIN_DM_RES_UP\r
+#define USBFS_Dm_DM_RES_DWN         PIN_DM_RES_DWN\r
+#define USBFS_Dm_DM_OD_LO           PIN_DM_OD_LO\r
+#define USBFS_Dm_DM_OD_HI           PIN_DM_OD_HI\r
+#define USBFS_Dm_DM_STRONG          PIN_DM_STRONG\r
+#define USBFS_Dm_DM_RES_UPDWN       PIN_DM_RES_UPDWN\r
+\r
+/* Digital Port Constants */\r
+#define USBFS_Dm_MASK               USBFS_Dm__MASK\r
+#define USBFS_Dm_SHIFT              USBFS_Dm__SHIFT\r
+#define USBFS_Dm_WIDTH              1u\r
+\r
+\r
+/***************************************\r
+*             Registers        \r
+***************************************/\r
+\r
+/* Main Port Registers */\r
+/* Pin State */\r
+#define USBFS_Dm_PS                     (* (reg8 *) USBFS_Dm__PS)\r
+/* Data Register */\r
+#define USBFS_Dm_DR                     (* (reg8 *) USBFS_Dm__DR)\r
+/* Port Number */\r
+#define USBFS_Dm_PRT_NUM                (* (reg8 *) USBFS_Dm__PRT) \r
+/* Connect to Analog Globals */                                                  \r
+#define USBFS_Dm_AG                     (* (reg8 *) USBFS_Dm__AG)                       \r
+/* Analog MUX bux enable */\r
+#define USBFS_Dm_AMUX                   (* (reg8 *) USBFS_Dm__AMUX) \r
+/* Bidirectional Enable */                                                        \r
+#define USBFS_Dm_BIE                    (* (reg8 *) USBFS_Dm__BIE)\r
+/* Bit-mask for Aliased Register Access */\r
+#define USBFS_Dm_BIT_MASK               (* (reg8 *) USBFS_Dm__BIT_MASK)\r
+/* Bypass Enable */\r
+#define USBFS_Dm_BYP                    (* (reg8 *) USBFS_Dm__BYP)\r
+/* Port wide control signals */                                                   \r
+#define USBFS_Dm_CTL                    (* (reg8 *) USBFS_Dm__CTL)\r
+/* Drive Modes */\r
+#define USBFS_Dm_DM0                    (* (reg8 *) USBFS_Dm__DM0) \r
+#define USBFS_Dm_DM1                    (* (reg8 *) USBFS_Dm__DM1)\r
+#define USBFS_Dm_DM2                    (* (reg8 *) USBFS_Dm__DM2) \r
+/* Input Buffer Disable Override */\r
+#define USBFS_Dm_INP_DIS                (* (reg8 *) USBFS_Dm__INP_DIS)\r
+/* LCD Common or Segment Drive */\r
+#define USBFS_Dm_LCD_COM_SEG            (* (reg8 *) USBFS_Dm__LCD_COM_SEG)\r
+/* Enable Segment LCD */\r
+#define USBFS_Dm_LCD_EN                 (* (reg8 *) USBFS_Dm__LCD_EN)\r
+/* Slew Rate Control */\r
+#define USBFS_Dm_SLW                    (* (reg8 *) USBFS_Dm__SLW)\r
+\r
+/* DSI Port Registers */\r
+/* Global DSI Select Register */\r
+#define USBFS_Dm_PRTDSI__CAPS_SEL       (* (reg8 *) USBFS_Dm__PRTDSI__CAPS_SEL) \r
+/* Double Sync Enable */\r
+#define USBFS_Dm_PRTDSI__DBL_SYNC_IN    (* (reg8 *) USBFS_Dm__PRTDSI__DBL_SYNC_IN) \r
+/* Output Enable Select Drive Strength */\r
+#define USBFS_Dm_PRTDSI__OE_SEL0        (* (reg8 *) USBFS_Dm__PRTDSI__OE_SEL0) \r
+#define USBFS_Dm_PRTDSI__OE_SEL1        (* (reg8 *) USBFS_Dm__PRTDSI__OE_SEL1) \r
+/* Port Pin Output Select Registers */\r
+#define USBFS_Dm_PRTDSI__OUT_SEL0       (* (reg8 *) USBFS_Dm__PRTDSI__OUT_SEL0) \r
+#define USBFS_Dm_PRTDSI__OUT_SEL1       (* (reg8 *) USBFS_Dm__PRTDSI__OUT_SEL1) \r
+/* Sync Output Enable Registers */\r
+#define USBFS_Dm_PRTDSI__SYNC_OUT       (* (reg8 *) USBFS_Dm__PRTDSI__SYNC_OUT) \r
+\r
+\r
+#if defined(USBFS_Dm__INTSTAT)  /* Interrupt Registers */\r
+\r
+    #define USBFS_Dm_INTSTAT                (* (reg8 *) USBFS_Dm__INTSTAT)\r
+    #define USBFS_Dm_SNAP                   (* (reg8 *) USBFS_Dm__SNAP)\r
+\r
+#endif /* Interrupt Registers */\r
+\r
+#endif /* CY_PSOC5A... */\r
+\r
+#endif /*  CY_PINS_USBFS_Dm_H */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm_aliases.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dm_aliases.h
new file mode 100755 (executable)
index 0000000..bc4f686
--- /dev/null
@@ -0,0 +1,32 @@
+/*******************************************************************************\r
+* File Name: USBFS_Dm.h  \r
+* Version 1.90\r
+*\r
+* Description:\r
+*  This file containts Control Register function prototypes and register defines\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions, \r
+* disclaimers, and limitations in the end user license agreement accompanying \r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_PINS_USBFS_Dm_ALIASES_H) /* Pins USBFS_Dm_ALIASES_H */\r
+#define CY_PINS_USBFS_Dm_ALIASES_H\r
+\r
+#include "cytypes.h"\r
+#include "cyfitter.h"\r
+\r
+\r
+\r
+/***************************************\r
+*              Constants        \r
+***************************************/\r
+#define USBFS_Dm_0             USBFS_Dm__0__PC\r
+\r
+#endif /* End Pins USBFS_Dm_ALIASES_H */\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp.c
new file mode 100755 (executable)
index 0000000..304d5d6
--- /dev/null
@@ -0,0 +1,137 @@
+/*******************************************************************************\r
+* File Name: USBFS_Dp.c  \r
+* Version 1.90\r
+*\r
+* Description:\r
+*  This file contains API to enable firmware control of a Pins component.\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions, \r
+* disclaimers, and limitations in the end user license agreement accompanying \r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "cytypes.h"\r
+#include "USBFS_Dp.h"\r
+\r
+/* APIs are not generated for P15[7:6] on PSoC 5 */\r
+#if !(CY_PSOC5A &&\\r
+        USBFS_Dp__PORT == 15 && ((USBFS_Dp__MASK & 0xC0) != 0))\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dp_Write\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Assign a new value to the digital port's data output register.  \r
+*\r
+* Parameters:  \r
+*  prtValue:  The value to be assigned to the Digital Port. \r
+*\r
+* Return: \r
+*  None\r
+*  \r
+*******************************************************************************/\r
+void USBFS_Dp_Write(uint8 value) \r
+{\r
+    uint8 staticBits = (USBFS_Dp_DR & (uint8)(~USBFS_Dp_MASK));\r
+    USBFS_Dp_DR = staticBits | ((uint8)(value << USBFS_Dp_SHIFT) & USBFS_Dp_MASK);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dp_SetDriveMode\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Change the drive mode on the pins of the port.\r
+* \r
+* Parameters:  \r
+*  mode:  Change the pins to this drive mode.\r
+*\r
+* Return: \r
+*  None\r
+*\r
+*******************************************************************************/\r
+void USBFS_Dp_SetDriveMode(uint8 mode) \r
+{\r
+       CyPins_SetPinDriveMode(USBFS_Dp_0, mode);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dp_Read\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Read the current value on the pins of the Digital Port in right justified \r
+*  form.\r
+*\r
+* Parameters:  \r
+*  None\r
+*\r
+* Return: \r
+*  Returns the current value of the Digital Port as a right justified number\r
+*  \r
+* Note:\r
+*  Macro USBFS_Dp_ReadPS calls this function. \r
+*  \r
+*******************************************************************************/\r
+uint8 USBFS_Dp_Read(void) \r
+{\r
+    return (USBFS_Dp_PS & USBFS_Dp_MASK) >> USBFS_Dp_SHIFT;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_Dp_ReadDataReg\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Read the current value assigned to a Digital Port's data output register\r
+*\r
+* Parameters:  \r
+*  None \r
+*\r
+* Return: \r
+*  Returns the current value assigned to the Digital Port's data output register\r
+*  \r
+*******************************************************************************/\r
+uint8 USBFS_Dp_ReadDataReg(void) \r
+{\r
+    return (USBFS_Dp_DR & USBFS_Dp_MASK) >> USBFS_Dp_SHIFT;\r
+}\r
+\r
+\r
+/* If Interrupts Are Enabled for this Pins component */ \r
+#if defined(USBFS_Dp_INTSTAT) \r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_Dp_ClearInterrupt\r
+    ********************************************************************************\r
+    * Summary:\r
+    *  Clears any active interrupts attached to port and returns the value of the \r
+    *  interrupt status register.\r
+    *\r
+    * Parameters:  \r
+    *  None \r
+    *\r
+    * Return: \r
+    *  Returns the value of the interrupt status register\r
+    *  \r
+    *******************************************************************************/\r
+    uint8 USBFS_Dp_ClearInterrupt(void) \r
+    {\r
+        return (USBFS_Dp_INTSTAT & USBFS_Dp_MASK) >> USBFS_Dp_SHIFT;\r
+    }\r
+\r
+#endif /* If Interrupts Are Enabled for this Pins component */ \r
+\r
+#endif /* CY_PSOC5A... */\r
+\r
+    \r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp.h
new file mode 100755 (executable)
index 0000000..2d03ad9
--- /dev/null
@@ -0,0 +1,130 @@
+/*******************************************************************************\r
+* File Name: USBFS_Dp.h  \r
+* Version 1.90\r
+*\r
+* Description:\r
+*  This file containts Control Register function prototypes and register defines\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions, \r
+* disclaimers, and limitations in the end user license agreement accompanying \r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_PINS_USBFS_Dp_H) /* Pins USBFS_Dp_H */\r
+#define CY_PINS_USBFS_Dp_H\r
+\r
+#include "cytypes.h"\r
+#include "cyfitter.h"\r
+#include "cypins.h"\r
+#include "USBFS_Dp_aliases.h"\r
+\r
+/* Check to see if required defines such as CY_PSOC5A are available */\r
+/* They are defined starting with cy_boot v3.0 */\r
+#if !defined (CY_PSOC5A)\r
+    #error Component cy_pins_v1_90 requires cy_boot v3.0 or later\r
+#endif /* (CY_PSOC5A) */\r
+\r
+/* APIs are not generated for P15[7:6] */\r
+#if !(CY_PSOC5A &&\\r
+        USBFS_Dp__PORT == 15 && ((USBFS_Dp__MASK & 0xC0) != 0))\r
+\r
+\r
+/***************************************\r
+*        Function Prototypes             \r
+***************************************/    \r
+\r
+void    USBFS_Dp_Write(uint8 value) ;\r
+void    USBFS_Dp_SetDriveMode(uint8 mode) ;\r
+uint8   USBFS_Dp_ReadDataReg(void) ;\r
+uint8   USBFS_Dp_Read(void) ;\r
+uint8   USBFS_Dp_ClearInterrupt(void) ;\r
+\r
+\r
+/***************************************\r
+*           API Constants        \r
+***************************************/\r
+\r
+/* Drive Modes */\r
+#define USBFS_Dp_DM_ALG_HIZ         PIN_DM_ALG_HIZ\r
+#define USBFS_Dp_DM_DIG_HIZ         PIN_DM_DIG_HIZ\r
+#define USBFS_Dp_DM_RES_UP          PIN_DM_RES_UP\r
+#define USBFS_Dp_DM_RES_DWN         PIN_DM_RES_DWN\r
+#define USBFS_Dp_DM_OD_LO           PIN_DM_OD_LO\r
+#define USBFS_Dp_DM_OD_HI           PIN_DM_OD_HI\r
+#define USBFS_Dp_DM_STRONG          PIN_DM_STRONG\r
+#define USBFS_Dp_DM_RES_UPDWN       PIN_DM_RES_UPDWN\r
+\r
+/* Digital Port Constants */\r
+#define USBFS_Dp_MASK               USBFS_Dp__MASK\r
+#define USBFS_Dp_SHIFT              USBFS_Dp__SHIFT\r
+#define USBFS_Dp_WIDTH              1u\r
+\r
+\r
+/***************************************\r
+*             Registers        \r
+***************************************/\r
+\r
+/* Main Port Registers */\r
+/* Pin State */\r
+#define USBFS_Dp_PS                     (* (reg8 *) USBFS_Dp__PS)\r
+/* Data Register */\r
+#define USBFS_Dp_DR                     (* (reg8 *) USBFS_Dp__DR)\r
+/* Port Number */\r
+#define USBFS_Dp_PRT_NUM                (* (reg8 *) USBFS_Dp__PRT) \r
+/* Connect to Analog Globals */                                                  \r
+#define USBFS_Dp_AG                     (* (reg8 *) USBFS_Dp__AG)                       \r
+/* Analog MUX bux enable */\r
+#define USBFS_Dp_AMUX                   (* (reg8 *) USBFS_Dp__AMUX) \r
+/* Bidirectional Enable */                                                        \r
+#define USBFS_Dp_BIE                    (* (reg8 *) USBFS_Dp__BIE)\r
+/* Bit-mask for Aliased Register Access */\r
+#define USBFS_Dp_BIT_MASK               (* (reg8 *) USBFS_Dp__BIT_MASK)\r
+/* Bypass Enable */\r
+#define USBFS_Dp_BYP                    (* (reg8 *) USBFS_Dp__BYP)\r
+/* Port wide control signals */                                                   \r
+#define USBFS_Dp_CTL                    (* (reg8 *) USBFS_Dp__CTL)\r
+/* Drive Modes */\r
+#define USBFS_Dp_DM0                    (* (reg8 *) USBFS_Dp__DM0) \r
+#define USBFS_Dp_DM1                    (* (reg8 *) USBFS_Dp__DM1)\r
+#define USBFS_Dp_DM2                    (* (reg8 *) USBFS_Dp__DM2) \r
+/* Input Buffer Disable Override */\r
+#define USBFS_Dp_INP_DIS                (* (reg8 *) USBFS_Dp__INP_DIS)\r
+/* LCD Common or Segment Drive */\r
+#define USBFS_Dp_LCD_COM_SEG            (* (reg8 *) USBFS_Dp__LCD_COM_SEG)\r
+/* Enable Segment LCD */\r
+#define USBFS_Dp_LCD_EN                 (* (reg8 *) USBFS_Dp__LCD_EN)\r
+/* Slew Rate Control */\r
+#define USBFS_Dp_SLW                    (* (reg8 *) USBFS_Dp__SLW)\r
+\r
+/* DSI Port Registers */\r
+/* Global DSI Select Register */\r
+#define USBFS_Dp_PRTDSI__CAPS_SEL       (* (reg8 *) USBFS_Dp__PRTDSI__CAPS_SEL) \r
+/* Double Sync Enable */\r
+#define USBFS_Dp_PRTDSI__DBL_SYNC_IN    (* (reg8 *) USBFS_Dp__PRTDSI__DBL_SYNC_IN) \r
+/* Output Enable Select Drive Strength */\r
+#define USBFS_Dp_PRTDSI__OE_SEL0        (* (reg8 *) USBFS_Dp__PRTDSI__OE_SEL0) \r
+#define USBFS_Dp_PRTDSI__OE_SEL1        (* (reg8 *) USBFS_Dp__PRTDSI__OE_SEL1) \r
+/* Port Pin Output Select Registers */\r
+#define USBFS_Dp_PRTDSI__OUT_SEL0       (* (reg8 *) USBFS_Dp__PRTDSI__OUT_SEL0) \r
+#define USBFS_Dp_PRTDSI__OUT_SEL1       (* (reg8 *) USBFS_Dp__PRTDSI__OUT_SEL1) \r
+/* Sync Output Enable Registers */\r
+#define USBFS_Dp_PRTDSI__SYNC_OUT       (* (reg8 *) USBFS_Dp__PRTDSI__SYNC_OUT) \r
+\r
+\r
+#if defined(USBFS_Dp__INTSTAT)  /* Interrupt Registers */\r
+\r
+    #define USBFS_Dp_INTSTAT                (* (reg8 *) USBFS_Dp__INTSTAT)\r
+    #define USBFS_Dp_SNAP                   (* (reg8 *) USBFS_Dp__SNAP)\r
+\r
+#endif /* Interrupt Registers */\r
+\r
+#endif /* CY_PSOC5A... */\r
+\r
+#endif /*  CY_PINS_USBFS_Dp_H */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp_aliases.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_Dp_aliases.h
new file mode 100755 (executable)
index 0000000..b77c3b9
--- /dev/null
@@ -0,0 +1,32 @@
+/*******************************************************************************\r
+* File Name: USBFS_Dp.h  \r
+* Version 1.90\r
+*\r
+* Description:\r
+*  This file containts Control Register function prototypes and register defines\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions, \r
+* disclaimers, and limitations in the end user license agreement accompanying \r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_PINS_USBFS_Dp_ALIASES_H) /* Pins USBFS_Dp_ALIASES_H */\r
+#define CY_PINS_USBFS_Dp_ALIASES_H\r
+\r
+#include "cytypes.h"\r
+#include "cyfitter.h"\r
+\r
+\r
+\r
+/***************************************\r
+*              Constants        \r
+***************************************/\r
+#define USBFS_Dp_0             USBFS_Dp__0__PC\r
+\r
+#endif /* End Pins USBFS_Dp_ALIASES_H */\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_audio.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_audio.c
new file mode 100755 (executable)
index 0000000..cec388b
--- /dev/null
@@ -0,0 +1,318 @@
+/*******************************************************************************\r
+* File Name: USBFS_audio.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  USB AUDIO Class request handler.\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+\r
+#if defined(USBFS_ENABLE_AUDIO_CLASS)\r
+\r
+#include "USBFS_audio.h"\r
+#include "USBFS_pvt.h"\r
+#if defined(USBFS_ENABLE_MIDI_STREAMING) \r
+    #include "USBFS_midi.h"\r
+#endif /* End USBFS_ENABLE_MIDI_STREAMING*/\r
+\r
+\r
+/***************************************\r
+* Custom Declarations\r
+***************************************/\r
+\r
+/* `#START CUSTOM_DECLARATIONS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+#if !defined(USER_SUPPLIED_AUDIO_HANDLER)\r
+\r
+\r
+/***************************************\r
+*    AUDIO Variables\r
+***************************************/\r
+\r
+#if defined(USBFS_ENABLE_AUDIO_STREAMING)\r
+    volatile uint8 USBFS_currentSampleFrequency[USBFS_MAX_EP][USBFS_SAMPLE_FREQ_LEN];\r
+    volatile uint8 USBFS_frequencyChanged;\r
+    volatile uint8 USBFS_currentMute;\r
+    volatile uint8 USBFS_currentVolume[USBFS_VOLUME_LEN];\r
+    volatile uint8 USBFS_minimumVolume[USBFS_VOLUME_LEN] = {USBFS_VOL_MIN_LSB,\r
+                                                                                  USBFS_VOL_MIN_MSB};\r
+    volatile uint8 USBFS_maximumVolume[USBFS_VOLUME_LEN] = {USBFS_VOL_MAX_LSB,\r
+                                                                                  USBFS_VOL_MAX_MSB};\r
+    volatile uint8 USBFS_resolutionVolume[USBFS_VOLUME_LEN] = {USBFS_VOL_RES_LSB,\r
+                                                                                     USBFS_VOL_RES_MSB};\r
+#endif /* End USBFS_ENABLE_AUDIO_STREAMING */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_DispatchAUDIOClassRqst\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine dispatches class requests\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled\r
+*\r
+* Global variables:\r
+*   USBFS_currentSampleFrequency: Contains the current audio Sample\r
+*       Frequency. It is set by the Host using SET_CUR request to the endpoint.\r
+*   USBFS_frequencyChanged: This variable is used as a flag for the\r
+*       user code, to be aware that Host has been sent request for changing\r
+*       Sample Frequency. Sample frequency will be sent on the next OUT\r
+*       transaction. It is contains endpoint address when set. The following\r
+*       code is recommended for detecting new Sample Frequency in main code:\r
+*       if((USBFS_frequencyChanged != 0) &&\r
+*       (USBFS_transferState == USBFS_TRANS_STATE_IDLE))\r
+*       {\r
+*          USBFS_frequencyChanged = 0;\r
+*       }\r
+*       USBFS_transferState variable is checked to be sure that\r
+*             transfer completes.\r
+*   USBFS_currentMute: Contains mute configuration set by Host.\r
+*   USBFS_currentVolume: Contains volume level set by Host.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_DispatchAUDIOClassRqst(void) \r
+{\r
+    uint8 requestHandled = USBFS_FALSE;\r
+\r
+    #if defined(USBFS_ENABLE_AUDIO_STREAMING)\r
+        uint8 epNumber;\r
+        epNumber = CY_GET_REG8(USBFS_wIndexLo) & USBFS_DIR_UNUSED;\r
+    #endif /* End USBFS_ENABLE_AUDIO_STREAMING */\r
+\r
+    if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) == USBFS_RQST_DIR_D2H)\r
+    {\r
+        /* Control Read */\r
+        if((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_RCPT_MASK) == \\r
+                                                                                    USBFS_RQST_RCPT_EP)\r
+        {\r
+            /* Endpoint */\r
+            switch (CY_GET_REG8(USBFS_bRequest))\r
+            {\r
+                case USBFS_GET_CUR:\r
+                #if defined(USBFS_ENABLE_AUDIO_STREAMING)\r
+                    if(CY_GET_REG8(USBFS_wValueHi) == USBFS_SAMPLING_FREQ_CONTROL)\r
+                    {\r
+                         /* Endpoint Control Selector is Sampling Frequency */\r
+                        USBFS_currentTD.wCount = USBFS_SAMPLE_FREQ_LEN;\r
+                        USBFS_currentTD.pData  = USBFS_currentSampleFrequency[epNumber];\r
+                        requestHandled   = USBFS_InitControlRead();\r
+                    }\r
+                #endif /* End USBFS_ENABLE_AUDIO_STREAMING */\r
+\r
+                /* `#START AUDIO_READ_REQUESTS` Place other request handler here */\r
+\r
+                /* `#END` */\r
+                    break;\r
+                default:\r
+                    break;\r
+            }\r
+        }\r
+        else if((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_RCPT_MASK) == \\r
+                                                                                    USBFS_RQST_RCPT_IFC)\r
+        {\r
+            /* Interface or Entity ID */\r
+            switch (CY_GET_REG8(USBFS_bRequest))\r
+            {\r
+                case USBFS_GET_CUR:\r
+                #if defined(USBFS_ENABLE_AUDIO_STREAMING)\r
+                    if(CY_GET_REG8(USBFS_wValueHi) == USBFS_MUTE_CONTROL)\r
+                    {\r
+                        /* `#START MUTE_CONTROL_GET_REQUEST` Place multi-channel handler here */\r
+\r
+                        /* `#END` */\r
+                        \r
+                         /* Entity ID Control Selector is MUTE */\r
+                        USBFS_currentTD.wCount = 1u;\r
+                        USBFS_currentTD.pData  = &USBFS_currentMute;\r
+                        requestHandled   = USBFS_InitControlRead();\r
+                    }\r
+                    else if(CY_GET_REG8(USBFS_wValueHi) == USBFS_VOLUME_CONTROL)\r
+                    {\r
+                        /* `#START VOLUME_CONTROL_GET_REQUEST` Place multi-channel handler here */\r
+\r
+                        /* `#END` */\r
+\r
+                        /* Entity ID Control Selector is VOLUME, */\r
+                        USBFS_currentTD.wCount = USBFS_VOLUME_LEN;\r
+                        USBFS_currentTD.pData  = USBFS_currentVolume;\r
+                        requestHandled   = USBFS_InitControlRead();\r
+                    }\r
+                    else\r
+                    {\r
+                        /* `#START OTHER_GET_CUR_REQUESTS` Place other request handler here */\r
+\r
+                        /* `#END` */\r
+                    }\r
+                    break;\r
+                case USBFS_GET_MIN:    /* GET_MIN */\r
+                    if(CY_GET_REG8(USBFS_wValueHi) == USBFS_VOLUME_CONTROL)\r
+                    {\r
+                        /* Entity ID Control Selector is VOLUME, */\r
+                        USBFS_currentTD.wCount = USBFS_VOLUME_LEN;\r
+                        USBFS_currentTD.pData  = &USBFS_minimumVolume[0];\r
+                        requestHandled   = USBFS_InitControlRead();\r
+                    }\r
+                    break;\r
+                case USBFS_GET_MAX:    /* GET_MAX */\r
+                    if(CY_GET_REG8(USBFS_wValueHi) == USBFS_VOLUME_CONTROL)\r
+                    {\r
+                        /* Entity ID Control Selector is VOLUME, */\r
+                        USBFS_currentTD.wCount = USBFS_VOLUME_LEN;\r
+                        USBFS_currentTD.pData  = &USBFS_maximumVolume[0];\r
+                        requestHandled   = USBFS_InitControlRead();\r
+                    }\r
+                    break;\r
+                case USBFS_GET_RES:    /* GET_RES */\r
+                    if(CY_GET_REG8(USBFS_wValueHi) == USBFS_VOLUME_CONTROL)\r
+                    {\r
+                         /* Entity ID Control Selector is VOLUME, */\r
+                        USBFS_currentTD.wCount = USBFS_VOLUME_LEN;\r
+                        USBFS_currentTD.pData  = &USBFS_resolutionVolume[0];\r
+                        requestHandled   = USBFS_InitControlRead();\r
+                    }\r
+                    break;\r
+                /* The contents of the status message is reserved for future use.\r
+                *  For the time being, a null packet should be returned in the data stage of the\r
+                *  control transfer, and the received null packet should be ACKed.\r
+                */\r
+                case USBFS_GET_STAT:\r
+                        USBFS_currentTD.wCount = 0u;\r
+                        requestHandled   = USBFS_InitControlWrite();\r
+\r
+                #endif /* End USBFS_ENABLE_AUDIO_STREAMING */\r
+\r
+                /* `#START AUDIO_WRITE_REQUESTS` Place other request handler here */\r
+\r
+                /* `#END` */\r
+                    break;\r
+                default:\r
+                    break;\r
+            }\r
+        }\r
+        else\r
+        {   /* USBFS_RQST_RCPT_OTHER */\r
+        }\r
+    }\r
+    else if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) == \\r
+                                                                                    USBFS_RQST_DIR_H2D)\r
+    {\r
+        /* Control Write */\r
+        if((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_RCPT_MASK) == \\r
+                                                                                    USBFS_RQST_RCPT_EP)\r
+        {\r
+            /* Endpoint */\r
+            switch (CY_GET_REG8(USBFS_bRequest))\r
+            {\r
+                case USBFS_SET_CUR:\r
+                #if defined(USBFS_ENABLE_AUDIO_STREAMING)\r
+                    if(CY_GET_REG8(USBFS_wValueHi) == USBFS_SAMPLING_FREQ_CONTROL)\r
+                    {\r
+                         /* Endpoint Control Selector is Sampling Frequency */\r
+                        USBFS_currentTD.wCount = USBFS_SAMPLE_FREQ_LEN;\r
+                        USBFS_currentTD.pData  = USBFS_currentSampleFrequency[epNumber];\r
+                        requestHandled   = USBFS_InitControlWrite();\r
+                        USBFS_frequencyChanged = epNumber;\r
+                    }\r
+                #endif /* End USBFS_ENABLE_AUDIO_STREAMING */\r
+\r
+                /* `#START AUDIO_SAMPLING_FREQ_REQUESTS` Place other request handler here */\r
+\r
+                /* `#END` */\r
+                    break;\r
+                default:\r
+                    break;\r
+            }\r
+        }\r
+        else if((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_RCPT_MASK) == \\r
+                                                                                    USBFS_RQST_RCPT_IFC)\r
+        {\r
+            /* Interface or Entity ID */\r
+            switch (CY_GET_REG8(USBFS_bRequest))\r
+            {\r
+                case USBFS_SET_CUR:\r
+                #if defined(USBFS_ENABLE_AUDIO_STREAMING)\r
+                    if(CY_GET_REG8(USBFS_wValueHi) == USBFS_MUTE_CONTROL)\r
+                    {\r
+                        /* `#START MUTE_SET_REQUEST` Place multi-channel handler here */\r
+\r
+                        /* `#END` */\r
+\r
+                        /* Entity ID Control Selector is MUTE */\r
+                        USBFS_currentTD.wCount = 1u;\r
+                        USBFS_currentTD.pData  = &USBFS_currentMute;\r
+                        requestHandled   = USBFS_InitControlWrite();\r
+                    }\r
+                    else if(CY_GET_REG8(USBFS_wValueHi) == USBFS_VOLUME_CONTROL)\r
+                    {\r
+                        /* `#START VOLUME_CONTROL_SET_REQUEST` Place multi-channel handler here */\r
+\r
+                        /* `#END` */\r
+\r
+                        /* Entity ID Control Selector is VOLUME */\r
+                        USBFS_currentTD.wCount = USBFS_VOLUME_LEN;\r
+                        USBFS_currentTD.pData  = USBFS_currentVolume;\r
+                        requestHandled   = USBFS_InitControlWrite();\r
+                    }\r
+                    else\r
+                    {\r
+                        /* `#START OTHER_SET_CUR_REQUESTS` Place other request handler here */\r
+\r
+                        /* `#END` */\r
+                    }\r
+                #endif /* End USBFS_ENABLE_AUDIO_STREAMING */\r
+\r
+                /* `#START AUDIO_CONTROL_SEL_REQUESTS` Place other request handler here */\r
+\r
+                /* `#END` */\r
+                    break;\r
+                default:\r
+                    break;\r
+            }\r
+        }\r
+        else\r
+        {   /* USBFS_RQST_RCPT_OTHER */\r
+        }\r
+    }\r
+    else\r
+    {   /* requestHandled is initialized as FALSE by default */\r
+    }\r
+\r
+    return(requestHandled);\r
+}\r
+\r
+\r
+#endif /* USER_SUPPLIED_AUDIO_HANDLER */\r
+\r
+\r
+/*******************************************************************************\r
+* Additional user functions supporting AUDIO Requests\r
+********************************************************************************/\r
+\r
+/* `#START AUDIO_FUNCTIONS` Place any additional functions here */\r
+\r
+/* `#END` */\r
+\r
+#endif  /* End USBFS_ENABLE_AUDIO_CLASS*/\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_audio.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_audio.h
new file mode 100755 (executable)
index 0000000..1e6186b
--- /dev/null
@@ -0,0 +1,95 @@
+/*******************************************************************************\r
+* File Name: USBFS_audio.h\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  Header File for the USFS component. Contains prototypes and constant values.\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_USBFS_USBFS_audio_H)\r
+#define CY_USBFS_USBFS_audio_H\r
+\r
+#include "cytypes.h"\r
+\r
+\r
+/***************************************\r
+* Custom Declarations\r
+***************************************/\r
+\r
+/* `#START CUSTOM_CONSTANTS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+/***************************************\r
+*  Constants for USBFS_audio API.\r
+***************************************/\r
+\r
+/* Audio Class-Specific Request Codes (AUDIO Table A-9) */\r
+#define USBFS_REQUEST_CODE_UNDEFINED     (0x00u)\r
+#define USBFS_SET_CUR                    (0x01u)\r
+#define USBFS_GET_CUR                    (0x81u)\r
+#define USBFS_SET_MIN                    (0x02u)\r
+#define USBFS_GET_MIN                    (0x82u)\r
+#define USBFS_SET_MAX                    (0x03u)\r
+#define USBFS_GET_MAX                    (0x83u)\r
+#define USBFS_SET_RES                    (0x04u)\r
+#define USBFS_GET_RES                    (0x84u)\r
+#define USBFS_SET_MEM                    (0x05u)\r
+#define USBFS_GET_MEM                    (0x85u)\r
+#define USBFS_GET_STAT                   (0xFFu)\r
+\r
+/* Endpoint Control Selectors (AUDIO Table A-19) */\r
+#define USBFS_EP_CONTROL_UNDEFINED       (0x00u)\r
+#define USBFS_SAMPLING_FREQ_CONTROL      (0x01u)\r
+#define USBFS_PITCH_CONTROL              (0x02u)\r
+\r
+/* Feature Unit Control Selectors (AUDIO Table A-11) */\r
+#define USBFS_FU_CONTROL_UNDEFINED       (0x00u)\r
+#define USBFS_MUTE_CONTROL               (0x01u)\r
+#define USBFS_VOLUME_CONTROL             (0x02u)\r
+#define USBFS_BASS_CONTROL               (0x03u)\r
+#define USBFS_MID_CONTROL                (0x04u)\r
+#define USBFS_TREBLE_CONTROL             (0x05u)\r
+#define USBFS_GRAPHIC_EQUALIZER_CONTROL  (0x06u)\r
+#define USBFS_AUTOMATIC_GAIN_CONTROL     (0x07u)\r
+#define USBFS_DELAY_CONTROL              (0x08u)\r
+#define USBFS_BASS_BOOST_CONTROL         (0x09u)\r
+#define USBFS_LOUDNESS_CONTROL           (0x0Au)\r
+\r
+#define USBFS_SAMPLE_FREQ_LEN            (3u)\r
+#define USBFS_VOLUME_LEN                 (2u)\r
+\r
+#if !defined(USER_SUPPLIED_DEFAULT_VOLUME_VALUE)\r
+    #define USBFS_VOL_MIN_MSB            (0x80u)\r
+    #define USBFS_VOL_MIN_LSB            (0x01u)\r
+    #define USBFS_VOL_MAX_MSB            (0x7Fu)\r
+    #define USBFS_VOL_MAX_LSB            (0xFFu)\r
+    #define USBFS_VOL_RES_MSB            (0x00u)\r
+    #define USBFS_VOL_RES_LSB            (0x01u)\r
+#endif /* USER_SUPPLIED_DEFAULT_VOLUME_VALUE */\r
+\r
+\r
+/***************************************\r
+* External data references\r
+***************************************/\r
+\r
+extern volatile uint8 USBFS_currentSampleFrequency[USBFS_MAX_EP]\r
+                                                             [USBFS_SAMPLE_FREQ_LEN];\r
+extern volatile uint8 USBFS_frequencyChanged;\r
+extern volatile uint8 USBFS_currentMute;\r
+extern volatile uint8 USBFS_currentVolume[USBFS_VOLUME_LEN];\r
+extern volatile uint8 USBFS_minimumVolume[USBFS_VOLUME_LEN];\r
+extern volatile uint8 USBFS_maximumVolume[USBFS_VOLUME_LEN];\r
+extern volatile uint8 USBFS_resolutionVolume[USBFS_VOLUME_LEN];\r
+\r
+#endif /* End CY_USBFS_USBFS_audio_H */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_boot.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_boot.c
new file mode 100755 (executable)
index 0000000..2843057
--- /dev/null
@@ -0,0 +1,262 @@
+/*******************************************************************************\r
+* File Name: USBFS_boot.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  Boot loader API for USBFS Component.\r
+*\r
+*  Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+\r
+#if defined(CYDEV_BOOTLOADER_IO_COMP) && ((CYDEV_BOOTLOADER_IO_COMP == CyBtldr_USBFS) || \\r
+                                          (CYDEV_BOOTLOADER_IO_COMP == CyBtldr_Custom_Interface))\r
+\r
+\r
+/***************************************\r
+*    Bootloader defines\r
+***************************************/\r
+\r
+#define USBFS_CyBtLdrStarttimer(X, T)         {USBFS_universalTime = T * 10; X = 0u;}\r
+#define USBFS_CyBtLdrChecktimer(X)            ((X++ < USBFS_universalTime) ? 1u : 0u)\r
+\r
+#define USBFS_BTLDR_OUT_EP      (0x01u)\r
+#define USBFS_BTLDR_IN_EP       (0x02u)\r
+\r
+\r
+/***************************************\r
+*    Bootloader Variables\r
+***************************************/\r
+\r
+static uint16 USBFS_universalTime;\r
+static uint8 USBFS_started = 0u;\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_CyBtldrCommStart\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Starts the component and enables the interrupt.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Side Effects:\r
+*  This function starts the USB with 3V or 5V operation.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_CyBtldrCommStart(void) \r
+{\r
+    CyGlobalIntEnable;      /* Enable Global Interrupts */\r
+\r
+    /*Start USBFS Operation/device 0 and with 5V or 3V operation depend on Voltage Configuration in DWR */\r
+    USBFS_Start(0u, USBFS_DWR_VDDD_OPERATION);\r
+\r
+    /* USB component started, the correct enumeration will be checked in first Read operation */\r
+    USBFS_started = 1u;\r
+\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_CyBtldrCommStop.\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Disable the component and disable the interrupt.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+*******************************************************************************/\r
+void USBFS_CyBtldrCommStop(void) \r
+{\r
+    USBFS_Stop();\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_CyBtldrCommReset.\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Resets the receive and transmit communication Buffers.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_CyBtldrCommReset(void) \r
+{\r
+    USBFS_EnableOutEP(USBFS_BTLDR_OUT_EP);  /* Enable the OUT endpoint */\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_CyBtldrCommWrite.\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Allows the caller to write data to the boot loader host. The function will\r
+*  handle polling to allow a block of data to be completely sent to the host\r
+*  device.\r
+*\r
+* Parameters:\r
+*  pData:    A pointer to the block of data to send to the device\r
+*  size:     The number of bytes to write.\r
+*  count:    Pointer to an unsigned short variable to write the number of\r
+*             bytes actually written.\r
+*  timeOut:  Number of units to wait before returning because of a timeout.\r
+*\r
+* Return:\r
+*  Returns the value that best describes the problem.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+cystatus USBFS_CyBtldrCommWrite(uint8 *pData, uint16 size, uint16 *count, uint8 timeOut) CYSMALL\r
+                                                            \r
+{\r
+    uint16 time;\r
+    cystatus status;\r
+\r
+    /* Enable IN transfer */\r
+    USBFS_LoadInEP(USBFS_BTLDR_IN_EP, pData, USBFS_BTLDR_SIZEOF_READ_BUFFER);\r
+\r
+    /* Start a timer to wait on. */\r
+    USBFS_CyBtLdrStarttimer(time, timeOut);\r
+\r
+    /* Wait for the master to read it. */\r
+    while((USBFS_GetEPState(USBFS_BTLDR_IN_EP) == USBFS_IN_BUFFER_FULL) && \\r
+           USBFS_CyBtLdrChecktimer(time))\r
+    {\r
+        CyDelay(1u); /* 1ms delay */\r
+    }\r
+\r
+    if (USBFS_GetEPState(USBFS_BTLDR_IN_EP) == USBFS_IN_BUFFER_FULL)\r
+    {\r
+        status = CYRET_TIMEOUT;\r
+    }\r
+    else\r
+    {\r
+        *count = size;\r
+        status = CYRET_SUCCESS;\r
+    }\r
+\r
+    return(status);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_CyBtldrCommRead.\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Allows the caller to read data from the boot loader host. The function will\r
+*  handle polling to allow a block of data to be completely received from the\r
+*  host device.\r
+*\r
+* Parameters:\r
+*  pData:    A pointer to the area to store the block of data received\r
+*             from the device.\r
+*  size:     The number of bytes to read.\r
+*  count:    Pointer to an unsigned short variable to write the number\r
+*             of bytes actually read.\r
+*  timeOut:  Number of units to wait before returning because of a timeOut.\r
+*            Timeout is measured in 10s of ms.\r
+*\r
+* Return:\r
+*  Returns the value that best describes the problem.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+cystatus USBFS_CyBtldrCommRead(uint8 *pData, uint16 size, uint16 *count, uint8 timeOut) CYSMALL\r
+                                                            \r
+{\r
+    cystatus status;\r
+    uint16 time;\r
+\r
+    if(size > USBFS_BTLDR_SIZEOF_WRITE_BUFFER)\r
+    {\r
+        size = USBFS_BTLDR_SIZEOF_WRITE_BUFFER;\r
+    }\r
+    /* Start a timer to wait on. */\r
+    USBFS_CyBtLdrStarttimer(time, timeOut);\r
+\r
+    /* Wait on enumeration in first time */\r
+    if(USBFS_started)\r
+    {\r
+        /* Wait for Device to enumerate */\r
+        while(!USBFS_GetConfiguration() && USBFS_CyBtLdrChecktimer(time))\r
+        {\r
+            CyDelay(1u); /* 1ms delay */\r
+        }\r
+        /* Enable first OUT, if enumeration complete */\r
+        if(USBFS_GetConfiguration())\r
+        {\r
+            USBFS_IsConfigurationChanged();  /* Clear configuration changes state status */\r
+            USBFS_CyBtldrCommReset();\r
+            USBFS_started = 0u;\r
+        }\r
+    }\r
+    else /* Check for configuration changes, has been done by Host */\r
+    {\r
+        if(USBFS_IsConfigurationChanged() != 0u) /* Host could send double SET_INTERFACE request or RESET */\r
+        {\r
+            if(USBFS_GetConfiguration() != 0u)   /* Init OUT endpoints when device reconfigured */\r
+            {\r
+                USBFS_CyBtldrCommReset();\r
+            }\r
+        }\r
+    }\r
+    /* Wait on next packet */\r
+    while((USBFS_GetEPState(USBFS_BTLDR_OUT_EP) != USBFS_OUT_BUFFER_FULL) && \\r
+           USBFS_CyBtLdrChecktimer(time))\r
+    {\r
+        CyDelay(1u); /* 1ms delay */\r
+    }\r
+\r
+    /* OUT EP has completed */\r
+    if (USBFS_GetEPState(USBFS_BTLDR_OUT_EP) == USBFS_OUT_BUFFER_FULL)\r
+    {\r
+        *count = USBFS_ReadOutEP(USBFS_BTLDR_OUT_EP, pData, size);\r
+        status = CYRET_SUCCESS;\r
+    }\r
+    else\r
+    {\r
+        *count = 0u;\r
+        status = CYRET_TIMEOUT;\r
+    }\r
+    return(status);\r
+}\r
+\r
+#endif /* End CYDEV_BOOTLOADER_IO_COMP == CyBtldr_USBFS */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.c
new file mode 100755 (executable)
index 0000000..82951c8
--- /dev/null
@@ -0,0 +1,706 @@
+/*******************************************************************************\r
+* File Name: USBFS_cdc.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  USB HID Class request handler.\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2012-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+\r
+#if defined(USBFS_ENABLE_CDC_CLASS)\r
+\r
+#include "USBFS_cdc.h"\r
+#include "USBFS_pvt.h"\r
+\r
+\r
+/***************************************\r
+*    CDC Variables\r
+***************************************/\r
+\r
+volatile uint8 USBFS_lineCoding[USBFS_LINE_CODING_SIZE];\r
+volatile uint8 USBFS_lineChanged;\r
+volatile uint16 USBFS_lineControlBitmap;\r
+volatile uint8 USBFS_cdc_data_in_ep;\r
+volatile uint8 USBFS_cdc_data_out_ep;\r
+\r
+\r
+/***************************************\r
+*     Static Function Prototypes\r
+***************************************/\r
+static uint16 USBFS_StrLen(const char8 string[]) ;\r
+\r
+\r
+/***************************************\r
+* Custom Declarations\r
+***************************************/\r
+\r
+/* `#START CDC_CUSTOM_DECLARATIONS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_DispatchCDCClassRqst\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine dispatches CDC class requests.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled\r
+*\r
+* Global variables:\r
+*   USBFS_lineCoding: Contains the current line coding structure.\r
+*     It is set by the Host using SET_LINE_CODING request and returned to the\r
+*     user code by the USBFS_GetDTERate(), USBFS_GetCharFormat(),\r
+*     USBFS_GetParityType(), USBFS_GetDataBits() APIs.\r
+*   USBFS_lineControlBitmap: Contains the current control signal\r
+*     bitmap. It is set by the Host using SET_CONTROL_LINE request and returned\r
+*     to the user code by the USBFS_GetLineControl() API.\r
+*   USBFS_lineChanged: This variable is used as a flag for the\r
+*     USBFS_IsLineChanged() API, to be aware that Host has been sent request\r
+*     for changing Line Coding or Control Bitmap.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_DispatchCDCClassRqst(void) \r
+{\r
+    uint8 requestHandled = USBFS_FALSE;\r
+\r
+    if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) == USBFS_RQST_DIR_D2H)\r
+    {   /* Control Read */\r
+        switch (CY_GET_REG8(USBFS_bRequest))\r
+        {\r
+            case USBFS_CDC_GET_LINE_CODING:\r
+                USBFS_currentTD.count = USBFS_LINE_CODING_SIZE;\r
+                USBFS_currentTD.pData = USBFS_lineCoding;\r
+                requestHandled  = USBFS_InitControlRead();\r
+                break;\r
+\r
+            /* `#START CDC_READ_REQUESTS` Place other request handler here */\r
+\r
+            /* `#END` */\r
+\r
+            default:    /* requestHandled is initialized as FALSE by default */\r
+                break;\r
+        }\r
+    }\r
+    else if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) == \\r
+                                                                            USBFS_RQST_DIR_H2D)\r
+    {   /* Control Write */\r
+        switch (CY_GET_REG8(USBFS_bRequest))\r
+        {\r
+            case USBFS_CDC_SET_LINE_CODING:\r
+                USBFS_currentTD.count = USBFS_LINE_CODING_SIZE;\r
+                USBFS_currentTD.pData = USBFS_lineCoding;\r
+                USBFS_lineChanged |= USBFS_LINE_CODING_CHANGED;\r
+                requestHandled = USBFS_InitControlWrite();\r
+                break;\r
+\r
+            case USBFS_CDC_SET_CONTROL_LINE_STATE:\r
+                USBFS_lineControlBitmap = CY_GET_REG8(USBFS_wValueLo);\r
+                USBFS_lineChanged |= USBFS_LINE_CONTROL_CHANGED;\r
+                requestHandled = USBFS_InitNoDataControlTransfer();\r
+                break;\r
+\r
+            /* `#START CDC_WRITE_REQUESTS` Place other request handler here */\r
+\r
+            /* `#END` */\r
+\r
+            default:    /* requestHandled is initialized as FALSE by default */\r
+                break;\r
+        }\r
+    }\r
+    else\r
+    {   /* requestHandled is initialized as FALSE by default */\r
+    }\r
+\r
+    return(requestHandled);\r
+}\r
+\r
+\r
+/***************************************\r
+* Optional CDC APIs\r
+***************************************/\r
+#if (USBFS_ENABLE_CDC_CLASS_API != 0u)\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_CDC_Init\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  This function initialize the CDC interface to be ready for the receive data\r
+    *  from the PC.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_lineChanged: Initialized to zero.\r
+    *   USBFS_cdc_data_out_ep: Used as an OUT endpoint number.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    void USBFS_CDC_Init(void) \r
+    {\r
+        USBFS_lineChanged = 0u;\r
+        USBFS_EnableOutEP(USBFS_cdc_data_out_ep);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_PutData\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Sends a specified number of bytes from the location specified by a\r
+    *  pointer to the PC.\r
+    *\r
+    * Parameters:\r
+    *  pData: pointer to the buffer containing data to be sent.\r
+    *  length: Specifies the number of bytes to send from the pData\r
+    *  buffer. Maximum length will be limited by the maximum packet\r
+    *  size for the endpoint.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending\r
+    *     data.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    void USBFS_PutData(const uint8* pData, uint16 length) \r
+    {\r
+        /* Limits length to maximum packet size for the EP */\r
+        if(length > USBFS_EP[USBFS_cdc_data_in_ep].bufferSize)\r
+        {\r
+            /* Caution: Data will be lost if length is greater than Max Packet Length */\r
+            length = USBFS_EP[USBFS_cdc_data_in_ep].bufferSize;\r
+             /* Halt CPU in debug mode */\r
+            CYASSERT(0u != 0u);\r
+        }\r
+        USBFS_LoadInEP(USBFS_cdc_data_in_ep, pData, length);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_StrLen\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Calculates length of a null terminated string.\r
+    *\r
+    * Parameters:\r
+    *  string: pointer to the string.\r
+    *\r
+    * Return:\r
+    *  Length of the string\r
+    *\r
+    *******************************************************************************/\r
+    static uint16 USBFS_StrLen(const char8 string[]) \r
+    {\r
+        uint16 len = 0u;\r
+\r
+        while (string[len] != (char8)0)\r
+        {\r
+            len++;\r
+        }\r
+\r
+        return (len);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_PutString\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Sends a null terminated string to the PC.\r
+    *\r
+    * Parameters:\r
+    *  string: pointer to the string to be sent to the PC\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending\r
+    *     data.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    * Theory:\r
+    *  This function will block if there is not enough memory to place the whole\r
+    *  string, it will block until the entire string has been written to the\r
+    *  transmit buffer.\r
+    *\r
+    *******************************************************************************/\r
+    void USBFS_PutString(const char8 string[]) \r
+    {\r
+        uint16 str_length;\r
+        uint16 send_length;\r
+        uint16 buf_index = 0u;\r
+\r
+        /* Get length of the null terminated string */\r
+        str_length = USBFS_StrLen(string);\r
+        do\r
+        {\r
+            /* Limits length to maximum packet size for the EP */\r
+            send_length = (str_length > USBFS_EP[USBFS_cdc_data_in_ep].bufferSize) ?\r
+                          USBFS_EP[USBFS_cdc_data_in_ep].bufferSize : str_length;\r
+             /* Enable IN transfer */\r
+            USBFS_LoadInEP(USBFS_cdc_data_in_ep, (const uint8 *)&string[buf_index], send_length);\r
+            str_length -= send_length;\r
+\r
+            /* If more data are present to send */\r
+            if(str_length > 0u)\r
+            {\r
+                buf_index += send_length;\r
+                /* Wait for the Host to read it. */\r
+                while(USBFS_EP[USBFS_cdc_data_in_ep].apiEpState ==\r
+                                          USBFS_IN_BUFFER_FULL)\r
+                {\r
+                    ;\r
+                }\r
+            }\r
+        }while(str_length > 0u);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_PutChar\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Writes a single character to the PC.\r
+    *\r
+    * Parameters:\r
+    *  txDataByte: Character to be sent to the PC.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending\r
+    *     data.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    void USBFS_PutChar(char8 txDataByte) \r
+    {\r
+        uint8 dataByte;\r
+        dataByte = (uint8)txDataByte;\r
+\r
+        USBFS_LoadInEP(USBFS_cdc_data_in_ep, &dataByte, 1u);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_PutCRLF\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Sends a carriage return (0x0D) and line feed (0x0A) to the PC\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending\r
+    *     data.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    void USBFS_PutCRLF(void) \r
+    {\r
+        const uint8 CYCODE txData[] = {0x0Du, 0x0Au};\r
+\r
+        USBFS_LoadInEP(USBFS_cdc_data_in_ep, (const uint8 *)txData, 2u);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetCount\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  This function returns the number of bytes that were received from the PC.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  Returns the number of received bytes.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.\r
+    *\r
+    *******************************************************************************/\r
+    uint16 USBFS_GetCount(void) \r
+    {\r
+        uint16 bytesCount = 0u;\r
+\r
+        if (USBFS_EP[USBFS_cdc_data_out_ep].apiEpState == USBFS_OUT_BUFFER_FULL)\r
+        {\r
+            bytesCount = USBFS_GetEPCount(USBFS_cdc_data_out_ep);\r
+        }\r
+\r
+        return(bytesCount);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_DataIsReady\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Returns a nonzero value if the component received data or received\r
+    *  zero-length packet. The GetAll() or GetData() API should be called to read\r
+    *  data from the buffer and re-init OUT endpoint even when zero-length packet\r
+    *  received.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  If the OUT packet received this function returns a nonzero value.\r
+    *  Otherwise zero is returned.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_DataIsReady(void) \r
+    {\r
+        return(USBFS_EP[USBFS_cdc_data_out_ep].apiEpState);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_CDCIsReady\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Returns a nonzero value if the component is ready to send more data to the\r
+    *  PC. Otherwise returns zero. Should be called before sending new data to\r
+    *  ensure the previous data has finished sending.This function returns the\r
+    *  number of bytes that were received from the PC.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  If the buffer can accept new data then this function returns a nonzero value.\r
+    *  Otherwise zero is returned.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_in_ep: CDC IN endpoint number used.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_CDCIsReady(void) \r
+    {\r
+        return(USBFS_EP[USBFS_cdc_data_in_ep].apiEpState);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetData\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Gets a specified number of bytes from the input buffer and places it in a\r
+    *  data array specified by the passed pointer.\r
+    *  USBFS_DataIsReady() API should be called before, to be sure\r
+    *  that data is received from the Host.\r
+    *\r
+    * Parameters:\r
+    *  pData: Pointer to the data array where data will be placed.\r
+    *  Length: Number of bytes to read into the data array from the RX buffer.\r
+    *          Maximum length is limited by the the number of received bytes.\r
+    *\r
+    * Return:\r
+    *  Number of bytes received.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    uint16 USBFS_GetData(uint8* pData, uint16 length) \r
+    {\r
+        return(USBFS_ReadOutEP(USBFS_cdc_data_out_ep, pData, length));\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetAll\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Gets all bytes of received data from the input buffer and places it into a\r
+    *  specified data array. USBFS_DataIsReady() API should be called\r
+    *  before, to be sure that data is received from the Host.\r
+    *\r
+    * Parameters:\r
+    *  pData: Pointer to the data array where data will be placed.\r
+    *\r
+    * Return:\r
+    *  Number of bytes received.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.\r
+    *   USBFS_EP[].bufferSize: EP max packet size is used as a length\r
+    *     to read all data from the EP buffer.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    uint16 USBFS_GetAll(uint8* pData) \r
+    {\r
+        return (USBFS_ReadOutEP(USBFS_cdc_data_out_ep, pData,\r
+                                           USBFS_EP[USBFS_cdc_data_out_ep].bufferSize));\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetChar\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Reads one byte of received data from the buffer.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  Received one character.\r
+    *\r
+    * Global variables:\r
+    *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.\r
+    *\r
+    * Reentrant:\r
+    *  No.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_GetChar(void) \r
+    {\r
+         uint8 rxData;\r
+\r
+        (void) USBFS_ReadOutEP(USBFS_cdc_data_out_ep, &rxData, 1u);\r
+\r
+        return(rxData);\r
+    }\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_IsLineChanged\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  This function returns clear on read status of the line.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  If SET_LINE_CODING or CDC_SET_CONTROL_LINE_STATE request received then not\r
+    *  zero value returned. Otherwise zero is returned.\r
+    *\r
+    * Global variables:\r
+    *  USBFS_transferState - it is checked to be sure then OUT data\r
+    *    phase has been complete, and data written to the lineCoding or Control\r
+    *    Bitmap buffer.\r
+    *  USBFS_lineChanged: used as a flag to be aware that Host has been\r
+    *    sent request for changing Line Coding or Control Bitmap.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_IsLineChanged(void) \r
+    {\r
+        uint8 state = 0u;\r
+\r
+        /* transferState is checked to be sure then OUT data phase has been complete */\r
+        if(USBFS_transferState == USBFS_TRANS_STATE_IDLE)\r
+        {\r
+            if(USBFS_lineChanged != 0u)\r
+            {\r
+                state = USBFS_lineChanged;\r
+                USBFS_lineChanged = 0u;\r
+            }\r
+        }\r
+\r
+        return(state);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetDTERate\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Returns the data terminal rate set for this port in bits per second.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  Returns a uint32 value of the data rate in bits per second.\r
+    *\r
+    * Global variables:\r
+    *  USBFS_lineCoding: First four bytes converted to uint32\r
+    *    depend on compiler, and returned as a data rate.\r
+    *\r
+    *******************************************************************************/\r
+    uint32 USBFS_GetDTERate(void) \r
+    {\r
+        uint32 rate;\r
+\r
+        rate = USBFS_lineCoding[USBFS_LINE_CODING_RATE + 3u];\r
+        rate = (rate << 8u) | USBFS_lineCoding[USBFS_LINE_CODING_RATE + 2u];\r
+        rate = (rate << 8u) | USBFS_lineCoding[USBFS_LINE_CODING_RATE + 1u];\r
+        rate = (rate << 8u) | USBFS_lineCoding[USBFS_LINE_CODING_RATE];\r
+\r
+        return(rate);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetCharFormat\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Returns the number of stop bits.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  Returns the number of stop bits.\r
+    *\r
+    * Global variables:\r
+    *  USBFS_lineCoding: used to get a parameter.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_GetCharFormat(void) \r
+    {\r
+        return(USBFS_lineCoding[USBFS_LINE_CODING_STOP_BITS]);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetParityType\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Returns the parity type for the CDC port.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  Returns the parity type.\r
+    *\r
+    * Global variables:\r
+    *  USBFS_lineCoding: used to get a parameter.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_GetParityType(void) \r
+    {\r
+        return(USBFS_lineCoding[USBFS_LINE_CODING_PARITY]);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetDataBits\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Returns the number of data bits for the CDC port.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  Returns the number of data bits.\r
+    *  The number of data bits can be 5, 6, 7, 8 or 16.\r
+    *\r
+    * Global variables:\r
+    *  USBFS_lineCoding: used to get a parameter.\r
+    *\r
+    *******************************************************************************/\r
+    uint8 USBFS_GetDataBits(void) \r
+    {\r
+        return(USBFS_lineCoding[USBFS_LINE_CODING_DATA_BITS]);\r
+    }\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_GetLineControl\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Returns Line control bitmap.\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  Returns Line control bitmap.\r
+    *\r
+    * Global variables:\r
+    *  USBFS_lineControlBitmap: used to get a parameter.\r
+    *\r
+    *******************************************************************************/\r
+    uint16 USBFS_GetLineControl(void) \r
+    {\r
+        return(USBFS_lineControlBitmap);\r
+    }\r
+\r
+#endif  /* End USBFS_ENABLE_CDC_CLASS_API*/\r
+\r
+\r
+/*******************************************************************************\r
+* Additional user functions supporting CDC Requests\r
+********************************************************************************/\r
+\r
+/* `#START CDC_FUNCTIONS` Place any additional functions here */\r
+\r
+/* `#END` */\r
+\r
+#endif  /* End USBFS_ENABLE_CDC_CLASS*/\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.h
new file mode 100755 (executable)
index 0000000..334bc58
--- /dev/null
@@ -0,0 +1,92 @@
+/*******************************************************************************\r
+* File Name: USBFS_cdc.h\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  Header File for the USFS component.\r
+*  Contains CDC class prototypes and constant values.\r
+*\r
+********************************************************************************\r
+* Copyright 2012-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_USBFS_USBFS_cdc_H)\r
+#define CY_USBFS_USBFS_cdc_H\r
+\r
+#include "cytypes.h"\r
+\r
+\r
+/***************************************\r
+* Prototypes of the USBFS_cdc API.\r
+***************************************/\r
+\r
+#if (USBFS_ENABLE_CDC_CLASS_API != 0u)\r
+    void USBFS_CDC_Init(void) ;\r
+    void USBFS_PutData(const uint8* pData, uint16 length) ;\r
+    void USBFS_PutString(const char8 string[]) ;\r
+    void USBFS_PutChar(char8 txDataByte) ;\r
+    void USBFS_PutCRLF(void) ;\r
+    uint16 USBFS_GetCount(void) ;\r
+    uint8 USBFS_CDCIsReady(void) ;\r
+    uint8 USBFS_DataIsReady(void) ;\r
+    uint16 USBFS_GetData(uint8* pData, uint16 length) ;\r
+    uint16 USBFS_GetAll(uint8* pData) ;\r
+    uint8 USBFS_GetChar(void) ;\r
+    uint8 USBFS_IsLineChanged(void) ;\r
+    uint32 USBFS_GetDTERate(void) ;\r
+    uint8 USBFS_GetCharFormat(void) ;\r
+    uint8 USBFS_GetParityType(void) ;\r
+    uint8 USBFS_GetDataBits(void) ;\r
+    uint16 USBFS_GetLineControl(void) ;\r
+#endif  /* End USBFS_ENABLE_CDC_CLASS_API*/\r
+\r
+\r
+/***************************************\r
+*  Constants for USBFS_cdc API.\r
+***************************************/\r
+\r
+/* CDC Class-Specific Request Codes (CDC ver 1.2 Table 19) */\r
+#define USBFS_CDC_SET_LINE_CODING        (0x20u)\r
+#define USBFS_CDC_GET_LINE_CODING        (0x21u)\r
+#define USBFS_CDC_SET_CONTROL_LINE_STATE (0x22u)\r
+\r
+#define USBFS_LINE_CODING_CHANGED        (0x01u)\r
+#define USBFS_LINE_CONTROL_CHANGED       (0x02u)\r
+\r
+#define USBFS_1_STOPBIT                  (0x00u)\r
+#define USBFS_1_5_STOPBITS               (0x01u)\r
+#define USBFS_2_STOPBITS                 (0x02u)\r
+\r
+#define USBFS_PARITY_NONE                (0x00u)\r
+#define USBFS_PARITY_ODD                 (0x01u)\r
+#define USBFS_PARITY_EVEN                (0x02u)\r
+#define USBFS_PARITY_MARK                (0x03u)\r
+#define USBFS_PARITY_SPACE               (0x04u)\r
+\r
+#define USBFS_LINE_CODING_SIZE           (0x07u)\r
+#define USBFS_LINE_CODING_RATE           (0x00u)\r
+#define USBFS_LINE_CODING_STOP_BITS      (0x04u)\r
+#define USBFS_LINE_CODING_PARITY         (0x05u)\r
+#define USBFS_LINE_CODING_DATA_BITS      (0x06u)\r
+\r
+#define USBFS_LINE_CONTROL_DTR           (0x01u)\r
+#define USBFS_LINE_CONTROL_RTS           (0x02u)\r
+\r
+\r
+/***************************************\r
+* External data references\r
+***************************************/\r
+\r
+extern volatile uint8 USBFS_lineCoding[USBFS_LINE_CODING_SIZE];\r
+extern volatile uint8 USBFS_lineChanged;\r
+extern volatile uint16 USBFS_lineControlBitmap;\r
+extern volatile uint8 USBFS_cdc_data_in_ep;\r
+extern volatile uint8 USBFS_cdc_data_out_ep;\r
+\r
+#endif /* End CY_USBFS_USBFS_cdc_H */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.inf b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cdc.inf
new file mode 100755 (executable)
index 0000000..c3477c2
--- /dev/null
@@ -0,0 +1,122 @@
+;******************************************************************************\r
+; File Name: USBFS_cdc.inf\r
+; Version 2.60\r
+;\r
+; Description:\r
+;  Windows USB CDC setup file for USBUART Device.\r
+;\r
+;******************************************************************************\r
+; Copyright 2007-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+; You may use this file only in accordance with the license, terms, conditions,\r
+; disclaimers, and limitations in the end user license agreement accompanying\r
+; the software package with which this file was provided.\r
+;******************************************************************************\r
+\r
+[Version]\r
+Signature="$Windows NT$"\r
+Class=Ports\r
+ClassGuid={4D36E978-E325-11CE-BFC1-08002BE10318}\r
+Provider=%PROVIDER%\r
+LayoutFile=layout.inf\r
+DriverVer=03/05/2007,2.0.0000.0\r
+\r
+[Manufacturer]\r
+%MFGNAME%=DeviceList, NTx86, NTia64, NTamd64\r
+\r
+[DestinationDirs]\r
+DefaultDestDir=12\r
+\r
+[SourceDisksFiles]\r
+\r
+[SourceDisksNames]\r
+\r
+[DeviceList.NTx86]\r
+%DESCRIPTION%=DriverInstall, USB\VID_04B4&PID_F232\r
+\r
+[DeviceList.NTia64]\r
+%DESCRIPTION%=DriverInstall, USB\VID_04B4&PID_F232\r
+\r
+[DeviceList.NTamd64]\r
+%DESCRIPTION%=DriverInstall, USB\VID_04B4&PID_F232\r
+\r
+\r
+;------------------------------------------------------------------------------\r
+;  32 bit section for Windows 2000/2003/XP/Vista\r
+;------------------------------------------------------------------------------\r
+\r
+[DriverInstall.NTx86]\r
+include=mdmcpq.inf\r
+CopyFiles=DriverCopyFiles\r
+AddReg=DriverInstall.NTx86.AddReg\r
+\r
+[DriverCopyFiles]\r
+usbser.sys,,,0x20\r
+\r
+[DriverInstall.NTx86.AddReg]\r
+HKR,,DevLoader,,*ntkern\r
+HKR,,NTMPDriver,,usbser.sys\r
+HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"\r
+\r
+[DriverInstall.NTx86.Services]\r
+AddService=usbser, 0x00000002, DriverService\r
+\r
+;------------------------------------------------------------------------------\r
+;  64 bit section for Intel Itanium based systems\r
+;------------------------------------------------------------------------------\r
+\r
+[DriverInstall.NTia64]\r
+include=mdmcpq.inf\r
+CopyFiles=DriverCopyFiles\r
+AddReg=DriverInstall.NTia64.AddReg\r
+\r
+[DriverCopyFiles]\r
+usbser.sys,,,0x20\r
+\r
+[DriverInstall.NTia64.AddReg]\r
+HKR,,DevLoader,,*ntkern\r
+HKR,,NTMPDriver,,usbser.sys\r
+HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"\r
+\r
+[DriverInstall.NTia64.Services]\r
+AddService=usbser, 0x00000002, DriverService\r
+\r
+;------------------------------------------------------------------------------\r
+;  64 bit section for AMD64 and Intel EM64T based systems\r
+;------------------------------------------------------------------------------\r
+\r
+[DriverInstall.NTamd64]\r
+include=mdmcpq.inf\r
+CopyFiles=DriverCopyFiles\r
+AddReg=DriverInstall.NTamd64.AddReg\r
+\r
+[DriverCopyFiles]\r
+usbser.sys,,,0x20\r
+\r
+[DriverInstall.NTamd64.AddReg]\r
+HKR,,DevLoader,,*ntkern\r
+HKR,,NTMPDriver,,usbser.sys\r
+HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"\r
+\r
+[DriverInstall.NTamd64.Services]\r
+AddService=usbser, 0x00000002, DriverService\r
+\r
+;------------------------------------------------------------------------------\r
+;\r
+;------------------------------------------------------------------------------\r
+\r
+[DriverService]\r
+DisplayName=%SERVICE%\r
+ServiceType=1\r
+StartType=3\r
+ErrorControl=1\r
+ServiceBinary=%12%\usbser.sys\r
+\r
+;------------------------------------------------------------------------------\r
+;  String Definitions\r
+;------------------------------------------------------------------------------\r
+\r
+[Strings]\r
+PROVIDER="Cypress"\r
+MFGNAME="Cypress Semiconductor Corporation"\r
+DESCRIPTION="Cypress USB UART"\r
+SERVICE="USB UART"\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cls.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_cls.c
new file mode 100755 (executable)
index 0000000..7bbd8d1
--- /dev/null
@@ -0,0 +1,107 @@
+/*******************************************************************************\r
+* File Name: USBFS_cls.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  USB Class request handler.\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+\r
+#if(USBFS_EXTERN_CLS == USBFS_FALSE)\r
+\r
+#include "USBFS_pvt.h"\r
+\r
+\r
+/***************************************\r
+* User Implemented Class Driver Declarations.\r
+***************************************/\r
+/* `#START USER_DEFINED_CLASS_DECLARATIONS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_DispatchClassRqst\r
+********************************************************************************\r
+* Summary:\r
+*  This routine dispatches class specific requests depend on interface class.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_DispatchClassRqst(void) \r
+{\r
+    uint8 requestHandled = USBFS_FALSE;\r
+    uint8 interfaceNumber = 0u;\r
+\r
+    switch(CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_RCPT_MASK)\r
+    {\r
+        case USBFS_RQST_RCPT_IFC:        /* Class-specific request directed to an interface */\r
+            interfaceNumber = CY_GET_REG8(USBFS_wIndexLo); /* wIndexLo contain Interface number */\r
+            break;\r
+        case USBFS_RQST_RCPT_EP:         /* Class-specific request directed to the endpoint */\r
+            /* Find related interface to the endpoint, wIndexLo contain EP number */\r
+            interfaceNumber =\r
+                USBFS_EP[CY_GET_REG8(USBFS_wIndexLo) & USBFS_DIR_UNUSED].interface;\r
+            break;\r
+        default:    /* RequestHandled is initialized as FALSE by default */\r
+            break;\r
+    }\r
+    /* Handle Class request depend on interface type */\r
+    switch(USBFS_interfaceClass[interfaceNumber])\r
+    {\r
+        case USBFS_CLASS_HID:\r
+            #if defined(USBFS_ENABLE_HID_CLASS)\r
+                requestHandled = USBFS_DispatchHIDClassRqst();\r
+            #endif /* USBFS_ENABLE_HID_CLASS */\r
+            break;\r
+        case USBFS_CLASS_AUDIO:\r
+            #if defined(USBFS_ENABLE_AUDIO_CLASS)\r
+                requestHandled = USBFS_DispatchAUDIOClassRqst();\r
+            #endif /* USBFS_ENABLE_HID_CLASS */\r
+            break;\r
+        case USBFS_CLASS_CDC:\r
+            #if defined(USBFS_ENABLE_CDC_CLASS)\r
+                requestHandled = USBFS_DispatchCDCClassRqst();\r
+            #endif /* USBFS_ENABLE_CDC_CLASS */\r
+            break;\r
+        default:    /* requestHandled is initialized as FALSE by default */\r
+            break;\r
+    }\r
+\r
+    /* `#START USER_DEFINED_CLASS_CODE` Place your Class request here */\r
+\r
+    /* `#END` */\r
+\r
+    return(requestHandled);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Additional user functions supporting Class Specific Requests\r
+********************************************************************************/\r
+\r
+/* `#START CLASS_SPECIFIC_FUNCTIONS` Place any additional functions here */\r
+\r
+/* `#END` */\r
+\r
+#endif /* USBFS_EXTERN_CLS */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_descr.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_descr.c
new file mode 100755 (executable)
index 0000000..cce3cf3
--- /dev/null
@@ -0,0 +1,319 @@
+/*******************************************************************************\r
+* File Name: USBFS_descr.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  USB descriptors and storage.\r
+*\r
+*  Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+#include "USBFS_pvt.h"\r
+\r
+\r
+/*****************************************************************************\r
+*  User supplied descriptors.  If you want to specify your own descriptors,\r
+*  remove the comments around the define USER_SUPPLIED_DESCRIPTORS below and\r
+*  add your descriptors.\r
+*****************************************************************************/\r
+/* `#START USER_DESCRIPTORS_DECLARATIONS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+/***************************************\r
+*  USB Customizer Generated Descriptors\r
+***************************************/\r
+\r
+#if !defined(USER_SUPPLIED_DESCRIPTORS)\r
+/*********************************************************************\r
+* Device Descriptors\r
+*********************************************************************/\r
+const uint8 CYCODE USBFS_DEVICE0_DESCR[18u] = {\r
+/* Descriptor Length                       */ 0x12u,\r
+/* DescriptorType: DEVICE                  */ 0x01u,\r
+/* bcdUSB (ver 2.0)                        */ 0x00u, 0x02u,\r
+/* bDeviceClass                            */ 0x00u,\r
+/* bDeviceSubClass                         */ 0x00u,\r
+/* bDeviceProtocol                         */ 0x00u,\r
+/* bMaxPacketSize0                         */ 0x08u,\r
+/* idVendor                                */ 0xB4u, 0x04u,\r
+/* idProduct                               */ 0x37u, 0x13u,\r
+/* bcdDevice                               */ 0x00u, 0x30u,\r
+/* iManufacturer                           */ 0x02u,\r
+/* iProduct                                */ 0x01u,\r
+/* iSerialNumber                           */ 0x80u,\r
+/* bNumConfigurations                      */ 0x01u\r
+};\r
+/*********************************************************************\r
+* Config Descriptor  \r
+*********************************************************************/\r
+const uint8 CYCODE USBFS_DEVICE0_CONFIGURATION0_DESCR[41u] = {\r
+/*  Config Descriptor Length               */ 0x09u,\r
+/*  DescriptorType: CONFIG                 */ 0x02u,\r
+/*  wTotalLength                           */ 0x29u, 0x00u,\r
+/*  bNumInterfaces                         */ 0x01u,\r
+/*  bConfigurationValue                    */ 0x01u,\r
+/*  iConfiguration                         */ 0x00u,\r
+/*  bmAttributes                           */ 0x80u,\r
+/*  bMaxPower                              */ 0xFAu,\r
+/*********************************************************************\r
+* Interface Descriptor\r
+*********************************************************************/\r
+/*  Interface Descriptor Length            */ 0x09u,\r
+/*  DescriptorType: INTERFACE              */ 0x04u,\r
+/*  bInterfaceNumber                       */ 0x00u,\r
+/*  bAlternateSetting                      */ 0x00u,\r
+/*  bNumEndpoints                          */ 0x02u,\r
+/*  bInterfaceClass                        */ 0x03u,\r
+/*  bInterfaceSubClass                     */ 0x00u,\r
+/*  bInterfaceProtocol                     */ 0x00u,\r
+/*  iInterface                             */ 0x00u,\r
+/*********************************************************************\r
+* HID Class Descriptor\r
+*********************************************************************/\r
+/*  HID Class Descriptor Length            */ 0x09u,\r
+/*  DescriptorType: HID_CLASS              */ 0x21u,\r
+/*  bcdHID                                 */ 0x11u, 0x01u,\r
+/*  bCountryCode                           */ 0x00u,\r
+/*  bNumDescriptors                        */ 0x01u,\r
+/*  bDescriptorType                        */ 0x22u,\r
+/*  wDescriptorLength (LSB)                */ USBFS_HID_RPT_1_SIZE_LSB,\r
+/*  wDescriptorLength (MSB)                */ USBFS_HID_RPT_1_SIZE_MSB,\r
+/*********************************************************************\r
+* Endpoint Descriptor\r
+*********************************************************************/\r
+/*  Endpoint Descriptor Length             */ 0x07u,\r
+/*  DescriptorType: ENDPOINT               */ 0x05u,\r
+/*  bEndpointAddress                       */ 0x01u,\r
+/*  bmAttributes                           */ 0x03u,\r
+/*  wMaxPacketSize                         */ 0x40u, 0x00u,\r
+/*  bInterval                              */ 0x80u,\r
+/*********************************************************************\r
+* Endpoint Descriptor\r
+*********************************************************************/\r
+/*  Endpoint Descriptor Length             */ 0x07u,\r
+/*  DescriptorType: ENDPOINT               */ 0x05u,\r
+/*  bEndpointAddress                       */ 0x82u,\r
+/*  bmAttributes                           */ 0x03u,\r
+/*  wMaxPacketSize                         */ 0x40u, 0x00u,\r
+/*  bInterval                              */ 0x80u\r
+};\r
+\r
+/*********************************************************************\r
+* String Descriptor Table\r
+*********************************************************************/\r
+const uint8 CYCODE USBFS_STRING_DESCRIPTORS[45u] = {\r
+/*********************************************************************\r
+* Language ID Descriptor\r
+*********************************************************************/\r
+/* Descriptor Length                       */ 0x04u,\r
+/* DescriptorType: STRING                  */ 0x03u,\r
+/* Language Id                             */ 0x09u, 0x04u,\r
+/*********************************************************************\r
+* String Descriptor: "SCSI2SD"\r
+*********************************************************************/\r
+/* Descriptor Length                       */ 0x10u,\r
+/* DescriptorType: STRING                  */ 0x03u,\r
+ (uint8)'S', 0u,(uint8)'C', 0u,(uint8)'S', 0u,(uint8)'I', 0u,(uint8)'2', 0u,\r
+ (uint8)'S', 0u,(uint8)'D', 0u,\r
+/*********************************************************************\r
+* String Descriptor: "codesrc.com"\r
+*********************************************************************/\r
+/* Descriptor Length                       */ 0x18u,\r
+/* DescriptorType: STRING                  */ 0x03u,\r
+ (uint8)'c', 0u,(uint8)'o', 0u,(uint8)'d', 0u,(uint8)'e', 0u,(uint8)'s', 0u,\r
+ (uint8)'r', 0u,(uint8)'c', 0u,(uint8)'.', 0u,(uint8)'c', 0u,(uint8)'o', 0u,\r
+ (uint8)'m', 0u,\r
+/*********************************************************************/\r
+/* Marks the end of the list.              */ 0x00u};\r
+/*********************************************************************/\r
+\r
+/*********************************************************************\r
+* Serial Number String Descriptor\r
+*********************************************************************/\r
+const uint8 CYCODE USBFS_SN_STRING_DESCRIPTOR[10] = {\r
+/* Descriptor Length                       */ 0x0Au,\r
+/* DescriptorType: STRING                  */ 0x03u,\r
+(uint8)'1', 0u,(uint8)'2', 0u,(uint8)'3', 0u,(uint8)'4', 0u\r
+};\r
+\r
+/*********************************************************************\r
+* HID Report Descriptor: Generic HID\r
+*********************************************************************/\r
+const uint8 CYCODE USBFS_HIDREPORT_DESCRIPTOR1[40u] = {\r
+/*  Descriptor Size (Not part of descriptor)*/ USBFS_HID_RPT_1_SIZE_LSB,\r
+USBFS_HID_RPT_1_SIZE_MSB,\r
+/* USAGE_PAGE                              */ 0x05u, 0x01u, \r
+/* USAGE                                   */ 0x09u, 0x00u, \r
+/* COLLECTION                              */ 0xA1u, 0x00u, \r
+/* USAGE                                   */ 0x09u, 0x00u, \r
+/* COLLECTION                              */ 0xA1u, 0x00u, \r
+/* USAGE                                   */ 0x09u, 0x00u, \r
+/* LOGICAL_MINIMUM                         */ 0x15u, 0x00u, \r
+/* LOGICAL_MAXIMUM                         */ 0x25u, 0xFFu, \r
+/* REPORT_SIZE                             */ 0x75u, 0x08u, \r
+/* REPORT_COUNT                            */ 0x95u, 0x40u, \r
+/* OUTPUT                                  */ 0x91u, 0x02u, \r
+/* USAGE                                   */ 0x09u, 0x00u, \r
+/* LOGICAL_MINIMUM                         */ 0x15u, 0x00u, \r
+/* LOGICAL_MAXIMUM                         */ 0x25u, 0xFFu, \r
+/* REPORT_SIZE                             */ 0x75u, 0x08u, \r
+/* REPORT_COUNT                            */ 0x95u, 0x40u, \r
+/* INPUT                                   */ 0x81u, 0x02u, \r
+/* END_COLLECTION                          */ 0xC0u, \r
+/* END_COLLECTION                          */ 0xC0u, \r
+/*********************************************************************/\r
+/* End of the HID Report Descriptor        */ 0x00u, 0x00u};\r
+/*********************************************************************/\r
+\r
+#if !defined(USER_DEFINE_USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_HID_RPT_STORAGE)\r
+/*********************************************************************\r
+* HID Input Report Storage\r
+*********************************************************************/\r
+T_USBFS_XFER_STATUS_BLOCK USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_RPT_SCB;\r
+uint8 USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_BUF[\r
+            USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_BUF_SIZE];\r
+\r
+/*********************************************************************\r
+* HID Input Report TD Table\r
+*********************************************************************/\r
+const T_USBFS_TD CYCODE USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_RPT_TABLE[1u] = {\r
+    {USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_BUF_SIZE,\r
+    &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_BUF[0u],\r
+    &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_RPT_SCB},\r
+};\r
+/*********************************************************************\r
+* HID Output Report Storage\r
+*********************************************************************/\r
+T_USBFS_XFER_STATUS_BLOCK USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_RPT_SCB;\r
+uint8 USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_BUF[\r
+            USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_BUF_SIZE];\r
+\r
+/*********************************************************************\r
+* HID Output Report TD Table\r
+*********************************************************************/\r
+const T_USBFS_TD CYCODE USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_RPT_TABLE[1u] = {\r
+    {USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_BUF_SIZE,\r
+    &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_BUF[0u],\r
+    &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_RPT_SCB},\r
+};\r
+/*********************************************************************\r
+* HID Report Look Up Table         This table has four entries:\r
+*                                        IN Report Table\r
+*                                        OUT Report Table\r
+*                                        Feature Report Table\r
+*                                        HID Report Descriptor\r
+*                                        HID Class Descriptor\r
+*********************************************************************/\r
+const T_USBFS_LUT CYCODE USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_TABLE[5u] = {\r
+    {0x00u,     &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_IN_RPT_TABLE},\r
+    {0x00u,     &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_OUT_RPT_TABLE},\r
+    {0x00u,    NULL},\r
+    {0x01u,     (const void *)&USBFS_HIDREPORT_DESCRIPTOR1[0]},\r
+    {0x01u,     (const void *)&USBFS_DEVICE0_CONFIGURATION0_DESCR[18]}\r
+};\r
+#endif /* USER_DEFINE_USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_HID_RPT_STORAGE */\r
+\r
+/*********************************************************************\r
+* Interface Dispatch Table -- Points to the Class Dispatch Tables\r
+*********************************************************************/\r
+const T_USBFS_LUT CYCODE USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_TABLE[1u] = {\r
+    {USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_COUNT, \r
+    &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_ALTERNATE0_HID_TABLE}\r
+};\r
+/*********************************************************************\r
+* Endpoint Setting Table -- This table contain the endpoint setting\r
+*                           for each endpoint in the configuration. It\r
+*                           contains the necessary information to\r
+*                           configure the endpoint hardware for each\r
+*                           interface and alternate setting.\r
+*********************************************************************/\r
+const T_USBFS_EP_SETTINGS_BLOCK CYCODE USBFS_DEVICE0_CONFIGURATION0_EP_SETTINGS_TABLE[2u] = {\r
+/* IFC  ALT    EPAddr bmAttr MaxPktSize Class ********************/\r
+{0x00u, 0x00u, 0x01u, 0x03u, 0x0040u,   0x03u},\r
+{0x00u, 0x00u, 0x82u, 0x03u, 0x0040u,   0x03u}\r
+};\r
+const uint8 CYCODE USBFS_DEVICE0_CONFIGURATION0_INTERFACE_CLASS[1u] = {\r
+0x03u\r
+};\r
+/*********************************************************************\r
+* Config Dispatch Table -- Points to the Config Descriptor and each of\r
+*                          and endpoint setup table and to each\r
+*                          interface table if it specifies a USB Class\r
+*********************************************************************/\r
+const T_USBFS_LUT CYCODE USBFS_DEVICE0_CONFIGURATION0_TABLE[4u] = {\r
+    {0x01u,     &USBFS_DEVICE0_CONFIGURATION0_DESCR},\r
+    {0x02u,     &USBFS_DEVICE0_CONFIGURATION0_EP_SETTINGS_TABLE},\r
+    {0x01u,     &USBFS_DEVICE0_CONFIGURATION0_INTERFACE0_TABLE},\r
+    {0x00u,     &USBFS_DEVICE0_CONFIGURATION0_INTERFACE_CLASS}\r
+};\r
+/*********************************************************************\r
+* Device Dispatch Table -- Points to the Device Descriptor and each of\r
+*                          and Configuration Tables for this Device \r
+*********************************************************************/\r
+const T_USBFS_LUT CYCODE USBFS_DEVICE0_TABLE[2u] = {\r
+    {0x01u,     &USBFS_DEVICE0_DESCR},\r
+    {0x01u,     &USBFS_DEVICE0_CONFIGURATION0_TABLE}\r
+};\r
+/*********************************************************************\r
+* Device Table -- Indexed by the device number.\r
+*********************************************************************/\r
+const T_USBFS_LUT CYCODE USBFS_TABLE[1u] = {\r
+    {0x01u,     &USBFS_DEVICE0_TABLE}\r
+};\r
+\r
+#endif /* USER_SUPPLIED_DESCRIPTORS */\r
+\r
+#if defined(USBFS_ENABLE_MSOS_STRING)\r
+\r
+    /******************************************************************************\r
+    *  USB Microsoft OS String Descriptor\r
+    *  "MSFT" identifies a Microsoft host\r
+    *  "100" specifies version 1.00\r
+    *  USBFS_GET_EXTENDED_CONFIG_DESCRIPTOR becomes the bRequest value\r
+    *  in a host vendor device/class request\r
+    ******************************************************************************/\r
+\r
+    const uint8 CYCODE USBFS_MSOS_DESCRIPTOR[USBFS_MSOS_DESCRIPTOR_LENGTH] = {\r
+    /* Descriptor Length                       */   0x12u,\r
+    /* DescriptorType: STRING                  */   0x03u,\r
+    /* qwSignature - "MSFT100"                 */   (uint8)'M', 0u, (uint8)'S', 0u, (uint8)'F', 0u, (uint8)'T', 0u,\r
+                                                    (uint8)'1', 0u, (uint8)'0', 0u, (uint8)'0', 0u,\r
+    /* bMS_VendorCode:                         */   USBFS_GET_EXTENDED_CONFIG_DESCRIPTOR,\r
+    /* bPad                                    */   0x00u\r
+    };\r
+\r
+    /* Extended Configuration Descriptor */\r
+\r
+    const uint8 CYCODE USBFS_MSOS_CONFIGURATION_DESCR[USBFS_MSOS_CONF_DESCR_LENGTH] = {\r
+    /*  Length of the descriptor 4 bytes       */   0x28u, 0x00u, 0x00u, 0x00u,\r
+    /*  Version of the descriptor 2 bytes      */   0x00u, 0x01u,\r
+    /*  wIndex - Fixed:INDEX_CONFIG_DESCRIPTOR */   0x04u, 0x00u,\r
+    /*  bCount - Count of device functions.    */   0x01u,\r
+    /*  Reserved : 7 bytes                     */   0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,\r
+    /*  bFirstInterfaceNumber                  */   0x00u,\r
+    /*  Reserved                               */   0x01u,\r
+    /*  compatibleID    - "CYUSB\0\0"          */   (uint8)'C', (uint8)'Y', (uint8)'U', (uint8)'S', (uint8)'B',\r
+                                                    0x00u, 0x00u, 0x00u,\r
+    /*  subcompatibleID - "00001\0\0"          */   (uint8)'0', (uint8)'0', (uint8)'0', (uint8)'0', (uint8)'1',\r
+                                                    0x00u, 0x00u, 0x00u,\r
+    /*  Reserved : 6 bytes                     */   0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u\r
+    };\r
+\r
+#endif /* USBFS_ENABLE_MSOS_STRING */\r
+\r
+/* DIE ID string descriptor for 8 bytes ID */\r
+#if defined(USBFS_ENABLE_IDSN_STRING)\r
+    uint8 USBFS_idSerialNumberStringDescriptor[USBFS_IDSN_DESCR_LENGTH];\r
+#endif /* USBFS_ENABLE_IDSN_STRING */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_drv.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_drv.c
new file mode 100755 (executable)
index 0000000..e78a41b
--- /dev/null
@@ -0,0 +1,781 @@
+/*******************************************************************************\r
+* File Name: USBFS_drv.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  Endpoint 0 Driver for the USBFS Component.\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+#include "USBFS_pvt.h"\r
+\r
+\r
+/***************************************\r
+* Global data allocation\r
+***************************************/\r
+\r
+volatile T_USBFS_EP_CTL_BLOCK USBFS_EP[USBFS_MAX_EP];\r
+volatile uint8 USBFS_configuration;\r
+volatile uint8 USBFS_interfaceNumber;\r
+volatile uint8 USBFS_configurationChanged;\r
+volatile uint8 USBFS_deviceAddress;\r
+volatile uint8 USBFS_deviceStatus;\r
+volatile uint8 USBFS_interfaceSetting[USBFS_MAX_INTERFACES_NUMBER];\r
+volatile uint8 USBFS_interfaceSetting_last[USBFS_MAX_INTERFACES_NUMBER];\r
+volatile uint8 USBFS_interfaceStatus[USBFS_MAX_INTERFACES_NUMBER];\r
+volatile uint8 USBFS_device;\r
+const uint8 CYCODE *USBFS_interfaceClass;\r
+\r
+\r
+/***************************************\r
+* Local data allocation\r
+***************************************/\r
+\r
+volatile uint8 USBFS_ep0Toggle;\r
+volatile uint8 USBFS_lastPacketSize;\r
+volatile uint8 USBFS_transferState;\r
+volatile T_USBFS_TD USBFS_currentTD;\r
+volatile uint8 USBFS_ep0Mode;\r
+volatile uint8 USBFS_ep0Count;\r
+volatile uint16 USBFS_transferByteCount;\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_ep_0_Interrupt\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This Interrupt Service Routine handles Endpoint 0 (Control Pipe) traffic.\r
+*  It dispatches setup requests and handles the data and status stages.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+*******************************************************************************/\r
+CY_ISR(USBFS_EP_0_ISR)\r
+{\r
+    uint8 bRegTemp;\r
+    uint8 modifyReg;\r
+\r
+\r
+    bRegTemp = CY_GET_REG8(USBFS_EP0_CR_PTR);\r
+    if ((bRegTemp & USBFS_MODE_ACKD) != 0u)\r
+    {\r
+        modifyReg = 1u;\r
+        if ((bRegTemp & USBFS_MODE_SETUP_RCVD) != 0u)\r
+        {\r
+            if((bRegTemp & USBFS_MODE_MASK) != USBFS_MODE_NAK_IN_OUT)\r
+            {\r
+                modifyReg = 0u;                                     /* When mode not NAK_IN_OUT => invalid setup */\r
+            }\r
+            else\r
+            {\r
+                USBFS_HandleSetup();\r
+                if((USBFS_ep0Mode & USBFS_MODE_SETUP_RCVD) != 0u)\r
+                {\r
+                    modifyReg = 0u;                         /* if SETUP bit set -> exit without modifying the mode */\r
+                }\r
+\r
+            }\r
+        }\r
+        else if ((bRegTemp & USBFS_MODE_IN_RCVD) != 0u)\r
+        {\r
+            USBFS_HandleIN();\r
+        }\r
+        else if ((bRegTemp & USBFS_MODE_OUT_RCVD) != 0u)\r
+        {\r
+            USBFS_HandleOUT();\r
+        }\r
+        else\r
+        {\r
+            modifyReg = 0u;\r
+        }\r
+        if(modifyReg != 0u)\r
+        {\r
+            bRegTemp = CY_GET_REG8(USBFS_EP0_CR_PTR);    /* unlock registers */\r
+            if((bRegTemp & USBFS_MODE_SETUP_RCVD) == 0u)  /* Check if SETUP bit is not set, otherwise exit */\r
+            {\r
+                /* Update the count register */\r
+                bRegTemp = USBFS_ep0Toggle | USBFS_ep0Count;\r
+                CY_SET_REG8(USBFS_EP0_CNT_PTR, bRegTemp);\r
+                if(bRegTemp == CY_GET_REG8(USBFS_EP0_CNT_PTR))   /* continue if writing was successful */\r
+                {\r
+                    do\r
+                    {\r
+                        modifyReg = USBFS_ep0Mode;       /* Init temporary variable */\r
+                        /* Unlock registers */\r
+                        bRegTemp = CY_GET_REG8(USBFS_EP0_CR_PTR) & USBFS_MODE_SETUP_RCVD;\r
+                        if(bRegTemp == 0u)                          /* Check if SETUP bit is not set */\r
+                        {\r
+                            /* Set the Mode Register  */\r
+                            CY_SET_REG8(USBFS_EP0_CR_PTR, USBFS_ep0Mode);\r
+                            /* Writing check */\r
+                            modifyReg = CY_GET_REG8(USBFS_EP0_CR_PTR) & USBFS_MODE_MASK;\r
+                        }\r
+                    }while(modifyReg != USBFS_ep0Mode);  /* Repeat if writing was not successful */\r
+                }\r
+            }\r
+        }\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_HandleSetup\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This Routine dispatches requests for the four USB request types\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_HandleSetup(void) \r
+{\r
+    uint8 requestHandled;\r
+\r
+    requestHandled = CY_GET_REG8(USBFS_EP0_CR_PTR);      /* unlock registers */\r
+    CY_SET_REG8(USBFS_EP0_CR_PTR, requestHandled);       /* clear setup bit */\r
+    requestHandled = CY_GET_REG8(USBFS_EP0_CR_PTR);      /* reread register */\r
+    if((requestHandled & USBFS_MODE_SETUP_RCVD) != 0u)\r
+    {\r
+        USBFS_ep0Mode = requestHandled;        /* if SETUP bit set -> exit without modifying the mode */\r
+    }\r
+    else\r
+    {\r
+        /* In case the previous transfer did not complete, close it out */\r
+        USBFS_UpdateStatusBlock(USBFS_XFER_PREMATURE);\r
+\r
+        switch (CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_TYPE_MASK)\r
+        {\r
+            case USBFS_RQST_TYPE_STD:\r
+                requestHandled = USBFS_HandleStandardRqst();\r
+                break;\r
+            case USBFS_RQST_TYPE_CLS:\r
+                requestHandled = USBFS_DispatchClassRqst();\r
+                break;\r
+            case USBFS_RQST_TYPE_VND:\r
+                requestHandled = USBFS_HandleVendorRqst();\r
+                break;\r
+            default:\r
+                requestHandled = USBFS_FALSE;\r
+                break;\r
+        }\r
+        if (requestHandled == USBFS_FALSE)\r
+        {\r
+            USBFS_ep0Mode = USBFS_MODE_STALL_IN_OUT;\r
+        }\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_HandleIN\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine handles EP0 IN transfers.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_HandleIN(void) \r
+{\r
+    switch (USBFS_transferState)\r
+    {\r
+        case USBFS_TRANS_STATE_IDLE:\r
+            break;\r
+        case USBFS_TRANS_STATE_CONTROL_READ:\r
+            USBFS_ControlReadDataStage();\r
+            break;\r
+        case USBFS_TRANS_STATE_CONTROL_WRITE:\r
+            USBFS_ControlWriteStatusStage();\r
+            break;\r
+        case USBFS_TRANS_STATE_NO_DATA_CONTROL:\r
+            USBFS_NoDataControlStatusStage();\r
+            break;\r
+        default:    /* there are no more states */\r
+            break;\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_HandleOUT\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine handles EP0 OUT transfers.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_HandleOUT(void) \r
+{\r
+    switch (USBFS_transferState)\r
+    {\r
+        case USBFS_TRANS_STATE_IDLE:\r
+            break;\r
+        case USBFS_TRANS_STATE_CONTROL_READ:\r
+            USBFS_ControlReadStatusStage();\r
+            break;\r
+        case USBFS_TRANS_STATE_CONTROL_WRITE:\r
+            USBFS_ControlWriteDataStage();\r
+            break;\r
+        case USBFS_TRANS_STATE_NO_DATA_CONTROL:\r
+            /* Update the completion block */\r
+            USBFS_UpdateStatusBlock(USBFS_XFER_ERROR);\r
+            /* We expect no more data, so stall INs and OUTs */\r
+            USBFS_ep0Mode = USBFS_MODE_STALL_IN_OUT;\r
+            break;\r
+        default:    /* There are no more states */\r
+            break;\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_LoadEP0\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine loads the EP0 data registers for OUT transfers.  It uses the\r
+*  currentTD (previously initialized by the _InitControlWrite function and\r
+*  updated for each OUT transfer, and the bLastPacketSize) to determine how\r
+*  many uint8s to transfer on the current OUT.\r
+*\r
+*  If the number of uint8s remaining is zero and the last transfer was full,\r
+*  we need to send a zero length packet.  Otherwise we send the minimum\r
+*  of the control endpoint size (8) or remaining number of uint8s for the\r
+*  transaction.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*  USBFS_transferByteCount - Update the transfer byte count from the\r
+*     last transaction.\r
+*  USBFS_ep0Count - counts the data loaded to the SIE memory in\r
+*     current packet.\r
+*  USBFS_lastPacketSize - remembers the USBFS_ep0Count value for the\r
+*     next packet.\r
+*  USBFS_transferByteCount - sum of the previous bytes transferred\r
+*     on previous packets(sum of USBFS_lastPacketSize)\r
+*  USBFS_ep0Toggle - inverted\r
+*  USBFS_ep0Mode  - prepare for mode register content.\r
+*  USBFS_transferState - set to TRANS_STATE_CONTROL_READ\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_LoadEP0(void) \r
+{\r
+    uint8 ep0Count = 0u;\r
+\r
+    /* Update the transfer byte count from the last transaction */\r
+    USBFS_transferByteCount += USBFS_lastPacketSize;\r
+    /* Now load the next transaction */\r
+    while ((USBFS_currentTD.count > 0u) && (ep0Count < 8u))\r
+    {\r
+        CY_SET_REG8((reg8 *)(USBFS_EP0_DR0_IND + ep0Count), *USBFS_currentTD.pData);\r
+        USBFS_currentTD.pData = &USBFS_currentTD.pData[1u];\r
+        ep0Count++;\r
+        USBFS_currentTD.count--;\r
+    }\r
+    /* Support zero-length packet*/\r
+    if( (USBFS_lastPacketSize == 8u) || (ep0Count > 0u) )\r
+    {\r
+        /* Update the data toggle */\r
+        USBFS_ep0Toggle ^= USBFS_EP0_CNT_DATA_TOGGLE;\r
+        /* Set the Mode Register  */\r
+        USBFS_ep0Mode = USBFS_MODE_ACK_IN_STATUS_OUT;\r
+        /* Update the state (or stay the same) */\r
+        USBFS_transferState = USBFS_TRANS_STATE_CONTROL_READ;\r
+    }\r
+    else\r
+    {\r
+        /* Expect Status Stage Out */\r
+        USBFS_ep0Mode = USBFS_MODE_STATUS_OUT_ONLY;\r
+        /* Update the state (or stay the same) */\r
+        USBFS_transferState = USBFS_TRANS_STATE_CONTROL_READ;\r
+    }\r
+\r
+    /* Save the packet size for next time */\r
+    USBFS_lastPacketSize = ep0Count;\r
+    USBFS_ep0Count = ep0Count;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_InitControlRead\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Initialize a control read transaction, usable to send data to the host.\r
+*  The following global variables should be initialized before this function\r
+*  called. To send zero length packet use InitZeroLengthControlTransfer\r
+*  function.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled state.\r
+*\r
+* Global variables:\r
+*  USBFS_currentTD.count - counts of data to be sent.\r
+*  USBFS_currentTD.pData - data pointer.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_InitControlRead(void) \r
+{\r
+    uint16 xferCount;\r
+    if(USBFS_currentTD.count == 0u)\r
+    {\r
+        (void) USBFS_InitZeroLengthControlTransfer();\r
+    }\r
+    else\r
+    {\r
+        /* Set up the state machine */\r
+        USBFS_transferState = USBFS_TRANS_STATE_CONTROL_READ;\r
+        /* Set the toggle, it gets updated in LoadEP */\r
+        USBFS_ep0Toggle = 0u;\r
+        /* Initialize the Status Block */\r
+        USBFS_InitializeStatusBlock();\r
+        xferCount = (((uint16)CY_GET_REG8(USBFS_lengthHi) << 8u) | (CY_GET_REG8(USBFS_lengthLo)));\r
+\r
+        if (USBFS_currentTD.count > xferCount)\r
+        {\r
+            USBFS_currentTD.count = xferCount;\r
+        }\r
+        USBFS_LoadEP0();\r
+    }\r
+\r
+    return(USBFS_TRUE);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_InitZeroLengthControlTransfer\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Initialize a zero length data IN transfer.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled state.\r
+*\r
+* Global variables:\r
+*  USBFS_ep0Toggle - set to EP0_CNT_DATA_TOGGLE\r
+*  USBFS_ep0Mode  - prepare for mode register content.\r
+*  USBFS_transferState - set to TRANS_STATE_CONTROL_READ\r
+*  USBFS_ep0Count - cleared, means the zero-length packet.\r
+*  USBFS_lastPacketSize - cleared.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_InitZeroLengthControlTransfer(void)\r
+                                                \r
+{\r
+    /* Update the state */\r
+    USBFS_transferState = USBFS_TRANS_STATE_CONTROL_READ;\r
+    /* Set the data toggle */\r
+    USBFS_ep0Toggle = USBFS_EP0_CNT_DATA_TOGGLE;\r
+    /* Set the Mode Register  */\r
+    USBFS_ep0Mode = USBFS_MODE_ACK_IN_STATUS_OUT;\r
+    /* Save the packet size for next time */\r
+    USBFS_lastPacketSize = 0u;\r
+    USBFS_ep0Count = 0u;\r
+\r
+    return(USBFS_TRUE);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_ControlReadDataStage\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Handle the Data Stage of a control read transfer.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_ControlReadDataStage(void) \r
+\r
+{\r
+    USBFS_LoadEP0();\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_ControlReadStatusStage\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Handle the Status Stage of a control read transfer.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*  USBFS_USBFS_transferByteCount - updated with last packet size.\r
+*  USBFS_transferState - set to TRANS_STATE_IDLE.\r
+*  USBFS_ep0Mode  - set to MODE_STALL_IN_OUT.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_ControlReadStatusStage(void) \r
+{\r
+    /* Update the transfer byte count */\r
+    USBFS_transferByteCount += USBFS_lastPacketSize;\r
+    /* Go Idle */\r
+    USBFS_transferState = USBFS_TRANS_STATE_IDLE;\r
+    /* Update the completion block */\r
+    USBFS_UpdateStatusBlock(USBFS_XFER_STATUS_ACK);\r
+    /* We expect no more data, so stall INs and OUTs */\r
+    USBFS_ep0Mode =  USBFS_MODE_STALL_IN_OUT;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_InitControlWrite\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Initialize a control write transaction\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled state.\r
+*\r
+* Global variables:\r
+*  USBFS_USBFS_transferState - set to TRANS_STATE_CONTROL_WRITE\r
+*  USBFS_ep0Toggle - set to EP0_CNT_DATA_TOGGLE\r
+*  USBFS_ep0Mode  - set to MODE_ACK_OUT_STATUS_IN\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_InitControlWrite(void) \r
+{\r
+    uint16 xferCount;\r
+\r
+    /* Set up the state machine */\r
+    USBFS_transferState = USBFS_TRANS_STATE_CONTROL_WRITE;\r
+    /* This might not be necessary */\r
+    USBFS_ep0Toggle = USBFS_EP0_CNT_DATA_TOGGLE;\r
+    /* Initialize the Status Block */\r
+    USBFS_InitializeStatusBlock();\r
+\r
+    xferCount = (((uint16)CY_GET_REG8(USBFS_lengthHi) << 8u) | (CY_GET_REG8(USBFS_lengthLo)));\r
+\r
+    if (USBFS_currentTD.count > xferCount)\r
+    {\r
+        USBFS_currentTD.count = xferCount;\r
+    }\r
+\r
+    /* Expect Data or Status Stage */\r
+    USBFS_ep0Mode = USBFS_MODE_ACK_OUT_STATUS_IN;\r
+\r
+    return(USBFS_TRUE);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_ControlWriteDataStage\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Handle the Data Stage of a control write transfer\r
+*       1. Get the data (We assume the destination was validated previously)\r
+*       2. Update the count and data toggle\r
+*       3. Update the mode register for the next transaction\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*  USBFS_transferByteCount - Update the transfer byte count from the\r
+*    last transaction.\r
+*  USBFS_ep0Count - counts the data loaded from the SIE memory\r
+*    in current packet.\r
+*  USBFS_transferByteCount - sum of the previous bytes transferred\r
+*    on previous packets(sum of USBFS_lastPacketSize)\r
+*  USBFS_ep0Toggle - inverted\r
+*  USBFS_ep0Mode  - set to MODE_ACK_OUT_STATUS_IN.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_ControlWriteDataStage(void) \r
+{\r
+    uint8 ep0Count;\r
+    uint8 regIndex = 0u;\r
+\r
+    ep0Count = (CY_GET_REG8(USBFS_EP0_CNT_PTR) & USBFS_EPX_CNT0_MASK) -\r
+               USBFS_EPX_CNTX_CRC_COUNT;\r
+\r
+    USBFS_transferByteCount += ep0Count;\r
+\r
+    while ((USBFS_currentTD.count > 0u) && (ep0Count > 0u))\r
+    {\r
+        *USBFS_currentTD.pData = CY_GET_REG8((reg8 *)(USBFS_EP0_DR0_IND + regIndex));\r
+        USBFS_currentTD.pData = &USBFS_currentTD.pData[1u];\r
+        regIndex++;\r
+        ep0Count--;\r
+        USBFS_currentTD.count--;\r
+    }\r
+    USBFS_ep0Count = ep0Count;\r
+    /* Update the data toggle */\r
+    USBFS_ep0Toggle ^= USBFS_EP0_CNT_DATA_TOGGLE;\r
+    /* Expect Data or Status Stage */\r
+    USBFS_ep0Mode = USBFS_MODE_ACK_OUT_STATUS_IN;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_ControlWriteStatusStage\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Handle the Status Stage of a control write transfer\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*  USBFS_transferState - set to TRANS_STATE_IDLE.\r
+*  USBFS_USBFS_ep0Mode  - set to MODE_STALL_IN_OUT.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_ControlWriteStatusStage(void) \r
+{\r
+    /* Go Idle */\r
+    USBFS_transferState = USBFS_TRANS_STATE_IDLE;\r
+    /* Update the completion block */\r
+    USBFS_UpdateStatusBlock(USBFS_XFER_STATUS_ACK);\r
+    /* We expect no more data, so stall INs and OUTs */\r
+    USBFS_ep0Mode = USBFS_MODE_STALL_IN_OUT;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_InitNoDataControlTransfer\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Initialize a no data control transfer\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled state.\r
+*\r
+* Global variables:\r
+*  USBFS_transferState - set to TRANS_STATE_NO_DATA_CONTROL.\r
+*  USBFS_ep0Mode  - set to MODE_STATUS_IN_ONLY.\r
+*  USBFS_ep0Count - cleared.\r
+*  USBFS_ep0Toggle - set to EP0_CNT_DATA_TOGGLE\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_InitNoDataControlTransfer(void) \r
+{\r
+    USBFS_transferState = USBFS_TRANS_STATE_NO_DATA_CONTROL;\r
+    USBFS_ep0Mode = USBFS_MODE_STATUS_IN_ONLY;\r
+    USBFS_ep0Toggle = USBFS_EP0_CNT_DATA_TOGGLE;\r
+    USBFS_ep0Count = 0u;\r
+\r
+    return(USBFS_TRUE);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_NoDataControlStatusStage\r
+********************************************************************************\r
+* Summary:\r
+*  Handle the Status Stage of a no data control transfer.\r
+*\r
+*  SET_ADDRESS is special, since we need to receive the status stage with\r
+*  the old address.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*  USBFS_transferState - set to TRANS_STATE_IDLE.\r
+*  USBFS_ep0Mode  - set to MODE_STALL_IN_OUT.\r
+*  USBFS_ep0Toggle - set to EP0_CNT_DATA_TOGGLE\r
+*  USBFS_deviceAddress - used to set new address and cleared\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_NoDataControlStatusStage(void) \r
+{\r
+    /* Change the USB address register if we got a SET_ADDRESS. */\r
+    if (USBFS_deviceAddress != 0u)\r
+    {\r
+        CY_SET_REG8(USBFS_CR0_PTR, USBFS_deviceAddress | USBFS_CR0_ENABLE);\r
+        USBFS_deviceAddress = 0u;\r
+    }\r
+    /* Go Idle */\r
+    USBFS_transferState = USBFS_TRANS_STATE_IDLE;\r
+    /* Update the completion block */\r
+    USBFS_UpdateStatusBlock(USBFS_XFER_STATUS_ACK);\r
+     /* We expect no more data, so stall INs and OUTs */\r
+    USBFS_ep0Mode = USBFS_MODE_STALL_IN_OUT;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_UpdateStatusBlock\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Update the Completion Status Block for a Request.  The block is updated\r
+*  with the completion code the USBFS_transferByteCount.  The\r
+*  StatusBlock Pointer is set to NULL.\r
+*\r
+* Parameters:\r
+*  completionCode - status.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*  USBFS_currentTD.pStatusBlock->status - updated by the\r
+*    completionCode parameter.\r
+*  USBFS_currentTD.pStatusBlock->length - updated.\r
+*  USBFS_currentTD.pStatusBlock - cleared.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_UpdateStatusBlock(uint8 completionCode) \r
+{\r
+    if (USBFS_currentTD.pStatusBlock != NULL)\r
+    {\r
+        USBFS_currentTD.pStatusBlock->status = completionCode;\r
+        USBFS_currentTD.pStatusBlock->length = USBFS_transferByteCount;\r
+        USBFS_currentTD.pStatusBlock = NULL;\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_InitializeStatusBlock\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Initialize the Completion Status Block for a Request.  The completion\r
+*  code is set to USB_XFER_IDLE.\r
+*\r
+*  Also, initializes USBFS_transferByteCount.  Save some space,\r
+*  this is the only consumer.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+* Global variables:\r
+*  USBFS_currentTD.pStatusBlock->status - set to XFER_IDLE.\r
+*  USBFS_currentTD.pStatusBlock->length - cleared.\r
+*  USBFS_transferByteCount - cleared.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_InitializeStatusBlock(void) \r
+{\r
+    USBFS_transferByteCount = 0u;\r
+    if(USBFS_currentTD.pStatusBlock != NULL)\r
+    {\r
+        USBFS_currentTD.pStatusBlock->status = USBFS_XFER_IDLE;\r
+        USBFS_currentTD.pStatusBlock->length = 0u;\r
+    }\r
+}\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_episr.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_episr.c
new file mode 100755 (executable)
index 0000000..cd88e92
--- /dev/null
@@ -0,0 +1,658 @@
+/*******************************************************************************\r
+* File Name: USBFS_episr.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  Data endpoint Interrupt Service Routines\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+#include "USBFS_pvt.h"\r
+#if defined(USBFS_ENABLE_MIDI_STREAMING) && (USBFS_ENABLE_MIDI_API != 0u)\r
+    #include "USBFS_midi.h"\r
+#endif /* End USBFS_ENABLE_MIDI_STREAMING*/\r
+\r
+\r
+/***************************************\r
+* Custom Declarations\r
+***************************************/\r
+/* `#START CUSTOM_DECLARATIONS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+#if(USBFS_EP1_ISR_REMOVE == 0u)\r
+\r
+\r
+    /******************************************************************************\r
+    * Function Name: USBFS_EP_1_ISR\r
+    *******************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 1 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    ******************************************************************************/\r
+    CY_ISR(USBFS_EP_1_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 */\r
+\r
+        /* `#START EP1_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP1_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP1].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP1].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP1].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR) &\r
+                                                                    (uint8)~USBFS_SIE_EP_INT_EP1_MASK);\r
+\r
+        #if( defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT )\r
+            if(USBFS_midi_out_ep == USBFS_EP1)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT */\r
+\r
+        /* `#START EP1_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if ( defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 )\r
+            EA = int_en;\r
+        #endif /* USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 */\r
+    }\r
+\r
+#endif   /* End USBFS_EP1_ISR_REMOVE */\r
+\r
+\r
+#if(USBFS_EP2_ISR_REMOVE == 0u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_EP_2_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 2 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_EP_2_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 */\r
+\r
+        /* `#START EP2_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 )\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP2_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP2].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP2].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP2].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR)\r
+                                                                        & (uint8)~USBFS_SIE_EP_INT_EP2_MASK);\r
+\r
+        #if( defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT )\r
+            if(USBFS_midi_out_ep == USBFS_EP2)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT */\r
+\r
+        /* `#START EP2_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            EA = int_en;\r
+        #endif /* USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 */\r
+    }\r
+\r
+#endif   /* End USBFS_EP2_ISR_REMOVE */\r
+\r
+\r
+#if(USBFS_EP3_ISR_REMOVE == 0u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_EP_3_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 3 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_EP_3_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3 */\r
+\r
+        /* `#START EP3_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP3_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP3].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP3].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP3].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR)\r
+                                                                        & (uint8)~USBFS_SIE_EP_INT_EP3_MASK);\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT)\r
+            if(USBFS_midi_out_ep == USBFS_EP3)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT */\r
+\r
+        /* `#START EP3_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            EA = int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+    }\r
+\r
+#endif   /* End USBFS_EP3_ISR_REMOVE */\r
+\r
+\r
+#if(USBFS_EP4_ISR_REMOVE == 0u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_EP_4_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 4 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_EP_4_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        /* `#START EP4_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP4_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP4].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP4].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP4].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR)\r
+                                                                        & (uint8)~USBFS_SIE_EP_INT_EP4_MASK);\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT)\r
+            if(USBFS_midi_out_ep == USBFS_EP4)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT */\r
+\r
+        /* `#START EP4_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            EA = int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+    }\r
+\r
+#endif   /* End USBFS_EP4_ISR_REMOVE */\r
+\r
+\r
+#if(USBFS_EP5_ISR_REMOVE == 0u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_EP_5_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 5 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_EP_5_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        /* `#START EP5_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP5_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP5].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP5].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP5].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR)\r
+                                                                        & (uint8)~USBFS_SIE_EP_INT_EP5_MASK);\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT)\r
+            if(USBFS_midi_out_ep == USBFS_EP5)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT */\r
+\r
+        /* `#START EP5_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            EA = int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+    }\r
+#endif   /* End USBFS_EP5_ISR_REMOVE */\r
+\r
+\r
+#if(USBFS_EP6_ISR_REMOVE == 0u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_EP_6_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 6 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_EP_6_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        /* `#START EP6_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP6_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP6].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP6].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP6].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR)\r
+                                                                        & (uint8)~USBFS_SIE_EP_INT_EP6_MASK);\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT)\r
+            if(USBFS_midi_out_ep == USBFS_EP6)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        /* `#START EP6_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            EA = int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+    }\r
+\r
+#endif   /* End USBFS_EP6_ISR_REMOVE */\r
+\r
+\r
+#if(USBFS_EP7_ISR_REMOVE == 0u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_EP_7_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 7 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_EP_7_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        /* `#START EP7_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP7_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP7].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP7].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP7].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR)\r
+                                                                        & (uint8)~USBFS_SIE_EP_INT_EP7_MASK);\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT)\r
+            if(USBFS_midi_out_ep == USBFS_EP7)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        /* `#START EP7_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            EA = int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+    }\r
+\r
+#endif   /* End USBFS_EP7_ISR_REMOVE */\r
+\r
+\r
+#if(USBFS_EP8_ISR_REMOVE == 0u)\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_EP_8_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Endpoint 8 Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_EP_8_ISR)\r
+    {\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            uint8 int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        /* `#START EP8_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            int_en = EA;\r
+            CyGlobalIntEnable;  /* Make sure nested interrupt is enabled */\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+\r
+        CY_GET_REG8(USBFS_SIE_EP8_CR0_PTR); /* Must read the mode reg */\r
+        /* Do not toggle ISOC endpoint */\r
+        if((USBFS_EP[USBFS_EP8].attrib & USBFS_EP_TYPE_MASK) !=\r
+                                                                                    USBFS_EP_TYPE_ISOC)\r
+        {\r
+            USBFS_EP[USBFS_EP8].epToggle ^= USBFS_EPX_CNT_DATA_TOGGLE;\r
+        }\r
+        USBFS_EP[USBFS_EP8].apiEpState = USBFS_EVENT_PENDING;\r
+        CY_SET_REG8(USBFS_SIE_EP_INT_SR_PTR, CY_GET_REG8(USBFS_SIE_EP_INT_SR_PTR)\r
+                                                                        & (uint8)~USBFS_SIE_EP_INT_EP8_MASK);\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT)\r
+            if(USBFS_midi_out_ep == USBFS_EP8)\r
+            {\r
+                USBFS_MIDI_OUT_EP_Service();\r
+            }\r
+        #endif /* End USBFS_ISR_SERVICE_MIDI_OUT */\r
+\r
+        /* `#START EP8_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_OUT && CY_PSOC3)\r
+            EA = int_en;\r
+        #endif /* CY_PSOC3 & USBFS_ISR_SERVICE_MIDI_OUT  */\r
+    }\r
+\r
+#endif   /* End USBFS_EP8_ISR_REMOVE */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_SOF_ISR\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Start of Frame Interrupt Service Routine\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+*******************************************************************************/\r
+CY_ISR(USBFS_SOF_ISR)\r
+{\r
+    /* `#START SOF_USER_CODE` Place your code here */\r
+\r
+    /* `#END` */\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_BUS_RESET_ISR\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  USB Bus Reset Interrupt Service Routine.  Calls _Start with the same\r
+*  parameters as the last USER call to _Start\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  None.\r
+*\r
+*******************************************************************************/\r
+CY_ISR(USBFS_BUS_RESET_ISR)\r
+{\r
+    /* `#START BUS_RESET_USER_CODE` Place your code here */\r
+\r
+    /* `#END` */\r
+\r
+    USBFS_ReInitComponent();\r
+}\r
+\r
+\r
+#if((USBFS_EP_MM != USBFS__EP_MANUAL) && (USBFS_ARB_ISR_REMOVE == 0u))\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_ARB_ISR\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Arbiter Interrupt Service Routine\r
+    *\r
+    * Parameters:\r
+    *  None.\r
+    *\r
+    * Return:\r
+    *  None.\r
+    *\r
+    * Side effect:\r
+    *  Search for EP8 int_status will be much slower than search for EP1 int_status.\r
+    *\r
+    *******************************************************************************/\r
+    CY_ISR(USBFS_ARB_ISR)\r
+    {\r
+        uint8 int_status;\r
+        uint8 ep_status;\r
+        uint8 ep = USBFS_EP1;\r
+        uint8 ptr = 0u;\r
+\r
+        /* `#START ARB_BEGIN_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+\r
+        int_status = USBFS_ARB_INT_SR_REG;                   /* read Arbiter Status Register */\r
+        USBFS_ARB_INT_SR_REG = int_status;                   /* Clear Serviced Interrupts */\r
+\r
+        while(int_status != 0u)\r
+        {\r
+            if((int_status & 1u) != 0u)  /* If EpX interrupt present */\r
+            {   /* read Endpoint Status Register */\r
+                ep_status  = CY_GET_REG8((reg8 *)(USBFS_ARB_EP1_SR_IND + ptr));\r
+                /* If In Buffer Full */\r
+                if((ep_status & USBFS_ARB_EPX_SR_IN_BUF_FULL) != 0u)\r
+                {\r
+                    if((USBFS_EP[ep].addr & USBFS_DIR_IN) != 0u)\r
+                    {\r
+                        /* Clear Data ready status */\r
+                        *(reg8 *)(USBFS_ARB_EP1_CFG_IND + ptr) &=\r
+                                                                    (uint8)~USBFS_ARB_EPX_CFG_IN_DATA_RDY;\r
+                        /* Write the Mode register */\r
+                        CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ptr), USBFS_EP[ep].epMode);\r
+                        #if (defined(USBFS_ENABLE_MIDI_STREAMING) && USBFS_ISR_SERVICE_MIDI_IN)\r
+                            if(ep == USBFS_midi_in_ep)\r
+                            {   /* Clear MIDI input pointer */\r
+                                USBFS_midiInPointer = 0u;\r
+                            }\r
+                        #endif /* End USBFS_ENABLE_MIDI_STREAMING*/\r
+                    }\r
+                }\r
+                /* (re)arm Out EP only for mode2 */\r
+                #if(USBFS_EP_MM != USBFS__EP_DMAAUTO)\r
+                    /* If DMA Grant */\r
+                    if((ep_status & USBFS_ARB_EPX_SR_DMA_GNT) != 0u)\r
+                    {\r
+                        if((USBFS_EP[ep].addr & USBFS_DIR_IN) == 0u)\r
+                        {\r
+                                USBFS_EP[ep].apiEpState = USBFS_NO_EVENT_PENDING;\r
+                                /* Write the Mode register */\r
+                                CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ptr),\r
+                                                                                    USBFS_EP[ep].epMode);\r
+                        }\r
+                    }\r
+                #endif /* End USBFS_EP_MM */\r
+\r
+                /* `#START ARB_USER_CODE` Place your code here for handle Buffer Underflow/Overflow */\r
+\r
+                /* `#END` */\r
+\r
+                CY_SET_REG8((reg8 *)(USBFS_ARB_EP1_SR_IND + ptr), ep_status);   /* Clear Serviced events */\r
+            }\r
+            ptr += USBFS_EPX_CNTX_ADDR_OFFSET;               /* prepare pointer for next EP */\r
+            ep++;\r
+            int_status >>= 1u;\r
+        }\r
+\r
+        /* `#START ARB_END_USER_CODE` Place your code here */\r
+\r
+        /* `#END` */\r
+    }\r
+\r
+#endif /* End USBFS_EP_MM */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_hid.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_hid.c
new file mode 100755 (executable)
index 0000000..ba9fdf5
--- /dev/null
@@ -0,0 +1,422 @@
+/*******************************************************************************\r
+* File Name: USBFS_hid.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  USB HID Class request handler.\r
+*\r
+* Note:\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+\r
+#if defined(USBFS_ENABLE_HID_CLASS)\r
+\r
+#include "USBFS_pvt.h"\r
+#include "USBFS_hid.h"\r
+\r
+\r
+/***************************************\r
+*    HID Variables\r
+***************************************/\r
+\r
+volatile uint8 USBFS_hidProtocol[USBFS_MAX_INTERFACES_NUMBER];  /* HID device protocol status */\r
+volatile uint8 USBFS_hidIdleRate[USBFS_MAX_INTERFACES_NUMBER];  /* HID device idle reload value */\r
+volatile uint8 USBFS_hidIdleTimer[USBFS_MAX_INTERFACES_NUMBER]; /* HID device idle rate value */\r
+\r
+\r
+/***************************************\r
+* Custom Declarations\r
+***************************************/\r
+\r
+/* `#START HID_CUSTOM_DECLARATIONS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_UpdateHIDTimer\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Updates the HID report timer and reloads it if expired\r
+*\r
+* Parameters:\r
+*  interface:  Interface Number.\r
+*\r
+* Return:\r
+*  status.\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_UpdateHIDTimer(uint8 interface) \r
+{\r
+    uint8 stat = USBFS_IDLE_TIMER_INDEFINITE;\r
+\r
+    if(USBFS_hidIdleRate[interface] != 0u)\r
+    {\r
+        if(USBFS_hidIdleTimer[interface] > 0u)\r
+        {\r
+            USBFS_hidIdleTimer[interface]--;\r
+            stat = USBFS_IDLE_TIMER_RUNNING;\r
+        }\r
+        else\r
+        {\r
+            USBFS_hidIdleTimer[interface] = USBFS_hidIdleRate[interface];\r
+            stat = USBFS_IDLE_TIMER_EXPIRED;\r
+        }\r
+    }\r
+\r
+    return(stat);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_GetProtocol\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  Returns the selected protocol value to the application\r
+*\r
+* Parameters:\r
+*  interface:  Interface Number.\r
+*\r
+* Return:\r
+*  Interface protocol.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_GetProtocol(uint8 interface) \r
+{\r
+    return(USBFS_hidProtocol[interface]);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_DispatchHIDClassRqst\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine dispatches class requests\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  requestHandled\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+uint8 USBFS_DispatchHIDClassRqst(void) \r
+{\r
+    uint8 requestHandled = USBFS_FALSE;\r
+    uint8 interfaceNumber;\r
+\r
+    interfaceNumber = CY_GET_REG8(USBFS_wIndexLo);\r
+    if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) == USBFS_RQST_DIR_D2H)\r
+    {   /* Control Read */\r
+        switch (CY_GET_REG8(USBFS_bRequest))\r
+        {\r
+            case USBFS_GET_DESCRIPTOR:\r
+                if (CY_GET_REG8(USBFS_wValueHi) == USBFS_DESCR_HID_CLASS)\r
+                {\r
+                    USBFS_FindHidClassDecriptor();\r
+                    if (USBFS_currentTD.count != 0u)\r
+                    {\r
+                        requestHandled = USBFS_InitControlRead();\r
+                    }\r
+                }\r
+                else if (CY_GET_REG8(USBFS_wValueHi) == USBFS_DESCR_HID_REPORT)\r
+                {\r
+                    USBFS_FindReportDescriptor();\r
+                    if (USBFS_currentTD.count != 0u)\r
+                    {\r
+                        requestHandled = USBFS_InitControlRead();\r
+                    }\r
+                }\r
+                else\r
+                {   /* requestHandled is initialezed as FALSE by default */\r
+                }\r
+                break;\r
+            case USBFS_HID_GET_REPORT:\r
+                USBFS_FindReport();\r
+                if (USBFS_currentTD.count != 0u)\r
+                {\r
+                    requestHandled = USBFS_InitControlRead();\r
+                }\r
+                break;\r
+\r
+            case USBFS_HID_GET_IDLE:\r
+                /* This function does not support multiple reports per interface*/\r
+                /* Validate interfaceNumber and Report ID (should be 0) */\r
+                if( (interfaceNumber < USBFS_MAX_INTERFACES_NUMBER) &&\r
+                    (CY_GET_REG8(USBFS_wValueLo) == 0u ) ) /* Do not support Idle per Report ID */\r
+                {\r
+                    USBFS_currentTD.count = 1u;\r
+                    USBFS_currentTD.pData = &USBFS_hidIdleRate[interfaceNumber];\r
+                    requestHandled  = USBFS_InitControlRead();\r
+                }\r
+                break;\r
+            case USBFS_HID_GET_PROTOCOL:\r
+                /* Validate interfaceNumber */\r
+                if( interfaceNumber < USBFS_MAX_INTERFACES_NUMBER)\r
+                {\r
+                    USBFS_currentTD.count = 1u;\r
+                    USBFS_currentTD.pData = &USBFS_hidProtocol[interfaceNumber];\r
+                    requestHandled  = USBFS_InitControlRead();\r
+                }\r
+                break;\r
+            default:    /* requestHandled is initialized as FALSE by default */\r
+                break;\r
+        }\r
+    }\r
+    else if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) ==\r
+                                                                            USBFS_RQST_DIR_H2D)\r
+    {   /* Control Write */\r
+        switch (CY_GET_REG8(USBFS_bRequest))\r
+        {\r
+            case USBFS_HID_SET_REPORT:\r
+                USBFS_FindReport();\r
+                if (USBFS_currentTD.count != 0u)\r
+                {\r
+                    requestHandled = USBFS_InitControlWrite();\r
+                }\r
+                break;\r
+            case USBFS_HID_SET_IDLE:\r
+                /* This function does not support multiple reports per interface */\r
+                /* Validate interfaceNumber and Report ID (should be 0) */\r
+                if( (interfaceNumber < USBFS_MAX_INTERFACES_NUMBER) &&\r
+                    (CY_GET_REG8(USBFS_wValueLo) == 0u ) ) /* Do not support Idle per Report ID */\r
+                {\r
+                    USBFS_hidIdleRate[interfaceNumber] = CY_GET_REG8(USBFS_wValueHi);\r
+                    /* With regards to HID spec: "7.2.4 Set_Idle Request"\r
+                    *  Latency. If the current period has gone past the\r
+                    *  newly proscribed time duration, then a report\r
+                    *  will be generated immediately.\r
+                    */\r
+                    if(USBFS_hidIdleRate[interfaceNumber] <\r
+                       USBFS_hidIdleTimer[interfaceNumber])\r
+                    {\r
+                        /* Set the timer to zero and let the UpdateHIDTimer() API return IDLE_TIMER_EXPIRED status*/\r
+                        USBFS_hidIdleTimer[interfaceNumber] = 0u;\r
+                    }\r
+                    /* If the new request is received within 4 milliseconds\r
+                    *  (1 count) of the end of the current period, then the\r
+                    *  new request will have no effect until after the report.\r
+                    */\r
+                    else if(USBFS_hidIdleTimer[interfaceNumber] <= 1u)\r
+                    {\r
+                        /* Do nothing.\r
+                        *  Let the UpdateHIDTimer() API continue to work and\r
+                        *  return IDLE_TIMER_EXPIRED status\r
+                        */\r
+                    }\r
+                    else\r
+                    {   /* Reload the timer*/\r
+                        USBFS_hidIdleTimer[interfaceNumber] =\r
+                        USBFS_hidIdleRate[interfaceNumber];\r
+                    }\r
+                    requestHandled = USBFS_InitNoDataControlTransfer();\r
+                }\r
+                break;\r
+\r
+            case USBFS_HID_SET_PROTOCOL:\r
+                /* Validate interfaceNumber and protocol (must be 0 or 1) */\r
+                if( (interfaceNumber < USBFS_MAX_INTERFACES_NUMBER) &&\r
+                    (CY_GET_REG8(USBFS_wValueLo) <= 1u) )\r
+                {\r
+                    USBFS_hidProtocol[interfaceNumber] = CY_GET_REG8(USBFS_wValueLo);\r
+                    requestHandled = USBFS_InitNoDataControlTransfer();\r
+                }\r
+                break;\r
+            default:    /* requestHandled is initialized as FALSE by default */\r
+                break;\r
+        }\r
+    }\r
+    else\r
+    {   /* requestHandled is initialized as FALSE by default */\r
+    }\r
+\r
+    return(requestHandled);\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USB_FindHidClassDescriptor\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine find Hid Class Descriptor pointer based on the Interface number\r
+*  and Alternate setting then loads the currentTD structure with the address of\r
+*  the buffer and the size.\r
+*  The HID Class Descriptor resides inside the config descriptor.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  currentTD\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_FindHidClassDecriptor(void) \r
+{\r
+    const T_USBFS_LUT CYCODE *pTmp;\r
+    volatile uint8 *pDescr;\r
+    uint8 interfaceN;\r
+\r
+    pTmp = USBFS_GetConfigTablePtr(USBFS_configuration - 1u);\r
+    interfaceN = CY_GET_REG8(USBFS_wIndexLo);\r
+    /* Third entry in the LUT starts the Interface Table pointers */\r
+    /* Now use the request interface number*/\r
+    pTmp = &pTmp[interfaceN + 2u];\r
+    /* USB_DEVICEx_CONFIGURATIONy_INTERFACEz_TABLE */\r
+    pTmp = (const T_USBFS_LUT CYCODE *) pTmp->p_list;\r
+    /* Now use Alternate setting number */\r
+    pTmp = &pTmp[USBFS_interfaceSetting[interfaceN]];\r
+    /* USB_DEVICEx_CONFIGURATIONy_INTERFACEz_ALTERNATEi_HID_TABLE */\r
+    pTmp = (const T_USBFS_LUT CYCODE *) pTmp->p_list;\r
+    /* Fifth entry in the LUT points to Hid Class Descriptor in Configuration Descriptor */\r
+    pTmp = &pTmp[4u];\r
+    pDescr = (volatile uint8 *)pTmp->p_list;\r
+    /* The first byte contains the descriptor length */\r
+    USBFS_currentTD.count = *pDescr;\r
+    USBFS_currentTD.pData = pDescr;\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USB_FindReportDescriptor\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine find Hid Report Descriptor pointer based on the Interface\r
+*  number, then loads the currentTD structure with the address of the buffer\r
+*  and the size.\r
+*  Hid Report Descriptor is located after IN/OUT/FEATURE reports.\r
+*\r
+* Parameters:\r
+*   void\r
+*\r
+* Return:\r
+*  currentTD\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_FindReportDescriptor(void) \r
+{\r
+    const T_USBFS_LUT CYCODE *pTmp;\r
+    volatile uint8 *pDescr;\r
+    uint8 interfaceN;\r
+\r
+    pTmp = USBFS_GetConfigTablePtr(USBFS_configuration - 1u);\r
+    interfaceN = CY_GET_REG8(USBFS_wIndexLo);\r
+    /* Third entry in the LUT starts the Interface Table pointers */\r
+    /* Now use the request interface number */\r
+    pTmp = &pTmp[interfaceN + 2u];\r
+    /* USB_DEVICEx_CONFIGURATIONy_INTERFACEz_TABLE */\r
+    pTmp = (const T_USBFS_LUT CYCODE *) pTmp->p_list;\r
+    /* Now use Alternate setting number */\r
+    pTmp = &pTmp[USBFS_interfaceSetting[interfaceN]];\r
+    /* USB_DEVICEx_CONFIGURATIONy_INTERFACEz_ALTERNATEi_HID_TABLE */\r
+    pTmp = (const T_USBFS_LUT CYCODE *) pTmp->p_list;\r
+    /* Fourth entry in the LUT starts the Hid Report Descriptor */\r
+    pTmp = &pTmp[3u];\r
+    pDescr = (volatile uint8 *)pTmp->p_list;\r
+    /* The 1st and 2nd bytes of descriptor contain its length. LSB is 1st. */\r
+    USBFS_currentTD.count =  (((uint16)pDescr[1u] << 8u) | pDescr[0u]);\r
+    USBFS_currentTD.pData = &pDescr[2u];\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_FindReport\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This routine sets up a transfer based on the Interface number, Report Type\r
+*  and Report ID, then loads the currentTD structure with the address of the\r
+*  buffer and the size.  The caller has to decide if it is a control read or\r
+*  control write.\r
+*\r
+* Parameters:\r
+*  None.\r
+*\r
+* Return:\r
+*  currentTD\r
+*\r
+* Reentrant:\r
+*  No.\r
+*\r
+*******************************************************************************/\r
+void USBFS_FindReport(void) \r
+{\r
+    const T_USBFS_LUT CYCODE *pTmp;\r
+    T_USBFS_TD *pTD;\r
+    uint8 interfaceN;\r
+    uint8 reportType;\r
+\r
+    /* `#START HID_FINDREPORT` Place custom handling here */\r
+\r
+    /* `#END` */\r
+    USBFS_currentTD.count = 0u;   /* Init not supported condition */\r
+    pTmp = USBFS_GetConfigTablePtr(USBFS_configuration - 1u);\r
+    reportType = CY_GET_REG8(USBFS_wValueHi);\r
+    interfaceN = CY_GET_REG8(USBFS_wIndexLo);\r
+    /* Third entry in the LUT COnfiguration Table starts the Interface Table pointers */\r
+    /* Now use the request interface number */\r
+    pTmp = &pTmp[interfaceN + 2u];\r
+    /* USB_DEVICEx_CONFIGURATIONy_INTERFACEz_TABLE*/\r
+    pTmp = (const T_USBFS_LUT CYCODE *) pTmp->p_list;\r
+    if(interfaceN < USBFS_MAX_INTERFACES_NUMBER)\r
+    {\r
+        /* Now use Alternate setting number */\r
+        pTmp = &pTmp[USBFS_interfaceSetting[interfaceN]];\r
+        /* USB_DEVICEx_CONFIGURATIONy_INTERFACEz_ALTERNATEi_HID_TABLE */\r
+        pTmp = (const T_USBFS_LUT CYCODE *) pTmp->p_list;\r
+        /* Validate reportType to comply with "7.2.1 Get_Report Request" */\r
+        if((reportType >= USBFS_HID_GET_REPORT_INPUT) &&\r
+           (reportType <= USBFS_HID_GET_REPORT_FEATURE))\r
+        {\r
+            /* Get the entry proper TD (IN, OUT or Feature Report Table)*/\r
+            pTmp = &pTmp[reportType - 1u];\r
+            reportType = CY_GET_REG8(USBFS_wValueLo);    /* Get reportID */\r
+            /* Validate table support by the HID descriptor, compare table count with reportID */\r
+            if(pTmp->c >= reportType)\r
+            {\r
+                pTD = (T_USBFS_TD *) pTmp->p_list;\r
+                pTD = &pTD[reportType];                          /* select entry depend on report ID*/\r
+                USBFS_currentTD.pData = pTD->pData;   /* Buffer pointer */\r
+                USBFS_currentTD.count = pTD->count;   /* Buffer Size */\r
+                USBFS_currentTD.pStatusBlock = pTD->pStatusBlock;\r
+            }\r
+        }\r
+    }\r
+}\r
+\r
+\r
+/*******************************************************************************\r
+* Additional user functions supporting HID Requests\r
+********************************************************************************/\r
+\r
+/* `#START HID_FUNCTIONS` Place any additional functions here */\r
+\r
+/* `#END` */\r
+\r
+#endif  /* End USBFS_ENABLE_HID_CLASS */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_hid.h b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_hid.h
new file mode 100755 (executable)
index 0000000..9a6201c
--- /dev/null
@@ -0,0 +1,64 @@
+/*******************************************************************************\r
+* File Name: USBFS_hid.h\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  Header File for the USFS component. Contains prototypes and constant values.\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#if !defined(CY_USBFS_USBFS_hid_H)\r
+#define CY_USBFS_USBFS_hid_H\r
+\r
+#include "cytypes.h"\r
+\r
+\r
+/***************************************\r
+* Prototypes of the USBFS_hid API.\r
+***************************************/\r
+\r
+uint8 USBFS_UpdateHIDTimer(uint8 interface) ;\r
+uint8 USBFS_GetProtocol(uint8 interface) ;\r
+\r
+\r
+/***************************************\r
+*Renamed Functions for backward compatible\r
+***************************************/\r
+\r
+#define USBFS_bGetProtocol               USBFS_GetProtocol\r
+\r
+\r
+/***************************************\r
+*  Constants for USBFS_hid API.\r
+***************************************/\r
+\r
+#define USBFS_PROTOCOL_BOOT              (0x00u)\r
+#define USBFS_PROTOCOL_REPORT            (0x01u)\r
+\r
+/* Request Types (HID Chapter 7.2) */\r
+#define USBFS_HID_GET_REPORT             (0x01u)\r
+#define USBFS_HID_GET_IDLE               (0x02u)\r
+#define USBFS_HID_GET_PROTOCOL           (0x03u)\r
+#define USBFS_HID_SET_REPORT             (0x09u)\r
+#define USBFS_HID_SET_IDLE               (0x0Au)\r
+#define USBFS_HID_SET_PROTOCOL           (0x0Bu)\r
+\r
+/* Descriptor Types (HID Chapter 7.1) */\r
+#define USBFS_DESCR_HID_CLASS            (0x21u)\r
+#define USBFS_DESCR_HID_REPORT           (0x22u)\r
+#define USBFS_DESCR_HID_PHYSICAL         (0x23u)\r
+\r
+/* Report Request Types (HID Chapter 7.2.1) */\r
+#define USBFS_HID_GET_REPORT_INPUT       (0x01u)\r
+#define USBFS_HID_GET_REPORT_OUTPUT      (0x02u)\r
+#define USBFS_HID_GET_REPORT_FEATURE     (0x03u)\r
+\r
+#endif /* End CY_USBFS_USBFS_hid_H */\r
+\r
+\r
+/* [] END OF FILE */\r
diff --git a/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_midi.c b/software/SCSI2SD/SCSI2SD.cydsn/Generated_Source/PSoC5/USBFS_midi.c
new file mode 100755 (executable)
index 0000000..1f0ce51
--- /dev/null
@@ -0,0 +1,1341 @@
+/*******************************************************************************\r
+* File Name: USBFS_midi.c\r
+* Version 2.60\r
+*\r
+* Description:\r
+*  MIDI Streaming request handler.\r
+*  This file contains routines for sending and receiving MIDI\r
+*  messages, and handles running status in both directions.\r
+*\r
+********************************************************************************\r
+* Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
+* You may use this file only in accordance with the license, terms, conditions,\r
+* disclaimers, and limitations in the end user license agreement accompanying\r
+* the software package with which this file was provided.\r
+*******************************************************************************/\r
+\r
+#include "USBFS.h"\r
+\r
+#if defined(USBFS_ENABLE_MIDI_STREAMING)\r
+\r
+#include "USBFS_midi.h"\r
+#include "USBFS_pvt.h"\r
+\r
+\r
+/***************************************\r
+*    MIDI Constants\r
+***************************************/\r
+\r
+#if (USBFS_MIDI_EXT_MODE >= USBFS_ONE_EXT_INTRF)\r
+    /* The Size of the MIDI messages (MIDI Table 4-1) */\r
+    static const uint8 CYCODE USBFS_MIDI_SIZE[] = {\r
+    /*  Miscellaneous function codes(Reserved)  */ 0x03u,\r
+    /*  Cable events (Reserved)                 */ 0x03u,\r
+    /*  Two-byte System Common messages         */ 0x02u,\r
+    /*  Three-byte System Common messages       */ 0x03u,\r
+    /*  SysEx starts or continues               */ 0x03u,\r
+    /*  Single-byte System Common Message or\r
+        SysEx ends with following single byte   */ 0x01u,\r
+    /*  SysEx ends with following two bytes     */ 0x02u,\r
+    /*  SysEx ends with following three bytes   */ 0x03u,\r
+    /*  Note-off                                */ 0x03u,\r
+    /*  Note-on                                 */ 0x03u,\r
+    /*  Poly-KeyPress                           */ 0x03u,\r
+    /*  Control Change                          */ 0x03u,\r
+    /*  Program Change                          */ 0x02u,\r
+    /*  Channel Pressure                        */ 0x02u,\r
+    /*  PitchBend Change                        */ 0x03u,\r
+    /*  Single Byte                             */ 0x01u\r
+    };\r
+#endif  /* USBFS_MIDI_EXT_MODE >= USBFS_ONE_EXT_INTRF */\r
+\r
+\r
+\r
+/***************************************\r
+*  Global variables\r
+***************************************/\r
+\r
+#if (USBFS_MIDI_IN_BUFF_SIZE > 0)\r
+    #if (USBFS_MIDI_IN_BUFF_SIZE >= 256)\r
+        volatile uint16 USBFS_midiInPointer;                            /* Input endpoint buffer pointer */\r
+    #else\r
+        volatile uint8 USBFS_midiInPointer;                             /* Input endpoint buffer pointer */\r
+    #endif /* End USBFS_MIDI_IN_BUFF_SIZE >=256 */\r
+    volatile uint8 USBFS_midi_in_ep;                                    /* Input endpoint number */\r
+    uint8 USBFS_midiInBuffer[USBFS_MIDI_IN_BUFF_SIZE];       /* Input endpoint buffer */\r
+#endif /* USBFS_MIDI_IN_BUFF_SIZE > 0 */\r
+\r
+#if (USBFS_MIDI_OUT_BUFF_SIZE > 0)\r
+    volatile uint8 USBFS_midi_out_ep;                                   /* Output endpoint number */\r
+    uint8 USBFS_midiOutBuffer[USBFS_MIDI_OUT_BUFF_SIZE];     /* Output endpoint buffer */\r
+#endif /* USBFS_MIDI_OUT_BUFF_SIZE > 0 */\r
+\r
+#if (USBFS_MIDI_EXT_MODE >= USBFS_ONE_EXT_INTRF)\r
+    static USBFS_MIDI_RX_STATUS USBFS_MIDI1_Event;            /* MIDI RX status structure */\r
+    static volatile uint8 USBFS_MIDI1_TxRunStat;                         /* MIDI Output running status */\r
+    volatile uint8 USBFS_MIDI1_InqFlags;                                 /* Device inquiry flag */\r
+\r
+    #if (USBFS_MIDI_EXT_MODE >= USBFS_TWO_EXT_INTRF)\r
+        static USBFS_MIDI_RX_STATUS USBFS_MIDI2_Event;        /* MIDI RX status structure */\r
+        static volatile uint8 USBFS_MIDI2_TxRunStat;                     /* MIDI Output running status */\r
+        volatile uint8 USBFS_MIDI2_InqFlags;                             /* Device inquiry flag */\r
+    #endif /* End USBFS_MIDI_EXT_MODE >= USBFS_TWO_EXT_INTRF */\r
+#endif /* End USBFS_MIDI_EXT_MODE >= USBFS_ONE_EXT_INTRF */\r
+\r
+\r
+/***************************************\r
+* Custom Declarations\r
+***************************************/\r
+\r
+/* `#START MIDI_CUSTOM_DECLARATIONS` Place your declaration here */\r
+\r
+/* `#END` */\r
+\r
+\r
+/***************************************\r
+* Optional MIDI APIs\r
+***************************************/\r
+#if (USBFS_ENABLE_MIDI_API != 0u)\r
+\r
+\r
+/*******************************************************************************\r
+* Function Name: USBFS_MIDI_EP_Init\r
+********************************************************************************\r
+*\r
+* Summary:\r
+*  This function initializes the MIDI interface and UART(s) to be ready to\r
+*   receive data from the PC and MIDI ports.\r
+*\r
+* Parameters:\r
+*  None\r
+*\r
+* Return:\r
+*  None\r
+*\r
+* Global variables:\r
+*  USBFS_midiInBuffer: This buffer is used for saving and combining\r
+*    the received data from UART(s) and(or) generated internally by\r
+*    PutUsbMidiIn() function messages. USBFS_MIDI_IN_EP_Service()\r
+*    function transfers the data from this buffer to the PC.\r
+*  USBFS_midiOutBuffer: This buffer is used by the\r
+*    USBFS_MIDI_OUT_EP_Service() function for saving the received\r
+*    from the PC data, then the data are parsed and transferred to UART(s)\r
+*    buffer and to the internal processing by the\r
+*    USBFS_callbackLocalMidiEvent function.\r
+*  USBFS_midi_out_ep: Used as an OUT endpoint number.\r
+*  USBFS_midi_in_ep: Used as an IN endpoint number.\r
+*   USBFS_midiInPointer: Initialized to zero.\r
+*\r
+* Reentrant:\r
+*  No\r
+*\r
+*******************************************************************************/\r
+void USBFS_MIDI_EP_Init(void) \r
+{\r
+    #if (USBFS_MIDI_IN_BUFF_SIZE > 0)\r
+       USBFS_midiInPointer = 0u;\r
+    #endif  /* USBFS_MIDI_IN_BUFF_SIZE > 0 */\r
+\r
+    #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)\r
+        #if (USBFS_MIDI_IN_BUFF_SIZE > 0)\r
+            /* Init DMA configurations for IN EP*/\r
+            USBFS_LoadInEP(USBFS_midi_in_ep, USBFS_midiInBuffer,\r
+                                                                                USBFS_MIDI_IN_BUFF_SIZE);\r
+                                                                                \r
+        #endif  /* USBFS_MIDI_IN_BUFF_SIZE > 0 */\r
+        #if (USBFS_MIDI_OUT_BUFF_SIZE > 0)\r
+            /* Init DMA configurations for OUT EP*/\r
+            (void)USBFS_ReadOutEP(USBFS_midi_out_ep, USBFS_midiOutBuffer,\r
+                                                                                USBFS_MIDI_OUT_BUFF_SIZE);\r
+        #endif /*USBFS_MIDI_OUT_BUFF_SIZE > 0 */\r
+    #endif  /* End USBFS__EP_DMAAUTO */\r
+\r
+    #if (USBFS_MIDI_OUT_BUFF_SIZE > 0)\r
+        USBFS_EnableOutEP(USBFS_midi_out_ep);\r
+    #endif /* USBFS_MIDI_OUT_BUFF_SIZE > 0 */\r
+\r
+    /* Initialize the MIDI port(s) */\r
+    #if (USBFS_MIDI_EXT_MODE >= USBFS_ONE_EXT_INTRF)\r
+        USBFS_MIDI_Init();\r
+    #endif /* USBFS_MIDI_EXT_MODE >= USBFS_ONE_EXT_INTRF */\r
+}\r
+\r
+#if (USBFS_MIDI_OUT_BUFF_SIZE > 0)\r
+\r
+\r
+    /*******************************************************************************\r
+    * Function Name: USBFS_MIDI_OUT_EP_Service\r
+    ********************************************************************************\r
+    *\r
+    * Summary:\r
+    *  Services the USB MIDI OUT en