Add second SPI master for 5.2 board
[SCSI2SD.git] / software / SCSI2SD / v5.2 / SCSI2SD.cydsn / Generated_Source / PSoC5 / NOR_SPI.c
1 /*******************************************************************************
2 * File Name: NOR_SPI.c
3 * Version 2.50
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-2015, 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 "NOR_SPI_PVT.h"
19
20 #if(NOR_SPI_TX_SOFTWARE_BUF_ENABLED)
21     volatile uint8 NOR_SPI_txBuffer[NOR_SPI_TX_BUFFER_SIZE];
22     volatile uint8 NOR_SPI_txBufferFull;
23     volatile uint8 NOR_SPI_txBufferRead;
24     volatile uint8 NOR_SPI_txBufferWrite;
25 #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED) */
26
27 #if(NOR_SPI_RX_SOFTWARE_BUF_ENABLED)
28     volatile uint8 NOR_SPI_rxBuffer[NOR_SPI_RX_BUFFER_SIZE];
29     volatile uint8 NOR_SPI_rxBufferFull;
30     volatile uint8 NOR_SPI_rxBufferRead;
31     volatile uint8 NOR_SPI_rxBufferWrite;
32 #endif /* (NOR_SPI_RX_SOFTWARE_BUF_ENABLED) */
33
34 uint8 NOR_SPI_initVar = 0u;
35
36 volatile uint8 NOR_SPI_swStatusTx;
37 volatile uint8 NOR_SPI_swStatusRx;
38
39
40 /*******************************************************************************
41 * Function Name: NOR_SPI_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 NOR_SPI_Init(void) 
64 {
65     /* Initialize the Bit counter */
66     NOR_SPI_COUNTER_PERIOD_REG = NOR_SPI_BITCTR_INIT;
67
68     /* Init TX ISR  */
69     #if(0u != NOR_SPI_INTERNAL_TX_INT_ENABLED)
70         CyIntDisable         (NOR_SPI_TX_ISR_NUMBER);
71         CyIntSetPriority     (NOR_SPI_TX_ISR_NUMBER,  NOR_SPI_TX_ISR_PRIORITY);
72         (void) CyIntSetVector(NOR_SPI_TX_ISR_NUMBER, &NOR_SPI_TX_ISR);
73     #endif /* (0u != NOR_SPI_INTERNAL_TX_INT_ENABLED) */
74
75     /* Init RX ISR  */
76     #if(0u != NOR_SPI_INTERNAL_RX_INT_ENABLED)
77         CyIntDisable         (NOR_SPI_RX_ISR_NUMBER);
78         CyIntSetPriority     (NOR_SPI_RX_ISR_NUMBER,  NOR_SPI_RX_ISR_PRIORITY);
79         (void) CyIntSetVector(NOR_SPI_RX_ISR_NUMBER, &NOR_SPI_RX_ISR);
80     #endif /* (0u != NOR_SPI_INTERNAL_RX_INT_ENABLED) */
81
82     /* Clear any stray data from the RX and TX FIFO */
83     NOR_SPI_ClearFIFO();
84
85     #if(NOR_SPI_RX_SOFTWARE_BUF_ENABLED)
86         NOR_SPI_rxBufferFull  = 0u;
87         NOR_SPI_rxBufferRead  = 0u;
88         NOR_SPI_rxBufferWrite = 0u;
89     #endif /* (NOR_SPI_RX_SOFTWARE_BUF_ENABLED) */
90
91     #if(NOR_SPI_TX_SOFTWARE_BUF_ENABLED)
92         NOR_SPI_txBufferFull  = 0u;
93         NOR_SPI_txBufferRead  = 0u;
94         NOR_SPI_txBufferWrite = 0u;
95     #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED) */
96
97     (void) NOR_SPI_ReadTxStatus(); /* Clear Tx status and swStatusTx */
98     (void) NOR_SPI_ReadRxStatus(); /* Clear Rx status and swStatusRx */
99
100     /* Configure TX and RX interrupt mask */
101     NOR_SPI_TX_STATUS_MASK_REG = NOR_SPI_TX_INIT_INTERRUPTS_MASK;
102     NOR_SPI_RX_STATUS_MASK_REG = NOR_SPI_RX_INIT_INTERRUPTS_MASK;
103 }
104
105
106 /*******************************************************************************
107 * Function Name: NOR_SPI_Enable
108 ********************************************************************************
109 *
110 * Summary:
111 *  Enable SPIM component.
112 *
113 * Parameters:
114 *  None.
115 *
116 * Return:
117 *  None.
118 *
119 *******************************************************************************/
120 void NOR_SPI_Enable(void) 
121 {
122     uint8 enableInterrupts;
123
124     enableInterrupts = CyEnterCriticalSection();
125     NOR_SPI_COUNTER_CONTROL_REG |= NOR_SPI_CNTR_ENABLE;
126     NOR_SPI_TX_STATUS_ACTL_REG  |= NOR_SPI_INT_ENABLE;
127     NOR_SPI_RX_STATUS_ACTL_REG  |= NOR_SPI_INT_ENABLE;
128     CyExitCriticalSection(enableInterrupts);
129
130     #if(0u != NOR_SPI_INTERNAL_CLOCK)
131         NOR_SPI_IntClock_Enable();
132     #endif /* (0u != NOR_SPI_INTERNAL_CLOCK) */
133
134     NOR_SPI_EnableTxInt();
135     NOR_SPI_EnableRxInt();
136 }
137
138
139 /*******************************************************************************
140 * Function Name: NOR_SPI_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 *  NOR_SPI_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 NOR_SPI_Start(void) 
164 {
165     if(0u == NOR_SPI_initVar)
166     {
167         NOR_SPI_Init();
168         NOR_SPI_initVar = 1u;
169     }
170
171     NOR_SPI_Enable();
172 }
173
174
175 /*******************************************************************************
176 * Function Name: NOR_SPI_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 NOR_SPI_Stop(void) 
193 {
194     uint8 enableInterrupts;
195
196     enableInterrupts = CyEnterCriticalSection();
197     NOR_SPI_TX_STATUS_ACTL_REG &= ((uint8) ~NOR_SPI_INT_ENABLE);
198     NOR_SPI_RX_STATUS_ACTL_REG &= ((uint8) ~NOR_SPI_INT_ENABLE);
199     CyExitCriticalSection(enableInterrupts);
200
201     #if(0u != NOR_SPI_INTERNAL_CLOCK)
202         NOR_SPI_IntClock_Disable();
203     #endif /* (0u != NOR_SPI_INTERNAL_CLOCK) */
204
205     NOR_SPI_DisableTxInt();
206     NOR_SPI_DisableRxInt();
207 }
208
209
210 /*******************************************************************************
211 * Function Name: NOR_SPI_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 NOR_SPI_EnableTxInt(void) 
228 {
229     #if(0u != NOR_SPI_INTERNAL_TX_INT_ENABLED)
230         CyIntEnable(NOR_SPI_TX_ISR_NUMBER);
231     #endif /* (0u != NOR_SPI_INTERNAL_TX_INT_ENABLED) */
232 }
233
234
235 /*******************************************************************************
236 * Function Name: NOR_SPI_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 NOR_SPI_EnableRxInt(void) 
253 {
254     #if(0u != NOR_SPI_INTERNAL_RX_INT_ENABLED)
255         CyIntEnable(NOR_SPI_RX_ISR_NUMBER);
256     #endif /* (0u != NOR_SPI_INTERNAL_RX_INT_ENABLED) */
257 }
258
259
260 /*******************************************************************************
261 * Function Name: NOR_SPI_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 NOR_SPI_DisableTxInt(void) 
278 {
279     #if(0u != NOR_SPI_INTERNAL_TX_INT_ENABLED)
280         CyIntDisable(NOR_SPI_TX_ISR_NUMBER);
281     #endif /* (0u != NOR_SPI_INTERNAL_TX_INT_ENABLED) */
282 }
283
284
285 /*******************************************************************************
286 * Function Name: NOR_SPI_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 NOR_SPI_DisableRxInt(void) 
303 {
304     #if(0u != NOR_SPI_INTERNAL_RX_INT_ENABLED)
305         CyIntDisable(NOR_SPI_RX_ISR_NUMBER);
306     #endif /* (0u != NOR_SPI_INTERNAL_RX_INT_ENABLED) */
307 }
308
309
310 /*******************************************************************************
311 * Function Name: NOR_SPI_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 NOR_SPI_SetTxInterruptMode(uint8 intSrc) 
329 {
330     NOR_SPI_TX_STATUS_MASK_REG = intSrc;
331 }
332
333
334 /*******************************************************************************
335 * Function Name: NOR_SPI_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 NOR_SPI_SetRxInterruptMode(uint8 intSrc) 
353 {
354     NOR_SPI_RX_STATUS_MASK_REG  = intSrc;
355 }
356
357
358 /*******************************************************************************
359 * Function Name: NOR_SPI_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 *  NOR_SPI_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 NOR_SPI_ReadTxStatus(void) 
387 {
388     uint8 tmpStatus;
389
390     #if(NOR_SPI_TX_SOFTWARE_BUF_ENABLED)
391         /* Disable TX interrupt to protect global veriables */
392         NOR_SPI_DisableTxInt();
393
394         tmpStatus = NOR_SPI_GET_STATUS_TX(NOR_SPI_swStatusTx);
395         NOR_SPI_swStatusTx = 0u;
396
397         NOR_SPI_EnableTxInt();
398
399     #else
400
401         tmpStatus = NOR_SPI_TX_STATUS_REG;
402
403     #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED) */
404
405     return(tmpStatus);
406 }
407
408
409 /*******************************************************************************
410 * Function Name: NOR_SPI_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 *  NOR_SPI_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 NOR_SPI_ReadRxStatus(void) 
438 {
439     uint8 tmpStatus;
440
441     #if(NOR_SPI_RX_SOFTWARE_BUF_ENABLED)
442         /* Disable RX interrupt to protect global veriables */
443         NOR_SPI_DisableRxInt();
444
445         tmpStatus = NOR_SPI_GET_STATUS_RX(NOR_SPI_swStatusRx);
446         NOR_SPI_swStatusRx = 0u;
447
448         NOR_SPI_EnableRxInt();
449
450     #else
451
452         tmpStatus = NOR_SPI_RX_STATUS_REG;
453
454     #endif /* (NOR_SPI_RX_SOFTWARE_BUF_ENABLED) */
455
456     return(tmpStatus);
457 }
458
459
460 /*******************************************************************************
461 * Function Name: NOR_SPI_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 *  NOR_SPI_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 *  NOR_SPI_txBufferRead - used for the account of the bytes which
478 *  have been read from the TX software buffer.
479 *  NOR_SPI_txBuffer[NOR_SPI_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 NOR_SPI_WriteTxData(uint8 txData) 
495 {
496     #if(NOR_SPI_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 = NOR_SPI_txBufferRead;
505             if(0u == tmpTxBufferRead)
506             {
507                 tmpTxBufferRead = (NOR_SPI_TX_BUFFER_SIZE - 1u);
508             }
509             else
510             {
511                 tmpTxBufferRead--;
512             }
513
514         }while(tmpTxBufferRead == NOR_SPI_txBufferWrite);
515
516         /* Disable TX interrupt to protect global veriables */
517         NOR_SPI_DisableTxInt();
518
519         tempStatus = NOR_SPI_GET_STATUS_TX(NOR_SPI_swStatusTx);
520         NOR_SPI_swStatusTx = tempStatus;
521
522
523         if((NOR_SPI_txBufferRead == NOR_SPI_txBufferWrite) &&
524            (0u != (NOR_SPI_swStatusTx & NOR_SPI_STS_TX_FIFO_NOT_FULL)))
525         {
526             /* Put data element into the TX FIFO */
527             CY_SET_REG8(NOR_SPI_TXDATA_PTR, txData);
528         }
529         else
530         {
531             /* Add to the TX software buffer */
532             NOR_SPI_txBufferWrite++;
533             if(NOR_SPI_txBufferWrite >= NOR_SPI_TX_BUFFER_SIZE)
534             {
535                 NOR_SPI_txBufferWrite = 0u;
536             }
537
538             if(NOR_SPI_txBufferWrite == NOR_SPI_txBufferRead)
539             {
540                 NOR_SPI_txBufferRead++;
541                 if(NOR_SPI_txBufferRead >= NOR_SPI_TX_BUFFER_SIZE)
542                 {
543                     NOR_SPI_txBufferRead = 0u;
544                 }
545                 NOR_SPI_txBufferFull = 1u;
546             }
547
548             NOR_SPI_txBuffer[NOR_SPI_txBufferWrite] = txData;
549
550             NOR_SPI_TX_STATUS_MASK_REG |= NOR_SPI_STS_TX_FIFO_NOT_FULL;
551         }
552
553         NOR_SPI_EnableTxInt();
554
555     #else
556         /* Wait until TX FIFO has a place */
557         while(0u == (NOR_SPI_TX_STATUS_REG & NOR_SPI_STS_TX_FIFO_NOT_FULL))
558         {
559         }
560
561         /* Put data element into the TX FIFO */
562         CY_SET_REG8(NOR_SPI_TXDATA_PTR, txData);
563
564     #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED) */
565 }
566
567
568 /*******************************************************************************
569 * Function Name: NOR_SPI_ReadRxData
570 ********************************************************************************
571 *
572 * Summary:
573 *  Read the next byte of data received across the SPI.
574 *
575 * Parameters:
576 *  None.
577 *
578 * Return:
579 *  The next byte of data read from the FIFO.
580 *
581 * Global variables:
582 *  NOR_SPI_rxBufferWrite - used for the account of the bytes which
583 *  have been written down in the RX software buffer.
584 *  NOR_SPI_rxBufferRead - used for the account of the bytes which
585 *  have been read from the RX software buffer, modified every function
586 *  call if RX Software Buffer is used.
587 *  NOR_SPI_rxBuffer[NOR_SPI_RX_BUFFER_SIZE] - used to store
588 *  received data.
589 *
590 * Theory:
591 *  Allows the user to read a byte of data received.
592 *
593 * Side Effects:
594 *  Will return invalid data if the FIFO is empty. The user should Call
595 *  GetRxBufferSize() and if it returns a non-zero value then it is safe to call
596 *  ReadByte() function.
597 *
598 * Reentrant:
599 *  No.
600 *
601 *******************************************************************************/
602 uint8 NOR_SPI_ReadRxData(void) 
603 {
604     uint8 rxData;
605
606     #if(NOR_SPI_RX_SOFTWARE_BUF_ENABLED)
607
608         /* Disable RX interrupt to protect global veriables */
609         NOR_SPI_DisableRxInt();
610
611         if(NOR_SPI_rxBufferRead != NOR_SPI_rxBufferWrite)
612         {
613             if(0u == NOR_SPI_rxBufferFull)
614             {
615                 NOR_SPI_rxBufferRead++;
616                 if(NOR_SPI_rxBufferRead >= NOR_SPI_RX_BUFFER_SIZE)
617                 {
618                     NOR_SPI_rxBufferRead = 0u;
619                 }
620             }
621             else
622             {
623                 NOR_SPI_rxBufferFull = 0u;
624             }
625         }
626
627         rxData = NOR_SPI_rxBuffer[NOR_SPI_rxBufferRead];
628
629         NOR_SPI_EnableRxInt();
630
631     #else
632
633         rxData = CY_GET_REG8(NOR_SPI_RXDATA_PTR);
634
635     #endif /* (NOR_SPI_RX_SOFTWARE_BUF_ENABLED) */
636
637     return(rxData);
638 }
639
640
641 /*******************************************************************************
642 * Function Name: NOR_SPI_GetRxBufferSize
643 ********************************************************************************
644 *
645 * Summary:
646 *  Returns the number of bytes/words of data currently held in the RX buffer.
647 *  If RX Software Buffer not used then function return 0 if FIFO empty or 1 if
648 *  FIFO not empty. In another case function return size of RX Software Buffer.
649 *
650 * Parameters:
651 *  None.
652 *
653 * Return:
654 *  Integer count of the number of bytes/words in the RX buffer.
655 *
656 * Global variables:
657 *  NOR_SPI_rxBufferWrite - used for the account of the bytes which
658 *  have been written down in the RX software buffer.
659 *  NOR_SPI_rxBufferRead - used for the account of the bytes which
660 *  have been read from the RX software buffer.
661 *
662 * Side Effects:
663 *  Clear status register of the component.
664 *
665 *******************************************************************************/
666 uint8 NOR_SPI_GetRxBufferSize(void) 
667 {
668     uint8 size;
669
670     #if(NOR_SPI_RX_SOFTWARE_BUF_ENABLED)
671
672         /* Disable RX interrupt to protect global veriables */
673         NOR_SPI_DisableRxInt();
674
675         if(NOR_SPI_rxBufferRead == NOR_SPI_rxBufferWrite)
676         {
677             size = 0u;
678         }
679         else if(NOR_SPI_rxBufferRead < NOR_SPI_rxBufferWrite)
680         {
681             size = (NOR_SPI_rxBufferWrite - NOR_SPI_rxBufferRead);
682         }
683         else
684         {
685             size = (NOR_SPI_RX_BUFFER_SIZE - NOR_SPI_rxBufferRead) + NOR_SPI_rxBufferWrite;
686         }
687
688         NOR_SPI_EnableRxInt();
689
690     #else
691
692         /* We can only know if there is data in the RX FIFO */
693         size = (0u != (NOR_SPI_RX_STATUS_REG & NOR_SPI_STS_RX_FIFO_NOT_EMPTY)) ? 1u : 0u;
694
695     #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED) */
696
697     return(size);
698 }
699
700
701 /*******************************************************************************
702 * Function Name: NOR_SPI_GetTxBufferSize
703 ********************************************************************************
704 *
705 * Summary:
706 *  Returns the number of bytes/words of data currently held in the TX buffer.
707 *  If TX Software Buffer not used then function return 0 - if FIFO empty, 1 - if
708 *  FIFO not full, 4 - if FIFO full. In another case function return size of TX
709 *  Software Buffer.
710 *
711 * Parameters:
712 *  None.
713 *
714 * Return:
715 *  Integer count of the number of bytes/words in the TX buffer.
716 *
717 * Global variables:
718 *  NOR_SPI_txBufferWrite - used for the account of the bytes which
719 *  have been written down in the TX software buffer.
720 *  NOR_SPI_txBufferRead - used for the account of the bytes which
721 *  have been read from the TX software buffer.
722 *
723 * Side Effects:
724 *  Clear status register of the component.
725 *
726 *******************************************************************************/
727 uint8  NOR_SPI_GetTxBufferSize(void) 
728 {
729     uint8 size;
730
731     #if(NOR_SPI_TX_SOFTWARE_BUF_ENABLED)
732         /* Disable TX interrupt to protect global veriables */
733         NOR_SPI_DisableTxInt();
734
735         if(NOR_SPI_txBufferRead == NOR_SPI_txBufferWrite)
736         {
737             size = 0u;
738         }
739         else if(NOR_SPI_txBufferRead < NOR_SPI_txBufferWrite)
740         {
741             size = (NOR_SPI_txBufferWrite - NOR_SPI_txBufferRead);
742         }
743         else
744         {
745             size = (NOR_SPI_TX_BUFFER_SIZE - NOR_SPI_txBufferRead) + NOR_SPI_txBufferWrite;
746         }
747
748         NOR_SPI_EnableTxInt();
749
750     #else
751
752         size = NOR_SPI_TX_STATUS_REG;
753
754         if(0u != (size & NOR_SPI_STS_TX_FIFO_EMPTY))
755         {
756             size = 0u;
757         }
758         else if(0u != (size & NOR_SPI_STS_TX_FIFO_NOT_FULL))
759         {
760             size = 1u;
761         }
762         else
763         {
764             size = NOR_SPI_FIFO_SIZE;
765         }
766
767     #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED) */
768
769     return(size);
770 }
771
772
773 /*******************************************************************************
774 * Function Name: NOR_SPI_ClearRxBuffer
775 ********************************************************************************
776 *
777 * Summary:
778 *  Clear the RX RAM buffer by setting the read and write pointers both to zero.
779 *
780 * Parameters:
781 *  None.
782 *
783 * Return:
784 *  None.
785 *
786 * Global variables:
787 *  NOR_SPI_rxBufferWrite - used for the account of the bytes which
788 *  have been written down in the RX software buffer, modified every function
789 *  call - resets to zero.
790 *  NOR_SPI_rxBufferRead - used for the account of the bytes which
791 *  have been read from the RX software buffer, modified every function call -
792 *  resets to zero.
793 *
794 * Theory:
795 *  Setting the pointers to zero makes the system believe there is no data to
796 *  read and writing will resume at address 0 overwriting any data that may have
797 *  remained in the RAM.
798 *
799 * Side Effects:
800 *  Any received data not read from the RAM buffer will be lost when overwritten.
801 *
802 * Reentrant:
803 *  No.
804 *
805 *******************************************************************************/
806 void NOR_SPI_ClearRxBuffer(void) 
807 {
808     /* Clear Hardware RX FIFO */
809     while(0u !=(NOR_SPI_RX_STATUS_REG & NOR_SPI_STS_RX_FIFO_NOT_EMPTY))
810     {
811         (void) CY_GET_REG8(NOR_SPI_RXDATA_PTR);
812     }
813
814     #if(NOR_SPI_RX_SOFTWARE_BUF_ENABLED)
815         /* Disable RX interrupt to protect global veriables */
816         NOR_SPI_DisableRxInt();
817
818         NOR_SPI_rxBufferFull  = 0u;
819         NOR_SPI_rxBufferRead  = 0u;
820         NOR_SPI_rxBufferWrite = 0u;
821
822         NOR_SPI_EnableRxInt();
823     #endif /* (NOR_SPI_RX_SOFTWARE_BUF_ENABLED) */
824 }
825
826
827 /*******************************************************************************
828 * Function Name: NOR_SPI_ClearTxBuffer
829 ********************************************************************************
830 *
831 * Summary:
832 *  Clear the TX RAM buffer by setting the read and write pointers both to zero.
833 *
834 * Parameters:
835 *  None.
836 *
837 * Return:
838 *  None.
839 *
840 * Global variables:
841 *  NOR_SPI_txBufferWrite - used for the account of the bytes which
842 *  have been written down in the TX software buffer, modified every function
843 *  call - resets to zero.
844 *  NOR_SPI_txBufferRead - used for the account of the bytes which
845 *  have been read from the TX software buffer, modified every function call -
846 *  resets to zero.
847 *
848 * Theory:
849 *  Setting the pointers to zero makes the system believe there is no data to
850 *  read and writing will resume at address 0 overwriting any data that may have
851 *  remained in the RAM.
852 *
853 * Side Effects:
854 *  Any data not yet transmitted from the RAM buffer will be lost when
855 *  overwritten.
856 *
857 * Reentrant:
858 *  No.
859 *
860 *******************************************************************************/
861 void NOR_SPI_ClearTxBuffer(void) 
862 {
863     uint8 enableInterrupts;
864
865     enableInterrupts = CyEnterCriticalSection();
866     /* Clear TX FIFO */
867     NOR_SPI_AUX_CONTROL_DP0_REG |= ((uint8)  NOR_SPI_TX_FIFO_CLR);
868     NOR_SPI_AUX_CONTROL_DP0_REG &= ((uint8) ~NOR_SPI_TX_FIFO_CLR);
869
870     #if(NOR_SPI_USE_SECOND_DATAPATH)
871         /* Clear TX FIFO for 2nd Datapath */
872         NOR_SPI_AUX_CONTROL_DP1_REG |= ((uint8)  NOR_SPI_TX_FIFO_CLR);
873         NOR_SPI_AUX_CONTROL_DP1_REG &= ((uint8) ~NOR_SPI_TX_FIFO_CLR);
874     #endif /* (NOR_SPI_USE_SECOND_DATAPATH) */
875     CyExitCriticalSection(enableInterrupts);
876
877     #if(NOR_SPI_TX_SOFTWARE_BUF_ENABLED)
878         /* Disable TX interrupt to protect global veriables */
879         NOR_SPI_DisableTxInt();
880
881         NOR_SPI_txBufferFull  = 0u;
882         NOR_SPI_txBufferRead  = 0u;
883         NOR_SPI_txBufferWrite = 0u;
884
885         /* Buffer is EMPTY: disable TX FIFO NOT FULL interrupt */
886         NOR_SPI_TX_STATUS_MASK_REG &= ((uint8) ~NOR_SPI_STS_TX_FIFO_NOT_FULL);
887
888         NOR_SPI_EnableTxInt();
889     #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED) */
890 }
891
892
893 #if(0u != NOR_SPI_BIDIRECTIONAL_MODE)
894     /*******************************************************************************
895     * Function Name: NOR_SPI_TxEnable
896     ********************************************************************************
897     *
898     * Summary:
899     *  If the SPI master is configured to use a single bi-directional pin then this
900     *  will set the bi-directional pin to transmit.
901     *
902     * Parameters:
903     *  None.
904     *
905     * Return:
906     *  None.
907     *
908     *******************************************************************************/
909     void NOR_SPI_TxEnable(void) 
910     {
911         NOR_SPI_CONTROL_REG |= NOR_SPI_CTRL_TX_SIGNAL_EN;
912     }
913
914
915     /*******************************************************************************
916     * Function Name: NOR_SPI_TxDisable
917     ********************************************************************************
918     *
919     * Summary:
920     *  If the SPI master is configured to use a single bi-directional pin then this
921     *  will set the bi-directional pin to receive.
922     *
923     * Parameters:
924     *  None.
925     *
926     * Return:
927     *  None.
928     *
929     *******************************************************************************/
930     void NOR_SPI_TxDisable(void) 
931     {
932         NOR_SPI_CONTROL_REG &= ((uint8) ~NOR_SPI_CTRL_TX_SIGNAL_EN);
933     }
934
935 #endif /* (0u != NOR_SPI_BIDIRECTIONAL_MODE) */
936
937
938 /*******************************************************************************
939 * Function Name: NOR_SPI_PutArray
940 ********************************************************************************
941 *
942 * Summary:
943 *  Write available data from ROM/RAM to the TX buffer while space is available
944 *  in the TX buffer. Keep trying until all data is passed to the TX buffer.
945 *
946 * Parameters:
947 *  *buffer: Pointer to the location in RAM containing the data to send
948 *  byteCount: The number of bytes to move to the transmit buffer.
949 *
950 * Return:
951 *  None.
952 *
953 * Side Effects:
954 *  Will stay in this routine until all data has been sent.  May get locked in
955 *  this loop if data is not being initiated by the master if there is not
956 *  enough room in the TX FIFO.
957 *
958 * Reentrant:
959 *  No.
960 *
961 *******************************************************************************/
962 void NOR_SPI_PutArray(const uint8 buffer[], uint8 byteCount)
963                                                                           
964 {
965     uint8 bufIndex;
966
967     bufIndex = 0u;
968
969     while(byteCount > 0u)
970     {
971         NOR_SPI_WriteTxData(buffer[bufIndex]);
972         bufIndex++;
973         byteCount--;
974     }
975 }
976
977
978 /*******************************************************************************
979 * Function Name: NOR_SPI_ClearFIFO
980 ********************************************************************************
981 *
982 * Summary:
983 *  Clear the RX and TX FIFO's of all data for a fresh start.
984 *
985 * Parameters:
986 *  None.
987 *
988 * Return:
989 *  None.
990 *
991 * Side Effects:
992 *  Clear status register of the component.
993 *
994 *******************************************************************************/
995 void NOR_SPI_ClearFIFO(void) 
996 {
997     uint8 enableInterrupts;
998
999     /* Clear Hardware RX FIFO */
1000     while(0u !=(NOR_SPI_RX_STATUS_REG & NOR_SPI_STS_RX_FIFO_NOT_EMPTY))
1001     {
1002         (void) CY_GET_REG8(NOR_SPI_RXDATA_PTR);
1003     }
1004
1005     enableInterrupts = CyEnterCriticalSection();
1006     /* Clear TX FIFO */
1007     NOR_SPI_AUX_CONTROL_DP0_REG |= ((uint8)  NOR_SPI_TX_FIFO_CLR);
1008     NOR_SPI_AUX_CONTROL_DP0_REG &= ((uint8) ~NOR_SPI_TX_FIFO_CLR);
1009
1010     #if(NOR_SPI_USE_SECOND_DATAPATH)
1011         /* Clear TX FIFO for 2nd Datapath */
1012         NOR_SPI_AUX_CONTROL_DP1_REG |= ((uint8)  NOR_SPI_TX_FIFO_CLR);
1013         NOR_SPI_AUX_CONTROL_DP1_REG &= ((uint8) ~NOR_SPI_TX_FIFO_CLR);
1014     #endif /* (NOR_SPI_USE_SECOND_DATAPATH) */
1015     CyExitCriticalSection(enableInterrupts);
1016 }
1017
1018
1019 /* Following functions are for version Compatibility, they are obsolete.
1020 *  Please do not use it in new projects.
1021 */
1022
1023
1024 /*******************************************************************************
1025 * Function Name: NOR_SPI_EnableInt
1026 ********************************************************************************
1027 *
1028 * Summary:
1029 *  Enable internal interrupt generation.
1030 *
1031 * Parameters:
1032 *  None.
1033 *
1034 * Return:
1035 *  None.
1036 *
1037 * Theory:
1038 *  Enable the internal interrupt output -or- the interrupt component itself.
1039 *
1040 *******************************************************************************/
1041 void NOR_SPI_EnableInt(void) 
1042 {
1043     NOR_SPI_EnableRxInt();
1044     NOR_SPI_EnableTxInt();
1045 }
1046
1047
1048 /*******************************************************************************
1049 * Function Name: NOR_SPI_DisableInt
1050 ********************************************************************************
1051 *
1052 * Summary:
1053 *  Disable internal interrupt generation.
1054 *
1055 * Parameters:
1056 *  None.
1057 *
1058 * Return:
1059 *  None.
1060 *
1061 * Theory:
1062 *  Disable the internal interrupt output -or- the interrupt component itself.
1063 *
1064 *******************************************************************************/
1065 void NOR_SPI_DisableInt(void) 
1066 {
1067     NOR_SPI_DisableTxInt();
1068     NOR_SPI_DisableRxInt();
1069 }
1070
1071
1072 /*******************************************************************************
1073 * Function Name: NOR_SPI_SetInterruptMode
1074 ********************************************************************************
1075 *
1076 * Summary:
1077 *  Configure which status bits trigger an interrupt event.
1078 *
1079 * Parameters:
1080 *  intSrc: An or'd combination of the desired status bit masks (defined in the
1081 *  header file).
1082 *
1083 * Return:
1084 *  None.
1085 *
1086 * Theory:
1087 *  Enables the output of specific status bits to the interrupt controller.
1088 *
1089 *******************************************************************************/
1090 void NOR_SPI_SetInterruptMode(uint8 intSrc) 
1091 {
1092     NOR_SPI_TX_STATUS_MASK_REG  = (intSrc & ((uint8) ~NOR_SPI_STS_SPI_IDLE));
1093     NOR_SPI_RX_STATUS_MASK_REG  =  intSrc;
1094 }
1095
1096
1097 /*******************************************************************************
1098 * Function Name: NOR_SPI_ReadStatus
1099 ********************************************************************************
1100 *
1101 * Summary:
1102 *  Read the status register for the component.
1103 *
1104 * Parameters:
1105 *  None.
1106 *
1107 * Return:
1108 *  Contents of the status register.
1109 *
1110 * Global variables:
1111 *  NOR_SPI_swStatus - used to store in software status register,
1112 *  modified every function call - resets to zero.
1113 *
1114 * Theory:
1115 *  Allows the user and the API to read the status register for error detection
1116 *  and flow control.
1117 *
1118 * Side Effects:
1119 *  Clear status register of the component.
1120 *
1121 * Reentrant:
1122 *  No.
1123 *
1124 *******************************************************************************/
1125 uint8 NOR_SPI_ReadStatus(void) 
1126 {
1127     uint8 tmpStatus;
1128
1129     #if(NOR_SPI_TX_SOFTWARE_BUF_ENABLED || NOR_SPI_RX_SOFTWARE_BUF_ENABLED)
1130
1131         NOR_SPI_DisableInt();
1132
1133         tmpStatus  = NOR_SPI_GET_STATUS_RX(NOR_SPI_swStatusRx);
1134         tmpStatus |= NOR_SPI_GET_STATUS_TX(NOR_SPI_swStatusTx);
1135         tmpStatus &= ((uint8) ~NOR_SPI_STS_SPI_IDLE);
1136
1137         NOR_SPI_swStatusTx = 0u;
1138         NOR_SPI_swStatusRx = 0u;
1139
1140         NOR_SPI_EnableInt();
1141
1142     #else
1143
1144         tmpStatus  = NOR_SPI_RX_STATUS_REG;
1145         tmpStatus |= NOR_SPI_TX_STATUS_REG;
1146         tmpStatus &= ((uint8) ~NOR_SPI_STS_SPI_IDLE);
1147
1148     #endif /* (NOR_SPI_TX_SOFTWARE_BUF_ENABLED || NOR_SPI_RX_SOFTWARE_BUF_ENABLED) */
1149
1150     return(tmpStatus);
1151 }
1152
1153
1154 /* [] END OF FILE */