Merge PCB updates
[SCSI2SD.git] / software / SCSI2SD / v4 / SCSI2SD.cydsn / Generated_Source / PSoC5 / USBFS.c
1 /*******************************************************************************
2 * File Name: USBFS.c
3 * Version 2.60
4 *
5 * Description:
6 *  API for USBFS Component.
7 *
8 * Note:
9 *  Many of the functions use endpoint number.  RAM arrays are sized with 9
10 *  elements so they are indexed directly by epNumber.  The SIE and ARB
11 *  registers are indexed by variations of epNumber - 1.
12 *
13 ********************************************************************************
14 * Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.
15 * You may use this file only in accordance with the license, terms, conditions,
16 * disclaimers, and limitations in the end user license agreement accompanying
17 * the software package with which this file was provided.
18 *******************************************************************************/
19
20 #include <CyDmac.h>
21 #include "USBFS.h"
22 #include "USBFS_pvt.h"
23 #include "USBFS_hid.h"
24 #if(USBFS_DMA1_REMOVE == 0u)
25     #include "USBFS_ep1_dma.h"
26 #endif   /* End USBFS_DMA1_REMOVE */
27 #if(USBFS_DMA2_REMOVE == 0u)
28     #include "USBFS_ep2_dma.h"
29 #endif   /* End USBFS_DMA2_REMOVE */
30 #if(USBFS_DMA3_REMOVE == 0u)
31     #include "USBFS_ep3_dma.h"
32 #endif   /* End USBFS_DMA3_REMOVE */
33 #if(USBFS_DMA4_REMOVE == 0u)
34     #include "USBFS_ep4_dma.h"
35 #endif   /* End USBFS_DMA4_REMOVE */
36 #if(USBFS_DMA5_REMOVE == 0u)
37     #include "USBFS_ep5_dma.h"
38 #endif   /* End USBFS_DMA5_REMOVE */
39 #if(USBFS_DMA6_REMOVE == 0u)
40     #include "USBFS_ep6_dma.h"
41 #endif   /* End USBFS_DMA6_REMOVE */
42 #if(USBFS_DMA7_REMOVE == 0u)
43     #include "USBFS_ep7_dma.h"
44 #endif   /* End USBFS_DMA7_REMOVE */
45 #if(USBFS_DMA8_REMOVE == 0u)
46     #include "USBFS_ep8_dma.h"
47 #endif   /* End USBFS_DMA8_REMOVE */
48
49
50 /***************************************
51 * Global data allocation
52 ***************************************/
53
54 uint8 USBFS_initVar = 0u;
55 #if(USBFS_EP_MM != USBFS__EP_MANUAL)
56     uint8 USBFS_DmaChan[USBFS_MAX_EP];
57     uint8 USBFS_DmaTd[USBFS_MAX_EP];
58 #endif /* End USBFS_EP_MM */
59
60
61 /*******************************************************************************
62 * Function Name: USBFS_Start
63 ********************************************************************************
64 *
65 * Summary:
66 *  This function initialize the USB SIE, arbiter and the
67 *  endpoint APIs, including setting the D+ Pullup
68 *
69 * Parameters:
70 *  device: Contains the device number of the desired device descriptor.
71 *          The device number can be found in the Device Descriptor Tab of
72 *          "Configure" dialog, under the settings of desired Device Descriptor,
73 *          in the "Device Number" field.
74 *  mode: The operating voltage. This determines whether the voltage regulator
75 *        is enabled for 5V operation or if pass through mode is used for 3.3V
76 *        operation. Symbolic names and their associated values are given in the
77 *        following table.
78 *       USBFS_3V_OPERATION - Disable voltage regulator and pass-thru
79 *                                       Vcc for pull-up
80 *       USBFS_5V_OPERATION - Enable voltage regulator and use
81 *                                       regulator for pull-up
82 *       USBFS_DWR_VDDD_OPERATION - Enable or Disable voltage
83 *                         regulator depend on Vddd Voltage configuration in DWR.
84 *
85 * Return:
86 *   None.
87 *
88 * Global variables:
89 *  The USBFS_intiVar variable is used to indicate initial
90 *  configuration of this component. The variable is initialized to zero (0u)
91 *  and set to one (1u) the first time USBFS_Start() is called.
92 *  This allows for component Re-Start without unnecessary re-initialization
93 *  in all subsequent calls to the USBFS_Start() routine.
94 *  If re-initialization of the component is required the variable should be set
95 *  to zero before call of UART_Start() routine, or the user may call
96 *  USBFS_Init() and USBFS_InitComponent() as done
97 *  in the USBFS_Start() routine.
98 *
99 * Side Effects:
100 *   This function will reset all communication states to default.
101 *
102 * Reentrant:
103 *  No.
104 *
105 *******************************************************************************/
106 void USBFS_Start(uint8 device, uint8 mode) 
107 {
108     /* If not Initialized then initialize all required hardware and software */
109     if(USBFS_initVar == 0u)
110     {
111         USBFS_Init();
112         USBFS_initVar = 1u;
113     }
114     USBFS_InitComponent(device, mode);
115 }
116
117
118 /*******************************************************************************
119 * Function Name: USBFS_Init
120 ********************************************************************************
121 *
122 * Summary:
123 *  Initialize component's hardware. Usually called in USBFS_Start().
124 *
125 * Parameters:
126 *  None.
127 *
128 * Return:
129 *  None.
130 *
131 * Reentrant:
132 *  No.
133 *
134 *******************************************************************************/
135 void USBFS_Init(void) 
136 {
137     uint8 enableInterrupts;
138     #if(USBFS_EP_MM != USBFS__EP_MANUAL)
139         uint16 i;
140     #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */
141
142     enableInterrupts = CyEnterCriticalSection();
143
144     /* Enable USB block  */
145     USBFS_PM_ACT_CFG_REG |= USBFS_PM_ACT_EN_FSUSB;
146     /* Enable USB block for Standby Power Mode */
147     USBFS_PM_STBY_CFG_REG |= USBFS_PM_STBY_EN_FSUSB;
148
149     /* Enable core clock */
150     USBFS_USB_CLK_EN_REG = USBFS_USB_CLK_ENABLE;
151
152     USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK;
153
154     /* ENABLING USBIO PADS IN USB MODE FROM I/O MODE */
155     /* Ensure USB transmit enable is low (USB_USBIO_CR0.ten). - Manual Transmission - Disabled */
156     USBFS_USBIO_CR0_REG &= ((uint8)(~USBFS_USBIO_CR0_TEN));
157     CyDelayUs(0u);  /*~50ns delay */
158     /* Disable the USBIO by asserting PM.USB_CR0.fsusbio_pd_n(Inverted)
159     *  high. This will have been set low by the power manger out of reset.
160     *  Also confirm USBIO pull-up disabled
161     */
162     USBFS_PM_USB_CR0_REG &= ((uint8)(~(USBFS_PM_USB_CR0_PD_N |
163                                                   USBFS_PM_USB_CR0_PD_PULLUP_N)));
164
165     /* Select iomode to USB mode*/
166     USBFS_USBIO_CR1_REG &= ((uint8)(~USBFS_USBIO_CR1_IOMODE));
167
168     /* Enable the USBIO reference by setting PM.USB_CR0.fsusbio_ref_en.*/
169     USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_REF_EN;
170     /* The reference will be available 1 us after the regulator is enabled */
171     CyDelayUs(1u);
172     /* OR 40us after power restored */
173     CyDelayUs(40u);
174     /* Ensure the single ended disable bits are low (PRT15.INP_DIS[7:6])(input receiver enabled). */
175     USBFS_DM_INP_DIS_REG &= ((uint8)(~USBFS_DM_MASK));
176     USBFS_DP_INP_DIS_REG &= ((uint8)(~USBFS_DP_MASK));
177
178     /* Enable USBIO */
179     USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_PD_N;
180     CyDelayUs(2u);
181     /* Set the USBIO pull-up enable */
182     USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_PD_PULLUP_N;
183
184     /* Write WAx */
185     CY_SET_REG8(USBFS_ARB_RW1_WA_PTR,     0u);
186     CY_SET_REG8(USBFS_ARB_RW1_WA_MSB_PTR, 0u);
187
188     #if(USBFS_EP_MM != USBFS__EP_MANUAL)
189         /* Init transfer descriptor. This will be used to detect the DMA state - initialized or not. */
190         for (i = 0u; i < USBFS_MAX_EP; i++)
191         {
192             USBFS_DmaTd[i] = DMA_INVALID_TD;
193         }
194     #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */
195
196     CyExitCriticalSection(enableInterrupts);
197
198
199     /* Set the bus reset Interrupt. */
200     (void) CyIntSetVector(USBFS_BUS_RESET_VECT_NUM,   &USBFS_BUS_RESET_ISR);
201     CyIntSetPriority(USBFS_BUS_RESET_VECT_NUM, USBFS_BUS_RESET_PRIOR);
202
203     /* Set the SOF Interrupt. */
204     #if(USBFS_SOF_ISR_REMOVE == 0u)
205         (void) CyIntSetVector(USBFS_SOF_VECT_NUM,   &USBFS_SOF_ISR);
206         CyIntSetPriority(USBFS_SOF_VECT_NUM, USBFS_SOF_PRIOR);
207     #endif   /* End USBFS_SOF_ISR_REMOVE */
208
209     /* Set the Control Endpoint Interrupt. */
210     (void) CyIntSetVector(USBFS_EP_0_VECT_NUM,   &USBFS_EP_0_ISR);
211     CyIntSetPriority(USBFS_EP_0_VECT_NUM, USBFS_EP_0_PRIOR);
212
213     /* Set the Data Endpoint 1 Interrupt. */
214     #if(USBFS_EP1_ISR_REMOVE == 0u)
215         (void) CyIntSetVector(USBFS_EP_1_VECT_NUM,   &USBFS_EP_1_ISR);
216         CyIntSetPriority(USBFS_EP_1_VECT_NUM, USBFS_EP_1_PRIOR);
217     #endif   /* End USBFS_EP1_ISR_REMOVE */
218
219     /* Set the Data Endpoint 2 Interrupt. */
220     #if(USBFS_EP2_ISR_REMOVE == 0u)
221         (void) CyIntSetVector(USBFS_EP_2_VECT_NUM,   &USBFS_EP_2_ISR);
222         CyIntSetPriority(USBFS_EP_2_VECT_NUM, USBFS_EP_2_PRIOR);
223     #endif   /* End USBFS_EP2_ISR_REMOVE */
224
225     /* Set the Data Endpoint 3 Interrupt. */
226     #if(USBFS_EP3_ISR_REMOVE == 0u)
227         (void) CyIntSetVector(USBFS_EP_3_VECT_NUM,   &USBFS_EP_3_ISR);
228         CyIntSetPriority(USBFS_EP_3_VECT_NUM, USBFS_EP_3_PRIOR);
229     #endif   /* End USBFS_EP3_ISR_REMOVE */
230
231     /* Set the Data Endpoint 4 Interrupt. */
232     #if(USBFS_EP4_ISR_REMOVE == 0u)
233         (void) CyIntSetVector(USBFS_EP_4_VECT_NUM,   &USBFS_EP_4_ISR);
234         CyIntSetPriority(USBFS_EP_4_VECT_NUM, USBFS_EP_4_PRIOR);
235     #endif   /* End USBFS_EP4_ISR_REMOVE */
236
237     /* Set the Data Endpoint 5 Interrupt. */
238     #if(USBFS_EP5_ISR_REMOVE == 0u)
239         (void) CyIntSetVector(USBFS_EP_5_VECT_NUM,   &USBFS_EP_5_ISR);
240         CyIntSetPriority(USBFS_EP_5_VECT_NUM, USBFS_EP_5_PRIOR);
241     #endif   /* End USBFS_EP5_ISR_REMOVE */
242
243     /* Set the Data Endpoint 6 Interrupt. */
244     #if(USBFS_EP6_ISR_REMOVE == 0u)
245         (void) CyIntSetVector(USBFS_EP_6_VECT_NUM,   &USBFS_EP_6_ISR);
246         CyIntSetPriority(USBFS_EP_6_VECT_NUM, USBFS_EP_6_PRIOR);
247     #endif   /* End USBFS_EP6_ISR_REMOVE */
248
249      /* Set the Data Endpoint 7 Interrupt. */
250     #if(USBFS_EP7_ISR_REMOVE == 0u)
251         (void) CyIntSetVector(USBFS_EP_7_VECT_NUM,   &USBFS_EP_7_ISR);
252         CyIntSetPriority(USBFS_EP_7_VECT_NUM, USBFS_EP_7_PRIOR);
253     #endif   /* End USBFS_EP7_ISR_REMOVE */
254
255     /* Set the Data Endpoint 8 Interrupt. */
256     #if(USBFS_EP8_ISR_REMOVE == 0u)
257         (void) CyIntSetVector(USBFS_EP_8_VECT_NUM,   &USBFS_EP_8_ISR);
258         CyIntSetPriority(USBFS_EP_8_VECT_NUM, USBFS_EP_8_PRIOR);
259     #endif   /* End USBFS_EP8_ISR_REMOVE */
260
261     #if((USBFS_EP_MM != USBFS__EP_MANUAL) && (USBFS_ARB_ISR_REMOVE == 0u))
262         /* Set the ARB Interrupt. */
263         (void) CyIntSetVector(USBFS_ARB_VECT_NUM,   &USBFS_ARB_ISR);
264         CyIntSetPriority(USBFS_ARB_VECT_NUM, USBFS_ARB_PRIOR);
265     #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */
266
267 }
268
269
270 /*******************************************************************************
271 * Function Name: USBFS_InitComponent
272 ********************************************************************************
273 *
274 * Summary:
275 *  Initialize the component, except for the HW which is done one time in
276 *  the Start function.  This function pulls up D+.
277 *
278 * Parameters:
279 *  device: Contains the device number of the desired device descriptor.
280 *          The device number can be found in the Device Descriptor Tab of
281 *          "Configure" dialog, under the settings of desired Device Descriptor,
282 *          in the "Device Number" field.
283 *  mode: The operating voltage. This determines whether the voltage regulator
284 *        is enabled for 5V operation or if pass through mode is used for 3.3V
285 *        operation. Symbolic names and their associated values are given in the
286 *        following table.
287 *       USBFS_3V_OPERATION - Disable voltage regulator and pass-thru
288 *                                       Vcc for pull-up
289 *       USBFS_5V_OPERATION - Enable voltage regulator and use
290 *                                       regulator for pull-up
291 *       USBFS_DWR_VDDD_OPERATION - Enable or Disable voltage
292 *                         regulator depend on Vddd Voltage configuration in DWR.
293 *
294 * Return:
295 *   None.
296 *
297 * Global variables:
298 *   USBFS_device: Contains the device number of the desired device
299 *       descriptor. The device number can be found in the Device Descriptor Tab
300 *       of "Configure" dialog, under the settings of desired Device Descriptor,
301 *       in the "Device Number" field.
302 *   USBFS_transferState: This variable used by the communication
303 *       functions to handle current transfer state. Initialized to
304 *       TRANS_STATE_IDLE in this API.
305 *   USBFS_configuration: Contains current configuration number
306 *       which is set by the Host using SET_CONFIGURATION request.
307 *       Initialized to zero in this API.
308 *   USBFS_deviceAddress: Contains current device address. This
309 *       variable is initialized to zero in this API. Host starts to communicate
310 *      to device with address 0 and then set it to whatever value using
311 *      SET_ADDRESS request.
312 *   USBFS_deviceStatus: initialized to 0.
313 *       This is two bit variable which contain power status in first bit
314 *       (DEVICE_STATUS_BUS_POWERED or DEVICE_STATUS_SELF_POWERED) and remote
315 *       wakeup status (DEVICE_STATUS_REMOTE_WAKEUP) in second bit.
316 *   USBFS_lastPacketSize initialized to 0;
317 *
318 * Reentrant:
319 *  No.
320 *
321 *******************************************************************************/
322 void USBFS_InitComponent(uint8 device, uint8 mode) 
323 {
324     /* Initialize _hidProtocol variable to comply with
325     *  HID 7.2.6 Set_Protocol Request:
326     *  "When initialized, all devices default to report protocol."
327     */
328     #if defined(USBFS_ENABLE_HID_CLASS)
329         uint8 i;
330
331         for (i = 0u; i < USBFS_MAX_INTERFACES_NUMBER; i++)
332         {
333             USBFS_hidProtocol[i] = USBFS_PROTOCOL_REPORT;
334         }
335     #endif /* USBFS_ENABLE_HID_CLASS */
336
337     /* Enable Interrupts. */
338     CyIntEnable(USBFS_BUS_RESET_VECT_NUM);
339     CyIntEnable(USBFS_EP_0_VECT_NUM);
340     #if(USBFS_EP1_ISR_REMOVE == 0u)
341         CyIntEnable(USBFS_EP_1_VECT_NUM);
342     #endif   /* End USBFS_EP1_ISR_REMOVE */
343     #if(USBFS_EP2_ISR_REMOVE == 0u)
344         CyIntEnable(USBFS_EP_2_VECT_NUM);
345     #endif   /* End USBFS_EP2_ISR_REMOVE */
346     #if(USBFS_EP3_ISR_REMOVE == 0u)
347         CyIntEnable(USBFS_EP_3_VECT_NUM);
348     #endif   /* End USBFS_EP3_ISR_REMOVE */
349     #if(USBFS_EP4_ISR_REMOVE == 0u)
350         CyIntEnable(USBFS_EP_4_VECT_NUM);
351     #endif   /* End USBFS_EP4_ISR_REMOVE */
352     #if(USBFS_EP5_ISR_REMOVE == 0u)
353         CyIntEnable(USBFS_EP_5_VECT_NUM);
354     #endif   /* End USBFS_EP5_ISR_REMOVE */
355     #if(USBFS_EP6_ISR_REMOVE == 0u)
356         CyIntEnable(USBFS_EP_6_VECT_NUM);
357     #endif   /* End USBFS_EP6_ISR_REMOVE */
358     #if(USBFS_EP7_ISR_REMOVE == 0u)
359         CyIntEnable(USBFS_EP_7_VECT_NUM);
360     #endif   /* End USBFS_EP7_ISR_REMOVE */
361     #if(USBFS_EP8_ISR_REMOVE == 0u)
362         CyIntEnable(USBFS_EP_8_VECT_NUM);
363     #endif   /* End USBFS_EP8_ISR_REMOVE */
364     #if((USBFS_EP_MM != USBFS__EP_MANUAL) && (USBFS_ARB_ISR_REMOVE == 0u))
365         /* usb arb interrupt enable */
366         USBFS_ARB_INT_EN_REG = USBFS_ARB_INT_MASK;
367         CyIntEnable(USBFS_ARB_VECT_NUM);
368     #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */
369
370     /* Arbiter configuration for DMA transfers */
371     #if(USBFS_EP_MM != USBFS__EP_MANUAL)
372
373         #if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)
374             USBFS_ARB_CFG_REG = USBFS_ARB_CFG_MANUAL_DMA;
375         #endif   /* End USBFS_EP_MM == USBFS__EP_DMAMANUAL */
376         #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)
377             /*Set cfg cmplt this rises DMA request when the full configuration is done */
378             USBFS_ARB_CFG_REG = USBFS_ARB_CFG_AUTO_DMA | USBFS_ARB_CFG_AUTO_MEM;
379         #endif   /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */
380     #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */
381
382     USBFS_transferState = USBFS_TRANS_STATE_IDLE;
383
384     /* USB Locking: Enabled, VRegulator: depend on mode or DWR Voltage configuration*/
385     switch(mode)
386     {
387         case USBFS_3V_OPERATION:
388             USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK;
389             break;
390         case USBFS_5V_OPERATION:
391             USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK | USBFS_CR1_REG_ENABLE;
392             break;
393         default:   /*USBFS_DWR_VDDD_OPERATION */
394             #if(USBFS_VDDD_MV < USBFS_3500MV)
395                 USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK;
396             #else
397                 USBFS_CR1_REG = USBFS_CR1_ENABLE_LOCK | USBFS_CR1_REG_ENABLE;
398             #endif /* End USBFS_VDDD_MV < USBFS_3500MV */
399             break;
400     }
401
402     /* Record the descriptor selection */
403     USBFS_device = device;
404
405     /* Clear all of the component data */
406     USBFS_configuration = 0u;
407     USBFS_interfaceNumber = 0u;
408     USBFS_configurationChanged = 0u;
409     USBFS_deviceAddress  = 0u;
410     USBFS_deviceStatus = 0u;
411
412     USBFS_lastPacketSize = 0u;
413
414     /*  ACK Setup, Stall IN/OUT */
415     CY_SET_REG8(USBFS_EP0_CR_PTR, USBFS_MODE_STALL_IN_OUT);
416
417     /* Enable the SIE with an address 0 */
418     CY_SET_REG8(USBFS_CR0_PTR, USBFS_CR0_ENABLE);
419
420     /* Workaround for PSOC5LP */
421     CyDelayCycles(1u);
422
423     /* Finally, Enable d+ pullup and select iomode to USB mode*/
424     CY_SET_REG8(USBFS_USBIO_CR1_PTR, USBFS_USBIO_CR1_USBPUEN);
425 }
426
427
428 /*******************************************************************************
429 * Function Name: USBFS_ReInitComponent
430 ********************************************************************************
431 *
432 * Summary:
433 *  This function reinitialize the component configuration and is
434 *  intend to be called from the Reset interrupt.
435 *
436 * Parameters:
437 *  None.
438 *
439 * Return:
440 *   None.
441 *
442 * Global variables:
443 *   USBFS_device: Contains the device number of the desired device
444 *        descriptor. The device number can be found in the Device Descriptor Tab
445 *       of "Configure" dialog, under the settings of desired Device Descriptor,
446 *       in the "Device Number" field.
447 *   USBFS_transferState: This variable used by the communication
448 *       functions to handle current transfer state. Initialized to
449 *       TRANS_STATE_IDLE in this API.
450 *   USBFS_configuration: Contains current configuration number
451 *       which is set by the Host using SET_CONFIGURATION request.
452 *       Initialized to zero in this API.
453 *   USBFS_deviceAddress: Contains current device address. This
454 *       variable is initialized to zero in this API. Host starts to communicate
455 *      to device with address 0 and then set it to whatever value using
456 *      SET_ADDRESS request.
457 *   USBFS_deviceStatus: initialized to 0.
458 *       This is two bit variable which contain power status in first bit
459 *       (DEVICE_STATUS_BUS_POWERED or DEVICE_STATUS_SELF_POWERED) and remote
460 *       wakeup status (DEVICE_STATUS_REMOTE_WAKEUP) in second bit.
461 *   USBFS_lastPacketSize initialized to 0;
462 *
463 * Reentrant:
464 *  No.
465 *
466 *******************************************************************************/
467 void USBFS_ReInitComponent(void) 
468 {
469     /* Initialize _hidProtocol variable to comply with HID 7.2.6 Set_Protocol
470     *  Request: "When initialized, all devices default to report protocol."
471     */
472     #if defined(USBFS_ENABLE_HID_CLASS)
473         uint8 i;
474
475         for (i = 0u; i < USBFS_MAX_INTERFACES_NUMBER; i++)
476         {
477             USBFS_hidProtocol[i] = USBFS_PROTOCOL_REPORT;
478         }
479     #endif /* USBFS_ENABLE_HID_CLASS */
480
481     USBFS_transferState = USBFS_TRANS_STATE_IDLE;
482
483     /* Clear all of the component data */
484     USBFS_configuration = 0u;
485     USBFS_interfaceNumber = 0u;
486     USBFS_configurationChanged = 0u;
487     USBFS_deviceAddress  = 0u;
488     USBFS_deviceStatus = 0u;
489
490     USBFS_lastPacketSize = 0u;
491
492
493     /*  ACK Setup, Stall IN/OUT */
494     CY_SET_REG8(USBFS_EP0_CR_PTR, USBFS_MODE_STALL_IN_OUT);
495
496     /* Enable the SIE with an address 0 */
497     CY_SET_REG8(USBFS_CR0_PTR, USBFS_CR0_ENABLE);
498
499 }
500
501
502 /*******************************************************************************
503 * Function Name: USBFS_Stop
504 ********************************************************************************
505 *
506 * Summary:
507 *  This function shuts down the USB function including to release
508 *  the D+ Pullup and disabling the SIE.
509 *
510 * Parameters:
511 *  None.
512 *
513 * Return:
514 *  None.
515 *
516 * Global variables:
517 *   USBFS_configuration: Contains current configuration number
518 *       which is set by the Host using SET_CONFIGURATION request.
519 *       Initialized to zero in this API.
520 *   USBFS_deviceAddress: Contains current device address. This
521 *       variable is initialized to zero in this API. Host starts to communicate
522 *      to device with address 0 and then set it to whatever value using
523 *      SET_ADDRESS request.
524 *   USBFS_deviceStatus: initialized to 0.
525 *       This is two bit variable which contain power status in first bit
526 *       (DEVICE_STATUS_BUS_POWERED or DEVICE_STATUS_SELF_POWERED) and remote
527 *       wakeup status (DEVICE_STATUS_REMOTE_WAKEUP) in second bit.
528 *   USBFS_configurationChanged: This variable is set to one after
529 *       SET_CONFIGURATION request and cleared in this function.
530 *   USBFS_intiVar variable is set to zero
531 *
532 *******************************************************************************/
533 void USBFS_Stop(void) 
534 {
535
536     #if(USBFS_EP_MM != USBFS__EP_MANUAL)
537         USBFS_Stop_DMA(USBFS_MAX_EP);     /* Stop all DMAs */
538     #endif   /* End USBFS_EP_MM != USBFS__EP_MANUAL */
539
540     /* Disable the SIE */
541     USBFS_CR0_REG &= (uint8)(~USBFS_CR0_ENABLE);
542     /* Disable the d+ pullup */
543     USBFS_USBIO_CR1_REG &= (uint8)(~USBFS_USBIO_CR1_USBPUEN);
544     /* Disable USB in ACT PM */
545     USBFS_PM_ACT_CFG_REG &= (uint8)(~USBFS_PM_ACT_EN_FSUSB);
546     /* Disable USB block for Standby Power Mode */
547     USBFS_PM_STBY_CFG_REG &= (uint8)(~USBFS_PM_STBY_EN_FSUSB);
548
549     /* Disable the reset and EP interrupts */
550     CyIntDisable(USBFS_BUS_RESET_VECT_NUM);
551     CyIntDisable(USBFS_EP_0_VECT_NUM);
552     #if(USBFS_EP1_ISR_REMOVE == 0u)
553         CyIntDisable(USBFS_EP_1_VECT_NUM);
554     #endif   /* End USBFS_EP1_ISR_REMOVE */
555     #if(USBFS_EP2_ISR_REMOVE == 0u)
556         CyIntDisable(USBFS_EP_2_VECT_NUM);
557     #endif   /* End USBFS_EP2_ISR_REMOVE */
558     #if(USBFS_EP3_ISR_REMOVE == 0u)
559         CyIntDisable(USBFS_EP_3_VECT_NUM);
560     #endif   /* End USBFS_EP3_ISR_REMOVE */
561     #if(USBFS_EP4_ISR_REMOVE == 0u)
562         CyIntDisable(USBFS_EP_4_VECT_NUM);
563     #endif   /* End USBFS_EP4_ISR_REMOVE */
564     #if(USBFS_EP5_ISR_REMOVE == 0u)
565         CyIntDisable(USBFS_EP_5_VECT_NUM);
566     #endif   /* End USBFS_EP5_ISR_REMOVE */
567     #if(USBFS_EP6_ISR_REMOVE == 0u)
568         CyIntDisable(USBFS_EP_6_VECT_NUM);
569     #endif   /* End USBFS_EP6_ISR_REMOVE */
570     #if(USBFS_EP7_ISR_REMOVE == 0u)
571         CyIntDisable(USBFS_EP_7_VECT_NUM);
572     #endif   /* End USBFS_EP7_ISR_REMOVE */
573     #if(USBFS_EP8_ISR_REMOVE == 0u)
574         CyIntDisable(USBFS_EP_8_VECT_NUM);
575     #endif   /* End USBFS_EP8_ISR_REMOVE */
576
577     /* Clear all of the component data */
578     USBFS_configuration = 0u;
579     USBFS_interfaceNumber = 0u;
580     USBFS_configurationChanged = 0u;
581     USBFS_deviceAddress  = 0u;
582     USBFS_deviceStatus = 0u;
583     USBFS_initVar = 0u;
584
585 }
586
587
588 /*******************************************************************************
589 * Function Name: USBFS_CheckActivity
590 ********************************************************************************
591 *
592 * Summary:
593 *  Returns the activity status of the bus.  Clears the status hardware to
594 *  provide fresh activity status on the next call of this routine.
595 *
596 * Parameters:
597 *  None.
598 *
599 * Return:
600 *  1 - If bus activity was detected since the last call to this function
601 *  0 - If bus activity not was detected since the last call to this function
602 *
603 *******************************************************************************/
604 uint8 USBFS_CheckActivity(void) 
605 {
606     uint8 r;
607
608     r = CY_GET_REG8(USBFS_CR1_PTR);
609     CY_SET_REG8(USBFS_CR1_PTR, (r & ((uint8)(~USBFS_CR1_BUS_ACTIVITY))));
610
611     return((r & USBFS_CR1_BUS_ACTIVITY) >> USBFS_CR1_BUS_ACTIVITY_SHIFT);
612 }
613
614
615 /*******************************************************************************
616 * Function Name: USBFS_GetConfiguration
617 ********************************************************************************
618 *
619 * Summary:
620 *  Returns the current configuration setting
621 *
622 * Parameters:
623 *  None.
624 *
625 * Return:
626 *  configuration.
627 *
628 *******************************************************************************/
629 uint8 USBFS_GetConfiguration(void) 
630 {
631     return(USBFS_configuration);
632 }
633
634
635 /*******************************************************************************
636 * Function Name: USBFS_IsConfigurationChanged
637 ********************************************************************************
638 *
639 * Summary:
640 *  Returns the clear on read configuration state. It is usefull when PC send
641 *  double SET_CONFIGURATION request with same configuration number.
642 *
643 * Parameters:
644 *  None.
645 *
646 * Return:
647 *  Not zero value when new configuration has been changed, otherwise zero is
648 *  returned.
649 *
650 * Global variables:
651 *   USBFS_configurationChanged: This variable is set to one after
652 *       SET_CONFIGURATION request and cleared in this function.
653 *
654 *******************************************************************************/
655 uint8 USBFS_IsConfigurationChanged(void) 
656 {
657     uint8 res = 0u;
658
659     if(USBFS_configurationChanged != 0u)
660     {
661         res = USBFS_configurationChanged;
662         USBFS_configurationChanged = 0u;
663     }
664
665     return(res);
666 }
667
668
669 /*******************************************************************************
670 * Function Name: USBFS_GetInterfaceSetting
671 ********************************************************************************
672 *
673 * Summary:
674 *  Returns the alternate setting from current interface
675 *
676 * Parameters:
677 *  uint8 interfaceNumber, interface number
678 *
679 * Return:
680 *  Alternate setting.
681 *
682 *******************************************************************************/
683 uint8  USBFS_GetInterfaceSetting(uint8 interfaceNumber)
684                                                     
685 {
686     return(USBFS_interfaceSetting[interfaceNumber]);
687 }
688
689
690 /*******************************************************************************
691 * Function Name: USBFS_GetEPState
692 ********************************************************************************
693 *
694 * Summary:
695 *  Returned the state of the requested endpoint.
696 *
697 * Parameters:
698 *  epNumber: Endpoint Number
699 *
700 * Return:
701 *  State of the requested endpoint.
702 *
703 *******************************************************************************/
704 uint8 USBFS_GetEPState(uint8 epNumber) 
705 {
706     return(USBFS_EP[epNumber].apiEpState);
707 }
708
709
710 /*******************************************************************************
711 * Function Name: USBFS_GetEPCount
712 ********************************************************************************
713 *
714 * Summary:
715 *  This function supports Data Endpoints only(EP1-EP8).
716 *  Returns the transfer count for the requested endpoint.  The value from
717 *  the count registers includes 2 counts for the two byte checksum of the
718 *  packet.  This function subtracts the two counts.
719 *
720 * Parameters:
721 *  epNumber: Data Endpoint Number.
722 *            Valid values are between 1 and 8.
723 *
724 * Return:
725 *  Returns the current byte count from the specified endpoint or 0 for an
726 *  invalid endpoint.
727 *
728 *******************************************************************************/
729 uint16 USBFS_GetEPCount(uint8 epNumber) 
730 {
731     uint8 ri;
732     uint16 result = 0u;
733
734     if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))
735     {
736         ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);
737
738         result = (uint8)(CY_GET_REG8((reg8 *)(USBFS_SIE_EP1_CNT0_IND + ri)) &
739                           USBFS_EPX_CNT0_MASK);
740         result = (result << 8u) | CY_GET_REG8((reg8 *)(USBFS_SIE_EP1_CNT1_IND + ri));
741         result -= USBFS_EPX_CNTX_CRC_COUNT;
742     }
743     return(result);
744 }
745
746
747 #if(USBFS_EP_MM != USBFS__EP_MANUAL)
748
749
750     /*******************************************************************************
751     * Function Name: USBFS_InitEP_DMA
752     ********************************************************************************
753     *
754     * Summary:
755     *  This function allocates and initializes a DMA channel to be used by the
756     *  USBFS_LoadInEP() or USBFS_ReadOutEP() APIs for data
757     *  transfer.
758     *
759     * Parameters:
760     *  epNumber: Contains the data endpoint number.
761     *            Valid values are between 1 and 8.
762     *  *pData: Pointer to a data array that is related to the EP transfers.
763     *
764     * Return:
765     *  None.
766     *
767     * Reentrant:
768     *  No.
769     *
770     *******************************************************************************/
771     void USBFS_InitEP_DMA(uint8 epNumber, const uint8 *pData)
772                                                                     
773     {
774         uint16 src;
775         uint16 dst;
776         #if (CY_PSOC3)                  /* PSoC 3 */
777             src = HI16(CYDEV_SRAM_BASE);
778             dst = HI16(CYDEV_PERIPH_BASE);
779             pData = pData;
780         #else                           /* PSoC 5 */
781             if((USBFS_EP[epNumber].addr & USBFS_DIR_IN) != 0u )
782             {   /* for the IN EP source is the SRAM memory buffer */
783                 src = HI16(pData);
784                 dst = HI16(CYDEV_PERIPH_BASE);
785             }
786             else
787             {   /* for the OUT EP source is the SIE register */
788                 src = HI16(CYDEV_PERIPH_BASE);
789                 dst = HI16(pData);
790             }
791         #endif  /* End C51 */
792         switch(epNumber)
793         {
794             case USBFS_EP1:
795                 #if(USBFS_DMA1_REMOVE == 0u)
796                     USBFS_DmaChan[epNumber] = USBFS_ep1_DmaInitialize(
797                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
798                 #endif   /* End USBFS_DMA1_REMOVE */
799                 break;
800             case USBFS_EP2:
801                 #if(USBFS_DMA2_REMOVE == 0u)
802                     USBFS_DmaChan[epNumber] = USBFS_ep2_DmaInitialize(
803                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
804                 #endif   /* End USBFS_DMA2_REMOVE */
805                 break;
806             case USBFS_EP3:
807                 #if(USBFS_DMA3_REMOVE == 0u)
808                     USBFS_DmaChan[epNumber] = USBFS_ep3_DmaInitialize(
809                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
810                 #endif   /* End USBFS_DMA3_REMOVE */
811                 break;
812             case USBFS_EP4:
813                 #if(USBFS_DMA4_REMOVE == 0u)
814                     USBFS_DmaChan[epNumber] = USBFS_ep4_DmaInitialize(
815                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
816                 #endif   /* End USBFS_DMA4_REMOVE */
817                 break;
818             case USBFS_EP5:
819                 #if(USBFS_DMA5_REMOVE == 0u)
820                     USBFS_DmaChan[epNumber] = USBFS_ep5_DmaInitialize(
821                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
822                 #endif   /* End USBFS_DMA5_REMOVE */
823                 break;
824             case USBFS_EP6:
825                 #if(USBFS_DMA6_REMOVE == 0u)
826                     USBFS_DmaChan[epNumber] = USBFS_ep6_DmaInitialize(
827                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
828                 #endif   /* End USBFS_DMA6_REMOVE */
829                 break;
830             case USBFS_EP7:
831                 #if(USBFS_DMA7_REMOVE == 0u)
832                     USBFS_DmaChan[epNumber] = USBFS_ep7_DmaInitialize(
833                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
834                 #endif   /* End USBFS_DMA7_REMOVE */
835                 break;
836             case USBFS_EP8:
837                 #if(USBFS_DMA8_REMOVE == 0u)
838                     USBFS_DmaChan[epNumber] = USBFS_ep8_DmaInitialize(
839                         USBFS_DMA_BYTES_PER_BURST, USBFS_DMA_REQUEST_PER_BURST, src, dst);
840                 #endif   /* End USBFS_DMA8_REMOVE */
841                 break;
842             default:
843                 /* Do not support EP0 DMA transfers */
844                 break;
845         }
846         if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))
847         {
848             USBFS_DmaTd[epNumber] = CyDmaTdAllocate();
849         }
850     }
851
852
853     /*******************************************************************************
854     * Function Name: USBFS_Stop_DMA
855     ********************************************************************************
856     *
857     * Summary: Stops and free DMA
858     *
859     * Parameters:
860     *  epNumber: Contains the data endpoint number or
861     *           USBFS_MAX_EP to stop all DMAs
862     *
863     * Return:
864     *  None.
865     *
866     * Reentrant:
867     *  No.
868     *
869     *******************************************************************************/
870     void USBFS_Stop_DMA(uint8 epNumber) 
871     {
872         uint8 i;
873         i = (epNumber < USBFS_MAX_EP) ? epNumber : USBFS_EP1;
874         do
875         {
876             if(USBFS_DmaTd[i] != DMA_INVALID_TD)
877             {
878                 (void) CyDmaChDisable(USBFS_DmaChan[i]);
879                 CyDmaTdFree(USBFS_DmaTd[i]);
880                 USBFS_DmaTd[i] = DMA_INVALID_TD;
881             }
882             i++;
883         }while((i < USBFS_MAX_EP) && (epNumber == USBFS_MAX_EP));
884     }
885
886 #endif /* End USBFS_EP_MM != USBFS__EP_MANUAL */
887
888
889 /*******************************************************************************
890 * Function Name: USBFS_LoadInEP
891 ********************************************************************************
892 *
893 * Summary:
894 *  Loads and enables the specified USB data endpoint for an IN interrupt or bulk
895 *  transfer.
896 *
897 * Parameters:
898 *  epNumber: Contains the data endpoint number.
899 *            Valid values are between 1 and 8.
900 *  *pData: A pointer to a data array from which the data for the endpoint space
901 *          is loaded.
902 *  length: The number of bytes to transfer from the array and then send as a
903 *          result of an IN request. Valid values are between 0 and 512.
904 *
905 * Return:
906 *  None.
907 *
908 * Reentrant:
909 *  No.
910 *
911 *******************************************************************************/
912 void USBFS_LoadInEP(uint8 epNumber, const uint8 pData[], uint16 length)
913                                                                         
914 {
915     uint8 ri;
916     reg8 *p;
917     #if(USBFS_EP_MM == USBFS__EP_MANUAL)
918         uint16 i;
919     #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */
920
921     if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))
922     {
923         ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);
924         p = (reg8 *)(USBFS_ARB_RW1_DR_IND + ri);
925
926         #if(USBFS_EP_MM != USBFS__EP_DMAAUTO)
927             /* Limits length to available buffer space, auto MM could send packets up to 1024 bytes */
928             if(length > (USBFS_EPX_DATA_BUF_MAX - USBFS_EP[epNumber].buffOffset))
929             {
930                 length = USBFS_EPX_DATA_BUF_MAX - USBFS_EP[epNumber].buffOffset;
931             }
932         #endif /* End USBFS_EP_MM != USBFS__EP_DMAAUTO */
933
934         /* Set the count and data toggle */
935         CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CNT0_IND + ri),
936                             (length >> 8u) | (USBFS_EP[epNumber].epToggle));
937         CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CNT1_IND + ri),  length & 0xFFu);
938
939         #if(USBFS_EP_MM == USBFS__EP_MANUAL)
940             if(pData != NULL)
941             {
942                 /* Copy the data using the arbiter data register */
943                 for (i = 0u; i < length; i++)
944                 {
945                     CY_SET_REG8(p, pData[i]);
946                 }
947             }
948             USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;
949             /* Write the Mode register */
950             CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);
951         #else
952             /* Init DMA if it was not initialized */
953             if(USBFS_DmaTd[epNumber] == DMA_INVALID_TD)
954             {
955                 USBFS_InitEP_DMA(epNumber, pData);
956             }
957         #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */
958
959         #if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)
960             USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;
961             if((pData != NULL) && (length > 0u))
962             {
963                 /* Enable DMA in mode2 for transferring data */
964                 (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);
965                 (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length, CY_DMA_DISABLE_TD,
966                                                                                  TD_TERMIN_EN | TD_INC_SRC_ADR);
967                 (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)pData), LO16((uint32)p));
968                 /* Enable the DMA */
969                 (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);
970                 (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);
971                 /* Generate DMA request */
972                 * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) |= USBFS_ARB_EPX_CFG_DMA_REQ;
973                 * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) &= ((uint8)(~USBFS_ARB_EPX_CFG_DMA_REQ));
974                 /* Mode register will be written in arb ISR after DMA transfer complete */
975             }
976             else
977             {
978                 /* When zero-length packet - write the Mode register directly */
979                 CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);
980             }
981         #endif /* End USBFS_EP_MM == USBFS__EP_DMAMANUAL */
982
983         #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)
984             if(pData != NULL)
985             {
986                 /* Enable DMA in mode3 for transferring data */
987                 (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);
988                 (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length,
989                                                USBFS_DmaTd[epNumber], TD_TERMIN_EN | TD_INC_SRC_ADR);
990                 (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)pData), LO16((uint32)p));
991                 /* Clear Any potential pending DMA requests before starting the DMA channel to transfer data */
992                 (void) CyDmaClearPendingDrq(USBFS_DmaChan[epNumber]);
993                 /* Enable the DMA */
994                 (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);
995                 (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);
996             }
997             else
998             {
999                 USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;
1000                 if(length > 0u)
1001                 {
1002                     /* Set Data ready status, This will generate DMA request */
1003                     * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) |= USBFS_ARB_EPX_CFG_IN_DATA_RDY;
1004                     /* Mode register will be written in arb ISR(In Buffer Full) after first DMA transfer complete */
1005                 }
1006                 else
1007                 {
1008                     /* When zero-length packet - write the Mode register directly */
1009                     CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);
1010                 }
1011             }
1012         #endif /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */
1013
1014     }
1015 }
1016
1017
1018 /*******************************************************************************
1019 * Function Name: USBFS_ReadOutEP
1020 ********************************************************************************
1021 *
1022 * Summary:
1023 *  Read data from an endpoint.  The application must call
1024 *  USBFS_GetEPState to see if an event is pending.
1025 *
1026 * Parameters:
1027 *  epNumber: Contains the data endpoint number.
1028 *            Valid values are between 1 and 8.
1029 *  pData: A pointer to a data array from which the data for the endpoint space
1030 *         is loaded.
1031 *  length: The number of bytes to transfer from the USB Out endpoint and loads
1032 *          it into data array. Valid values are between 0 and 1023. The function
1033 *          moves fewer than the requested number of bytes if the host sends
1034 *          fewer bytes than requested.
1035 *
1036 * Returns:
1037 *  Number of bytes received, 0 for an invalid endpoint.
1038 *
1039 * Reentrant:
1040 *  No.
1041 *
1042 *******************************************************************************/
1043 uint16 USBFS_ReadOutEP(uint8 epNumber, uint8 pData[], uint16 length)
1044                                                                         
1045 {
1046     uint8 ri;
1047     reg8 *p;
1048     #if(USBFS_EP_MM == USBFS__EP_MANUAL)
1049         uint16 i;
1050     #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */
1051     #if(USBFS_EP_MM != USBFS__EP_DMAAUTO)
1052         uint16 xferCount;
1053     #endif /* End USBFS_EP_MM != USBFS__EP_DMAAUTO */
1054
1055     if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP) && (pData != NULL))
1056     {
1057         ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);
1058         p = (reg8 *)(USBFS_ARB_RW1_DR_IND + ri);
1059
1060         #if(USBFS_EP_MM != USBFS__EP_DMAAUTO)
1061             /* Determine which is smaller the requested data or the available data */
1062             xferCount = USBFS_GetEPCount(epNumber);
1063             if (length > xferCount)
1064             {
1065                 length = xferCount;
1066             }
1067         #endif /* End USBFS_EP_MM != USBFS__EP_DMAAUTO */
1068
1069         #if(USBFS_EP_MM == USBFS__EP_MANUAL)
1070             /* Copy the data using the arbiter data register */
1071             for (i = 0u; i < length; i++)
1072             {
1073                 pData[i] = CY_GET_REG8(p);
1074             }
1075
1076             /* (re)arming of OUT endpoint */
1077             USBFS_EnableOutEP(epNumber);
1078         #else
1079             /*Init DMA if it was not initialized */
1080             if(USBFS_DmaTd[epNumber] == DMA_INVALID_TD)
1081             {
1082                 USBFS_InitEP_DMA(epNumber, pData);
1083             }
1084         #endif /* End USBFS_EP_MM == USBFS__EP_MANUAL */
1085
1086         #if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)
1087             /* Enable DMA in mode2 for transferring data */
1088             (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);
1089             (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length, CY_DMA_DISABLE_TD,
1090                                                                                 TD_TERMIN_EN | TD_INC_DST_ADR);
1091             (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)p), LO16((uint32)pData));
1092             /* Enable the DMA */
1093             (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);
1094             (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);
1095
1096             /* Generate DMA request */
1097             * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) |= USBFS_ARB_EPX_CFG_DMA_REQ;
1098             * (reg8 *)(USBFS_ARB_EP1_CFG_IND + ri) &= ((uint8)(~USBFS_ARB_EPX_CFG_DMA_REQ));
1099             /* Out EP will be (re)armed in arb ISR after transfer complete */
1100         #endif /* End USBFS_EP_MM == USBFS__EP_DMAMANUAL */
1101
1102         #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)
1103             /* Enable DMA in mode3 for transferring data */
1104             (void) CyDmaChDisable(USBFS_DmaChan[epNumber]);
1105             (void) CyDmaTdSetConfiguration(USBFS_DmaTd[epNumber], length, USBFS_DmaTd[epNumber],
1106                                                                                 TD_TERMIN_EN | TD_INC_DST_ADR);
1107             (void) CyDmaTdSetAddress(USBFS_DmaTd[epNumber],  LO16((uint32)p), LO16((uint32)pData));
1108
1109             /* Clear Any potential pending DMA requests before starting the DMA channel to transfer data */
1110             (void) CyDmaClearPendingDrq(USBFS_DmaChan[epNumber]);
1111             /* Enable the DMA */
1112             (void) CyDmaChSetInitialTd(USBFS_DmaChan[epNumber], USBFS_DmaTd[epNumber]);
1113             (void) CyDmaChEnable(USBFS_DmaChan[epNumber], 1u);
1114             /* Out EP will be (re)armed in arb ISR after transfer complete */
1115         #endif /* End USBFS_EP_MM == USBFS__EP_DMAAUTO */
1116
1117     }
1118     else
1119     {
1120         length = 0u;
1121     }
1122
1123     return(length);
1124 }
1125
1126
1127 /*******************************************************************************
1128 * Function Name: USBFS_EnableOutEP
1129 ********************************************************************************
1130 *
1131 * Summary:
1132 *  This function enables an OUT endpoint.  It should not be
1133 *  called for an IN endpoint.
1134 *
1135 * Parameters:
1136 *  epNumber: Endpoint Number
1137 *            Valid values are between 1 and 8.
1138 *
1139 * Return:
1140 *   None.
1141 *
1142 * Global variables:
1143 *  USBFS_EP[epNumber].apiEpState - set to NO_EVENT_PENDING
1144 *
1145 * Reentrant:
1146 *  No.
1147 *
1148 *******************************************************************************/
1149 void USBFS_EnableOutEP(uint8 epNumber) 
1150 {
1151     uint8 ri;
1152
1153     if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))
1154     {
1155         ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);
1156         USBFS_EP[epNumber].apiEpState = USBFS_NO_EVENT_PENDING;
1157         /* Write the Mode register */
1158         CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_EP[epNumber].epMode);
1159     }
1160 }
1161
1162
1163 /*******************************************************************************
1164 * Function Name: USBFS_DisableOutEP
1165 ********************************************************************************
1166 *
1167 * Summary:
1168 *  This function disables an OUT endpoint.  It should not be
1169 *  called for an IN endpoint.
1170 *
1171 * Parameters:
1172 *  epNumber: Endpoint Number
1173 *            Valid values are between 1 and 8.
1174 *
1175 * Return:
1176 *  None.
1177 *
1178 *******************************************************************************/
1179 void USBFS_DisableOutEP(uint8 epNumber) 
1180 {
1181     uint8 ri ;
1182
1183     if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))
1184     {
1185         ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);
1186         /* Write the Mode register */
1187         CY_SET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri), USBFS_MODE_NAK_OUT);
1188     }
1189 }
1190
1191
1192 /*******************************************************************************
1193 * Function Name: USBFS_Force
1194 ********************************************************************************
1195 *
1196 * Summary:
1197 *  Forces the bus state
1198 *
1199 * Parameters:
1200 *  bState
1201 *    USBFS_FORCE_J
1202 *    USBFS_FORCE_K
1203 *    USBFS_FORCE_SE0
1204 *    USBFS_FORCE_NONE
1205 *
1206 * Return:
1207 *  None.
1208 *
1209 *******************************************************************************/
1210 void USBFS_Force(uint8 bState) 
1211 {
1212     CY_SET_REG8(USBFS_USBIO_CR0_PTR, bState);
1213 }
1214
1215
1216 /*******************************************************************************
1217 * Function Name: USBFS_GetEPAckState
1218 ********************************************************************************
1219 *
1220 * Summary:
1221 *  Returns the ACK of the CR0 Register (ACKD)
1222 *
1223 * Parameters:
1224 *  epNumber: Endpoint Number
1225 *            Valid values are between 1 and 8.
1226 *
1227 * Returns
1228 *  0 if nothing has been ACKD, non-=zero something has been ACKD
1229 *
1230 *******************************************************************************/
1231 uint8 USBFS_GetEPAckState(uint8 epNumber) 
1232 {
1233     uint8 ri;
1234     uint8 cr = 0u;
1235
1236     if((epNumber > USBFS_EP0) && (epNumber < USBFS_MAX_EP))
1237     {
1238         ri = ((epNumber - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT);
1239         cr = CY_GET_REG8((reg8 *)(USBFS_SIE_EP1_CR0_IND + ri)) & USBFS_MODE_ACKD;
1240     }
1241
1242     return(cr);
1243 }
1244
1245
1246 /*******************************************************************************
1247 * Function Name: USBFS_SetPowerStatus
1248 ********************************************************************************
1249 *
1250 * Summary:
1251 *  Sets the device power status for reporting in the Get Device Status
1252 *  request
1253 *
1254 * Parameters:
1255 *  powerStatus: USBFS_DEVICE_STATUS_BUS_POWERED(0) - Bus Powered,
1256 *               USBFS_DEVICE_STATUS_SELF_POWERED(1) - Self Powered
1257 *
1258 * Return:
1259 *   None.
1260 *
1261 * Global variables:
1262 *  USBFS_deviceStatus - set power status
1263 *
1264 * Reentrant:
1265 *  No.
1266 *
1267 *******************************************************************************/
1268 void USBFS_SetPowerStatus(uint8 powerStatus) 
1269 {
1270     if (powerStatus != USBFS_DEVICE_STATUS_BUS_POWERED)
1271     {
1272         USBFS_deviceStatus |=  USBFS_DEVICE_STATUS_SELF_POWERED;
1273     }
1274     else
1275     {
1276         USBFS_deviceStatus &=  ((uint8)(~USBFS_DEVICE_STATUS_SELF_POWERED));
1277     }
1278 }
1279
1280
1281 #if (USBFS_MON_VBUS == 1u)
1282
1283     /*******************************************************************************
1284     * Function Name: USBFS_VBusPresent
1285     ********************************************************************************
1286     *
1287     * Summary:
1288     *  Determines VBUS presence for Self Powered Devices.
1289     *
1290     * Parameters:
1291     *  None.
1292     *
1293     * Return:
1294     *  1 if VBUS is present, otherwise 0.
1295     *
1296     *******************************************************************************/
1297     uint8 USBFS_VBusPresent(void) 
1298     {
1299         return((0u != (CY_GET_REG8(USBFS_VBUS_PS_PTR) & USBFS_VBUS_MASK)) ? 1u : 0u);
1300     }
1301
1302 #endif /* USBFS_MON_VBUS */
1303
1304
1305 /*******************************************************************************
1306 * Function Name: USBFS_RWUEnabled
1307 ********************************************************************************
1308 *
1309 * Summary:
1310 *  Returns TRUE if Remote Wake Up is enabled, otherwise FALSE
1311 *
1312 * Parameters:
1313 *   None.
1314 *
1315 * Return:
1316 *  TRUE -  Remote Wake Up Enabled
1317 *  FALSE - Remote Wake Up Disabled
1318 *
1319 * Global variables:
1320 *  USBFS_deviceStatus - checked to determine remote status
1321 *
1322 *******************************************************************************/
1323 uint8 USBFS_RWUEnabled(void) 
1324 {
1325     uint8 result = USBFS_FALSE;
1326     if((USBFS_deviceStatus & USBFS_DEVICE_STATUS_REMOTE_WAKEUP) != 0u)
1327     {
1328         result = USBFS_TRUE;
1329     }
1330
1331     return(result);
1332 }
1333
1334
1335 /* [] END OF FILE */