packages/ti/boot/sbl/soc/k3/sbl_sci_client.c

   1 /*
   2  * Copyright (C) 2018-2020 Texas Instruments Incorporated - http://www.ti.com/
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the
  14  * distribution.
  15  *
  16  * Neither the name of Texas Instruments Incorporated nor the names of
  17  * its contributors may be used to endorse or promote products derived
  18  * from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  */
  33 #include <ti/csl/tistdtypes.h>
  34 #include <ti/csl/soc.h>
  35 #include <ti/csl/arch/csl_arch.h>
  36 #include <ti/csl/hw_types.h>
  37 #include <ti/drv/uart/UART_stdio.h>
  38 #include <ti/drv/uart/soc/UART_soc.h>
  39 #include <ti/board/board.h>
  40 #include <sbl_soc.h>
  41 #include <sbl_soc_cfg.h>
  42 #include <sbl_err_trap.h>
  43 #include <sbl_sci_client.h>
  44
  45 #if defined(SBL_ENABLE_HLOS_BOOT) && defined(SOC_AM65XX)
  46 const uint32_t gSciclient_boardCfgLow_hlos_rm[(SCICLIENT_BOARDCFG_RM_LINUX_SIZE_IN_BYTES+3U)/4U]
  47     __attribute__(( aligned(128), section(".boardcfg_data") ))
  48     = SCICLIENT_BOARDCFG_RM_LINUX;
  49 #endif
  50
  51 #ifdef __cplusplus
  52 #pragma DATA_SECTION(".firmware")
  53 #else
  54 #pragma WEAK (SBL_ReadSysfwImage)
  55 #pragma DATA_SECTION(gSciclient_firmware, ".firmware")
  56 #endif
  57 uint32_t gSciclient_firmware[1];
  58
  59 #if SCICLIENT_FIRMWARE_SIZE_IN_BYTES > SBL_SYSFW_MAX_SIZE
  60 #error "SYSFW too large...update SBL_SYSFW_MAX_SIZE"
  61 #endif
  62
  63 #if (!defined(SBL_SKIP_BRD_CFG_PM)) || (!defined(SBL_SKIP_BRD_CFG_RM))
  64 static int32_t Sciclient_setBoardConfigHeader ();
  65 #endif
  66 #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200)
  67 /* Firewall ID for MCU_FSS0_S0 */
  68 #define MCU_FSS0_S0_FWID (1036)
  69 #define MCU_FSS0_S0_FW_REGIONS (8)
  70
  71 #if defined (SOC_J721E) || defined (SOC_J7200)
  72 /** \brief Aligned address at which the X509 header is placed. */
  73 #define SCISERVER_COMMON_X509_HEADER_ADDR (0x41cffb00U)
  74
  75 /** \brief Aligned address at which the Board Config header is placed. */
  76 #define SCISERVER_BOARDCONFIG_HEADER_ADDR (0x41c80000U)
  77
  78 /** \brief Aligned address at which the Board Config is placed. */
  79 #define SCISERVER_BOARDCONFIG_DATA_ADDR (0x41c80040U)
  80
  81 #endif
  82 #endif
  83
  84 uint32_t SBL_IsAuthReq(void)
  85 {
  86     uint32_t retVal = SBL_ALWAYS_AUTH_APP;
  87     uint32_t dev_type;
  88     uint32_t dev_subtype;
  89
  90     SBL_ADD_PROFILE_POINT;
  91
  92     dev_type = CSL_REG32_RD(SBL_SYS_STATUS_REG) & SBL_SYS_STATUS_DEV_TYPE_MASK;
  93     dev_subtype = CSL_REG32_RD(SBL_SYS_STATUS_REG) & SBL_SYS_STATUS_DEV_SUBTYPE_MASK;
  94
  95     /* No auth possible, if valid SMPK/BMPK is not present */
  96     if ((dev_subtype == SBL_SYS_STATUS_DEV_SUBTYPE_FS) ||
  97         (dev_type == SBL_SYS_STATUS_DEV_TYPE_GP) ||
  98         (dev_type == SBL_SYS_STATUS_DEV_TYPE_TEST))
  99     {
 100         retVal = SBL_NEVER_AUTH_APP;
 101     }
 102
 103     SBL_ADD_PROFILE_POINT;
 104
 105     return retVal;
 106 }
 107
 108 #ifndef SBL_SKIP_SYSFW_INIT
 109 Sciclient_BoardCfgPrms_t sblBoardCfgPrms = {0};
 110 Sciclient_BoardCfgPrms_t sblBoardCfgPmPrms = {0};
 111 Sciclient_BoardCfgPrms_t sblBoardCfgRmPrms = {0};
 112 #ifndef SBL_SKIP_BRD_CFG_SEC
 113 Sciclient_BoardCfgPrms_t sblBoardCfgSecPrms = {0};
 114 #endif
 115 #endif
 116
 117 void SBL_SciClientInit(void)
 118 {
 119     int32_t status = CSL_EFAIL;
 120     void *sysfw_ptr = gSciclient_firmware;
 121
 122 #ifndef SBL_SKIP_SYSFW_INIT
 123     /* SYSFW board configurations */
 124     Sciclient_DefaultBoardCfgInfo_t boardCfgInfo;
 125     Sciclient_ConfigPrms_t config;
 126     Sciclient_configPrmsInit(&config);
 127     config.opModeFlag               =   SCICLIENT_SERVICE_OPERATION_MODE_POLLED;
 128     config.pBoardCfgPrms            =   NULL;
 129     config.isSecureMode             =   1;
 130     config.c66xRatRegion            =   0;
 131     config.skipLocalBoardCfgProcess =   TRUE;
 132
 133 #if defined(SOC_AM65XX)
 134     config.isSecureMode = 0U;
 135 #endif /* AM65xx the default board cfg is for non-secure mode */
 136
 137 #endif
 138
 139     SBL_ADD_PROFILE_POINT;
 140
 141     status = SBL_ReadSysfwImage(&sysfw_ptr, SBL_SYSFW_MAX_SIZE);
 142     if (status != CSL_PASS)
 143     {
 144 #if defined(SOC_J721E) || defined(SOC_J7200)
 145         SBL_log(SBL_LOG_ERR,"TIFS read...FAILED \n");
 146 #else
 147         SBL_log(SBL_LOG_ERR,"SYSFW read...FAILED \n");
 148 #endif
 149         SblErrLoop(__FILE__, __LINE__);
 150     }
 151
 152 #ifndef SBL_SKIP_SYSFW_INIT
 153     SBL_ADD_PROFILE_POINT;
 154
 155     status = Sciclient_getDefaultBoardCfgInfo(&boardCfgInfo);
 156
 157 #if defined(SBL_ENABLE_HLOS_BOOT) && defined(SOC_AM65XX)
 158     /* Replace default Sciclient boardCfgLowRm with alternate version for HLOS boot */
 159         boardCfgInfo.boardCfgLowRm     = &gSciclient_boardCfgLow_hlos_rm[0U];
 160         boardCfgInfo.boardCfgLowRmSize = SCICLIENT_BOARDCFG_RM_LINUX_SIZE_IN_BYTES;
 161 #endif
 162
 163     if (status != CSL_PASS)
 164     {
 165         SBL_log(SBL_LOG_ERR,"Sciclient get default board config...FAILED \n");
 166         SblErrLoop(__FILE__, __LINE__);
 167     }
 168
 169     status = Sciclient_loadFirmware((const uint32_t *) sysfw_ptr);
 170     if (status != CSL_PASS)
 171     {
 172 #if defined(SOC_J721E) || defined(SOC_J7200)
 173         SBL_log(SBL_LOG_ERR,"TIFS load...FAILED \n");
 174 #else
 175         SBL_log(SBL_LOG_ERR,"SYSFW load...FAILED \n");
 176 #endif
 177         SblErrLoop(__FILE__, __LINE__);
 178     }
 179
 180     SBL_ADD_PROFILE_POINT;
 181     status = Sciclient_init(&config);
 182     if (status != CSL_PASS)
 183     {
 184         SBL_log(SBL_LOG_ERR,"Sciclient init ...FAILED \n");
 185         SblErrLoop(__FILE__, __LINE__);
 186     }
 187
 188 #ifndef SBL_SKIP_BRD_CFG_BOARD
 189     SBL_ADD_PROFILE_POINT;
 190     sblBoardCfgPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLow;
 191     sblBoardCfgPrms.boardConfigHigh = 0;
 192     sblBoardCfgPrms.boardConfigSize = boardCfgInfo.boardCfgLowSize;
 193     sblBoardCfgPrms.devGrp = SBL_DEVGRP;
 194     status = Sciclient_boardCfg(&sblBoardCfgPrms);
 195     if (status != CSL_PASS)
 196     {
 197         SBL_log(SBL_LOG_ERR,"Sciclient board config ...FAILED \n");
 198         SblErrLoop(__FILE__, __LINE__);
 199     }
 200 #endif
 201
 202 #ifndef SBL_SKIP_BRD_CFG_PM
 203     if (SBL_LOG_LEVEL > SBL_LOG_NONE)
 204     {
 205         SBL_ADD_PROFILE_POINT;
 206         UART_stdioDeInit();
 207     }
 208     SBL_ADD_PROFILE_POINT;
 209     sblBoardCfgPmPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLowPm;
 210     sblBoardCfgPmPrms.boardConfigHigh = 0;
 211     sblBoardCfgPmPrms.boardConfigSize = boardCfgInfo.boardCfgLowPmSize;
 212     sblBoardCfgPmPrms.devGrp = SBL_DEVGRP;
 213     status = Sciclient_boardCfgPm(&sblBoardCfgPmPrms);
 214     if (status != CSL_PASS)
 215     {
 216         SBL_log(SBL_LOG_ERR,"Sciclient board config pm...FAILED \n")
 217         SblErrLoop(__FILE__, __LINE__);
 218     }
 219
 220     if (SBL_LOG_LEVEL > SBL_LOG_NONE)
 221     {
 222         /* Re-init UART for logging */
 223         UART_HwAttrs uart_cfg;
 224
 225         SBL_ADD_PROFILE_POINT;
 226         UART_socGetInitCfg(BOARD_UART_INSTANCE, &uart_cfg);
 227         uart_cfg.frequency = SBL_SYSFW_UART_MODULE_INPUT_CLK;
 228         UART_socSetInitCfg(BOARD_UART_INSTANCE, &uart_cfg);
 229         UART_stdioInit(BOARD_UART_INSTANCE);
 230     }
 231 #endif
 232
 233 #ifndef SBL_SKIP_BRD_CFG_SEC
 234     SBL_ADD_PROFILE_POINT;
 235     sblBoardCfgSecPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLowSec;
 236     sblBoardCfgSecPrms.boardConfigHigh = 0;
 237     sblBoardCfgSecPrms.boardConfigSize = boardCfgInfo.boardCfgLowSecSize;
 238     sblBoardCfgSecPrms.devGrp = SBL_DEVGRP;
 239     status = Sciclient_boardCfgSec(&sblBoardCfgSecPrms);
 240     if (status != CSL_PASS)
 241     {
 242         SBL_log(SBL_LOG_ERR,"Sciclient board config sec...FAILED \n");
 243         SblErrLoop(__FILE__, __LINE__);
 244     }
 245 #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200)
 246     /* Secure ROM has left firewall regions for FSS DAT0 set.  Disable them for DMA usage. */
 247     uint16_t i;
 248     struct tisci_msg_fwl_set_firewall_region_resp respFwCtrl = {0};
 249     struct tisci_msg_fwl_set_firewall_region_req reqFwCtrl =
 250     {
 251         .fwl_id = (uint16_t) MCU_FSS0_S0_FWID,
 252         .region = (uint16_t) 0,
 253         .n_permission_regs = (uint32_t) 3,
 254         /* Set .control to zero to disable the firewall region */
 255         .control = (uint32_t) 0,
 256         .permissions[0] = (uint32_t) 0,
 257         .permissions[1] = (uint32_t) 0,
 258         .permissions[2] = (uint32_t) 0,
 259         .start_address = 0,
 260         .end_address = 0
 261     };
 262
 263     for (i = 0; i < MCU_FSS0_S0_FW_REGIONS; i++)
 264     {
 265         reqFwCtrl.region = i;
 266         status = Sciclient_firewallSetRegion(&reqFwCtrl, &respFwCtrl, SCICLIENT_SERVICE_WAIT_FOREVER);
 267         if (status != CSL_PASS)
 268         {
 269             SBL_log(SBL_LOG_ERR,"MCU FSS0_S0 firewall region # %d disable...FAILED \n", i);
 270         }
 271     }
 272 #endif
 273 #endif
 274
 275 #ifndef SBL_SKIP_BRD_CFG_RM
 276     SBL_ADD_PROFILE_POINT;
 277     sblBoardCfgRmPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLowRm;
 278     sblBoardCfgRmPrms.boardConfigHigh = 0;
 279     sblBoardCfgRmPrms.boardConfigSize = boardCfgInfo.boardCfgLowRmSize;
 280     sblBoardCfgRmPrms.devGrp = SBL_DEVGRP;
 281     status = Sciclient_boardCfgRm(&sblBoardCfgRmPrms);
 282     if (status != CSL_PASS)
 283     {
 284         SBL_log(SBL_LOG_ERR,"Sciclient board config rm...FAILED \n");
 285         SblErrLoop(__FILE__, __LINE__);
 286     }
 287 #endif
 288
 289     /* Get SYSFW/TIFS version */
 290     SBL_ADD_PROFILE_POINT;
 291
 292     if (SBL_LOG_LEVEL > SBL_LOG_ERR)
 293     {
 294         struct tisci_msg_version_req req = {0};
 295         const Sciclient_ReqPrm_t      reqPrm =
 296         {
 297             TISCI_MSG_VERSION,
 298             TISCI_MSG_FLAG_AOP,
 299             (const uint8_t *)&req,
 300             sizeof(req),
 301             SCICLIENT_SERVICE_WAIT_FOREVER
 302         };
 303
 304         struct tisci_msg_version_resp response;
 305         Sciclient_RespPrm_t           respPrm =
 306         {
 307             0,
 308             (uint8_t *) &response,
 309             (uint32_t)sizeof (response)
 310         };
 311
 312         status = Sciclient_service(&reqPrm, &respPrm);
 313         if (CSL_PASS == status)
 314         {
 315             if (respPrm.flags == (uint32_t)TISCI_MSG_FLAG_ACK)
 316             {
 317                 SBL_ADD_PROFILE_POINT;
 318 #if defined(SOC_J721E) || defined(SOC_J7200)
 319                 SBL_log(SBL_LOG_MIN,"TIFS  ver: %s\n", (char *) response.str);
 320 #else
 321                 SBL_log(SBL_LOG_MIN,"SYSFW  ver: %s\n", (char *) response.str);
 322 #endif
 323             }
 324             else
 325             {
 326 #if defined(SOC_J721E) || defined(SOC_J7200)
 327                 SBL_log(SBL_LOG_ERR,"TIFS Get Version failed \n");
 328 #else
 329                 SBL_log(SBL_LOG_ERR,"SYSFW Get Version failed \n");
 330 #endif
 331                 SblErrLoop(__FILE__, __LINE__);
 332             }
 333         }
 334     }
 335
 336
 337 #if (!defined(SBL_SKIP_BRD_CFG_PM)) || (!defined(SBL_SKIP_BRD_CFG_RM))
 338     status = Sciclient_setBoardConfigHeader();
 339     if (CSL_PASS == status)
 340     {
 341         SBL_log(SBL_LOG_MAX,"Sciclient_setBoardConfigHeader... PASSED\n");
 342     }
 343     else
 344     {
 345         SBL_log(SBL_LOG_ERR,"Sciclient_setBoardConfigHeader... FAILED\n");
 346         SblErrLoop(__FILE__, __LINE__);
 347     }
 348 #endif
 349
 350
 351 #if !defined(SBL_SKIP_MCU_RESET)
 352     /* RTI seems to be turned on by ROM. Turning it off so that Power domain can transition */
 353     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI0, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
 354     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI1, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
 355 #if defined(SOC_AM64X)
 356     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI8, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
 357     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI9, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
 358     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI10, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
 359     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI11, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
 360     Sciclient_pmSetModuleState(SBL_DEV_ID_MCU_RTI0, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
 361 #endif
 362 #endif
 363
 364
 365 #endif
 366
 367     SBL_ADD_PROFILE_POINT;
 368 }
 369
 370 #if (!defined(SBL_SKIP_BRD_CFG_PM)) || (!defined(SBL_SKIP_BRD_CFG_RM))
 371 static int32_t Sciclient_setBoardConfigHeader ()
 372 {
 373     int32_t status = CSL_PASS;
 374 #if defined (SOC_J7200) || defined (SOC_J721E)
 375     //uint32_t alignedOffset = ((SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES + 128U)/128U)*128U;
 376     uint32_t alignedOffset = SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES;
 377     Sciclient_BoardCfgPrms_t boardCfgPrms_pm =
 378     {
 379         .boardConfigLow = (uint32_t)SCISERVER_BOARDCONFIG_DATA_ADDR,
 380         .boardConfigHigh = 0,
 381         .boardConfigSize = SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES,
 382         .devGrp = DEVGRP_ALL
 383     };
 384     Sciclient_BoardCfgPrms_t boardCfgPrms_rm =
 385     {
 386         .boardConfigLow =
 387             (uint32_t) SCISERVER_BOARDCONFIG_DATA_ADDR + alignedOffset,
 388         .boardConfigHigh = 0,
 389         .boardConfigSize = SCICLIENT_BOARDCFG_RM_SIZE_IN_BYTES,
 390         .devGrp = DEVGRP_ALL
 391     };
 392     status = Sciclient_boardCfgPrepHeader (
 393         (uint8_t *) SCISERVER_COMMON_X509_HEADER_ADDR,
 394         (uint8_t *) SCISERVER_BOARDCONFIG_HEADER_ADDR,
 395         &boardCfgPrms_pm, &boardCfgPrms_rm);
 396     if (CSL_PASS == status)
 397     {
 398         SBL_log(SBL_LOG_MAX,"SCISERVER Board Configuration header population... ");
 399         SBL_log(SBL_LOG_MAX,"PASSED\n");
 400     }
 401     else
 402     {
 403         SBL_log(SBL_LOG_MIN,"SCISERVER Board Configuration header population... ");
 404         SBL_log(SBL_LOG_MIN,"FAILED\n");
 405     }
 406     memcpy((void *)boardCfgPrms_pm.boardConfigLow, (void *) sblBoardCfgPmPrms.boardConfigLow, SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES);
 407     memcpy((void *)boardCfgPrms_rm.boardConfigLow, (void *) sblBoardCfgRmPrms.boardConfigLow, SCICLIENT_BOARDCFG_RM_SIZE_IN_BYTES);
 408 #endif
 409     return status;
 410 }
 411 #endif