OSPI: FreeRTOS port
[processor-sdk/pdk.git] / packages / ti / drv / mibspi / test / loopback / src / mibspi_test_common.c
1 /*
2  *   @file  mibspi_test_common.c
3  *
4  *   @brief
5  *      Unit Test common code for the MibSpi Driver
6  *
7  *  \par
8  *  NOTE:
9  *      (C) Copyright 2020 Texas Instruments, Inc.
10  *
11  *  Redistribution and use in source and binary forms, with or without
12  *  modification, are permitted provided that the following conditions
13  *  are met:
14  *
15  *    Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  *
18  *    Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the
21  *    distribution.
22  *
23  *    Neither the name of Texas Instruments Incorporated nor the names of
24  *    its contributors may be used to endorse or promote products derived
25  *    from this software without specific prior written permission.
26  *
27  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38  */
40 /**************************************************************************
41  *************************** Include Files ********************************
42  **************************************************************************/
44 /* Standard Include Files. */
45 #include <stdint.h>
46 #include <stdlib.h>
47 #include <stddef.h>
48 #include <string.h>
49 #include <stdio.h>
51 #include "MIBSPI_log.h"
53 #if defined (USE_BIOS)
54 #ifdef BUILD_MCU1_0
55 #include <ti/sysbios/family/arm/v7a/Pmu.h>
56 #endif
57 #endif
59 #include <ti/csl/soc.h>
61 #include <ti/drv/mibspi/MIBSPI.h>
62 #include <ti/drv/edma/edma.h>
63 #include <ti/osal/HwiP.h>
65 #include "mibspi_test_common.h"
67 /**************************************************************************
68  *************************** Local Definitions *********************************
69  **************************************************************************/
71 /* Test flag for multiple icount */
72 #define SPI_MULT_ICOUNT_SUPPORT
74 /* VBUSP Frequency in MHz */
75 #define VBUSP_FREQ              MSS_SYS_VCLK /1000000U
77 /* Number of Loops of Data echo test when XWR1xxx is configured as Master */
78 #define SPI_TEST_LOOP           1000
80 #ifdef SPI_MULT_ICOUNT_SUPPORT
81  /* Block size used for the test*/
82 #define SPI_DATA_BLOCK_SIZE     1024
83 #else
84  /* Block size used for the test*/
85 #define SPI_DATA_BLOCK_SIZE     128
86 #endif
88 /* Test message definitio for SPI test as a slave with external devices */
89 #define MAGIC_NUMBER            0x3456
91 #ifdef SPI_MULT_ICOUNT_SUPPORT
92 #define SPI_TEST_MSGLEN         1024
93 #else
94 #define SPI_TEST_MSGLEN         128
95 #endif
96 #define SPI_TEST_SYNC_MSGLEN    16
97 #define SWAP_BYTES(x)           (( (x&0xff) << 8) | ((x >>8) & 0xff))
99 /**************************************************************************
100  *************************** Local Data Structure ******************************
101  **************************************************************************/
103 /* SPI Test message definition */
104 typedef struct spiTestMsg
106     /* Test message MAGIC number */
107     uint16_t magicNumber;
109     /* Test message sequence number */
110     uint16_t seqNo;
112     /* Test message valid data length */
113     uint16_t dataLen;
115     /* Test message checksum */
116     uint16_t checksum;
118     /* Test message data payload */
119     uint8_t data[SPI_TEST_MSGLEN - 8];
120 }spiTestMsg;
122 /**************************************************************************
123  *************************** Global Definitions ********************************
124  **************************************************************************/
125  /* Global data buffers used for SPI test */
126 volatile uint8_t    txBuf[SPI_DATA_BLOCK_SIZE] __attribute__ ((aligned(128)));
128 volatile uint8_t    rxBuf[SPI_DATA_BLOCK_SIZE] __attribute__ ((aligned(128)));
130 /* Debug flag */
131 uint32_t            gPrintHwStats = 1;
133 /**************************************************************************
134  *************************** SPI Test Functions *******************************
135  **************************************************************************/
136 static int32_t Test_spiLoopbackSlave(const MIBSPI_Handle handle, uint32_t maxElem, uint8_t dataSize);
138 /**
139  *  @b Description
140  *  @n
141  *      This function delay by running in tight loops.
142  *
143  *   @param[in] count             count for the delay loop
144  *
145  *  @retval
146  *      Not Applicable.
147  */
148 void Test_delay(uint32_t count)
150     volatile uint32_t i;
152     for(i=0; i<count; i++);
155 /**
156  *  @b Description
157  *  @n
158  *      This function starts a PMU counter .
159  *
160  *   @param[in] counter             Counter id used for benchmarking
161  *
162  *  @retval
163  *      Not Applicable.
164  */
165 void Test_benchmarkStart(uint32_t counter)
167 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
168     /* Initialize counter to count cycles */
169     Pmu_configureCounter(counter, 0x11, FALSE);
171     /* Reset PMU counter */
172     Pmu_resetCount(counter);
174     /* Start PMU counter */
175     Pmu_startCounter(counter);
176 #endif
179 /**
180  *  @b Description
181  *  @n
182  *      This function stops a PMU counter and returns the current counter value.
183  *
184  *   @param[in] counter             Counter id used for benchmarking
185  *
186  *  @retval
187  *      Current PMU counter value.
188  */
189 uint32_t Test_benchmarkStop(uint32_t counter)
191 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
192     /* Stop PMU counter */
193     Pmu_stopCounter(counter);
195     /* Read PMU counter */
196     return (Pmu_getCount(counter));
197 #else
198     return (0); //TODO
199 #endif
202 /**
203  *  @b Description
204  *  @n
205  *      SPI get hardware statistics function.
206  *
207  *   @param[in] handle            SPI driver handle
208  *   @param[in] printStats        Flag to print the stats
209  *
210  *   @retval    Successful        =0
211  *                 Failed         <0
212  */
213 static int32_t Test_getSpiStats(const MIBSPI_Handle handle, bool printStats)
215     MIBSPI_Stats   stats;
216     int32_t     retVal;
218     retVal = MIBSPI_getStats(handle, &stats);
219     if(retVal == 0)
220     {
221         if(printStats)
222         {
223             MIBSPI_log("SPI hardware stats:\n");
224             MIBSPI_log("datalen Error    = %d\n", stats.dlenErr);
225             MIBSPI_log("timeout          = %d\n", stats.timeout);
226             MIBSPI_log("Parity Error     = %d\n", stats.parErr);
227             MIBSPI_log("Desync error     = %d\n", stats.desync);
228             MIBSPI_log("Tx bit error     = %d\n", stats.bitErr);
229             MIBSPI_log("RX overrun       = %d\n", stats.rxOvrnErr);
230         }
231     }
233     return retVal;
236 /**
237  *  @b Description
238  *  @n
239  *      SPI read only function.
240  *
241  *   @param[in] handle            SPI driver handle
242  *   @param[in] dataLen           Number of bytes need to be transferred
243  *   @param[in] buffer            Pointer of the buffer
244  *   @param[in] slaveIndex        Slave index for the SPI transfer
245  *
246  *  @retval    Successful         =0
247  *                 Failed         <0
248  */
249 static int32_t Test_spiRead(const MIBSPI_Handle handle, uint32_t dataLen, void* buffer, uint8_t slaveIndex)
251     MIBSPI_Transaction transaction;
253     /* Configure Data Transfer */
254     transaction.count = dataLen;
255     transaction.txBuf = NULL;
256     transaction.rxBuf = buffer;
257     transaction.slaveIndex = slaveIndex;
259     /* Start Data Transfer */
260     if (MIBSPI_transfer(handle, &transaction) != true)
261     {
262         return -1;
263     }
264     return 0;
267 /**
268  *  @b Description
269  *  @n
270  *      SPI write only function.
271  *
272  *   @param[in] handle            SPI driver handle
273  *   @param[in] dataLen           Number of bytes need to be transferred
274  *   @param[in] buffer            Pointer of the buffer
275  *   @param[in] slaveIndex        Slave index for the SPI transfer
276  *
277  *  @retval    Successful         =0
278  *                 Failed         <0
279  */
280 static int32_t Test_spiWrite(const MIBSPI_Handle handle, uint32_t dataLen, void* buffer, uint8_t slaveIndex)
282     MIBSPI_Transaction transaction;
284     /* Configure Data Transfer */
285     transaction.count = dataLen;
286     transaction.txBuf = buffer;
287     transaction.rxBuf = NULL;
288     transaction.slaveIndex = slaveIndex;
290     /* Start Data Transfer */
291     if (MIBSPI_transfer(handle, &transaction) != true)
292     {
293         return -1;
294     }
295     return 0;
298 /* Test_spiReadWrite is called for the callback mode test also.
299  * So keep the MIBSPI_Transaction object persistant till the transfer is complete.
300  * So use the global variable insted of using the local variable
301  * which is initialized in stack.
302  */
303 static MIBSPI_Transaction  gTransactionRdWr;
305 /**
306  *  @b Description
307  *  @n
308  *      SPI read and write function.
309  *
310  *   @param[in] handle            SPI driver handle
311  *   @param[in] dataLen           Number of bytes need to be transferred
312  *   @param[in] inBuffer          Pointer of the read buffer
313  *   @param[in] outBuffer         Pointer of the write buffer
314  *   @param[in] slaveIndex        Slave index for the SPI transfer
315  *
316  *  @retval    Successful         =0
317  *                 Failed         <0
318  */
319 static int32_t Test_spiReadWrite(const MIBSPI_Handle handle, uint32_t dataLen, void* inBuffer, void* outBuffer, uint8_t slaveIndex)
321     /* Configure Data Transfer */
322     gTransactionRdWr.count = dataLen;
323     gTransactionRdWr.txBuf = outBuffer;
324     gTransactionRdWr.rxBuf = inBuffer;
325     gTransactionRdWr.slaveIndex = slaveIndex;
327     /* Start Data Transfer */
328     if (MIBSPI_transfer(handle, &gTransactionRdWr) != true)
329     {
330         return -1;
331     }
332     return 0;
335 /**
336  *  @b Description
337  *  @n
338  *      This function tests SPI driver in Digital Loopback mode.
339  *
340  *   @param[in] handle            SPI driver handle
341  *   @param[in] slaveIndex        Flag for internal/external loopback
342  *   @param[in] maxElem           Maxim data element
343  *   @param[in] dataSize          Data size in number of bytes
344  *
345  *  @retval    Successful                   =0
346  *             Number of transfer failures  >0
347  *             API failures                 <0
348  */
349 static int32_t Test_spiLoopback(const MIBSPI_Handle handle, uint8_t slaveIndex, uint32_t maxElem, uint8_t dataSize)
351     MibSpi_LoopBackType            loopback;
352     uint32_t           loop;
353     uint32_t           idx;
354     uint32_t           failed = 0;
355     uint32_t           len=0;
357     /* Only dataSize of 1 byte or 2 bytes are supported */
358     if ((dataSize != (uint8_t)1U) && (dataSize != (uint8_t)2U))
359         return -1;
361     /* Enable digital loopback */
362     loopback = MIBSPI_LOOPBK_DIGITAL;
363     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
364         return -1;
365     for(loop=0; loop < maxElem; loop++)
366     {
367         len = (maxElem - loop) * dataSize;
369         /* Prepare Tx/Rx Buffer */
370         for(idx=0; idx<maxElem * dataSize; idx++)
371         {
372             txBuf[idx] = (loop * 0x10 + 0x55 + idx) & 0xFF;
373         }
375         /* Clear receive buffer */
376         memset((void *)&rxBuf[0], 0x0, SPI_DATA_BLOCK_SIZE);
378         CacheP_wbInv((Ptr)txBuf, sizeof(txBuf));
379         CacheP_wbInv((Ptr)rxBuf, sizeof(rxBuf));
380         if(Test_spiReadWrite(handle, len, (void *)rxBuf, (void *)txBuf, slaveIndex) == 0)
381         {
382             /* Check data integrity */
383             if (memcmp((void *)txBuf, (void *)rxBuf, len) != 0)
384             {
385                 MIBSPI_log("Error: MIBSPI_transfer is successful with incorrect data(0x%x), length = %d\n", rxBuf[0], len);
386                 failed++;
387             }
388         }
389         else
390         {
391             MIBSPI_log("Debug: MIBSPI_transfer failed for length = %d\n", len);
392             failed++;
393         }
394     }
395     MIBSPI_log("Debug: Finished Digital loopback with various length test,  failed %d out of %d times\n", failed, loop);
397     /* Disable digital loopback */
398     loopback = MIBSPI_LOOPBK_NONE;
399     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
400         return -1;
402     /* Return number of failures */
403     return failed;
406 #ifdef MIBSPI_DMA_ENABLE
407 volatile uint32_t gTestCallbackDone = 0;
409 void Test_loopback_callbackFxn (MIBSPI_Handle handle,
410                                 MIBSPI_Transaction * transaction)
412     gTestCallbackDone = 1;
415 /**
416  *  @b Description
417  *  @n
418  *      This function tests SPI driver in Digital Loopback mode.
419  *
420  *   @param[in] handle            SPI driver handle
421  *   @param[in] slaveIndex        Flag for internal/external loopback
422  *   @param[in] maxElem           Maxim data element
423  *   @param[in] dataSize          Data size in number of bytes
424  *
425  *  @retval    Successful                   =0
426  *             Number of transfer failures  >0
427  *             API failures                 <0
428  */
429 static int32_t Test_spiLoopback_callback(const MIBSPI_Handle handle, uint8_t slaveIndex, uint32_t maxElem, uint8_t dataSize)
431     MibSpi_LoopBackType            loopback;
432     uint32_t           loop;
433     uint32_t           idx;
434     uint32_t           failed = 0;
435     uint32_t           len=0;
437     /* Only dataSize of 1 byte or 2 bytes are supported */
438     if ((dataSize != (uint8_t)1U) && (dataSize != (uint8_t)2U))
439         return -1;
441     /* Enable digital loopback */
442     loopback = MIBSPI_LOOPBK_DIGITAL;
443     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
444         return -1;
445     for(loop=0; loop < maxElem; loop++)
446     {
447         len = (maxElem - loop) * dataSize;
449         /* Prepare Tx/Rx Buffer */
450         for(idx=0; idx<maxElem * dataSize; idx++)
451         {
452             txBuf[idx] = (loop * 0x10 + 0x55 + idx) & 0xFF;
453         }
455         /* Clear receive buffer */
456         memset((void *)&rxBuf[0], 0x0, SPI_DATA_BLOCK_SIZE);
458         CacheP_wbInv((Ptr)txBuf, sizeof(txBuf));
459         CacheP_wbInv((Ptr)rxBuf, sizeof(rxBuf));
460         gTestCallbackDone = 0;
461         if(Test_spiReadWrite(handle, len, (void *)rxBuf, (void *)txBuf, slaveIndex) == 0)
462         {
463             /* Wait for the callback function. */
464             while (gTestCallbackDone == 0)
465             {
466                 /* waiting for the callback funciton to be called. */
467                 /* Need Nop so that interrupts get enabled atleast for a few cycles in C66x case */
468                 asm(" nop ");
469                 asm(" nop ");
470                 asm(" nop ");
471                 asm(" nop ");
472                 asm(" nop ");
473                 asm(" nop ");
474                 asm(" nop ");
475                 asm(" nop ");
476             }
477             /* Check data integrity */
478             if (memcmp((void *)txBuf, (void *)rxBuf, len) != 0)
479             {
480                 MIBSPI_log("Error: MIBSPI_transfer is successful with incorrect data(0x%x), length = %d\n", rxBuf[0], len);
481                 failed++;
482             }
483         }
484         else
485         {
486             MIBSPI_log("Debug: MIBSPI_transfer failed for length = %d\n", len);
487             failed++;
488         }
489     }
490     MIBSPI_log("Debug: Finished Digital loopback with various length test,  failed %d out of %d times\n", failed, loop);
492     /* Disable digital loopback */
493     loopback = MIBSPI_LOOPBK_NONE;
494     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
495         return -1;
497     /* Return number of failures */
498     return failed;
500 #endif
502 /**
503  *  @b Description
504  *  @n
505  *      This function tests SPI driver throughput in Loopback mode.
506  *      Test is performed with following configurations:
507  *       a. 16bits data size
508  *       b. one slave
509  *       c. Maximum data buffer
510  *
511  *   @param[in] inst             SPI instance (0=MibSPIA, 1=MibSPIB)
512  *   @param[in] bitRate          SPI clock bit rate
513  *
514  *  @retval
515  *      Not Applicable.
516  */
517 static void Test_spiLoopBackDataThroughput(uint32_t inst, uint32_t bitRate)
519     MIBSPI_Params       params;
520     MIBSPI_Handle       handle;
521     MIBSPI_Transaction  transaction;
522     MibSpi_LoopBackType loopback;
523     uint32_t         failed = 0;
524     uint32_t         idx=0;
525     uint32_t         loop;
526     volatile uint32_t  cycles;
527     float            throughput = 0;
529     /**************************************************************************
530      * Test: SPI Open
531      **************************************************************************/
532     /* Setup the default SPI Parameters */
533     MIBSPI_Params_init(&params);
534     params.frameFormat = MIBSPI_POL0_PHA0;
536     /* Enable DMA and set DMA channels to be used */
537 #ifdef MIBSPI_DMA_ENABLE
538     params.dmaEnable = 1;
539     params.dmaHandle = gDmaHandle[inst];
540 #else
541     params.dmaEnable = 0;
542     params.dmaHandle = NULL;
543 #endif
544     params.eccEnable = 0;
546     params.mode = MIBSPI_MASTER;
547     params.u.masterParams.bitRate = bitRate;
549     params.u.masterParams.numSlaves = 1U;
550     params.u.masterParams.slaveProf[0].chipSelect = 0U;
551     params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM;
552     params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
554     handle = MIBSPI_open(gMibspiInst[inst], &params);
555     if (handle == NULL)
556     {
557         MIBSPI_log("Error: Unable to open the SPI Instance\n");
559         return;
560     }
562     /* Set SPI Digital loopback mode */
563     loopback = MIBSPI_LOOPBK_DIGITAL;
564     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
565     {
566         return;
567     }
569     /* Prepare data in TX Buffer */
570     for(idx=0; idx<SPI_DATA_BLOCK_SIZE; idx++)
571     {
572         txBuf[idx] =  (0x55 + idx) & 0xFF;
573     }
575     memset((void *)&rxBuf[0], 0x0, SPI_DATA_BLOCK_SIZE);
577     CacheP_wbInv((Ptr)txBuf, sizeof(txBuf));
578     CacheP_wbInv((Ptr)rxBuf, sizeof(rxBuf));
580     // Start the counter
581     Test_benchmarkStart(0);
583     for(loop=0; loop < 10; loop++)
584     {
585         /* Configure Data Transfer */
586         transaction.count = SPI_DATA_BLOCK_SIZE;
587         transaction.txBuf = (void *)txBuf;
588         transaction.rxBuf = (void *)rxBuf;
589         transaction.slaveIndex = 0U;
591         /* Start Data Transfer */
592         if (MIBSPI_transfer(handle, &transaction) != true)
593         {
594             MIBSPI_log("Debug: MIBSPI_transfer failed for , loop=%d\n", loop);
595             failed++;
596         }
597     }
599     // Stop the counter
600     cycles = Test_benchmarkStop(0);
601     throughput = 8.0 * SPI_DATA_BLOCK_SIZE * loop  * VBUSP_FREQ / cycles;
603     MIBSPI_log("Debug: Finished Digital loopback througput test,  failed %d out of %d times\n", failed, loop);
605     /* Disable SPI Digital loopback mode */
606     loopback = MIBSPI_LOOPBK_NONE;
607     if (MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
608     {
609         return;
610     }
612     /* Check failures and return results */
613     if(failed == 0)
614     {
615         MIBSPI_log("SPI throughput at bitRate %d Kbps : %f Mbps", bitRate/1000, throughput);
616     }
617     else
618     {
620     }
622     /* Print hardware error stats */
623     Test_getSpiStats(handle, gPrintHwStats);
625     /* Close the driver: */
626     MIBSPI_close(handle);
629 /**
630  *  @b Description
631  *  @n
632  *       This function generates the test pattern for read/write test.
633  *
634  *   @param[in] buffer           Buffer pointer for the generated data
635  *   @param[in] dataLen          Buffer len (in bytes) for pattern generation
636  *
637  *  @retval    None
638  */
639 static void Test_generateTestPattern(volatile uint8_t * buffer, uint32_t dataLen)
641     uint32_t               index;
642     volatile uint8_t       *ptrBuff;
644     ptrBuff =  buffer;
645     for(index=0; index<dataLen; index++)
646     {
647         *ptrBuff = (index+0x55) & 0xFF;
648         ptrBuff++;
649     }
652 /**
653  *  @b Description
654  *  @n
655  *      This function tests SPI driver in SPI master mode.
656  *
657  *   @param[in] handle            SPI driver handle
658  *   @param[in] slaveIndex        Slave index for the SPI transfer
659  *
660  *  @retval
661  *      Not Applicable.
662  */
663 void Test_spiMasterWrite(const MIBSPI_Handle handle, uint8_t slaveIndex)
665     uint16_t    loop;
666     uint32_t    cycles;
667     uint32_t    delayCycles;
668     float       throughput;
669     uint32_t    delay = 8U * SPI_TEST_MSGLEN;
671     /* Initialize txBuf */
672     Test_generateTestPattern(txBuf, SPI_TEST_MSGLEN);
674     Test_benchmarkStart(0);
675     Test_benchmarkStart(1);
677     for (loop = 0; loop < SPI_TEST_LOOP; loop++)
678     {
679         /* Write data to slave */
680         txBuf[0] = loop;
681         Test_spiWrite(handle, SPI_TEST_MSGLEN, (void *)txBuf, slaveIndex);
683 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
684         Pmu_startCounter(1);
685 #endif
686         Test_delay(delay);
687 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
688         Pmu_stopCounter(1);
689 #endif
690     }
692     cycles = Test_benchmarkStop(0);
693 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
694     delayCycles = Pmu_getCount(1);
695 #else
696     delayCycles = 1000; //TODO
697 #endif
699     throughput = 8.0 * SPI_TEST_MSGLEN * loop  * VBUSP_FREQ / (cycles - delayCycles);
701     // Read and print the count
702     MIBSPI_log("Master write Throughput = %.2f Mbps\n", throughput);
705 /**
706  *  @b Description
707  *  @n
708  *      This function tests SPI driver master mode Read data from MSP  SPI slave.
709  *
710  *   @param[in] handle            SPI driver handle
711  *   @param[in] slaveIndex        Slave index for the SPI transfer
712  *
713  *  @retval
714  *      Not Applicable.
715  */
716 void Test_spiMasterRead(const MIBSPI_Handle handle, uint8_t slaveIndex)
718     uint16_t    loop;
719     uint32_t    cycles;
720     uint32_t    delayCycles;
721     float       throughput;
722     uint32_t    delay = 8U * SPI_TEST_MSGLEN;
724     Test_benchmarkStart(0);
725     Test_benchmarkStart(1);
727     for (loop=0; loop<SPI_TEST_LOOP; loop++)
728     {
729         /* Read data from slave */
730         Test_spiRead(handle, SPI_TEST_MSGLEN, (void *)rxBuf, slaveIndex);
731 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
732         Pmu_startCounter(1);
733 #endif
734         Test_delay(delay);
735 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
736         Pmu_stopCounter(1);
737 #endif
738         rxBuf[0] = loop;
739     }
740     cycles = Test_benchmarkStop(0);
741 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
742     delayCycles = Pmu_getCount(1);
743 #else
744     delayCycles = 1000;
745 #endif
747     throughput = 8.0 * SPI_TEST_MSGLEN * loop  * VBUSP_FREQ / (cycles -delayCycles) ;
749     // Read and print the count
750     MIBSPI_log("Debug: Master read Throughput = %.2f Mbps\n", throughput);
754 /**
755  *  @b Description
756  *  @n
757  *      This function tests SPI driver in slave  mode
758  *
759  *   @param[in] handle        SPI driver handle
760  *
761  *  @retval
762  *      Not Applicable.
763  */
764 void Test_spiSlaveRead(const MIBSPI_Handle handle)
766     uint16_t    loop;
768     for (loop=0; loop<SPI_TEST_LOOP; loop++)
769     {
770         /* Read two byte at a time */
771         {
772             Test_spiRead(handle, SPI_TEST_MSGLEN, (void *)rxBuf, 0U);
773         }
774     }
777 /**
778  *  @b Description
779  *  @n
780  *      This function tests SPI driver in slave mode.
781  *
782  *   @param[in] handle      SPI driver handle
783  *
784  *  @retval
785  *      Not Applicable.
786  */
787 void Test_spiSlaveWrite(const MIBSPI_Handle handle)
789     uint16_t    loop;
791     Test_generateTestPattern(txBuf, SPI_TEST_MSGLEN);
793     for (loop=0; loop<SPI_TEST_LOOP; loop++)
794     {
795         txBuf[0]= loop;
797         Test_spiWrite(handle, SPI_TEST_MSGLEN, (void *)txBuf, 0U);
798     }
803 /**
804  *  @b Description
805  *  @n
806  *      SPI API test for both instance - MibSPIA & MibSPIB.
807  *
808  *  @retval
809  *      Not Applicable.
810  */
811 void Test_spiAPI_twoInstance(void)
813     MIBSPI_Params     params;
814     MIBSPI_Handle     handleA = NULL;
815     MIBSPI_Handle     handleB = NULL;
816     uint32_t       instA = 0;
817     uint32_t       instB = 1;
818     char           testCase[64];
820     /**************************************************************************
821      * Test: Verify SPI open/close API
822      **************************************************************************/
823     snprintf(testCase, 64, "MIBSPI_open API test for two instances");
825     /* Setup the default SPIA Parameters */
826     MIBSPI_Params_init(&params);
828 #ifdef MIBSPI_DMA_ENABLE
829     /* Enable DMA and set DMA channels */
830     params.dmaEnable = 1;
831     params.dmaHandle = gDmaHandle[instA];
832 #else
833     params.dmaEnable = 0;
834     params.dmaHandle = NULL;
835 #endif
837     params.mode = MIBSPI_SLAVE;
838     params.u.slaveParams.dmaReqLine = 0;
840     /* Open the SPI Instance for MibSpiA */
841     handleA = MIBSPI_open(gMibspiInst[instA], &params);
842     if (handleA == NULL)
843     {
844         MIBSPI_log("Error: Unable to open the SPI Instance\n");
845         goto exit;
846     }
847     MIBSPI_log("Debug: SPI Instance(%d) %p has been opened successfully\n", instA, handleA);
849     /* Setup the default SPIB Parameters */
850     MIBSPI_Params_init(&params);
852 #ifdef MIBSPI_DMA_ENABLE
853     /* Enable DMA and set DMA channels */
854     params.dmaEnable = 1;
855     params.dmaHandle = gDmaHandle[instB];
856 #else
857     params.dmaEnable = 0;
858     params.dmaHandle = NULL;
859 #endif
861     params.mode = MIBSPI_SLAVE;
862     params.u.slaveParams.dmaReqLine = 0;
864     /* Open the SPI Instance for MibSpiB */
865     handleB = MIBSPI_open(gMibspiInst[instB], &params);
866     if (handleB == NULL)
867     {
868         MIBSPI_log("Error: Unable to open the SPI Instance\n");
869         goto exit;
870     }
871     MIBSPI_log("Debug: SPI Instance(1) %p has been opened successfully\n", handleB);
873     /* Close SPIA */
874     MIBSPI_close(handleA);
875     MIBSPI_log("Debug: SPI Instance(0) %p has been closed successfully\n", handleA);
876     handleA= NULL;
878     /* Close SPIB */
879     MIBSPI_close(handleB);
880     MIBSPI_log("Debug: SPI Instance(1) %p has been closed successfully\n", handleB);
881     handleB = NULL;
883     /**************************************************************************
884      * Test: Verify SPI API parameters for DMA channel configuration
885      **************************************************************************/
886     snprintf(testCase, 64, "MIBSPI_open API test for two instances: DMA channel validation");
888     /* Setup the default SPI Parameters */
889     MIBSPI_Params_init(&params);
891 #ifdef MIBSPI_DMA_ENABLE
892     /* Enable DMA and set DMA channels */
893     params.dmaEnable = 1;
894     params.dmaHandle = gDmaHandle[instA];
895 #else
896     params.dmaEnable = 0;
897     params.dmaHandle = NULL;
898 #endif
900     params.mode = MIBSPI_SLAVE;
901     params.u.slaveParams.dmaReqLine = 0U;
904     /* Open the SPI Instance for MibSpiA */
905     handleA = MIBSPI_open(gMibspiInst[instA], &params);
906     if (handleA != NULL)
907     {
908         MIBSPI_log("Debug: SPI Instance(0) %p has been opened successfully\n", handleA);
909     }
910     else
911     {
912         MIBSPI_log("Error: Failed to open SPI Instance(0)\n");
913         goto exit;
914     }
916 exit:
917     if(handleA != NULL)
918     {
919         MIBSPI_close(handleA);
920         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handleA);
921     }
923     if(handleB != NULL)
924     {
925         MIBSPI_close(handleB);
926         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handleB);
927     }
929     return;
932 /**
933  *  @b Description
934  *  @n
935  *      SPI API test for one instance.
936  *
937  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
938  *
939  *  @retval
940  *      Not Applicable.
941  */
942 void Test_spiAPI_oneInstance(uint8_t inst)
944     MIBSPI_Params     params;
945     MIBSPI_Handle     handle;
946     char           testCase[64];
948     /**************************************************************************
949      * Test: Verify SPI open/close API
950      **************************************************************************/
951     snprintf(testCase, 64, "MIBSPI_open API test (instance=%d)", inst);
953     /* Setup the default SPI Parameters */
954     MIBSPI_Params_init(&params);
956     params.mode = MIBSPI_SLAVE;
958     /* Enable DMA and set DMA channels */
959 #ifdef MIBSPI_DMA_ENABLE
960     params.dmaEnable = (uint8_t)1U;
961     params.dmaHandle = gDmaHandle[inst];
962 #else
963     params.dmaEnable = 0;
964     params.dmaHandle = NULL;
965 #endif
967     params.u.slaveParams.dmaReqLine = 0U;
969     /* Open the SPI Instance for MibSpi */
970     handle = MIBSPI_open(gMibspiInst[inst], &params);
971     if (handle == NULL)
972     {
973         MIBSPI_log("Error: Unable to open the SPI Instance\n");
974         return;
975     }
976     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
978     /* Close SPI */
979     MIBSPI_close(handle);
980     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
982     /**************************************************************************
983      * Test: Verify SPI parameters check::chipSelect
984      **************************************************************************/
985     snprintf(testCase, 64, "MIBSPI_open API test - chip select validation (instance=%d)", inst);
987     /* Setup the default SPI Parameters */
988     MIBSPI_Params_init(&params);
990     /* Enable DMA and set DMA channels */
991 #ifdef MIBSPI_DMA_ENABLE
992     params.dmaEnable = (uint8_t)1U;
993     params.dmaHandle = gDmaHandle[inst];
994 #else
995     params.dmaEnable = 0;
996     params.dmaHandle = NULL;
997 #endif
998     params.u.slaveParams.dmaReqLine = 0U;
1001     params.mode = MIBSPI_SLAVE;
1003     /* Incorrect chip select */
1004     params.u.slaveParams.chipSelect = (uint8_t)10U;
1006     /* Open the SPI Instance for MibSpiA */
1007     handle = MIBSPI_open(gMibspiInst[inst], &params);
1008     if (handle == NULL)
1009     {
1010     }
1011     else
1012     {
1013         /* Graceful shutdown */
1014         MIBSPI_close(handle);
1015         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1016     }
1018     /**************************************************************************
1019      * Test: Verify SPI open API for parameters check
1020      **************************************************************************/
1021     snprintf(testCase, 64, "MIBSPI_open API test - data size validation (instance=%d)", inst);
1023     /* Setup the default SPI Parameters */
1024     MIBSPI_Params_init(&params);
1026     /* Enable DMA and set DMA channels to be used */
1027 #ifdef MIBSPI_DMA_ENABLE
1028     params.dmaEnable = (uint8_t)1U;
1029     params.dmaHandle = gDmaHandle[inst];
1030 #else
1031     params.dmaEnable = 0;
1032     params.dmaHandle = NULL;
1033 #endif
1034     params.u.slaveParams.dmaReqLine  = 0U;
1037     params.mode = MIBSPI_SLAVE;
1039     /* Incorrect data Size */
1040     params.dataSize = 7U;
1042     /* Open the SPI Instance */
1043     handle = MIBSPI_open(gMibspiInst[inst], &params);
1044     if (handle == NULL)
1045     {
1047     }
1048     else
1049     {
1051         /* Graceful shutdown */
1052         MIBSPI_close(handle);
1053         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1054     }
1056     /**************************************************************************
1057      * Test: Verify SPI parameters check::master clock
1058      **************************************************************************/
1059     snprintf(testCase, 64, "MIBSPI_open API test - bit rate validation (instance=%d)", inst);
1061     /* Setup the default SPI Parameters */
1062     MIBSPI_Params_init(&params);
1064     /* Enable DMA and set DMA channels */
1065 #ifdef MIBSPI_DMA_ENABLE
1066     params.dmaEnable = (uint8_t)1U;
1067     params.dmaHandle = gDmaHandle[0];
1068 #else
1069     params.dmaEnable = 0;
1070     params.dmaHandle = NULL;
1071 #endif
1073     params.u.slaveParams.dmaReqLine  =0U;
1075     params.mode = MIBSPI_MASTER;
1076     params.u.masterParams.bitRate = 0;
1078     /* Open the SPI Instance for MibSpiA */
1079     handle = MIBSPI_open(gMibspiInst[0], &params);
1080     if (handle == NULL)
1081     {
1083     }
1084     else
1085     {
1088         /* Graceful shutdown */
1089         MIBSPI_close(handle);
1090         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1091     }
1093     /**************************************************************************
1094      * Test: Verify SPI transfer API for parameters check
1095      **************************************************************************/
1097     /* Setup the default SPI Parameters */
1098     MIBSPI_Params_init(&params);
1100     /* Enable DMA and set DMA channels to be used */
1101 #ifdef MIBSPI_DMA_ENABLE
1102     params.dmaEnable = (uint8_t)1U;
1103     params.dmaHandle = gDmaHandle[inst];
1104 #else
1105     params.dmaEnable = 0;
1106     params.dmaHandle = NULL;
1107 #endif
1109     params.dataSize = 16U;
1111     params.mode = MIBSPI_SLAVE;
1112     params.u.slaveParams.dmaReqLine  = 0U;
1114     MIBSPI_log("Debug: Open the SPI Instance for SPI transfer parameter check test\n");
1116     /* Open the SPI Instance for MibSpi */
1117     handle = MIBSPI_open(gMibspiInst[inst], &params);
1118     if (handle == NULL)
1119     {
1120         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1121     }
1122     else
1123     {
1124         MIBSPI_Transaction transaction;
1125         bool          ret;
1127         /* Configure Data Transfer */
1128         transaction.count = (uint16_t)1U;
1129         transaction.txBuf = (void *)txBuf;
1130         transaction.rxBuf = (void *)rxBuf;
1131         transaction.slaveIndex = (uint16_t)0U;
1133         snprintf(testCase, 64, "MIBSPI_transfer API test - data size=%d validation (instance=%d)", transaction.count, inst);
1135         /* Start Data Transfer */
1136         ret = MIBSPI_transfer(handle, &transaction);
1137         if (ret != true)
1138         {
1139             MIBSPI_log("Debug: MIBSPI_transfer with data size = %d failed with error=%d.\n", transaction.count, transaction.status );
1140         }
1141         else
1142         {
1143             MIBSPI_log("Error: MIBSPI_transfer with data size = %d should fail.\n", transaction.count);
1144         }
1146         /* Configure Data Transfer */
1147         transaction.count = (uint16_t)11U;
1148         transaction.txBuf = (void *)txBuf;
1149         transaction.rxBuf = (void *)rxBuf;
1150         transaction.slaveIndex = (uint16_t)0U;
1152         snprintf(testCase, 64, "MIBSPI_transfer API test - data size=%d validation (instance=%d)",transaction.count, inst);
1154         /* Start Data Transfer */
1155         ret = MIBSPI_transfer(handle, &transaction);
1156         if (ret != true)
1157         {
1158             MIBSPI_log("Debug: MIBSPI_transfer with data size = %d failed with error=%d. \n", transaction.count, transaction.status);
1159         }
1160         else
1161         {
1162             MIBSPI_log("Error: MIBSPI_transfer with data size = %d should fail.\n", transaction.count);
1163         }
1165         /* Configure Data Transfer */
1166         transaction.count = (uint16_t)10U;
1167         transaction.txBuf = (void *)NULL;
1168         transaction.rxBuf = (void *)NULL;
1169         transaction.slaveIndex = (uint16_t)0U;
1171         snprintf(testCase, 64, "MIBSPI_transfer API test - buffer address validation (instance=%d)", inst);
1173         /* Start Data Transfer */
1174         ret = MIBSPI_transfer(handle, &transaction);
1175         if (ret != true)
1176         {
1177             MIBSPI_log("Debug: MIBSPI_transfer failed with NULL pointers for both TX and RX with error=%d. \n", transaction.status);
1178         }
1179         else
1180         {
1181             MIBSPI_log("Error: MIBSPI_transfer with NULL pointers for both TX and RX should fail.\n");
1182         }
1184         /* Graceful shutdown */
1185         MIBSPI_close(handle);
1186         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1187     }
1190 /**
1191  *  @b Description
1192  *  @n
1193  *      SPI loopback test.
1194  *
1195  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
1196  *
1197  *  @retval
1198  *      Not Applicable.
1199  */
1200 void Test_loopback_oneInstance(uint32_t inst, uint8_t slaveIndex)
1202     MIBSPI_Params     params;
1203     MIBSPI_Handle     handle;
1204     char testCase[64];
1206     snprintf(testCase, 64, "SPI loopback test - instance(%d), 16bits DMA mode", inst);
1208     /**************************************************************************
1209      * Test: Open the driver in master mode for loopback test
1210      **************************************************************************/
1211     /* Setup the default SPI Parameters */
1212     MIBSPI_Params_init(&params);
1213     params.frameFormat = MIBSPI_POL0_PHA0;
1215     /* Enable DMA and set DMA channels to be used */
1216 #ifdef MIBSPI_DMA_ENABLE
1217     params.dmaEnable = 1;
1218     params.dmaHandle = gDmaHandle[inst];
1219 #else
1220     params.dmaEnable = 0;
1221     params.dmaHandle = NULL;
1222 #endif
1224     params.eccEnable = 0;
1225     params.mode = MIBSPI_MASTER;
1226     params.u.masterParams.bitRate = 1000000U;
1228     /* mibSPIA support only one slave */
1229     if(inst == 0)
1230     {
1231         params.u.masterParams.numSlaves = 1;
1232         params.u.masterParams.slaveProf[0].chipSelect = 0;
1233         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM;
1234         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1235     }
1236     else if(inst == 1)
1237     {
1238         /* The total element size of 3 slaves is MIBSPI_RAM_MAX_ELEM
1239          * In this example, it is distributed among 3 slaves by MIBSPI_RAM_MAX_ELEM - 6U, 4U, and 2U
1240          */
1241         memset((void *)&params.u.masterParams.slaveProf[0], 0, sizeof(params.u.masterParams.slaveProf));
1243         params.u.masterParams.numSlaves = 3;
1244         params.u.masterParams.slaveProf[0].chipSelect = 0;
1245         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM/2;
1246         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1247         params.u.masterParams.slaveProf[1].chipSelect = 1;
1248         params.u.masterParams.slaveProf[1].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1249         params.u.masterParams.slaveProf[1].dmaReqLine = 1U;
1250         params.u.masterParams.slaveProf[2].chipSelect = 2;
1251         params.u.masterParams.slaveProf[2].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1252         params.u.masterParams.slaveProf[2].dmaReqLine = 2U;
1253     }
1254     else
1255     {
1256         printf("Error: Invalid instance(=%d) of MibSPI\n", inst);
1257     }
1259     handle = MIBSPI_open(gMibspiInst[inst], &params);
1260     if (handle == NULL)
1261     {
1262         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1263         return;
1264     }
1265     MIBSPI_log("Debug: SPI Instance %p has been reopened in master mode successfully\n", handle);
1267     /* Start Internal Loopback Test in master mode */
1268     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 2) == 0)
1269     {
1271     }
1272     else
1273     {
1275     }
1277     /* Close the driver: */
1278     MIBSPI_close(handle);
1279     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1281     /**************************************************************************
1282      * Test: Reopen the driver in master mode for loopback test without DMA
1283      **************************************************************************/
1284     snprintf(testCase, 64, "SPI loopback test - instance(%d), 16bits non-DMA mode", inst);
1286     /* Change dma configuration */
1287     params.dmaEnable = 0;
1289     handle = MIBSPI_open(gMibspiInst[inst], &params);
1290     if (handle == NULL)
1291     {
1292         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1293         return;
1294     }
1295     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
1297     /* Start Internal Loopback Test in master mode */
1298     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 2) == 0U)
1299     {
1301     }
1302     else
1303     {
1305     }
1307     /* Close the driver: */
1308     MIBSPI_close(handle);
1309     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1311     /**************************************************************************
1312      * Test: Reopen the driver in master mode for loopback test DMA enabled 8bits
1313      **************************************************************************/
1314     snprintf(testCase, 64, "SPI loopback test - instance(%d), 8bits DMA mode", inst);
1316     params.dataSize =8;
1317 #ifdef MIBSPI_DMA_ENABLE
1318     /* Change dma configuration */
1319     params.dmaEnable = 1;
1320 #else
1321     params.dmaEnable = 0;
1322     params.dmaHandle = NULL;
1323 #endif
1326     handle = MIBSPI_open(gMibspiInst[inst], &params);
1327     if (handle == NULL)
1328     {
1329         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1330         return;
1331     }
1332     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
1334     /* Start Internal Loopback Test in master mode */
1335     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 1) == 0U)
1336     {
1338     }
1339     else
1340     {
1342     }
1344     /* Close the driver: */
1345     MIBSPI_close(handle);
1346     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1348     /**************************************************************************
1349      * Test: Reopen the driver in master mode for loopback test DMA enabled 8bits
1350      **************************************************************************/
1351     snprintf(testCase, 64, "SPI loopback test - instance(%d), 8bits non-DMA mode", inst);
1353     /* Change dma configuration */
1354     params.dmaEnable = 0;
1355     params.dataSize =8;
1357     handle = MIBSPI_open(gMibspiInst[inst], &params);
1358     if (handle == NULL)
1359     {
1360         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1361         return;
1362     }
1363     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
1365     /* Start Internal Loopback Test in master mode */
1366     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 1) == 0U)
1367     {
1369     }
1370     else
1371     {
1373     }
1375     /* Close the driver: */
1376     MIBSPI_close(handle);
1377     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1379     /**************************************************************************
1380      * Test: Reopen the driver in master mode for loopback throughput test
1381      **************************************************************************/
1382     /* Start Loopback throughput Test in master mode */
1383     Test_spiLoopBackDataThroughput(inst, 1000000U);
1385     /* Start Loopback throughput Test in master mode */
1386     Test_spiLoopBackDataThroughput(inst, 2000000U);
1388     /* Start Loopback throughput Test in master mode */
1389     Test_spiLoopBackDataThroughput(inst, 6000000U);
1391     /* Start Loopback throughput Test in master mode */
1392     Test_spiLoopBackDataThroughput(inst, 10000000U);
1394     /* Start Loopback throughput Test in master mode */
1395     Test_spiLoopBackDataThroughput(inst, 20000000U);
1397     /* Start Loopback throughput Test in master mode */
1398     Test_spiLoopBackDataThroughput(inst, 40000000U);
1401 #ifdef MIBSPI_DMA_ENABLE
1402 /**
1403  *  @b Description
1404  *  @n
1405  *      SPI loopback test.
1406  *
1407  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
1408  *
1409  *  @retval
1410  *      Not Applicable.
1411  */
1412 void Test_loopback_oneInstance_callback(uint32_t inst, uint8_t slaveIndex)
1414     MIBSPI_Params     params;
1415     MIBSPI_Handle     handle;
1416     char testCase[64];
1418     snprintf(testCase, 64, "SPI loopback test callback mode - instance(%d), 16bits DMA mode", inst);
1420     /**************************************************************************
1421      * Test: Open the driver in master mode for loopback test
1422      **************************************************************************/
1423     /* Setup the default SPI Parameters */
1424     MIBSPI_Params_init(&params);
1425     params.frameFormat = MIBSPI_POL0_PHA0;
1427     /* Configure for the callback mode. */
1428     params.transferMode = MIBSPI_MODE_CALLBACK;
1429     params.transferCallbackFxn = &Test_loopback_callbackFxn;
1431     /* Enable DMA and set DMA channels to be used */
1432     params.dmaEnable = 1;
1433     params.dmaHandle = gDmaHandle[inst];
1435     params.eccEnable = 0;
1436     params.mode = MIBSPI_MASTER;
1437     params.u.masterParams.bitRate = 1000000U;
1439     /* mibSPIA support only one slave */
1440     if(inst == 0)
1441     {
1442         params.u.masterParams.numSlaves = 1;
1443         params.u.masterParams.slaveProf[0].chipSelect = 0;
1444         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM;
1445         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1446     }
1447     else if(inst == 1)
1448     {
1449         /* The total element size of 3 slaves is MIBSPI_RAM_MAX_ELEM
1450          * In this example, it is distributed among 3 slaves by MIBSPI_RAM_MAX_ELEM - 6U, 4U, and 2U
1451          */
1452         memset((void *)&params.u.masterParams.slaveProf[0], 0, sizeof(params.u.masterParams.slaveProf));
1454         params.u.masterParams.numSlaves = 3;
1455         params.u.masterParams.slaveProf[0].chipSelect = 0;
1456         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM/2;
1457         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1458         params.u.masterParams.slaveProf[1].chipSelect = 1;
1459         params.u.masterParams.slaveProf[1].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1460         params.u.masterParams.slaveProf[1].dmaReqLine = 1U;
1461         params.u.masterParams.slaveProf[2].chipSelect = 2;
1462         params.u.masterParams.slaveProf[2].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1463         params.u.masterParams.slaveProf[2].dmaReqLine = 2U;
1464     }
1465     else
1466     {
1467         printf("Error: Invalid instance(=%d) of MibSPI\n", inst);
1468     }
1470     handle = MIBSPI_open(gMibspiInst[inst], &params);
1471     if (handle == NULL)
1472     {
1473         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1474         return;
1475     }
1476     MIBSPI_log("Debug: SPI Instance %p has been reopened in master mode successfully\n", handle);
1478     /* Start Internal Loopback Test in master mode */
1479     if(Test_spiLoopback_callback(handle, slaveIndex, 128, 2) == 0)
1480     {
1482     }
1483     else
1484     {
1486     }
1488     /* Close the driver: */
1489     MIBSPI_close(handle);
1490     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1492 #endif
1494 /**
1495  *  @b Description
1496  *  @n
1497  *      SPI loopback test.
1498  *
1499  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
1500  *
1501  *  @retval
1502  *      Not Applicable.
1503  */
1504 void Test_loopbackSlave_oneInstance(uint32_t inst)
1506     MIBSPI_Params     params;
1507     MIBSPI_Handle     handle;
1508     char testCase[64];
1510     snprintf(testCase, 64, "SPI loopback test - instance(%d), 16bits DMA mode", inst);
1512     /**************************************************************************
1513      * Test: Open the driver in master mode for loopback test
1514      **************************************************************************/
1515     /* Setup the default SPI Parameters */
1516     MIBSPI_Params_init(&params);
1517     params.frameFormat = MIBSPI_POL0_PHA0;
1519     /* Enable DMA and set DMA channels to be used */
1520 #ifdef MIBSPI_DMA_ENABLE
1521     params.dmaEnable = 1;
1522     params.dmaHandle = gDmaHandle[inst];
1523 #else
1524     params.dmaEnable = 0;
1525     params.dmaHandle = NULL;
1526 #endif
1528     params.eccEnable = 0;
1529     params.mode = MIBSPI_SLAVE;
1531     params.u.slaveParams.dmaReqLine = 0;
1532     params.u.slaveParams.chipSelect = 0;
1534     handle = MIBSPI_open(gMibspiInst[inst], &params);
1535     if (handle == NULL)
1536     {
1537         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1538         return;
1539     }
1540     MIBSPI_log("Debug: SPI Instance %p has been reopened in master mode successfully\n", handle);
1542     /* Start Internal Loopback Test in master mode */
1543     if(Test_spiLoopbackSlave(handle, MIBSPI_RAM_MAX_ELEM, 2) == 0)
1544     {
1546     }
1547     else
1548     {
1550     }
1552     /* Close the driver: */
1553     MIBSPI_close(handle);
1554     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1558 /**
1559  *  @b Description
1560  *  @n
1561  *      This function tests SPI driver in Digital Loopback mode.
1562  *
1563  *   @param[in] handle            SPI driver handle
1564  *   @param[in] slaveIndex        Flag for internal/external loopback
1565  *   @param[in] maxElem           Maxim data element
1566  *   @param[in] dataSize          Data size in number of bytes
1567  *
1568  *  @retval    Successful                   =0
1569  *             Number of transfer failures  >0
1570  *             API failures                 <0
1571  */
1572 static int32_t Test_spiLoopbackSlave(const MIBSPI_Handle handle, uint32_t maxElem, uint8_t dataSize)
1574     MibSpi_LoopBackType            loopback;
1575     uint32_t           loop;
1576     uint32_t           idx;
1577     uint32_t           failed = 0;
1578     uint32_t           len=0;
1580     /* Only dataSize of 1 byte or 2 bytes are supported */
1581     if ((dataSize != (uint8_t)1U) && (dataSize != (uint8_t)2U))
1582         return -1;
1584     /* Enable digital loopback */
1585     loopback = MIBSPI_LOOPBK_ANALOG;
1586     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
1587         return -1;
1588     for(loop=0; loop < maxElem; loop++)
1589     {
1590         len = (maxElem - loop) * dataSize;
1592         /* Prepare Tx/Rx Buffer */
1593         for(idx=0; idx<maxElem * dataSize; idx++)
1594         {
1595             txBuf[idx] = (loop * 0x10 + 0x55 + idx) & 0xFF;
1596         }
1598         /* Clear receive buffer */
1599         memset((void *)&rxBuf[0], 0x0, SPI_DATA_BLOCK_SIZE);
1601         CacheP_wbInv((Ptr)txBuf, sizeof(txBuf));
1602         CacheP_wbInv((Ptr)rxBuf, sizeof(rxBuf));
1603         if(Test_spiReadWrite(handle, len, (void *)rxBuf, (void *)txBuf, 0) == 0)
1604         {
1605             /* Check data integrity */
1606             if (memcmp((void *)txBuf, (void *)rxBuf, len) != 0)
1607             {
1608                 #if 0 /* Temporarily disable integrity check for MIBSPI SLAVE mode analog loopback until test setup issue is resolved */
1609                 MIBSPI_log("Error: MIBSPI_transfer is successful with incorrect data(0x%x), length = %d\n", rxBuf[0], len);
1610                 #endif
1611                 failed++;
1612             }
1613         }
1614         else
1615         {
1616             MIBSPI_log("Debug: MIBSPI_transfer failed for length = %d\n", len);
1617             failed++;
1618         }
1619     }
1620     MIBSPI_log("Debug: Finished Analog loopback with various length test,  failed %d out of %d times\n", failed, loop);
1622     /* Disable digital loopback */
1623     loopback = MIBSPI_LOOPBK_NONE;
1624     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
1625         return -1;
1627     /* Return number of failures */
1628     return failed;