packages/ti/drv/emac/test/EmacLoopbackTest/main_am65xx.c

   1 /**
   2  * @file   main_am65xx.c
   3  *
   4  * @brief  This file tests the EMAC driver APIs using loopback mode of operation
   5  */
   6 /*
   7  * Copyright (c) 2018, Texas Instruments Incorporated
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * *  Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  *
  17  * *  Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * *  Neither the name of Texas Instruments Incorporated nor the names of
  22  *    its contributors may be used to endorse or promote products derived
  23  *    from this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  35  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38
  39 #include <stdio.h>
  40 #include <string.h>
  41
  42
  43 /* XDCtools Header files */
  44 #include <xdc/std.h>
  45 #include <xdc/runtime/Error.h>
  46
  47 /* BIOS Header files */
  48 #include <ti/sysbios/BIOS.h>
  49 #include <ti/sysbios/knl/Task.h>
  50 #include <ti/sysbios/family/arm/v8a/Mmu.h>
  51
  52 /* CSL Header files */
  53 #include <ti/csl/soc.h>
  54
  55 /* OSAL Header files */
  56 #include <ti/osal/osal.h>
  57
  58 /* BOARD Header files */
  59 #include <ti/board/board.h>
  60
  61 /* UART Header files */
  62 #include <ti/drv/uart/UART.h>
  63 #include <ti/drv/uart/UART_stdio.h>
  64
  65 /* EMAC Driver Header File. */
  66 #include <ti/drv/emac/emac_drv.h>
  67 #include <ti/drv/emac/soc/emac_soc_v5.h>
  68
  69 extern uint32_t app_test_recv_port;
  70
  71 /* UDMA Driver Header File. */
  72 #include <ti/drv/udma/udma.h>
  73 /* Test application local header file */
  74 #include "ti/drv/emac/test/EmacLoopbackTest/test_loc.h"
  75 #include "ti/drv/emac/test/EmacLoopbackTest/test_utils.h"
  76
  77
  78 extern void app_test_task_verify_ut_dual_mac_cpsw(UArg arg0, UArg arg1);
  79 extern void app_test_task_benchmark(UArg arg0, UArg arg1);
  80 extern void app_test_task_verify_ut_switch(UArg arg0, UArg arg1);
  81 /*
  82  *  ======== Globals========
  83  */
  84
  85 const char* rxTaskName[7] =  {"rxPort0","rxPort1","rxPort2","rxPort3","rxPort4","rxPort5","rxPort6"};
  86 const char* rxMgmtTaskName[7] =  {"rxMgmtPort0","rxMgmtPort1","rxMgmtPort2","rxMgmtPort3","rxMgmtPort4","rxMgmtPort5","rxMgmtPort6"};
  87
  88 #ifdef EMAC_TEST_APP_ICSSG_SWITCH
  89 int32_t port_en[EMAC_PORT_CPSW + 1] = {1, 1, 1, 1, 0, 0, 0};
  90 #else
  91     #ifdef EMAC_TEST_APP_WITHOUT_DDR
  92     int32_t port_en[EMAC_PORT_CPSW + 1] = {1, 1, 0, 0, 0, 0, 0};
  93     #else
  94         #ifdef EMAC_BENCHMARK
  95             #ifdef EMAC_TEST_APP_ICSSG
  96                 int32_t port_en[EMAC_PORT_CPSW + 1] = {0, 0, 0, 0, 1, 0, 0};
  97             #else /* CPSW use case */
  98                 int32_t port_en[EMAC_PORT_CPSW + 1] = {0, 0, 0, 0, 0, 0, 1};
  99             #endif
 100         #else
 101             #ifdef EMAC_TEST_APP_ICSSG
 102                 int32_t  port_en[EMAC_PORT_CPSW + 1] = {1, 1, 1, 1, 1, 1, 0};
 103             #else /* CPSW use case */
 104                 int32_t port_en[EMAC_PORT_CPSW + 1] = {0, 0, 0, 0, 0, 0, 1};
 105             #endif
 106         #endif
 107     #endif
 108 #endif
 109
 110 #ifdef EMAC_TEST_APP_CPSW
 111 uint32_t portNum = EMAC_PORT_CPSW;
 112 uint32_t endPort = EMAC_PORT_CPSW;
 113 #else
 114 /* ICSSG case */
 115 #ifdef am65xx_idk
 116 uint32_t portNum = EMAC_PORT_ICSS;
 117 uint32_t endPort = EMAC_PORT_ICSS+5;
 118 #else
 119 uint32_t portNum = EMAC_PORT_ICSS + 4;
 120 uint32_t endPort = EMAC_PORT_ICSS + 5;
 121 #endif
 122 #endif
 123 #ifdef BUILD_MCU
 124 uint32_t AsmReadActlr(void);
 125 void AsmWriteActlr(uint32_t);
 126 #endif
 127
 128 /*
 129  *  ======== main ========
 130  */
 131 int main(void)
 132 {
 133     Task_Params     taskParams;
 134     Error_Block eb;
 135     Error_init(&eb);
 136
 137 #ifdef EMAC_TEST_APP_ICSSG_SWITCH
 138 #ifndef EMAC_BENCHMARK
 139         /* Create the  task start the unit test.*/
 140         Task_Params_init(&taskParams);
 141         taskParams.priority = 10;
 142         taskParams.instance->name = "app_test_task_verify_ut_switch";
 143         Task_create( app_test_task_verify_ut_switch, &taskParams, NULL);
 144 #else
 145         /* Create the  task to start BENCHMARK testing.*/
 146         Task_Params_init(&taskParams);
 147         taskParams.priority = 11;
 148         taskParams.arg0 = EMAC_SWITCH_PORT1;
 149         taskParams.instance->name = "app_test_task_benchmark";
 150         Task_create( app_test_task_benchmark, &taskParams, NULL);
 151 #endif
 152
 153 #ifndef EMAC_CHECK_LINK_STATUS
 154     /* Create the  task to poll driver to rx pkts.*/
 155     /* set the priority to 10 for both polling tasks */
 156     taskParams.priority = 10;
 157
 158     taskParams.arg0 = EMAC_SWITCH_PORT1;
 159     taskParams.instance->name = rxTaskName[0];
 160     Task_create(app_test_task_poll_ctrl, &taskParams, NULL);
 161
 162     taskParams.arg0 = EMAC_SWITCH_PORT2;
 163     taskParams.instance->name = rxTaskName[2];
 164     Task_create(app_test_task_poll_ctrl, &taskParams, NULL);
 165 #endif
 166 #else
 167 #ifndef EMAC_BENCHMARK
 168     /* Create the  task start the unit test.*/
 169     Task_Params_init(&taskParams);
 170     taskParams.priority = 10;
 171     taskParams.instance->name = "app_test_task_verify_ut_dual_mac_cpsw";
 172     Task_create( app_test_task_verify_ut_dual_mac_cpsw, &taskParams, NULL);
 173 #else
 174     /* Create the  task to start BENCHMARK testing.*/
 175     Task_Params_init(&taskParams);
 176     taskParams.priority = 10;
 177     taskParams.arg0 = EMAC_PORT_ICSS + 4;
 178     taskParams.instance->name = "app_test_task_benchmark";
 179     Task_create( app_test_task_benchmark, &taskParams, NULL);
 180 #endif
 181
 182     int i;
 183     for (i = portNum; i <=endPort; i++)
 184     {
 185         /* will poll on app_test_recv_port */
 186 #ifdef EMAC_BENCHMARK
 187         if ((!port_en[i]) || (i != app_test_recv_port))
 188 #else
 189         if (!port_en[i])
 190 #endif
 191             continue;
 192             /* Create the  task to poll driver to rx packets driver.*/
 193             Task_Params_init(&taskParams);
 194             taskParams.arg0 = i;
 195             taskParams.priority = 10;
 196             taskParams.instance->name = rxTaskName[i];
 197             Task_create(app_test_task_poll_pkt, &taskParams, NULL);
 198
 199 #ifndef EMAC_BENCHMARK
 200             /* Create the  task to poll driver to rx cfg responses.*/
 201             Task_Params_init(&taskParams);
 202             taskParams.arg0 = i;
 203             taskParams.priority = 10;
 204             taskParams.instance->name = rxMgmtTaskName[i];
 205             Task_create(app_test_task_poll_ctrl, &taskParams, NULL);
 206 #endif
 207     }
 208
 209 #endif
 210     {
 211 #ifdef BUILD_MCU
 212         uint32_t actlrRegVal = AsmReadActlr();
 213         actlrRegVal |= (1 << 13);
 214         AsmWriteActlr(actlrRegVal);
 215 #endif
 216     }
 217     /* Start BIOS */
 218     BIOS_start();
 219     return 0;
 220 }
 221
 222
 223 #if defined (__aarch64__)
 224 struct MmuCfg_t {
 225     uint64_t    vaddr;
 226     uint64_t    paddr;
 227     size_t      size;
 228     int         attrInd;
 229 } MmuCfgTbl[] = {
 230     { 0x00100000, 0x00100000, 0x00900000, 0 }, /* Main MMR0     */
 231     { 0x00400000, 0x00400000, 0x00001000, 0 }, /* PSC0          */
 232     { 0x01800000, 0x01800000, 0x00100000, 0 }, /* gicv3         */
 233     { 0x02400000, 0x02400000, 0x000c0000, 0 }, /* dmtimer       */
 234     { 0x02800000, 0x02800000, 0x00001000, 0 }, /* uart          */
 235     { 0x02000000, 0x02000000, 0x00100000, 0 }, /* I2C           */
 236     { 0x02100000, 0x02100000, 0x00080000, 0 }, /* McSPI         */
 237     { 0x40F00000, 0x40F00000, 0x00020000, 0 }, /* MCU MMR0      */
 238     { 0x40d00000, 0x40d00000, 0x00002000, 0 }, /* PLL0          */
 239     { 0x43000000, 0x43000000, 0x00020000, 0 }, /* WKUP MMR0     */
 240     { 0x02C40000, 0x02C40000, 0x00100000, 0 }, /* pinmux ctrl   */
 241     { 0x30800000, 0x30800000, 0x0C000000, 0 }, /* main navss    */
 242     { 0x28380000, 0x28380000, 0x03880000, 0 }, /* mcu navss     */
 243     { 0x30000000, 0x30000000, 0x0F000000, 0 }, /* ctrcontrol0   */
 244     { CSL_MCU_CPSW0_NUSS_BASE, CSL_MCU_CPSW0_NUSS_BASE,
 245         (CSL_MCU_CPSW0_NUSS_SIZE*2), 0 },      /* for CPSW      */
 246     { 0x0b000000, 0x0b000000, 0x00100000, 0 }, /* ICSS-G 0      */
 247     { 0x0b100000, 0x0b100000, 0x00100000, 0 }, /* ICSS-G 1      */
 248     { 0x0b200000, 0x0b200000, 0x00100000, 0 }, /* ICSS-G 2      */
 249     { 0x42000000, 0x42000000, 0x00001000, 0 }, /* PSC WKUP      */
 250     { 0x03802000, 0x03802000, 0x00001000, 0 }, /* NB0_CFG_MMRS  */
 251     { 0x70000000, 0x70000000, 0x04000000, 7 }, /* msmc          */
 252     { 0x41C00000, 0x41C00000, 0x00080000, 7 }, /* ocmc          */
 253     { 0x80000000, 0x80000000, 0x10000000, 7 }, /* ddr_0          */
 254     { 0, 0, 0, 8 } /* attrInd = 8 -> end of table */
 255 };
 256
 257 void InitMmu(void)
 258 {
 259     bool        retVal = FALSE;
 260     uint32_t    j = 0;
 261     Mmu_MapAttrs attrs;
 262     Mmu_initMapAttrs(&attrs);
 263     while (MmuCfgTbl[j].attrInd < 8) {
 264         attrs.attrIndx = MmuCfgTbl[j].attrInd;
 265         retVal = Mmu_map(MmuCfgTbl[j].vaddr, MmuCfgTbl[j].paddr, MmuCfgTbl[j].size, &attrs);
 266         if(retVal == FALSE)
 267             break;
 268         j++;
 269     }
 270
 271     if(retVal == FALSE) {
 272         UART_printf("Mmu_map idx %d returned error %d", j, retVal);
 273         while(1);
 274     }
 275 }
 276 #endif
 277