d120c5f51106797f71d238968f0aa29212832937
[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 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             }
468             /* Check data integrity */
469             if (memcmp((void *)txBuf, (void *)rxBuf, len) != 0)
470             {
471                 MIBSPI_log("Error: MIBSPI_transfer is successful with incorrect data(0x%x), length = %d\n", rxBuf[0], len);
472                 failed++;
473             }
474         }
475         else
476         {
477             MIBSPI_log("Debug: MIBSPI_transfer failed for length = %d\n", len);
478             failed++;
479         }
480     }
481     MIBSPI_log("Debug: Finished Digital loopback with various length test,  failed %d out of %d times\n", failed, loop);
483     /* Disable digital loopback */
484     loopback = MIBSPI_LOOPBK_NONE;
485     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
486         return -1;
488     /* Return number of failures */
489     return failed;
491 #endif
493 /**
494  *  @b Description
495  *  @n
496  *      This function tests SPI driver throughput in Loopback mode.
497  *      Test is performed with following configurations:
498  *       a. 16bits data size
499  *       b. one slave
500  *       c. Maximum data buffer
501  *
502  *   @param[in] inst             SPI instance (0=MibSPIA, 1=MibSPIB)
503  *   @param[in] bitRate          SPI clock bit rate
504  *
505  *  @retval
506  *      Not Applicable.
507  */
508 static void Test_spiLoopBackDataThroughput(uint32_t inst, uint32_t bitRate)
510     MIBSPI_Params       params;
511     MIBSPI_Handle       handle;
512     MIBSPI_Transaction  transaction;
513     MibSpi_LoopBackType loopback;
514     uint32_t         failed = 0;
515     uint32_t         idx=0;
516     uint32_t         loop;
517     volatile uint32_t  cycles;
518     float            throughput = 0;
520     /**************************************************************************
521      * Test: SPI Open
522      **************************************************************************/
523     /* Setup the default SPI Parameters */
524     MIBSPI_Params_init(&params);
525     params.frameFormat = MIBSPI_POL0_PHA0;
527     /* Enable DMA and set DMA channels to be used */
528 #ifdef MIBSPI_DMA_ENABLE
529     params.dmaEnable = 1;
530     params.dmaHandle = gDmaHandle[inst];
531 #else
532     params.dmaEnable = 0;
533     params.dmaHandle = NULL;
534 #endif
535     params.eccEnable = 0;
537     params.mode = MIBSPI_MASTER;
538     params.u.masterParams.bitRate = bitRate;
540     params.u.masterParams.numSlaves = 1U;
541     params.u.masterParams.slaveProf[0].chipSelect = 0U;
542     params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM;
543     params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
545     handle = MIBSPI_open(gMibspiInst[inst], &params);
546     if (handle == NULL)
547     {
548         MIBSPI_log("Error: Unable to open the SPI Instance\n");
550         return;
551     }
553     /* Set SPI Digital loopback mode */
554     loopback = MIBSPI_LOOPBK_DIGITAL;
555     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
556     {
557         return;
558     }
560     /* Prepare data in TX Buffer */
561     for(idx=0; idx<SPI_DATA_BLOCK_SIZE; idx++)
562     {
563         txBuf[idx] =  (0x55 + idx) & 0xFF;
564     }
566     memset((void *)&rxBuf[0], 0x0, SPI_DATA_BLOCK_SIZE);
568     CacheP_wbInv((Ptr)txBuf, sizeof(txBuf));
569     CacheP_wbInv((Ptr)rxBuf, sizeof(rxBuf));
571     // Start the counter
572     Test_benchmarkStart(0);
574     for(loop=0; loop < 10; loop++)
575     {
576         /* Configure Data Transfer */
577         transaction.count = SPI_DATA_BLOCK_SIZE;
578         transaction.txBuf = (void *)txBuf;
579         transaction.rxBuf = (void *)rxBuf;
580         transaction.slaveIndex = 0U;
582         /* Start Data Transfer */
583         if (MIBSPI_transfer(handle, &transaction) != true)
584         {
585             MIBSPI_log("Debug: MIBSPI_transfer failed for , loop=%d\n", loop);
586             failed++;
587         }
588     }
590     // Stop the counter
591     cycles = Test_benchmarkStop(0);
592     throughput = 8.0 * SPI_DATA_BLOCK_SIZE * loop  * VBUSP_FREQ / cycles;
594     MIBSPI_log("Debug: Finished Digital loopback througput test,  failed %d out of %d times\n", failed, loop);
596     /* Disable SPI Digital loopback mode */
597     loopback = MIBSPI_LOOPBK_NONE;
598     if (MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
599     {
600         return;
601     }
603     /* Check failures and return results */
604     if(failed == 0)
605     {
606         MIBSPI_log("SPI throughput at bitRate %d Kbps : %f Mbps", bitRate/1000, throughput);
607     }
608     else
609     {
611     }
613     /* Print hardware error stats */
614     Test_getSpiStats(handle, gPrintHwStats);
616     /* Close the driver: */
617     MIBSPI_close(handle);
620 /**
621  *  @b Description
622  *  @n
623  *       This function generates the test pattern for read/write test.
624  *
625  *   @param[in] buffer           Buffer pointer for the generated data
626  *   @param[in] dataLen          Buffer len (in bytes) for pattern generation
627  *
628  *  @retval    None
629  */
630 static void Test_generateTestPattern(volatile uint8_t * buffer, uint32_t dataLen)
632     uint32_t               index;
633     volatile uint8_t       *ptrBuff;
635     ptrBuff =  buffer;
636     for(index=0; index<dataLen; index++)
637     {
638         *ptrBuff = (index+0x55) & 0xFF;
639         ptrBuff++;
640     }
643 /**
644  *  @b Description
645  *  @n
646  *      This function tests SPI driver in SPI master mode.
647  *
648  *   @param[in] handle            SPI driver handle
649  *   @param[in] slaveIndex        Slave index for the SPI transfer
650  *
651  *  @retval
652  *      Not Applicable.
653  */
654 void Test_spiMasterWrite(const MIBSPI_Handle handle, uint8_t slaveIndex)
656     uint16_t    loop;
657     uint32_t    cycles;
658     uint32_t    delayCycles;
659     float       throughput;
660     uint32_t    delay = 8U * SPI_TEST_MSGLEN;
662     /* Initialize txBuf */
663     Test_generateTestPattern(txBuf, SPI_TEST_MSGLEN);
665     Test_benchmarkStart(0);
666     Test_benchmarkStart(1);
668     for (loop = 0; loop < SPI_TEST_LOOP; loop++)
669     {
670         /* Write data to slave */
671         txBuf[0] = loop;
672         Test_spiWrite(handle, SPI_TEST_MSGLEN, (void *)txBuf, slaveIndex);
674 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
675         Pmu_startCounter(1);
676 #endif
677         Test_delay(delay);
678 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
679         Pmu_stopCounter(1);
680 #endif
681     }
683     cycles = Test_benchmarkStop(0);
684 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
685     delayCycles = Pmu_getCount(1);
686 #else
687     delayCycles = 1000; //TODO
688 #endif
690     throughput = 8.0 * SPI_TEST_MSGLEN * loop  * VBUSP_FREQ / (cycles - delayCycles);
692     // Read and print the count
693     MIBSPI_log("Master write Throughput = %.2f Mbps\n", throughput);
696 /**
697  *  @b Description
698  *  @n
699  *      This function tests SPI driver master mode Read data from MSP  SPI slave.
700  *
701  *   @param[in] handle            SPI driver handle
702  *   @param[in] slaveIndex        Slave index for the SPI transfer
703  *
704  *  @retval
705  *      Not Applicable.
706  */
707 void Test_spiMasterRead(const MIBSPI_Handle handle, uint8_t slaveIndex)
709     uint16_t    loop;
710     uint32_t    cycles;
711     uint32_t    delayCycles;
712     float       throughput;
713     uint32_t    delay = 8U * SPI_TEST_MSGLEN;
715     Test_benchmarkStart(0);
716     Test_benchmarkStart(1);
718     for (loop=0; loop<SPI_TEST_LOOP; loop++)
719     {
720         /* Read data from slave */
721         Test_spiRead(handle, SPI_TEST_MSGLEN, (void *)rxBuf, slaveIndex);
722 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
723         Pmu_startCounter(1);
724 #endif
725         Test_delay(delay);
726 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
727         Pmu_stopCounter(1);
728 #endif
729         rxBuf[0] = loop;
730     }
731     cycles = Test_benchmarkStop(0);
732 #if (defined (USE_BIOS) && (BUILD_MCU1_0))
733     delayCycles = Pmu_getCount(1);
734 #else
735     delayCycles = 1000;
736 #endif
738     throughput = 8.0 * SPI_TEST_MSGLEN * loop  * VBUSP_FREQ / (cycles -delayCycles) ;
740     // Read and print the count
741     MIBSPI_log("Debug: Master read Throughput = %.2f Mbps\n", throughput);
745 /**
746  *  @b Description
747  *  @n
748  *      This function tests SPI driver in slave  mode
749  *
750  *   @param[in] handle        SPI driver handle
751  *
752  *  @retval
753  *      Not Applicable.
754  */
755 void Test_spiSlaveRead(const MIBSPI_Handle handle)
757     uint16_t    loop;
759     for (loop=0; loop<SPI_TEST_LOOP; loop++)
760     {
761         /* Read two byte at a time */
762         {
763             Test_spiRead(handle, SPI_TEST_MSGLEN, (void *)rxBuf, 0U);
764         }
765     }
768 /**
769  *  @b Description
770  *  @n
771  *      This function tests SPI driver in slave mode.
772  *
773  *   @param[in] handle      SPI driver handle
774  *
775  *  @retval
776  *      Not Applicable.
777  */
778 void Test_spiSlaveWrite(const MIBSPI_Handle handle)
780     uint16_t    loop;
782     Test_generateTestPattern(txBuf, SPI_TEST_MSGLEN);
784     for (loop=0; loop<SPI_TEST_LOOP; loop++)
785     {
786         txBuf[0]= loop;
788         Test_spiWrite(handle, SPI_TEST_MSGLEN, (void *)txBuf, 0U);
789     }
794 /**
795  *  @b Description
796  *  @n
797  *      SPI API test for both instance - MibSPIA & MibSPIB.
798  *
799  *  @retval
800  *      Not Applicable.
801  */
802 void Test_spiAPI_twoInstance(void)
804     MIBSPI_Params     params;
805     MIBSPI_Handle     handleA = NULL;
806     MIBSPI_Handle     handleB = NULL;
807     uint32_t       instA = 0;
808     uint32_t       instB = 1;
809     char           testCase[64];
811     /**************************************************************************
812      * Test: Verify SPI open/close API
813      **************************************************************************/
814     snprintf(testCase, 64, "MIBSPI_open API test for two instances");
816     /* Setup the default SPIA Parameters */
817     MIBSPI_Params_init(&params);
819 #ifdef MIBSPI_DMA_ENABLE
820     /* Enable DMA and set DMA channels */
821     params.dmaEnable = 1;
822     params.dmaHandle = gDmaHandle[instA];
823 #else
824     params.dmaEnable = 0;
825     params.dmaHandle = NULL;
826 #endif
828     params.mode = MIBSPI_SLAVE;
829     params.u.slaveParams.dmaReqLine = 0;
831     /* Open the SPI Instance for MibSpiA */
832     handleA = MIBSPI_open(gMibspiInst[instA], &params);
833     if (handleA == NULL)
834     {
835         MIBSPI_log("Error: Unable to open the SPI Instance\n");
836         goto exit;
837     }
838     MIBSPI_log("Debug: SPI Instance(%d) %p has been opened successfully\n", instA, handleA);
840     /* Setup the default SPIB Parameters */
841     MIBSPI_Params_init(&params);
843 #ifdef MIBSPI_DMA_ENABLE
844     /* Enable DMA and set DMA channels */
845     params.dmaEnable = 1;
846     params.dmaHandle = gDmaHandle[instB];
847 #else
848     params.dmaEnable = 0;
849     params.dmaHandle = NULL;
850 #endif
852     params.mode = MIBSPI_SLAVE;
853     params.u.slaveParams.dmaReqLine = 0;
855     /* Open the SPI Instance for MibSpiB */
856     handleB = MIBSPI_open(gMibspiInst[instB], &params);
857     if (handleB == NULL)
858     {
859         MIBSPI_log("Error: Unable to open the SPI Instance\n");
860         goto exit;
861     }
862     MIBSPI_log("Debug: SPI Instance(1) %p has been opened successfully\n", handleB);
864     /* Close SPIA */
865     MIBSPI_close(handleA);
866     MIBSPI_log("Debug: SPI Instance(0) %p has been closed successfully\n", handleA);
867     handleA= NULL;
869     /* Close SPIB */
870     MIBSPI_close(handleB);
871     MIBSPI_log("Debug: SPI Instance(1) %p has been closed successfully\n", handleB);
872     handleB = NULL;
874     /**************************************************************************
875      * Test: Verify SPI API parameters for DMA channel configuration
876      **************************************************************************/
877     snprintf(testCase, 64, "MIBSPI_open API test for two instances: DMA channel validation");
879     /* Setup the default SPI Parameters */
880     MIBSPI_Params_init(&params);
882 #ifdef MIBSPI_DMA_ENABLE
883     /* Enable DMA and set DMA channels */
884     params.dmaEnable = 1;
885     params.dmaHandle = gDmaHandle[instA];
886 #else
887     params.dmaEnable = 0;
888     params.dmaHandle = NULL;
889 #endif
891     params.mode = MIBSPI_SLAVE;
892     params.u.slaveParams.dmaReqLine = 0U;
895     /* Open the SPI Instance for MibSpiA */
896     handleA = MIBSPI_open(gMibspiInst[instA], &params);
897     if (handleA != NULL)
898     {
899         MIBSPI_log("Debug: SPI Instance(0) %p has been opened successfully\n", handleA);
900     }
901     else
902     {
903         MIBSPI_log("Error: Failed to open SPI Instance(0)\n");
904         goto exit;
905     }
907 exit:
908     if(handleA != NULL)
909     {
910         MIBSPI_close(handleA);
911         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handleA);
912     }
914     if(handleB != NULL)
915     {
916         MIBSPI_close(handleB);
917         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handleB);
918     }
920     return;
923 /**
924  *  @b Description
925  *  @n
926  *      SPI API test for one instance.
927  *
928  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
929  *
930  *  @retval
931  *      Not Applicable.
932  */
933 void Test_spiAPI_oneInstance(uint8_t inst)
935     MIBSPI_Params     params;
936     MIBSPI_Handle     handle;
937     char           testCase[64];
939     /**************************************************************************
940      * Test: Verify SPI open/close API
941      **************************************************************************/
942     snprintf(testCase, 64, "MIBSPI_open API test (instance=%d)", inst);
944     /* Setup the default SPI Parameters */
945     MIBSPI_Params_init(&params);
947     params.mode = MIBSPI_SLAVE;
949     /* Enable DMA and set DMA channels */
950 #ifdef MIBSPI_DMA_ENABLE
951     params.dmaEnable = (uint8_t)1U;
952     params.dmaHandle = gDmaHandle[inst];
953 #else
954     params.dmaEnable = 0;
955     params.dmaHandle = NULL;
956 #endif
958     params.u.slaveParams.dmaReqLine = 0U;
960     /* Open the SPI Instance for MibSpi */
961     handle = MIBSPI_open(gMibspiInst[inst], &params);
962     if (handle == NULL)
963     {
964         MIBSPI_log("Error: Unable to open the SPI Instance\n");
965         return;
966     }
967     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
969     /* Close SPI */
970     MIBSPI_close(handle);
971     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
973     /**************************************************************************
974      * Test: Verify SPI parameters check::chipSelect
975      **************************************************************************/
976     snprintf(testCase, 64, "MIBSPI_open API test - chip select validation (instance=%d)", inst);
978     /* Setup the default SPI Parameters */
979     MIBSPI_Params_init(&params);
981     /* Enable DMA and set DMA channels */
982 #ifdef MIBSPI_DMA_ENABLE
983     params.dmaEnable = (uint8_t)1U;
984     params.dmaHandle = gDmaHandle[inst];
985 #else
986     params.dmaEnable = 0;
987     params.dmaHandle = NULL;
988 #endif
989     params.u.slaveParams.dmaReqLine = 0U;
992     params.mode = MIBSPI_SLAVE;
994     /* Incorrect chip select */
995     params.u.slaveParams.chipSelect = (uint8_t)10U;
997     /* Open the SPI Instance for MibSpiA */
998     handle = MIBSPI_open(gMibspiInst[inst], &params);
999     if (handle == NULL)
1000     {
1001     }
1002     else
1003     {
1004         /* Graceful shutdown */
1005         MIBSPI_close(handle);
1006         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1007     }
1009     /**************************************************************************
1010      * Test: Verify SPI open API for parameters check
1011      **************************************************************************/
1012     snprintf(testCase, 64, "MIBSPI_open API test - data size validation (instance=%d)", inst);
1014     /* Setup the default SPI Parameters */
1015     MIBSPI_Params_init(&params);
1017     /* Enable DMA and set DMA channels to be used */
1018 #ifdef MIBSPI_DMA_ENABLE
1019     params.dmaEnable = (uint8_t)1U;
1020     params.dmaHandle = gDmaHandle[inst];
1021 #else
1022     params.dmaEnable = 0;
1023     params.dmaHandle = NULL;
1024 #endif
1025     params.u.slaveParams.dmaReqLine  = 0U;
1028     params.mode = MIBSPI_SLAVE;
1030     /* Incorrect data Size */
1031     params.dataSize = 7U;
1033     /* Open the SPI Instance */
1034     handle = MIBSPI_open(gMibspiInst[inst], &params);
1035     if (handle == NULL)
1036     {
1038     }
1039     else
1040     {
1042         /* Graceful shutdown */
1043         MIBSPI_close(handle);
1044         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1045     }
1047     /**************************************************************************
1048      * Test: Verify SPI parameters check::master clock
1049      **************************************************************************/
1050     snprintf(testCase, 64, "MIBSPI_open API test - bit rate validation (instance=%d)", inst);
1052     /* Setup the default SPI Parameters */
1053     MIBSPI_Params_init(&params);
1055     /* Enable DMA and set DMA channels */
1056 #ifdef MIBSPI_DMA_ENABLE
1057     params.dmaEnable = (uint8_t)1U;
1058     params.dmaHandle = gDmaHandle[0];
1059 #else
1060     params.dmaEnable = 0;
1061     params.dmaHandle = NULL;
1062 #endif
1064     params.u.slaveParams.dmaReqLine  =0U;
1066     params.mode = MIBSPI_MASTER;
1067     params.u.masterParams.bitRate = 0;
1069     /* Open the SPI Instance for MibSpiA */
1070     handle = MIBSPI_open(gMibspiInst[0], &params);
1071     if (handle == NULL)
1072     {
1074     }
1075     else
1076     {
1079         /* Graceful shutdown */
1080         MIBSPI_close(handle);
1081         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1082     }
1084     /**************************************************************************
1085      * Test: Verify SPI transfer API for parameters check
1086      **************************************************************************/
1088     /* Setup the default SPI Parameters */
1089     MIBSPI_Params_init(&params);
1091     /* Enable DMA and set DMA channels to be used */
1092 #ifdef MIBSPI_DMA_ENABLE
1093     params.dmaEnable = (uint8_t)1U;
1094     params.dmaHandle = gDmaHandle[inst];
1095 #else
1096     params.dmaEnable = 0;
1097     params.dmaHandle = NULL;
1098 #endif
1100     params.dataSize = 16U;
1102     params.mode = MIBSPI_SLAVE;
1103     params.u.slaveParams.dmaReqLine  = 0U;
1105     MIBSPI_log("Debug: Open the SPI Instance for SPI transfer parameter check test\n");
1107     /* Open the SPI Instance for MibSpi */
1108     handle = MIBSPI_open(gMibspiInst[inst], &params);
1109     if (handle == NULL)
1110     {
1111         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1112     }
1113     else
1114     {
1115         MIBSPI_Transaction transaction;
1116         bool          ret;
1118         /* Configure Data Transfer */
1119         transaction.count = (uint16_t)1U;
1120         transaction.txBuf = (void *)txBuf;
1121         transaction.rxBuf = (void *)rxBuf;
1122         transaction.slaveIndex = (uint16_t)0U;
1124         snprintf(testCase, 64, "MIBSPI_transfer API test - data size=%d validation (instance=%d)", transaction.count, inst);
1126         /* Start Data Transfer */
1127         ret = MIBSPI_transfer(handle, &transaction);
1128         if (ret != true)
1129         {
1130             MIBSPI_log("Debug: MIBSPI_transfer with data size = %d failed with error=%d.\n", transaction.count, transaction.status );
1131         }
1132         else
1133         {
1134             MIBSPI_log("Error: MIBSPI_transfer with data size = %d should fail.\n", transaction.count);
1135         }
1137         /* Configure Data Transfer */
1138         transaction.count = (uint16_t)11U;
1139         transaction.txBuf = (void *)txBuf;
1140         transaction.rxBuf = (void *)rxBuf;
1141         transaction.slaveIndex = (uint16_t)0U;
1143         snprintf(testCase, 64, "MIBSPI_transfer API test - data size=%d validation (instance=%d)",transaction.count, inst);
1145         /* Start Data Transfer */
1146         ret = MIBSPI_transfer(handle, &transaction);
1147         if (ret != true)
1148         {
1149             MIBSPI_log("Debug: MIBSPI_transfer with data size = %d failed with error=%d. \n", transaction.count, transaction.status);
1150         }
1151         else
1152         {
1153             MIBSPI_log("Error: MIBSPI_transfer with data size = %d should fail.\n", transaction.count);
1154         }
1156         /* Configure Data Transfer */
1157         transaction.count = (uint16_t)10U;
1158         transaction.txBuf = (void *)NULL;
1159         transaction.rxBuf = (void *)NULL;
1160         transaction.slaveIndex = (uint16_t)0U;
1162         snprintf(testCase, 64, "MIBSPI_transfer API test - buffer address validation (instance=%d)", inst);
1164         /* Start Data Transfer */
1165         ret = MIBSPI_transfer(handle, &transaction);
1166         if (ret != true)
1167         {
1168             MIBSPI_log("Debug: MIBSPI_transfer failed with NULL pointers for both TX and RX with error=%d. \n", transaction.status);
1169         }
1170         else
1171         {
1172             MIBSPI_log("Error: MIBSPI_transfer with NULL pointers for both TX and RX should fail.\n");
1173         }
1175         /* Graceful shutdown */
1176         MIBSPI_close(handle);
1177         MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1178     }
1181 /**
1182  *  @b Description
1183  *  @n
1184  *      SPI loopback test.
1185  *
1186  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
1187  *
1188  *  @retval
1189  *      Not Applicable.
1190  */
1191 void Test_loopback_oneInstance(uint32_t inst, uint8_t slaveIndex)
1193     MIBSPI_Params     params;
1194     MIBSPI_Handle     handle;
1195     char testCase[64];
1197     snprintf(testCase, 64, "SPI loopback test - instance(%d), 16bits DMA mode", inst);
1199     /**************************************************************************
1200      * Test: Open the driver in master mode for loopback test
1201      **************************************************************************/
1202     /* Setup the default SPI Parameters */
1203     MIBSPI_Params_init(&params);
1204     params.frameFormat = MIBSPI_POL0_PHA0;
1206     /* Enable DMA and set DMA channels to be used */
1207 #ifdef MIBSPI_DMA_ENABLE
1208     params.dmaEnable = 1;
1209     params.dmaHandle = gDmaHandle[inst];
1210 #else
1211     params.dmaEnable = 0;
1212     params.dmaHandle = NULL;
1213 #endif
1215     params.eccEnable = 0;
1216     params.mode = MIBSPI_MASTER;
1217     params.u.masterParams.bitRate = 1000000U;
1219     /* mibSPIA support only one slave */
1220     if(inst == 0)
1221     {
1222         params.u.masterParams.numSlaves = 1;
1223         params.u.masterParams.slaveProf[0].chipSelect = 0;
1224         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM;
1225         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1226     }
1227     else if(inst == 1)
1228     {
1229         /* The total element size of 3 slaves is MIBSPI_RAM_MAX_ELEM
1230          * In this example, it is distributed among 3 slaves by MIBSPI_RAM_MAX_ELEM - 6U, 4U, and 2U
1231          */
1232         memset((void *)&params.u.masterParams.slaveProf[0], 0, sizeof(params.u.masterParams.slaveProf));
1234         params.u.masterParams.numSlaves = 3;
1235         params.u.masterParams.slaveProf[0].chipSelect = 0;
1236         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM/2;
1237         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1238         params.u.masterParams.slaveProf[1].chipSelect = 1;
1239         params.u.masterParams.slaveProf[1].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1240         params.u.masterParams.slaveProf[1].dmaReqLine = 1U;
1241         params.u.masterParams.slaveProf[2].chipSelect = 2;
1242         params.u.masterParams.slaveProf[2].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1243         params.u.masterParams.slaveProf[2].dmaReqLine = 2U;
1244     }
1245     else
1246     {
1247         printf("Error: Invalid instance(=%d) of MibSPI\n", inst);
1248     }
1250     handle = MIBSPI_open(gMibspiInst[inst], &params);
1251     if (handle == NULL)
1252     {
1253         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1254         return;
1255     }
1256     MIBSPI_log("Debug: SPI Instance %p has been reopened in master mode successfully\n", handle);
1258     /* Start Internal Loopback Test in master mode */
1259     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 2) == 0)
1260     {
1262     }
1263     else
1264     {
1266     }
1268     /* Close the driver: */
1269     MIBSPI_close(handle);
1270     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1272     /**************************************************************************
1273      * Test: Reopen the driver in master mode for loopback test without DMA
1274      **************************************************************************/
1275     snprintf(testCase, 64, "SPI loopback test - instance(%d), 16bits non-DMA mode", inst);
1277     /* Change dma configuration */
1278     params.dmaEnable = 0;
1280     handle = MIBSPI_open(gMibspiInst[inst], &params);
1281     if (handle == NULL)
1282     {
1283         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1284         return;
1285     }
1286     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
1288     /* Start Internal Loopback Test in master mode */
1289     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 2) == 0U)
1290     {
1292     }
1293     else
1294     {
1296     }
1298     /* Close the driver: */
1299     MIBSPI_close(handle);
1300     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1302     /**************************************************************************
1303      * Test: Reopen the driver in master mode for loopback test DMA enabled 8bits
1304      **************************************************************************/
1305     snprintf(testCase, 64, "SPI loopback test - instance(%d), 8bits DMA mode", inst);
1307     params.dataSize =8;
1308 #ifdef MIBSPI_DMA_ENABLE
1309     /* Change dma configuration */
1310     params.dmaEnable = 1;
1311 #else
1312     params.dmaEnable = 0;
1313     params.dmaHandle = NULL;
1314 #endif
1317     handle = MIBSPI_open(gMibspiInst[inst], &params);
1318     if (handle == NULL)
1319     {
1320         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1321         return;
1322     }
1323     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
1325     /* Start Internal Loopback Test in master mode */
1326     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 1) == 0U)
1327     {
1329     }
1330     else
1331     {
1333     }
1335     /* Close the driver: */
1336     MIBSPI_close(handle);
1337     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1339     /**************************************************************************
1340      * Test: Reopen the driver in master mode for loopback test DMA enabled 8bits
1341      **************************************************************************/
1342     snprintf(testCase, 64, "SPI loopback test - instance(%d), 8bits non-DMA mode", inst);
1344     /* Change dma configuration */
1345     params.dmaEnable = 0;
1346     params.dataSize =8;
1348     handle = MIBSPI_open(gMibspiInst[inst], &params);
1349     if (handle == NULL)
1350     {
1351         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1352         return;
1353     }
1354     MIBSPI_log("Debug: SPI Instance %p has been opened successfully\n", handle);
1356     /* Start Internal Loopback Test in master mode */
1357     if(Test_spiLoopback(handle, slaveIndex, params.u.masterParams.slaveProf[slaveIndex].ramBufLen, 1) == 0U)
1358     {
1360     }
1361     else
1362     {
1364     }
1366     /* Close the driver: */
1367     MIBSPI_close(handle);
1368     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1370     /**************************************************************************
1371      * Test: Reopen the driver in master mode for loopback throughput test
1372      **************************************************************************/
1373     /* Start Loopback throughput Test in master mode */
1374     Test_spiLoopBackDataThroughput(inst, 1000000U);
1376     /* Start Loopback throughput Test in master mode */
1377     Test_spiLoopBackDataThroughput(inst, 2000000U);
1379     /* Start Loopback throughput Test in master mode */
1380     Test_spiLoopBackDataThroughput(inst, 6000000U);
1382     /* Start Loopback throughput Test in master mode */
1383     Test_spiLoopBackDataThroughput(inst, 10000000U);
1385     /* Start Loopback throughput Test in master mode */
1386     Test_spiLoopBackDataThroughput(inst, 20000000U);
1388     /* Start Loopback throughput Test in master mode */
1389     Test_spiLoopBackDataThroughput(inst, 40000000U);
1392 #ifdef MIBSPI_DMA_ENABLE
1393 /**
1394  *  @b Description
1395  *  @n
1396  *      SPI loopback test.
1397  *
1398  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
1399  *
1400  *  @retval
1401  *      Not Applicable.
1402  */
1403 void Test_loopback_oneInstance_callback(uint32_t inst, uint8_t slaveIndex)
1405     MIBSPI_Params     params;
1406     MIBSPI_Handle     handle;
1407     char testCase[64];
1409     snprintf(testCase, 64, "SPI loopback test callback mode - instance(%d), 16bits DMA mode", inst);
1411     /**************************************************************************
1412      * Test: Open the driver in master mode for loopback test
1413      **************************************************************************/
1414     /* Setup the default SPI Parameters */
1415     MIBSPI_Params_init(&params);
1416     params.frameFormat = MIBSPI_POL0_PHA0;
1418     /* Configure for the callback mode. */
1419     params.transferMode = MIBSPI_MODE_CALLBACK;
1420     params.transferCallbackFxn = &Test_loopback_callbackFxn;
1422     /* Enable DMA and set DMA channels to be used */
1423     params.dmaEnable = 1;
1424     params.dmaHandle = gDmaHandle[inst];
1426     params.eccEnable = 0;
1427     params.mode = MIBSPI_MASTER;
1428     params.u.masterParams.bitRate = 1000000U;
1430     /* mibSPIA support only one slave */
1431     if(inst == 0)
1432     {
1433         params.u.masterParams.numSlaves = 1;
1434         params.u.masterParams.slaveProf[0].chipSelect = 0;
1435         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM;
1436         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1437     }
1438     else if(inst == 1)
1439     {
1440         /* The total element size of 3 slaves is MIBSPI_RAM_MAX_ELEM
1441          * In this example, it is distributed among 3 slaves by MIBSPI_RAM_MAX_ELEM - 6U, 4U, and 2U
1442          */
1443         memset((void *)&params.u.masterParams.slaveProf[0], 0, sizeof(params.u.masterParams.slaveProf));
1445         params.u.masterParams.numSlaves = 3;
1446         params.u.masterParams.slaveProf[0].chipSelect = 0;
1447         params.u.masterParams.slaveProf[0].ramBufLen = MIBSPI_RAM_MAX_ELEM/2;
1448         params.u.masterParams.slaveProf[0].dmaReqLine = 0U;
1449         params.u.masterParams.slaveProf[1].chipSelect = 1;
1450         params.u.masterParams.slaveProf[1].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1451         params.u.masterParams.slaveProf[1].dmaReqLine = 1U;
1452         params.u.masterParams.slaveProf[2].chipSelect = 2;
1453         params.u.masterParams.slaveProf[2].ramBufLen = MIBSPI_RAM_MAX_ELEM/4;
1454         params.u.masterParams.slaveProf[2].dmaReqLine = 2U;
1455     }
1456     else
1457     {
1458         printf("Error: Invalid instance(=%d) of MibSPI\n", inst);
1459     }
1461     handle = MIBSPI_open(gMibspiInst[inst], &params);
1462     if (handle == NULL)
1463     {
1464         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1465         return;
1466     }
1467     MIBSPI_log("Debug: SPI Instance %p has been reopened in master mode successfully\n", handle);
1469     /* Start Internal Loopback Test in master mode */
1470     if(Test_spiLoopback_callback(handle, slaveIndex, 128, 2) == 0)
1471     {
1473     }
1474     else
1475     {
1477     }
1479     /* Close the driver: */
1480     MIBSPI_close(handle);
1481     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1483 #endif
1485 /**
1486  *  @b Description
1487  *  @n
1488  *      SPI loopback test.
1489  *
1490  *   @param[in] inst               SPI instance: 0-SPIA, 1-SPIB
1491  *
1492  *  @retval
1493  *      Not Applicable.
1494  */
1495 void Test_loopbackSlave_oneInstance(uint32_t inst)
1497     MIBSPI_Params     params;
1498     MIBSPI_Handle     handle;
1499     char testCase[64];
1501     snprintf(testCase, 64, "SPI loopback test - instance(%d), 16bits DMA mode", inst);
1503     /**************************************************************************
1504      * Test: Open the driver in master mode for loopback test
1505      **************************************************************************/
1506     /* Setup the default SPI Parameters */
1507     MIBSPI_Params_init(&params);
1508     params.frameFormat = MIBSPI_POL0_PHA0;
1510     /* Enable DMA and set DMA channels to be used */
1511 #ifdef MIBSPI_DMA_ENABLE
1512     params.dmaEnable = 1;
1513     params.dmaHandle = gDmaHandle[inst];
1514 #else
1515     params.dmaEnable = 0;
1516     params.dmaHandle = NULL;
1517 #endif
1519     params.eccEnable = 0;
1520     params.mode = MIBSPI_SLAVE;
1522     params.u.slaveParams.dmaReqLine = 0;
1523     params.u.slaveParams.chipSelect = 0;
1525     handle = MIBSPI_open(gMibspiInst[inst], &params);
1526     if (handle == NULL)
1527     {
1528         MIBSPI_log("Error: Unable to open the SPI Instance\n");
1529         return;
1530     }
1531     MIBSPI_log("Debug: SPI Instance %p has been reopened in master mode successfully\n", handle);
1533     /* Start Internal Loopback Test in master mode */
1534     if(Test_spiLoopbackSlave(handle, MIBSPI_RAM_MAX_ELEM, 2) == 0)
1535     {
1537     }
1538     else
1539     {
1541     }
1543     /* Close the driver: */
1544     MIBSPI_close(handle);
1545     MIBSPI_log("Debug: SPI Instance %p has been closed successfully\n", handle);
1549 /**
1550  *  @b Description
1551  *  @n
1552  *      This function tests SPI driver in Digital Loopback mode.
1553  *
1554  *   @param[in] handle            SPI driver handle
1555  *   @param[in] slaveIndex        Flag for internal/external loopback
1556  *   @param[in] maxElem           Maxim data element
1557  *   @param[in] dataSize          Data size in number of bytes
1558  *
1559  *  @retval    Successful                   =0
1560  *             Number of transfer failures  >0
1561  *             API failures                 <0
1562  */
1563 static int32_t Test_spiLoopbackSlave(const MIBSPI_Handle handle, uint32_t maxElem, uint8_t dataSize)
1565     MibSpi_LoopBackType            loopback;
1566     uint32_t           loop;
1567     uint32_t           idx;
1568     uint32_t           failed = 0;
1569     uint32_t           len=0;
1571     /* Only dataSize of 1 byte or 2 bytes are supported */
1572     if ((dataSize != (uint8_t)1U) && (dataSize != (uint8_t)2U))
1573         return -1;
1575     /* Enable digital loopback */
1576     loopback = MIBSPI_LOOPBK_ANALOG;
1577     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
1578         return -1;
1579     for(loop=0; loop < maxElem; loop++)
1580     {
1581         len = (maxElem - loop) * dataSize;
1583         /* Prepare Tx/Rx Buffer */
1584         for(idx=0; idx<maxElem * dataSize; idx++)
1585         {
1586             txBuf[idx] = (loop * 0x10 + 0x55 + idx) & 0xFF;
1587         }
1589         /* Clear receive buffer */
1590         memset((void *)&rxBuf[0], 0x0, SPI_DATA_BLOCK_SIZE);
1592         CacheP_wbInv((Ptr)txBuf, sizeof(txBuf));
1593         CacheP_wbInv((Ptr)rxBuf, sizeof(rxBuf));
1594         if(Test_spiReadWrite(handle, len, (void *)rxBuf, (void *)txBuf, 0) == 0)
1595         {
1596             /* Check data integrity */
1597             if (memcmp((void *)txBuf, (void *)rxBuf, len) != 0)
1598             {
1599                 #if 0 /* Temporarily disable integrity check for MIBSPI SLAVE mode analog loopback until test setup issue is resolved */
1600                 MIBSPI_log("Error: MIBSPI_transfer is successful with incorrect data(0x%x), length = %d\n", rxBuf[0], len);
1601                 #endif
1602                 failed++;
1603             }
1604         }
1605         else
1606         {
1607             MIBSPI_log("Debug: MIBSPI_transfer failed for length = %d\n", len);
1608             failed++;
1609         }
1610     }
1611     MIBSPI_log("Debug: Finished Analog loopback with various length test,  failed %d out of %d times\n", failed, loop);
1613     /* Disable digital loopback */
1614     loopback = MIBSPI_LOOPBK_NONE;
1615     if(MIBSPI_control(handle, MIBSPI_CMD_LOOPBACK_ENABLE, (void *)&loopback) < 0)
1616         return -1;
1618     /* Return number of failures */
1619     return failed;