[PDK-8824] Addressing review comments
[processor-sdk/pdk.git] / packages / ti / drv / gpmc / example / src / main_gpmc_probing_example.c
1 /**
2  *  \file   main_gpmc_probing_example.c
3  *
4  *  \brief  Probing test application main file. This application will write the data
5  *          to GPMC SRAM memory using CPU multiple times to enable probing
6  *
7  */
9 /*
10  * Copyright (C) 2016 -2020 Texas Instruments Incorporated - http://www.ti.com/
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  *
16  * Redistributions of source code must retain the above copyright
17  * notice, this list of conditions and the following disclaimer.
18  *
19  * Redistributions in binary form must reproduce the above copyright
20  * notice, this list of conditions and the following disclaimer in the
21  * documentation and/or other materials provided with the
22  * distribution.
23  *
24  * Neither the name of Texas Instruments Incorporated nor the names of
25  * its contributors may be used to endorse or promote products derived
26  * from this software without specific prior written permission.
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39  *
40  */
42 #include <stdio.h>
43 #include <string.h>
45 /* GPMC Header files */
46 #include <ti/drv/gpmc/GPMC.h>
47 #include <ti/drv/gpmc/soc/GPMC_soc.h>
48 #include <ti/drv/gpmc/test/src/GPMC_board.h>
49 #include <ti/drv/gpmc/test/src/GPMC_log.h>
51 /* Board Header files */
52 #include <ti/board/board.h>
53 #include <ti/board/src/flash/include/board_flash.h>
55 #include <ti/drv/sciclient/sciclient.h>
56 #include <ti/osal/TimerP.h>
58 /**********************************************************************
59  ************************** Macros ************************************
60  **********************************************************************/
61 #define GPMC_PROFILE                                    /* Enable profiling */
62 #define GPMC_APP_STATUS_SUCCESS     ((int32_t)(0))      /* Succes code */
63 #define GPMC_APP_STATUS_ERROR       (-((int32_t)1))     /* Failure code */
65 /**********************************************************************
66  ************************** Global Variables **************************
67  **********************************************************************/
68 uint8_t txBuf[TEST_DATA_LEN]  __attribute__((aligned(4))) __attribute__((section(".benchmark_buffer")));
69 GPMC_Transaction transaction;
72 /**********************************************************************
73  ************************** Internal functions ************************
74  **********************************************************************/
75 /*
76  *  ======== GeneratePattern ========
77  */
78 static void GeneratePattern(uint8_t *txBuf, uint32_t length)
79 {
80     volatile uint32_t idx;
81     volatile uint8_t *txPtr = txBuf;
83     for(idx = 0; idx < length; idx++)
84     {
85         *txPtr++ = (uint8_t)idx;
86     }
87 }
89 int32_t gpmc_test()
90 {
91     int32_t     status = GPMC_APP_STATUS_SUCCESS;
92     uint32_t    i;
93     GPMC_Params params;
94     GPMC_Handle handle;
95 #ifdef GPMC_PROFILE
96     uint32_t    testLen = TEST_DATA_LEN;
97     uint64_t    startTime;                  /* start time stamp in usec */
98     uint64_t    elapsedTime;                /* elapsed time in usec */
99     float       xferRate;
100     uint32_t    xferRateInt;
101 #endif
103     GPMC_Params_init(&params);
104     handle = GPMC_open(BOARD_GPMC_INSTANCE, &params);
105     if (handle == NULL)
106     {
107         GPMC_log("\n GPMC open failed. \n");
108         status = GPMC_APP_STATUS_ERROR;
109         goto Err;
110     }
112     /* Generate the data */
113     GeneratePattern(txBuf, TEST_DATA_LEN);
115     /* Write data */
116     transaction.transType = GPMC_TRANSACTION_TYPE_WRITE;
117     transaction.offset    = 0U;
118     transaction.count     = TEST_DATA_LEN;
119     transaction.txBuf     = txBuf;
120     transaction.rxBuf     = NULL;
121     transaction.arg       = NULL;
123 #ifdef GPMC_PROFILE
124     /* Get start time stamp for the write performance measurement */
125     startTime = TimerP_getTimeInUsecs();
126 #endif
128     for(i=0; i<1000; i++)
129     {
130         if(!GPMC_transfer(handle, &transaction))
131         {
132                 GPMC_log("[Error] GPMC write failed. \n");
133                 status = GPMC_APP_STATUS_ERROR;
134                 break;
135             }
136         }
138 #ifdef GPMC_PROFILE
139     elapsedTime = TimerP_getTimeInUsecs() - startTime;
140     /* calculate the write transfer rate in MBps */
141     xferRate = (float) (((float)(testLen*i)) / elapsedTime);
142     xferRateInt = (uint32_t)xferRate;
143     GPMC_log("\n GPMC write %d bytes at transfer rate %d MBps \n", testLen, xferRateInt);
144 #endif
146 Err:
147     if (handle != NULL)
148     {
149         GPMC_close(handle);
150     }
152     return (status);
155 #if defined(SOC_AM64X)
156 uint32_t GPMC_configClk(uint32_t freq)
158     GPMC_v1_HwAttrs gpmc_cfg;
159     int32_t         retVal;
160     uint64_t        gpmc_clk;
161     uint32_t        parClk;
162     uint32_t        clkID = TISCI_DEV_GPMC0_FUNC_CLK;
163     uint32_t        devID = TISCI_DEV_GPMC0;
165     /* Get the default GPMC init configurations */
166     GPMC_socGetInitCfg(BOARD_GPMC_INSTANCE, &gpmc_cfg);
168     retVal = Sciclient_pmModuleClkRequest(devID,
169                                           clkID,
170                                           TISCI_MSG_VALUE_CLOCK_SW_STATE_REQ,
171                                           TISCI_MSG_FLAG_AOP,
172                                           SCICLIENT_SERVICE_WAIT_FOREVER);
173     if (retVal != CSL_PASS)
174     {
175         GPMC_log("\n Sciclient_pmModuleClkRequest failed");
176         goto clk_cfg_exit;
177     }
179     /* Set parent clock */
180     parClk = TISCI_DEV_GPMC0_FUNC_CLK_PARENT_HSDIV4_16FFT_MAIN_0_HSDIVOUT3_CLK;
181     retVal = Sciclient_pmSetModuleClkParent(devID,
182                                             clkID,
183                                             parClk,
184                                             SCICLIENT_SERVICE_WAIT_FOREVER);
186     if (retVal != CSL_PASS)
187     {
188         GPMC_log("\n Sciclient_pmSetModuleClkParent failed");
189         goto clk_cfg_exit;
190     }
192     gpmc_clk = (uint64_t)freq;
193     retVal = Sciclient_pmSetModuleClkFreq(devID,
194                                           clkID,
195                                           gpmc_clk,
196                                           TISCI_MSG_FLAG_AOP,
197                                           SCICLIENT_SERVICE_WAIT_FOREVER);
199     if (retVal != CSL_PASS)
200     {
201         GPMC_log("\n Sciclient_pmSetModuleClkFreq failed");
202         goto clk_cfg_exit;
203     }
205     gpmc_clk = 0;
206     retVal = Sciclient_pmGetModuleClkFreq(devID,
207                                           clkID,
208                                           &gpmc_clk,
209                                           SCICLIENT_SERVICE_WAIT_FOREVER);
210     if (retVal != CSL_PASS)
211     {
212         GPMC_log("\n Sciclient_pmGetModuleClkFreq failed");
213         goto clk_cfg_exit;
214     }
216     GPMC_log("\n GPMC CLK running at %d Hz. \n", freq);
218 clk_cfg_exit:
219     return retVal;
221 #endif
223 int32_t Board_initGPMC(void)
225     int32_t       status = GPMC_APP_STATUS_SUCCESS;
226     Board_initCfg boardCfg;
227     Board_STATUS  boardStatus;
228     Board_PinmuxConfig_t gpmcPinmux;
230     /* Pinmux configuration to enable probing from expansion board */
231     Board_pinmuxGetCfg(&gpmcPinmux);
232     gpmcPinmux.muxCfg = BOARD_PINMUX_CUSTOM;
233     gpmcPinmux.expBoardMux = BOARD_PINMUX_EXP_GPMC;
234     Board_pinmuxSetCfg(&gpmcPinmux);
236     boardCfg = BOARD_INIT_MODULE_CLOCK  |
237                BOARD_INIT_PINMUX_CONFIG |
238                BOARD_INIT_UART_STDIO;
239     boardStatus = Board_init(boardCfg);
240     if (boardStatus != BOARD_SOK)
241     {
242         GPMC_log("[Error] Board init failed!!\n");
243         status = GPMC_APP_STATUS_ERROR;
244     }
246 #if defined(SOC_AM64X)
247     if (status == GPMC_APP_STATUS_SUCCESS)
248     {
249         status += GPMC_configClk(GPMC_MODULE_CLK_80MHZ);
250         if(status != GPMC_APP_STATUS_SUCCESS)
251         {
252             GPMC_log("[Error] Config clock failed!!\n");
253         }
254     }
255 #endif
257     GPMC_init();
259     return (status);
262 int main(void)
264     int32_t status = GPMC_APP_STATUS_SUCCESS;
266     status += Board_initGPMC();
267     if(status != GPMC_APP_STATUS_SUCCESS)
268     {
269         GPMC_log("[Error] GPMC init failed!!\n");
270         goto testfail;
271     }
273     status += gpmc_test();
275 testfail:
276     if (status == GPMC_APP_STATUS_SUCCESS)
277     {
278         GPMC_log("GPMC probing test Passed!!\n");
279         GPMC_log("All tests have passed!!\n");
280     }
281     else
282     {
283         GPMC_log("GPMC probing test Failed!!\n");
284         GPMC_log("Some tests have failed!!\n");
285     }
287     return(0);