Merge PCB updates
[SCSI2SD.git] / software / SCSI2SD / v4 / SCSI2SD.cydsn / Generated_Source / PSoC5 / USBFS_cdc.c
1 /*******************************************************************************
2 * File Name: USBFS_cdc.c
3 * Version 2.60
4 *
5 * Description:
6 *  USB HID Class request handler.
7 *
8 * Note:
9 *
10 ********************************************************************************
11 * Copyright 2012-2013, Cypress Semiconductor Corporation.  All rights reserved.
12 * You may use this file only in accordance with the license, terms, conditions,
13 * disclaimers, and limitations in the end user license agreement accompanying
14 * the software package with which this file was provided.
15 *******************************************************************************/
16
17 #include "USBFS.h"
18
19 #if defined(USBFS_ENABLE_CDC_CLASS)
20
21 #include "USBFS_cdc.h"
22 #include "USBFS_pvt.h"
23
24
25 /***************************************
26 *    CDC Variables
27 ***************************************/
28
29 volatile uint8 USBFS_lineCoding[USBFS_LINE_CODING_SIZE];
30 volatile uint8 USBFS_lineChanged;
31 volatile uint16 USBFS_lineControlBitmap;
32 volatile uint8 USBFS_cdc_data_in_ep;
33 volatile uint8 USBFS_cdc_data_out_ep;
34
35
36 /***************************************
37 *     Static Function Prototypes
38 ***************************************/
39 static uint16 USBFS_StrLen(const char8 string[]) ;
40
41
42 /***************************************
43 * Custom Declarations
44 ***************************************/
45
46 /* `#START CDC_CUSTOM_DECLARATIONS` Place your declaration here */
47
48 /* `#END` */
49
50
51 /*******************************************************************************
52 * Function Name: USBFS_DispatchCDCClassRqst
53 ********************************************************************************
54 *
55 * Summary:
56 *  This routine dispatches CDC class requests.
57 *
58 * Parameters:
59 *  None.
60 *
61 * Return:
62 *  requestHandled
63 *
64 * Global variables:
65 *   USBFS_lineCoding: Contains the current line coding structure.
66 *     It is set by the Host using SET_LINE_CODING request and returned to the
67 *     user code by the USBFS_GetDTERate(), USBFS_GetCharFormat(),
68 *     USBFS_GetParityType(), USBFS_GetDataBits() APIs.
69 *   USBFS_lineControlBitmap: Contains the current control signal
70 *     bitmap. It is set by the Host using SET_CONTROL_LINE request and returned
71 *     to the user code by the USBFS_GetLineControl() API.
72 *   USBFS_lineChanged: This variable is used as a flag for the
73 *     USBFS_IsLineChanged() API, to be aware that Host has been sent request
74 *     for changing Line Coding or Control Bitmap.
75 *
76 * Reentrant:
77 *  No.
78 *
79 *******************************************************************************/
80 uint8 USBFS_DispatchCDCClassRqst(void) 
81 {
82     uint8 requestHandled = USBFS_FALSE;
83
84     if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) == USBFS_RQST_DIR_D2H)
85     {   /* Control Read */
86         switch (CY_GET_REG8(USBFS_bRequest))
87         {
88             case USBFS_CDC_GET_LINE_CODING:
89                 USBFS_currentTD.count = USBFS_LINE_CODING_SIZE;
90                 USBFS_currentTD.pData = USBFS_lineCoding;
91                 requestHandled  = USBFS_InitControlRead();
92                 break;
93
94             /* `#START CDC_READ_REQUESTS` Place other request handler here */
95
96             /* `#END` */
97
98             default:    /* requestHandled is initialized as FALSE by default */
99                 break;
100         }
101     }
102     else if ((CY_GET_REG8(USBFS_bmRequestType) & USBFS_RQST_DIR_MASK) == \
103                                                                             USBFS_RQST_DIR_H2D)
104     {   /* Control Write */
105         switch (CY_GET_REG8(USBFS_bRequest))
106         {
107             case USBFS_CDC_SET_LINE_CODING:
108                 USBFS_currentTD.count = USBFS_LINE_CODING_SIZE;
109                 USBFS_currentTD.pData = USBFS_lineCoding;
110                 USBFS_lineChanged |= USBFS_LINE_CODING_CHANGED;
111                 requestHandled = USBFS_InitControlWrite();
112                 break;
113
114             case USBFS_CDC_SET_CONTROL_LINE_STATE:
115                 USBFS_lineControlBitmap = CY_GET_REG8(USBFS_wValueLo);
116                 USBFS_lineChanged |= USBFS_LINE_CONTROL_CHANGED;
117                 requestHandled = USBFS_InitNoDataControlTransfer();
118                 break;
119
120             /* `#START CDC_WRITE_REQUESTS` Place other request handler here */
121
122             /* `#END` */
123
124             default:    /* requestHandled is initialized as FALSE by default */
125                 break;
126         }
127     }
128     else
129     {   /* requestHandled is initialized as FALSE by default */
130     }
131
132     return(requestHandled);
133 }
134
135
136 /***************************************
137 * Optional CDC APIs
138 ***************************************/
139 #if (USBFS_ENABLE_CDC_CLASS_API != 0u)
140
141
142     /*******************************************************************************
143     * Function Name: USBFS_CDC_Init
144     ********************************************************************************
145     *
146     * Summary:
147     *  This function initialize the CDC interface to be ready for the receive data
148     *  from the PC.
149     *
150     * Parameters:
151     *  None.
152     *
153     * Return:
154     *  None.
155     *
156     * Global variables:
157     *   USBFS_lineChanged: Initialized to zero.
158     *   USBFS_cdc_data_out_ep: Used as an OUT endpoint number.
159     *
160     * Reentrant:
161     *  No.
162     *
163     *******************************************************************************/
164     void USBFS_CDC_Init(void) 
165     {
166         USBFS_lineChanged = 0u;
167         USBFS_EnableOutEP(USBFS_cdc_data_out_ep);
168     }
169
170
171     /*******************************************************************************
172     * Function Name: USBFS_PutData
173     ********************************************************************************
174     *
175     * Summary:
176     *  Sends a specified number of bytes from the location specified by a
177     *  pointer to the PC.
178     *
179     * Parameters:
180     *  pData: pointer to the buffer containing data to be sent.
181     *  length: Specifies the number of bytes to send from the pData
182     *  buffer. Maximum length will be limited by the maximum packet
183     *  size for the endpoint.
184     *
185     * Return:
186     *  None.
187     *
188     * Global variables:
189     *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending
190     *     data.
191     *
192     * Reentrant:
193     *  No.
194     *
195     *******************************************************************************/
196     void USBFS_PutData(const uint8* pData, uint16 length) 
197     {
198         /* Limits length to maximum packet size for the EP */
199         if(length > USBFS_EP[USBFS_cdc_data_in_ep].bufferSize)
200         {
201             /* Caution: Data will be lost if length is greater than Max Packet Length */
202             length = USBFS_EP[USBFS_cdc_data_in_ep].bufferSize;
203              /* Halt CPU in debug mode */
204             CYASSERT(0u != 0u);
205         }
206         USBFS_LoadInEP(USBFS_cdc_data_in_ep, pData, length);
207     }
208
209
210     /*******************************************************************************
211     * Function Name: USBFS_StrLen
212     ********************************************************************************
213     *
214     * Summary:
215     *  Calculates length of a null terminated string.
216     *
217     * Parameters:
218     *  string: pointer to the string.
219     *
220     * Return:
221     *  Length of the string
222     *
223     *******************************************************************************/
224     static uint16 USBFS_StrLen(const char8 string[]) 
225     {
226         uint16 len = 0u;
227
228         while (string[len] != (char8)0)
229         {
230             len++;
231         }
232
233         return (len);
234     }
235
236
237     /*******************************************************************************
238     * Function Name: USBFS_PutString
239     ********************************************************************************
240     *
241     * Summary:
242     *  Sends a null terminated string to the PC.
243     *
244     * Parameters:
245     *  string: pointer to the string to be sent to the PC
246     *
247     * Return:
248     *  None.
249     *
250     * Global variables:
251     *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending
252     *     data.
253     *
254     * Reentrant:
255     *  No.
256     *
257     * Theory:
258     *  This function will block if there is not enough memory to place the whole
259     *  string, it will block until the entire string has been written to the
260     *  transmit buffer.
261     *
262     *******************************************************************************/
263     void USBFS_PutString(const char8 string[]) 
264     {
265         uint16 str_length;
266         uint16 send_length;
267         uint16 buf_index = 0u;
268
269         /* Get length of the null terminated string */
270         str_length = USBFS_StrLen(string);
271         do
272         {
273             /* Limits length to maximum packet size for the EP */
274             send_length = (str_length > USBFS_EP[USBFS_cdc_data_in_ep].bufferSize) ?
275                           USBFS_EP[USBFS_cdc_data_in_ep].bufferSize : str_length;
276              /* Enable IN transfer */
277             USBFS_LoadInEP(USBFS_cdc_data_in_ep, (const uint8 *)&string[buf_index], send_length);
278             str_length -= send_length;
279
280             /* If more data are present to send */
281             if(str_length > 0u)
282             {
283                 buf_index += send_length;
284                 /* Wait for the Host to read it. */
285                 while(USBFS_EP[USBFS_cdc_data_in_ep].apiEpState ==
286                                           USBFS_IN_BUFFER_FULL)
287                 {
288                     ;
289                 }
290             }
291         }while(str_length > 0u);
292     }
293
294
295     /*******************************************************************************
296     * Function Name: USBFS_PutChar
297     ********************************************************************************
298     *
299     * Summary:
300     *  Writes a single character to the PC.
301     *
302     * Parameters:
303     *  txDataByte: Character to be sent to the PC.
304     *
305     * Return:
306     *  None.
307     *
308     * Global variables:
309     *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending
310     *     data.
311     *
312     * Reentrant:
313     *  No.
314     *
315     *******************************************************************************/
316     void USBFS_PutChar(char8 txDataByte) 
317     {
318         uint8 dataByte;
319         dataByte = (uint8)txDataByte;
320
321         USBFS_LoadInEP(USBFS_cdc_data_in_ep, &dataByte, 1u);
322     }
323
324
325     /*******************************************************************************
326     * Function Name: USBFS_PutCRLF
327     ********************************************************************************
328     *
329     * Summary:
330     *  Sends a carriage return (0x0D) and line feed (0x0A) to the PC
331     *
332     * Parameters:
333     *  None.
334     *
335     * Return:
336     *  None.
337     *
338     * Global variables:
339     *   USBFS_cdc_data_in_ep: CDC IN endpoint number used for sending
340     *     data.
341     *
342     * Reentrant:
343     *  No.
344     *
345     *******************************************************************************/
346     void USBFS_PutCRLF(void) 
347     {
348         const uint8 CYCODE txData[] = {0x0Du, 0x0Au};
349
350         USBFS_LoadInEP(USBFS_cdc_data_in_ep, (const uint8 *)txData, 2u);
351     }
352
353
354     /*******************************************************************************
355     * Function Name: USBFS_GetCount
356     ********************************************************************************
357     *
358     * Summary:
359     *  This function returns the number of bytes that were received from the PC.
360     *
361     * Parameters:
362     *  None.
363     *
364     * Return:
365     *  Returns the number of received bytes.
366     *
367     * Global variables:
368     *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.
369     *
370     *******************************************************************************/
371     uint16 USBFS_GetCount(void) 
372     {
373         uint16 bytesCount = 0u;
374
375         if (USBFS_EP[USBFS_cdc_data_out_ep].apiEpState == USBFS_OUT_BUFFER_FULL)
376         {
377             bytesCount = USBFS_GetEPCount(USBFS_cdc_data_out_ep);
378         }
379
380         return(bytesCount);
381     }
382
383
384     /*******************************************************************************
385     * Function Name: USBFS_DataIsReady
386     ********************************************************************************
387     *
388     * Summary:
389     *  Returns a nonzero value if the component received data or received
390     *  zero-length packet. The GetAll() or GetData() API should be called to read
391     *  data from the buffer and re-init OUT endpoint even when zero-length packet
392     *  received.
393     *
394     * Parameters:
395     *  None.
396     *
397     * Return:
398     *  If the OUT packet received this function returns a nonzero value.
399     *  Otherwise zero is returned.
400     *
401     * Global variables:
402     *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.
403     *
404     *******************************************************************************/
405     uint8 USBFS_DataIsReady(void) 
406     {
407         return(USBFS_EP[USBFS_cdc_data_out_ep].apiEpState);
408     }
409
410
411     /*******************************************************************************
412     * Function Name: USBFS_CDCIsReady
413     ********************************************************************************
414     *
415     * Summary:
416     *  Returns a nonzero value if the component is ready to send more data to the
417     *  PC. Otherwise returns zero. Should be called before sending new data to
418     *  ensure the previous data has finished sending.This function returns the
419     *  number of bytes that were received from the PC.
420     *
421     * Parameters:
422     *  None.
423     *
424     * Return:
425     *  If the buffer can accept new data then this function returns a nonzero value.
426     *  Otherwise zero is returned.
427     *
428     * Global variables:
429     *   USBFS_cdc_data_in_ep: CDC IN endpoint number used.
430     *
431     *******************************************************************************/
432     uint8 USBFS_CDCIsReady(void) 
433     {
434         return(USBFS_EP[USBFS_cdc_data_in_ep].apiEpState);
435     }
436
437
438     /*******************************************************************************
439     * Function Name: USBFS_GetData
440     ********************************************************************************
441     *
442     * Summary:
443     *  Gets a specified number of bytes from the input buffer and places it in a
444     *  data array specified by the passed pointer.
445     *  USBFS_DataIsReady() API should be called before, to be sure
446     *  that data is received from the Host.
447     *
448     * Parameters:
449     *  pData: Pointer to the data array where data will be placed.
450     *  Length: Number of bytes to read into the data array from the RX buffer.
451     *          Maximum length is limited by the the number of received bytes.
452     *
453     * Return:
454     *  Number of bytes received.
455     *
456     * Global variables:
457     *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.
458     *
459     * Reentrant:
460     *  No.
461     *
462     *******************************************************************************/
463     uint16 USBFS_GetData(uint8* pData, uint16 length) 
464     {
465         return(USBFS_ReadOutEP(USBFS_cdc_data_out_ep, pData, length));
466     }
467
468
469     /*******************************************************************************
470     * Function Name: USBFS_GetAll
471     ********************************************************************************
472     *
473     * Summary:
474     *  Gets all bytes of received data from the input buffer and places it into a
475     *  specified data array. USBFS_DataIsReady() API should be called
476     *  before, to be sure that data is received from the Host.
477     *
478     * Parameters:
479     *  pData: Pointer to the data array where data will be placed.
480     *
481     * Return:
482     *  Number of bytes received.
483     *
484     * Global variables:
485     *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.
486     *   USBFS_EP[].bufferSize: EP max packet size is used as a length
487     *     to read all data from the EP buffer.
488     *
489     * Reentrant:
490     *  No.
491     *
492     *******************************************************************************/
493     uint16 USBFS_GetAll(uint8* pData) 
494     {
495         return (USBFS_ReadOutEP(USBFS_cdc_data_out_ep, pData,
496                                            USBFS_EP[USBFS_cdc_data_out_ep].bufferSize));
497     }
498
499
500     /*******************************************************************************
501     * Function Name: USBFS_GetChar
502     ********************************************************************************
503     *
504     * Summary:
505     *  Reads one byte of received data from the buffer.
506     *
507     * Parameters:
508     *  None.
509     *
510     * Return:
511     *  Received one character.
512     *
513     * Global variables:
514     *   USBFS_cdc_data_out_ep: CDC OUT endpoint number used.
515     *
516     * Reentrant:
517     *  No.
518     *
519     *******************************************************************************/
520     uint8 USBFS_GetChar(void) 
521     {
522          uint8 rxData;
523
524         (void) USBFS_ReadOutEP(USBFS_cdc_data_out_ep, &rxData, 1u);
525
526         return(rxData);
527     }
528
529     /*******************************************************************************
530     * Function Name: USBFS_IsLineChanged
531     ********************************************************************************
532     *
533     * Summary:
534     *  This function returns clear on read status of the line.
535     *
536     * Parameters:
537     *  None.
538     *
539     * Return:
540     *  If SET_LINE_CODING or CDC_SET_CONTROL_LINE_STATE request received then not
541     *  zero value returned. Otherwise zero is returned.
542     *
543     * Global variables:
544     *  USBFS_transferState - it is checked to be sure then OUT data
545     *    phase has been complete, and data written to the lineCoding or Control
546     *    Bitmap buffer.
547     *  USBFS_lineChanged: used as a flag to be aware that Host has been
548     *    sent request for changing Line Coding or Control Bitmap.
549     *
550     *******************************************************************************/
551     uint8 USBFS_IsLineChanged(void) 
552     {
553         uint8 state = 0u;
554
555         /* transferState is checked to be sure then OUT data phase has been complete */
556         if(USBFS_transferState == USBFS_TRANS_STATE_IDLE)
557         {
558             if(USBFS_lineChanged != 0u)
559             {
560                 state = USBFS_lineChanged;
561                 USBFS_lineChanged = 0u;
562             }
563         }
564
565         return(state);
566     }
567
568
569     /*******************************************************************************
570     * Function Name: USBFS_GetDTERate
571     ********************************************************************************
572     *
573     * Summary:
574     *  Returns the data terminal rate set for this port in bits per second.
575     *
576     * Parameters:
577     *  None.
578     *
579     * Return:
580     *  Returns a uint32 value of the data rate in bits per second.
581     *
582     * Global variables:
583     *  USBFS_lineCoding: First four bytes converted to uint32
584     *    depend on compiler, and returned as a data rate.
585     *
586     *******************************************************************************/
587     uint32 USBFS_GetDTERate(void) 
588     {
589         uint32 rate;
590
591         rate = USBFS_lineCoding[USBFS_LINE_CODING_RATE + 3u];
592         rate = (rate << 8u) | USBFS_lineCoding[USBFS_LINE_CODING_RATE + 2u];
593         rate = (rate << 8u) | USBFS_lineCoding[USBFS_LINE_CODING_RATE + 1u];
594         rate = (rate << 8u) | USBFS_lineCoding[USBFS_LINE_CODING_RATE];
595
596         return(rate);
597     }
598
599
600     /*******************************************************************************
601     * Function Name: USBFS_GetCharFormat
602     ********************************************************************************
603     *
604     * Summary:
605     *  Returns the number of stop bits.
606     *
607     * Parameters:
608     *  None.
609     *
610     * Return:
611     *  Returns the number of stop bits.
612     *
613     * Global variables:
614     *  USBFS_lineCoding: used to get a parameter.
615     *
616     *******************************************************************************/
617     uint8 USBFS_GetCharFormat(void) 
618     {
619         return(USBFS_lineCoding[USBFS_LINE_CODING_STOP_BITS]);
620     }
621
622
623     /*******************************************************************************
624     * Function Name: USBFS_GetParityType
625     ********************************************************************************
626     *
627     * Summary:
628     *  Returns the parity type for the CDC port.
629     *
630     * Parameters:
631     *  None.
632     *
633     * Return:
634     *  Returns the parity type.
635     *
636     * Global variables:
637     *  USBFS_lineCoding: used to get a parameter.
638     *
639     *******************************************************************************/
640     uint8 USBFS_GetParityType(void) 
641     {
642         return(USBFS_lineCoding[USBFS_LINE_CODING_PARITY]);
643     }
644
645
646     /*******************************************************************************
647     * Function Name: USBFS_GetDataBits
648     ********************************************************************************
649     *
650     * Summary:
651     *  Returns the number of data bits for the CDC port.
652     *
653     * Parameters:
654     *  None.
655     *
656     * Return:
657     *  Returns the number of data bits.
658     *  The number of data bits can be 5, 6, 7, 8 or 16.
659     *
660     * Global variables:
661     *  USBFS_lineCoding: used to get a parameter.
662     *
663     *******************************************************************************/
664     uint8 USBFS_GetDataBits(void) 
665     {
666         return(USBFS_lineCoding[USBFS_LINE_CODING_DATA_BITS]);
667     }
668
669
670     /*******************************************************************************
671     * Function Name: USBFS_GetLineControl
672     ********************************************************************************
673     *
674     * Summary:
675     *  Returns Line control bitmap.
676     *
677     * Parameters:
678     *  None.
679     *
680     * Return:
681     *  Returns Line control bitmap.
682     *
683     * Global variables:
684     *  USBFS_lineControlBitmap: used to get a parameter.
685     *
686     *******************************************************************************/
687     uint16 USBFS_GetLineControl(void) 
688     {
689         return(USBFS_lineControlBitmap);
690     }
691
692 #endif  /* End USBFS_ENABLE_CDC_CLASS_API*/
693
694
695 /*******************************************************************************
696 * Additional user functions supporting CDC Requests
697 ********************************************************************************/
698
699 /* `#START CDC_FUNCTIONS` Place any additional functions here */
700
701 /* `#END` */
702
703 #endif  /* End USBFS_ENABLE_CDC_CLASS*/
704
705
706 /* [] END OF FILE */