Merge PCB updates
[SCSI2SD.git] / software / SCSI2SD / v4 / SCSI2SD.cydsn / Generated_Source / PSoC5 / SDCard.c
1 /*******************************************************************************
2 * File Name: SDCard.c
3 * Version 2.40
4 *
5 * Description:
6 *  This file provides all API functionality of the SPI Master component.
7 *
8 * Note:
9 *  None.
10 *
11 ********************************************************************************
12 * Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.
13 * You may use this file only in accordance with the license, terms, conditions,
14 * disclaimers, and limitations in the end user license agreement accompanying
15 * the software package with which this file was provided.
16 *******************************************************************************/
17
18 #include "SDCard_PVT.h"
19
20 #if(SDCard_TX_SOFTWARE_BUF_ENABLED)
21     volatile uint8 SDCard_txBuffer[SDCard_TX_BUFFER_SIZE] = {0u};
22     volatile uint8 SDCard_txBufferFull;
23     volatile uint8 SDCard_txBufferRead;
24     volatile uint8 SDCard_txBufferWrite;
25 #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED) */
26
27 #if(SDCard_RX_SOFTWARE_BUF_ENABLED)
28     volatile uint8 SDCard_rxBuffer[SDCard_RX_BUFFER_SIZE] = {0u};
29     volatile uint8 SDCard_rxBufferFull;
30     volatile uint8 SDCard_rxBufferRead;
31     volatile uint8 SDCard_rxBufferWrite;
32 #endif /* (SDCard_RX_SOFTWARE_BUF_ENABLED) */
33
34 uint8 SDCard_initVar = 0u;
35
36 volatile uint8 SDCard_swStatusTx;
37 volatile uint8 SDCard_swStatusRx;
38
39
40 /*******************************************************************************
41 * Function Name: SDCard_Init
42 ********************************************************************************
43 *
44 * Summary:
45 *  Inits/Restores default SPIM configuration provided with customizer.
46 *
47 * Parameters:
48 *  None.
49 *
50 * Return:
51 *  None.
52 *
53 * Side Effects:
54 *  When this function is called it initializes all of the necessary parameters
55 *  for execution. i.e. setting the initial interrupt mask, configuring the
56 *  interrupt service routine, configuring the bit-counter parameters and
57 *  clearing the FIFO and Status Register.
58 *
59 * Reentrant:
60 *  No.
61 *
62 *******************************************************************************/
63 void SDCard_Init(void) 
64 {
65     /* Initialize the Bit counter */
66     SDCard_COUNTER_PERIOD_REG = SDCard_BITCTR_INIT;
67
68     /* Init TX ISR  */
69     #if(0u != SDCard_INTERNAL_TX_INT_ENABLED)
70         CyIntDisable         (SDCard_TX_ISR_NUMBER);
71         CyIntSetPriority     (SDCard_TX_ISR_NUMBER,  SDCard_TX_ISR_PRIORITY);
72         (void) CyIntSetVector(SDCard_TX_ISR_NUMBER, &SDCard_TX_ISR);
73     #endif /* (0u != SDCard_INTERNAL_TX_INT_ENABLED) */
74
75     /* Init RX ISR  */
76     #if(0u != SDCard_INTERNAL_RX_INT_ENABLED)
77         CyIntDisable         (SDCard_RX_ISR_NUMBER);
78         CyIntSetPriority     (SDCard_RX_ISR_NUMBER,  SDCard_RX_ISR_PRIORITY);
79         (void) CyIntSetVector(SDCard_RX_ISR_NUMBER, &SDCard_RX_ISR);
80     #endif /* (0u != SDCard_INTERNAL_RX_INT_ENABLED) */
81
82     /* Clear any stray data from the RX and TX FIFO */
83     SDCard_ClearFIFO();
84
85     #if(SDCard_RX_SOFTWARE_BUF_ENABLED)
86         SDCard_rxBufferFull  = 0u;
87         SDCard_rxBufferRead  = 0u;
88         SDCard_rxBufferWrite = 0u;
89     #endif /* (SDCard_RX_SOFTWARE_BUF_ENABLED) */
90
91     #if(SDCard_TX_SOFTWARE_BUF_ENABLED)
92         SDCard_txBufferFull  = 0u;
93         SDCard_txBufferRead  = 0u;
94         SDCard_txBufferWrite = 0u;
95     #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED) */
96
97     (void) SDCard_ReadTxStatus(); /* Clear Tx status and swStatusTx */
98     (void) SDCard_ReadRxStatus(); /* Clear Rx status and swStatusRx */
99
100     /* Configure TX and RX interrupt mask */
101     SDCard_TX_STATUS_MASK_REG = SDCard_TX_INIT_INTERRUPTS_MASK;
102     SDCard_RX_STATUS_MASK_REG = SDCard_RX_INIT_INTERRUPTS_MASK;
103 }
104
105
106 /*******************************************************************************
107 * Function Name: SDCard_Enable
108 ********************************************************************************
109 *
110 * Summary:
111 *  Enable SPIM component.
112 *
113 * Parameters:
114 *  None.
115 *
116 * Return:
117 *  None.
118 *
119 *******************************************************************************/
120 void SDCard_Enable(void) 
121 {
122     uint8 enableInterrupts;
123
124     enableInterrupts = CyEnterCriticalSection();
125     SDCard_COUNTER_CONTROL_REG |= SDCard_CNTR_ENABLE;
126     SDCard_TX_STATUS_ACTL_REG  |= SDCard_INT_ENABLE;
127     SDCard_RX_STATUS_ACTL_REG  |= SDCard_INT_ENABLE;
128     CyExitCriticalSection(enableInterrupts);
129
130     #if(0u != SDCard_INTERNAL_CLOCK)
131         SDCard_IntClock_Enable();
132     #endif /* (0u != SDCard_INTERNAL_CLOCK) */
133
134     SDCard_EnableTxInt();
135     SDCard_EnableRxInt();
136 }
137
138
139 /*******************************************************************************
140 * Function Name: SDCard_Start
141 ********************************************************************************
142 *
143 * Summary:
144 *  Initialize and Enable the SPI Master component.
145 *
146 * Parameters:
147 *  None.
148 *
149 * Return:
150 *  None.
151 *
152 * Global variables:
153 *  SDCard_initVar - used to check initial configuration, modified on
154 *  first function call.
155 *
156 * Theory:
157 *  Enable the clock input to enable operation.
158 *
159 * Reentrant:
160 *  No.
161 *
162 *******************************************************************************/
163 void SDCard_Start(void) 
164 {
165     if(0u == SDCard_initVar)
166     {
167         SDCard_Init();
168         SDCard_initVar = 1u;
169     }
170
171     SDCard_Enable();
172 }
173
174
175 /*******************************************************************************
176 * Function Name: SDCard_Stop
177 ********************************************************************************
178 *
179 * Summary:
180 *  Disable the SPI Master component.
181 *
182 * Parameters:
183 *  None.
184 *
185 * Return:
186 *  None.
187 *
188 * Theory:
189 *  Disable the clock input to enable operation.
190 *
191 *******************************************************************************/
192 void SDCard_Stop(void) 
193 {
194     uint8 enableInterrupts;
195
196     enableInterrupts = CyEnterCriticalSection();
197     SDCard_TX_STATUS_ACTL_REG &= ((uint8) ~SDCard_INT_ENABLE);
198     SDCard_RX_STATUS_ACTL_REG &= ((uint8) ~SDCard_INT_ENABLE);
199     CyExitCriticalSection(enableInterrupts);
200
201     #if(0u != SDCard_INTERNAL_CLOCK)
202         SDCard_IntClock_Disable();
203     #endif /* (0u != SDCard_INTERNAL_CLOCK) */
204
205     SDCard_DisableTxInt();
206     SDCard_DisableRxInt();
207 }
208
209
210 /*******************************************************************************
211 * Function Name: SDCard_EnableTxInt
212 ********************************************************************************
213 *
214 * Summary:
215 *  Enable internal Tx interrupt generation.
216 *
217 * Parameters:
218 *  None.
219 *
220 * Return:
221 *  None.
222 *
223 * Theory:
224 *  Enable the internal Tx interrupt output -or- the interrupt component itself.
225 *
226 *******************************************************************************/
227 void SDCard_EnableTxInt(void) 
228 {
229     #if(0u != SDCard_INTERNAL_TX_INT_ENABLED)
230         CyIntEnable(SDCard_TX_ISR_NUMBER);
231     #endif /* (0u != SDCard_INTERNAL_TX_INT_ENABLED) */
232 }
233
234
235 /*******************************************************************************
236 * Function Name: SDCard_EnableRxInt
237 ********************************************************************************
238 *
239 * Summary:
240 *  Enable internal Rx interrupt generation.
241 *
242 * Parameters:
243 *  None.
244 *
245 * Return:
246 *  None.
247 *
248 * Theory:
249 *  Enable the internal Rx interrupt output -or- the interrupt component itself.
250 *
251 *******************************************************************************/
252 void SDCard_EnableRxInt(void) 
253 {
254     #if(0u != SDCard_INTERNAL_RX_INT_ENABLED)
255         CyIntEnable(SDCard_RX_ISR_NUMBER);
256     #endif /* (0u != SDCard_INTERNAL_RX_INT_ENABLED) */
257 }
258
259
260 /*******************************************************************************
261 * Function Name: SDCard_DisableTxInt
262 ********************************************************************************
263 *
264 * Summary:
265 *  Disable internal Tx interrupt generation.
266 *
267 * Parameters:
268 *  None.
269 *
270 * Return:
271 *  None.
272 *
273 * Theory:
274 *  Disable the internal Tx interrupt output -or- the interrupt component itself.
275 *
276 *******************************************************************************/
277 void SDCard_DisableTxInt(void) 
278 {
279     #if(0u != SDCard_INTERNAL_TX_INT_ENABLED)
280         CyIntDisable(SDCard_TX_ISR_NUMBER);
281     #endif /* (0u != SDCard_INTERNAL_TX_INT_ENABLED) */
282 }
283
284
285 /*******************************************************************************
286 * Function Name: SDCard_DisableRxInt
287 ********************************************************************************
288 *
289 * Summary:
290 *  Disable internal Rx interrupt generation.
291 *
292 * Parameters:
293 *  None.
294 *
295 * Return:
296 *  None.
297 *
298 * Theory:
299 *  Disable the internal Rx interrupt output -or- the interrupt component itself.
300 *
301 *******************************************************************************/
302 void SDCard_DisableRxInt(void) 
303 {
304     #if(0u != SDCard_INTERNAL_RX_INT_ENABLED)
305         CyIntDisable(SDCard_RX_ISR_NUMBER);
306     #endif /* (0u != SDCard_INTERNAL_RX_INT_ENABLED) */
307 }
308
309
310 /*******************************************************************************
311 * Function Name: SDCard_SetTxInterruptMode
312 ********************************************************************************
313 *
314 * Summary:
315 *  Configure which status bits trigger an interrupt event.
316 *
317 * Parameters:
318 *  intSrc: An or'd combination of the desired status bit masks (defined in the
319 *  header file).
320 *
321 * Return:
322 *  None.
323 *
324 * Theory:
325 *  Enables the output of specific status bits to the interrupt controller.
326 *
327 *******************************************************************************/
328 void SDCard_SetTxInterruptMode(uint8 intSrc) 
329 {
330     SDCard_TX_STATUS_MASK_REG = intSrc;
331 }
332
333
334 /*******************************************************************************
335 * Function Name: SDCard_SetRxInterruptMode
336 ********************************************************************************
337 *
338 * Summary:
339 *  Configure which status bits trigger an interrupt event.
340 *
341 * Parameters:
342 *  intSrc: An or'd combination of the desired status bit masks (defined in the
343 *  header file).
344 *
345 * Return:
346 *  None.
347 *
348 * Theory:
349 *  Enables the output of specific status bits to the interrupt controller.
350 *
351 *******************************************************************************/
352 void SDCard_SetRxInterruptMode(uint8 intSrc) 
353 {
354     SDCard_RX_STATUS_MASK_REG  = intSrc;
355 }
356
357
358 /*******************************************************************************
359 * Function Name: SDCard_ReadTxStatus
360 ********************************************************************************
361 *
362 * Summary:
363 *  Read the Tx status register for the component.
364 *
365 * Parameters:
366 *  None.
367 *
368 * Return:
369 *  Contents of the Tx status register.
370 *
371 * Global variables:
372 *  SDCard_swStatusTx - used to store in software status register,
373 *  modified every function call - resets to zero.
374 *
375 * Theory:
376 *  Allows the user and the API to read the Tx status register for error
377 *  detection and flow control.
378 *
379 * Side Effects:
380 *  Clear Tx status register of the component.
381 *
382 * Reentrant:
383 *  No.
384 *
385 *******************************************************************************/
386 uint8 SDCard_ReadTxStatus(void) 
387 {
388     uint8 tmpStatus;
389
390     #if(SDCard_TX_SOFTWARE_BUF_ENABLED)
391         /* Disable TX interrupt to protect global veriables */
392         SDCard_DisableTxInt();
393
394         tmpStatus = SDCard_GET_STATUS_TX(SDCard_swStatusTx);
395         SDCard_swStatusTx = 0u;
396
397         SDCard_EnableTxInt();
398
399     #else
400
401         tmpStatus = SDCard_TX_STATUS_REG;
402
403     #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED) */
404
405     return(tmpStatus);
406 }
407
408
409 /*******************************************************************************
410 * Function Name: SDCard_ReadRxStatus
411 ********************************************************************************
412 *
413 * Summary:
414 *  Read the Rx status register for the component.
415 *
416 * Parameters:
417 *  None.
418 *
419 * Return:
420 *  Contents of the Rx status register.
421 *
422 * Global variables:
423 *  SDCard_swStatusRx - used to store in software Rx status register,
424 *  modified every function call - resets to zero.
425 *
426 * Theory:
427 *  Allows the user and the API to read the Rx status register for error
428 *  detection and flow control.
429 *
430 * Side Effects:
431 *  Clear Rx status register of the component.
432 *
433 * Reentrant:
434 *  No.
435 *
436 *******************************************************************************/
437 uint8 SDCard_ReadRxStatus(void) 
438 {
439     uint8 tmpStatus;
440
441     #if(SDCard_RX_SOFTWARE_BUF_ENABLED)
442         /* Disable RX interrupt to protect global veriables */
443         SDCard_DisableRxInt();
444
445         tmpStatus = SDCard_GET_STATUS_RX(SDCard_swStatusRx);
446         SDCard_swStatusRx = 0u;
447
448         SDCard_EnableRxInt();
449
450     #else
451
452         tmpStatus = SDCard_RX_STATUS_REG;
453
454     #endif /* (SDCard_RX_SOFTWARE_BUF_ENABLED) */
455
456     return(tmpStatus);
457 }
458
459
460 /*******************************************************************************
461 * Function Name: SDCard_WriteTxData
462 ********************************************************************************
463 *
464 * Summary:
465 *  Write a byte of data to be sent across the SPI.
466 *
467 * Parameters:
468 *  txDataByte: The data value to send across the SPI.
469 *
470 * Return:
471 *  None.
472 *
473 * Global variables:
474 *  SDCard_txBufferWrite - used for the account of the bytes which
475 *  have been written down in the TX software buffer, modified every function
476 *  call if TX Software Buffer is used.
477 *  SDCard_txBufferRead - used for the account of the bytes which
478 *  have been read from the TX software buffer.
479 *  SDCard_txBuffer[SDCard_TX_BUFFER_SIZE] - used to store
480 *  data to sending, modified every function call if TX Software Buffer is used.
481 *
482 * Theory:
483 *  Allows the user to transmit any byte of data in a single transfer.
484 *
485 * Side Effects:
486 *  If this function is called again before the previous byte is finished then
487 *  the next byte will be appended to the transfer with no time between
488 *  the byte transfers. Clear Tx status register of the component.
489 *
490 * Reentrant:
491 *  No.
492 *
493 *******************************************************************************/
494 void SDCard_WriteTxData(uint8 txData) 
495 {
496     #if(SDCard_TX_SOFTWARE_BUF_ENABLED)
497
498         uint8 tempStatus;
499         uint8 tmpTxBufferRead;
500
501         /* Block if TX buffer is FULL: don't overwrite */
502         do
503         {
504             tmpTxBufferRead = SDCard_txBufferRead;
505             if(0u == tmpTxBufferRead)
506             {
507                 tmpTxBufferRead = (SDCard_TX_BUFFER_SIZE - 1u);
508             }
509             else
510             {
511                 tmpTxBufferRead--;
512             }
513
514         }while(tmpTxBufferRead == SDCard_txBufferWrite);
515
516         /* Disable TX interrupt to protect global veriables */
517         SDCard_DisableTxInt();
518
519         tempStatus = SDCard_GET_STATUS_TX(SDCard_swStatusTx);
520         SDCard_swStatusTx = tempStatus;
521
522
523         if((SDCard_txBufferRead == SDCard_txBufferWrite) &&
524            (0u != (SDCard_swStatusTx & SDCard_STS_TX_FIFO_NOT_FULL)))
525         {
526             /* Add directly to the TX FIFO */
527             CY_SET_REG8(SDCard_TXDATA_PTR, txData);
528         }
529         else
530         {
531             /* Add to the TX software buffer */
532             SDCard_txBufferWrite++;
533             if(SDCard_txBufferWrite >= SDCard_TX_BUFFER_SIZE)
534             {
535                 SDCard_txBufferWrite = 0u;
536             }
537
538             if(SDCard_txBufferWrite == SDCard_txBufferRead)
539             {
540                 SDCard_txBufferRead++;
541                 if(SDCard_txBufferRead >= SDCard_TX_BUFFER_SIZE)
542                 {
543                     SDCard_txBufferRead = 0u;
544                 }
545                 SDCard_txBufferFull = 1u;
546             }
547
548             SDCard_txBuffer[SDCard_txBufferWrite] = txData;
549
550             SDCard_TX_STATUS_MASK_REG |= SDCard_STS_TX_FIFO_NOT_FULL;
551         }
552
553         SDCard_EnableTxInt();
554
555     #else
556
557         while(0u == (SDCard_TX_STATUS_REG & SDCard_STS_TX_FIFO_NOT_FULL))
558         {
559             ; /* Wait for room in FIFO */
560         }
561
562         /* Put byte in TX FIFO */
563         CY_SET_REG8(SDCard_TXDATA_PTR, txData);
564
565     #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED) */
566 }
567
568
569 /*******************************************************************************
570 * Function Name: SDCard_ReadRxData
571 ********************************************************************************
572 *
573 * Summary:
574 *  Read the next byte of data received across the SPI.
575 *
576 * Parameters:
577 *  None.
578 *
579 * Return:
580 *  The next byte of data read from the FIFO.
581 *
582 * Global variables:
583 *  SDCard_rxBufferWrite - used for the account of the bytes which
584 *  have been written down in the RX software buffer.
585 *  SDCard_rxBufferRead - used for the account of the bytes which
586 *  have been read from the RX software buffer, modified every function
587 *  call if RX Software Buffer is used.
588 *  SDCard_rxBuffer[SDCard_RX_BUFFER_SIZE] - used to store
589 *  received data.
590 *
591 * Theory:
592 *  Allows the user to read a byte of data received.
593 *
594 * Side Effects:
595 *  Will return invalid data if the FIFO is empty. The user should Call
596 *  GetRxBufferSize() and if it returns a non-zero value then it is safe to call
597 *  ReadByte() function.
598 *
599 * Reentrant:
600 *  No.
601 *
602 *******************************************************************************/
603 uint8 SDCard_ReadRxData(void) 
604 {
605     uint8 rxData;
606
607     #if(SDCard_RX_SOFTWARE_BUF_ENABLED)
608
609         /* Disable RX interrupt to protect global veriables */
610         SDCard_DisableRxInt();
611
612         if(SDCard_rxBufferRead != SDCard_rxBufferWrite)
613         {
614             if(0u == SDCard_rxBufferFull)
615             {
616                 SDCard_rxBufferRead++;
617                 if(SDCard_rxBufferRead >= SDCard_RX_BUFFER_SIZE)
618                 {
619                     SDCard_rxBufferRead = 0u;
620                 }
621             }
622             else
623             {
624                 SDCard_rxBufferFull = 0u;
625             }
626         }
627
628         rxData = SDCard_rxBuffer[SDCard_rxBufferRead];
629
630         SDCard_EnableRxInt();
631
632     #else
633
634         rxData = CY_GET_REG8(SDCard_RXDATA_PTR);
635
636     #endif /* (SDCard_RX_SOFTWARE_BUF_ENABLED) */
637
638     return(rxData);
639 }
640
641
642 /*******************************************************************************
643 * Function Name: SDCard_GetRxBufferSize
644 ********************************************************************************
645 *
646 * Summary:
647 *  Returns the number of bytes/words of data currently held in the RX buffer.
648 *  If RX Software Buffer not used then function return 0 if FIFO empty or 1 if
649 *  FIFO not empty. In another case function return size of RX Software Buffer.
650 *
651 * Parameters:
652 *  None.
653 *
654 * Return:
655 *  Integer count of the number of bytes/words in the RX buffer.
656 *
657 * Global variables:
658 *  SDCard_rxBufferWrite - used for the account of the bytes which
659 *  have been written down in the RX software buffer.
660 *  SDCard_rxBufferRead - used for the account of the bytes which
661 *  have been read from the RX software buffer.
662 *
663 * Side Effects:
664 *  Clear status register of the component.
665 *
666 *******************************************************************************/
667 uint8 SDCard_GetRxBufferSize(void) 
668 {
669     uint8 size;
670
671     #if(SDCard_RX_SOFTWARE_BUF_ENABLED)
672
673         /* Disable RX interrupt to protect global veriables */
674         SDCard_DisableRxInt();
675
676         if(SDCard_rxBufferRead == SDCard_rxBufferWrite)
677         {
678             size = 0u;
679         }
680         else if(SDCard_rxBufferRead < SDCard_rxBufferWrite)
681         {
682             size = (SDCard_rxBufferWrite - SDCard_rxBufferRead);
683         }
684         else
685         {
686             size = (SDCard_RX_BUFFER_SIZE - SDCard_rxBufferRead) + SDCard_rxBufferWrite;
687         }
688
689         SDCard_EnableRxInt();
690
691     #else
692
693         /* We can only know if there is data in the RX FIFO */
694         size = (0u != (SDCard_RX_STATUS_REG & SDCard_STS_RX_FIFO_NOT_EMPTY)) ? 1u : 0u;
695
696     #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED) */
697
698     return(size);
699 }
700
701
702 /*******************************************************************************
703 * Function Name: SDCard_GetTxBufferSize
704 ********************************************************************************
705 *
706 * Summary:
707 *  Returns the number of bytes/words of data currently held in the TX buffer.
708 *  If TX Software Buffer not used then function return 0 - if FIFO empty, 1 - if
709 *  FIFO not full, 4 - if FIFO full. In another case function return size of TX
710 *  Software Buffer.
711 *
712 * Parameters:
713 *  None.
714 *
715 * Return:
716 *  Integer count of the number of bytes/words in the TX buffer.
717 *
718 * Global variables:
719 *  SDCard_txBufferWrite - used for the account of the bytes which
720 *  have been written down in the TX software buffer.
721 *  SDCard_txBufferRead - used for the account of the bytes which
722 *  have been read from the TX software buffer.
723 *
724 * Side Effects:
725 *  Clear status register of the component.
726 *
727 *******************************************************************************/
728 uint8  SDCard_GetTxBufferSize(void) 
729 {
730     uint8 size;
731
732     #if(SDCard_TX_SOFTWARE_BUF_ENABLED)
733         /* Disable TX interrupt to protect global veriables */
734         SDCard_DisableTxInt();
735
736         if(SDCard_txBufferRead == SDCard_txBufferWrite)
737         {
738             size = 0u;
739         }
740         else if(SDCard_txBufferRead < SDCard_txBufferWrite)
741         {
742             size = (SDCard_txBufferWrite - SDCard_txBufferRead);
743         }
744         else
745         {
746             size = (SDCard_TX_BUFFER_SIZE - SDCard_txBufferRead) + SDCard_txBufferWrite;
747         }
748
749         SDCard_EnableTxInt();
750
751     #else
752
753         size = SDCard_TX_STATUS_REG;
754
755         if(0u != (size & SDCard_STS_TX_FIFO_EMPTY))
756         {
757             size = 0u;
758         }
759         else if(0u != (size & SDCard_STS_TX_FIFO_NOT_FULL))
760         {
761             size = 1u;
762         }
763         else
764         {
765             size = SDCard_FIFO_SIZE;
766         }
767
768     #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED) */
769
770     return(size);
771 }
772
773
774 /*******************************************************************************
775 * Function Name: SDCard_ClearRxBuffer
776 ********************************************************************************
777 *
778 * Summary:
779 *  Clear the RX RAM buffer by setting the read and write pointers both to zero.
780 *
781 * Parameters:
782 *  None.
783 *
784 * Return:
785 *  None.
786 *
787 * Global variables:
788 *  SDCard_rxBufferWrite - used for the account of the bytes which
789 *  have been written down in the RX software buffer, modified every function
790 *  call - resets to zero.
791 *  SDCard_rxBufferRead - used for the account of the bytes which
792 *  have been read from the RX software buffer, modified every function call -
793 *  resets to zero.
794 *
795 * Theory:
796 *  Setting the pointers to zero makes the system believe there is no data to
797 *  read and writing will resume at address 0 overwriting any data that may have
798 *  remained in the RAM.
799 *
800 * Side Effects:
801 *  Any received data not read from the RAM buffer will be lost when overwritten.
802 *
803 * Reentrant:
804 *  No.
805 *
806 *******************************************************************************/
807 void SDCard_ClearRxBuffer(void) 
808 {
809     /* Clear Hardware RX FIFO */
810     while(0u !=(SDCard_RX_STATUS_REG & SDCard_STS_RX_FIFO_NOT_EMPTY))
811     {
812         (void) CY_GET_REG8(SDCard_RXDATA_PTR);
813     }
814
815     #if(SDCard_RX_SOFTWARE_BUF_ENABLED)
816         /* Disable RX interrupt to protect global veriables */
817         SDCard_DisableRxInt();
818
819         SDCard_rxBufferFull  = 0u;
820         SDCard_rxBufferRead  = 0u;
821         SDCard_rxBufferWrite = 0u;
822
823         SDCard_EnableRxInt();
824     #endif /* (SDCard_RX_SOFTWARE_BUF_ENABLED) */
825 }
826
827
828 /*******************************************************************************
829 * Function Name: SDCard_ClearTxBuffer
830 ********************************************************************************
831 *
832 * Summary:
833 *  Clear the TX RAM buffer by setting the read and write pointers both to zero.
834 *
835 * Parameters:
836 *  None.
837 *
838 * Return:
839 *  None.
840 *
841 * Global variables:
842 *  SDCard_txBufferWrite - used for the account of the bytes which
843 *  have been written down in the TX software buffer, modified every function
844 *  call - resets to zero.
845 *  SDCard_txBufferRead - used for the account of the bytes which
846 *  have been read from the TX software buffer, modified every function call -
847 *  resets to zero.
848 *
849 * Theory:
850 *  Setting the pointers to zero makes the system believe there is no data to
851 *  read and writing will resume at address 0 overwriting any data that may have
852 *  remained in the RAM.
853 *
854 * Side Effects:
855 *  Any data not yet transmitted from the RAM buffer will be lost when
856 *  overwritten.
857 *
858 * Reentrant:
859 *  No.
860 *
861 *******************************************************************************/
862 void SDCard_ClearTxBuffer(void) 
863 {
864     uint8 enableInterrupts;
865
866     enableInterrupts = CyEnterCriticalSection();
867     /* Clear TX FIFO */
868     SDCard_AUX_CONTROL_DP0_REG |= ((uint8)  SDCard_TX_FIFO_CLR);
869     SDCard_AUX_CONTROL_DP0_REG &= ((uint8) ~SDCard_TX_FIFO_CLR);
870
871     #if(SDCard_USE_SECOND_DATAPATH)
872         /* Clear TX FIFO for 2nd Datapath */
873         SDCard_AUX_CONTROL_DP1_REG |= ((uint8)  SDCard_TX_FIFO_CLR);
874         SDCard_AUX_CONTROL_DP1_REG &= ((uint8) ~SDCard_TX_FIFO_CLR);
875     #endif /* (SDCard_USE_SECOND_DATAPATH) */
876     CyExitCriticalSection(enableInterrupts);
877
878     #if(SDCard_TX_SOFTWARE_BUF_ENABLED)
879         /* Disable TX interrupt to protect global veriables */
880         SDCard_DisableTxInt();
881
882         SDCard_txBufferFull  = 0u;
883         SDCard_txBufferRead  = 0u;
884         SDCard_txBufferWrite = 0u;
885
886         /* Buffer is EMPTY: disable TX FIFO NOT FULL interrupt */
887         SDCard_TX_STATUS_MASK_REG &= ((uint8) ~SDCard_STS_TX_FIFO_NOT_FULL);
888
889         SDCard_EnableTxInt();
890     #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED) */
891 }
892
893
894 #if(0u != SDCard_BIDIRECTIONAL_MODE)
895     /*******************************************************************************
896     * Function Name: SDCard_TxEnable
897     ********************************************************************************
898     *
899     * Summary:
900     *  If the SPI master is configured to use a single bi-directional pin then this
901     *  will set the bi-directional pin to transmit.
902     *
903     * Parameters:
904     *  None.
905     *
906     * Return:
907     *  None.
908     *
909     *******************************************************************************/
910     void SDCard_TxEnable(void) 
911     {
912         SDCard_CONTROL_REG |= SDCard_CTRL_TX_SIGNAL_EN;
913     }
914
915
916     /*******************************************************************************
917     * Function Name: SDCard_TxDisable
918     ********************************************************************************
919     *
920     * Summary:
921     *  If the SPI master is configured to use a single bi-directional pin then this
922     *  will set the bi-directional pin to receive.
923     *
924     * Parameters:
925     *  None.
926     *
927     * Return:
928     *  None.
929     *
930     *******************************************************************************/
931     void SDCard_TxDisable(void) 
932     {
933         SDCard_CONTROL_REG &= ((uint8) ~SDCard_CTRL_TX_SIGNAL_EN);
934     }
935
936 #endif /* (0u != SDCard_BIDIRECTIONAL_MODE) */
937
938
939 /*******************************************************************************
940 * Function Name: SDCard_PutArray
941 ********************************************************************************
942 *
943 * Summary:
944 *  Write available data from ROM/RAM to the TX buffer while space is available
945 *  in the TX buffer. Keep trying until all data is passed to the TX buffer.
946 *
947 * Parameters:
948 *  *buffer: Pointer to the location in RAM containing the data to send
949 *  byteCount: The number of bytes to move to the transmit buffer.
950 *
951 * Return:
952 *  None.
953 *
954 * Side Effects:
955 *  Will stay in this routine until all data has been sent.  May get locked in
956 *  this loop if data is not being initiated by the master if there is not
957 *  enough room in the TX FIFO.
958 *
959 * Reentrant:
960 *  No.
961 *
962 *******************************************************************************/
963 void SDCard_PutArray(const uint8 buffer[], uint8 byteCount)
964                                                                           
965 {
966     uint8 bufIndex;
967
968     bufIndex = 0u;
969
970     while(byteCount > 0u)
971     {
972         SDCard_WriteTxData(buffer[bufIndex]);
973         bufIndex++;
974         byteCount--;
975     }
976 }
977
978
979 /*******************************************************************************
980 * Function Name: SDCard_ClearFIFO
981 ********************************************************************************
982 *
983 * Summary:
984 *  Clear the RX and TX FIFO's of all data for a fresh start.
985 *
986 * Parameters:
987 *  None.
988 *
989 * Return:
990 *  None.
991 *
992 * Side Effects:
993 *  Clear status register of the component.
994 *
995 *******************************************************************************/
996 void SDCard_ClearFIFO(void) 
997 {
998     uint8 enableInterrupts;
999
1000     /* Clear Hardware RX FIFO */
1001     while(0u !=(SDCard_RX_STATUS_REG & SDCard_STS_RX_FIFO_NOT_EMPTY))
1002     {
1003         (void) CY_GET_REG8(SDCard_RXDATA_PTR);
1004     }
1005
1006     enableInterrupts = CyEnterCriticalSection();
1007     /* Clear TX FIFO */
1008     SDCard_AUX_CONTROL_DP0_REG |= ((uint8)  SDCard_TX_FIFO_CLR);
1009     SDCard_AUX_CONTROL_DP0_REG &= ((uint8) ~SDCard_TX_FIFO_CLR);
1010
1011     #if(SDCard_USE_SECOND_DATAPATH)
1012         /* Clear TX FIFO for 2nd Datapath */
1013         SDCard_AUX_CONTROL_DP1_REG |= ((uint8)  SDCard_TX_FIFO_CLR);
1014         SDCard_AUX_CONTROL_DP1_REG &= ((uint8) ~SDCard_TX_FIFO_CLR);
1015     #endif /* (SDCard_USE_SECOND_DATAPATH) */
1016     CyExitCriticalSection(enableInterrupts);
1017 }
1018
1019
1020 /* Following functions are for version Compatibility, they are obsolete.
1021 *  Please do not use it in new projects.
1022 */
1023
1024
1025 /*******************************************************************************
1026 * Function Name: SDCard_EnableInt
1027 ********************************************************************************
1028 *
1029 * Summary:
1030 *  Enable internal interrupt generation.
1031 *
1032 * Parameters:
1033 *  None.
1034 *
1035 * Return:
1036 *  None.
1037 *
1038 * Theory:
1039 *  Enable the internal interrupt output -or- the interrupt component itself.
1040 *
1041 *******************************************************************************/
1042 void SDCard_EnableInt(void) 
1043 {
1044     SDCard_EnableRxInt();
1045     SDCard_EnableTxInt();
1046 }
1047
1048
1049 /*******************************************************************************
1050 * Function Name: SDCard_DisableInt
1051 ********************************************************************************
1052 *
1053 * Summary:
1054 *  Disable internal interrupt generation.
1055 *
1056 * Parameters:
1057 *  None.
1058 *
1059 * Return:
1060 *  None.
1061 *
1062 * Theory:
1063 *  Disable the internal interrupt output -or- the interrupt component itself.
1064 *
1065 *******************************************************************************/
1066 void SDCard_DisableInt(void) 
1067 {
1068     SDCard_DisableTxInt();
1069     SDCard_DisableRxInt();
1070 }
1071
1072
1073 /*******************************************************************************
1074 * Function Name: SDCard_SetInterruptMode
1075 ********************************************************************************
1076 *
1077 * Summary:
1078 *  Configure which status bits trigger an interrupt event.
1079 *
1080 * Parameters:
1081 *  intSrc: An or'd combination of the desired status bit masks (defined in the
1082 *  header file).
1083 *
1084 * Return:
1085 *  None.
1086 *
1087 * Theory:
1088 *  Enables the output of specific status bits to the interrupt controller.
1089 *
1090 *******************************************************************************/
1091 void SDCard_SetInterruptMode(uint8 intSrc) 
1092 {
1093     SDCard_TX_STATUS_MASK_REG  = (intSrc & ((uint8) ~SDCard_STS_SPI_IDLE));
1094     SDCard_RX_STATUS_MASK_REG  =  intSrc;
1095 }
1096
1097
1098 /*******************************************************************************
1099 * Function Name: SDCard_ReadStatus
1100 ********************************************************************************
1101 *
1102 * Summary:
1103 *  Read the status register for the component.
1104 *
1105 * Parameters:
1106 *  None.
1107 *
1108 * Return:
1109 *  Contents of the status register.
1110 *
1111 * Global variables:
1112 *  SDCard_swStatus - used to store in software status register,
1113 *  modified every function call - resets to zero.
1114 *
1115 * Theory:
1116 *  Allows the user and the API to read the status register for error detection
1117 *  and flow control.
1118 *
1119 * Side Effects:
1120 *  Clear status register of the component.
1121 *
1122 * Reentrant:
1123 *  No.
1124 *
1125 *******************************************************************************/
1126 uint8 SDCard_ReadStatus(void) 
1127 {
1128     uint8 tmpStatus;
1129
1130     #if(SDCard_TX_SOFTWARE_BUF_ENABLED || SDCard_RX_SOFTWARE_BUF_ENABLED)
1131
1132         SDCard_DisableInt();
1133
1134         tmpStatus  = SDCard_GET_STATUS_RX(SDCard_swStatusRx);
1135         tmpStatus |= SDCard_GET_STATUS_TX(SDCard_swStatusTx);
1136         tmpStatus &= ((uint8) ~SDCard_STS_SPI_IDLE);
1137
1138         SDCard_swStatusTx = 0u;
1139         SDCard_swStatusRx = 0u;
1140
1141         SDCard_EnableInt();
1142
1143     #else
1144
1145         tmpStatus  = SDCard_RX_STATUS_REG;
1146         tmpStatus |= SDCard_TX_STATUS_REG;
1147         tmpStatus &= ((uint8) ~SDCard_STS_SPI_IDLE);
1148
1149     #endif /* (SDCard_TX_SOFTWARE_BUF_ENABLED || SDCard_RX_SOFTWARE_BUF_ENABLED) */
1150
1151     return(tmpStatus);
1152 }
1153
1154
1155 /* [] END OF FILE */