SBL: Fix Issues with OSPI DMA boot
[processor-sdk/pdk.git] / 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>
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
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];
59 #if SCICLIENT_FIRMWARE_SIZE_IN_BYTES > SBL_SYSFW_MAX_SIZE
60 #error "SYSFW too large...update SBL_SYSFW_MAX_SIZE"
61 #endif
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)
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)
75 /** \brief Aligned address at which the Board Config header is placed. */
76 #define SCISERVER_BOARDCONFIG_HEADER_ADDR (0x41c80000U)
78 /** \brief Aligned address at which the Board Config is placed. */
79 #define SCISERVER_BOARDCONFIG_DATA_ADDR (0x41c80040U)
81 #endif
82 #endif
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;
90     SBL_ADD_PROFILE_POINT;
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;
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     }
103     SBL_ADD_PROFILE_POINT;
105     return retVal;
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
117 #ifndef SBL_SKIP_BRD_CFG_RM
118 uint16_t gCertLength = 0;
119 #endif
120 static uint16_t boardcfgRmFindCertSize(uint32_t *msg_recv)
122     uint16_t cert_len = 0;
123     uint8_t *cert_len_ptr = (uint8_t *)&cert_len;
124     uint8_t *x509_cert_ptr;
126     x509_cert_ptr = (uint8_t *)msg_recv;
129     if (*x509_cert_ptr != 0x30)
130     {
131         /* The data does not contain a certificate - return */
132         return 0;
133     }
135     cert_len = *(x509_cert_ptr + 1);
137     /* If you need more than 2 bytes to store the cert length  */
138     /* it means that the cert length is greater than 64 Kbytes */
139     /* and we do not support it                                */
140     if ((cert_len > 0x80) &&
141         (cert_len != 0x82))
142     {
143         return 0;
144     }
146     if (cert_len == 0x82)
147     {
148         *cert_len_ptr = *(x509_cert_ptr + 3);
149         *(cert_len_ptr + 1) = *(x509_cert_ptr + 2);
151         /* add current offset from start of x509 cert */
152         cert_len += 3;
153     }
154     else
155     {
156         /* add current offset from start of x509 cert  */
157         /* if cert len was obtained from 2nd byte i.e. */
158         /* cert size is 127 bytes or less              */
159         cert_len += 1;
160     }
162     /* cert_len now contains the offset of the last byte */
163     /* of the cert from the ccert_start. To get the size */
164     /* of certificate, add 1                             */
166     return cert_len + 1;
169 void SBL_SciClientInit(void)
171     int32_t status = CSL_EFAIL;
172     void *sysfw_ptr = gSciclient_firmware;
174 #ifndef SBL_SKIP_SYSFW_INIT
175     /* SYSFW board configurations */
176     Sciclient_DefaultBoardCfgInfo_t boardCfgInfo;
177     Sciclient_ConfigPrms_t config;
178     Sciclient_configPrmsInit(&config);
179     config.opModeFlag               =   SCICLIENT_SERVICE_OPERATION_MODE_POLLED;
180     config.pBoardCfgPrms            =   NULL;
181     config.isSecureMode             =   0; /* default board cfg is for non-secure mode */
182     config.c66xRatRegion            =   0;
183     config.skipLocalBoardCfgProcess =   TRUE;
184 #endif
186     SBL_ADD_PROFILE_POINT;
188     status = SBL_ReadSysfwImage(&sysfw_ptr, SBL_SYSFW_MAX_SIZE);
189     if (status != CSL_PASS)
190     {
191 #if defined(SOC_J721E) || defined(SOC_J7200)
192         SBL_log(SBL_LOG_ERR,"TIFS read...FAILED \n");
193 #else
194         SBL_log(SBL_LOG_ERR,"SYSFW read...FAILED \n");
195 #endif
196         SblErrLoop(__FILE__, __LINE__);
197     }
199 #ifndef SBL_SKIP_SYSFW_INIT
200     SBL_ADD_PROFILE_POINT;
202     status = Sciclient_getDefaultBoardCfgInfo(&boardCfgInfo);
204 #if defined(SBL_ENABLE_HLOS_BOOT) && defined(SOC_AM65XX)
205     /* Replace default Sciclient boardCfgLowRm with alternate version for HLOS boot */
206         boardCfgInfo.boardCfgLowRm     = &gSciclient_boardCfgLow_hlos_rm[0U];
207         boardCfgInfo.boardCfgLowRmSize = SCICLIENT_BOARDCFG_RM_LINUX_SIZE_IN_BYTES;
208 #endif
210     if (status != CSL_PASS)
211     {
212         SBL_log(SBL_LOG_ERR,"Sciclient get default board config...FAILED \n");
213         SblErrLoop(__FILE__, __LINE__);
214     }
216     status = Sciclient_loadFirmware((const uint32_t *) sysfw_ptr);
217     if (status != CSL_PASS)
218     {
219 #if defined(SOC_J721E) || defined(SOC_J7200)
220         SBL_log(SBL_LOG_ERR,"TIFS load...FAILED \n");
221 #else
222         SBL_log(SBL_LOG_ERR,"SYSFW load...FAILED \n");
223 #endif
224         SblErrLoop(__FILE__, __LINE__);
225     }
227     SBL_ADD_PROFILE_POINT;
228     status = Sciclient_init(&config);
229     if (status != CSL_PASS)
230     {
231         SBL_log(SBL_LOG_ERR,"Sciclient init ...FAILED \n");
232         SblErrLoop(__FILE__, __LINE__);
233     }
235 #ifndef SBL_SKIP_BRD_CFG_BOARD
236     SBL_ADD_PROFILE_POINT;
237     sblBoardCfgPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLow;
238     sblBoardCfgPrms.boardConfigHigh = 0;
239     sblBoardCfgPrms.boardConfigSize = boardCfgInfo.boardCfgLowSize;
240     sblBoardCfgPrms.devGrp = SBL_DEVGRP;
241     status = Sciclient_boardCfg(&sblBoardCfgPrms);
242     if (status != CSL_PASS)
243     {
244         SBL_log(SBL_LOG_ERR,"Sciclient board config ...FAILED \n");
245         SblErrLoop(__FILE__, __LINE__);
246     }
247 #endif
249 #ifndef SBL_SKIP_BRD_CFG_PM
250     if (SBL_LOG_LEVEL > SBL_LOG_NONE)
251     {
252         SBL_ADD_PROFILE_POINT;
253         UART_stdioDeInit();
254     }
255     SBL_ADD_PROFILE_POINT;
256     sblBoardCfgPmPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLowPm;
257     sblBoardCfgPmPrms.boardConfigHigh = 0;
258     sblBoardCfgPmPrms.boardConfigSize = boardCfgInfo.boardCfgLowPmSize;
259     sblBoardCfgPmPrms.devGrp = SBL_DEVGRP;
260     status = Sciclient_boardCfgPm(&sblBoardCfgPmPrms);
261     if (status != CSL_PASS)
262     {
263         SBL_log(SBL_LOG_ERR,"Sciclient board config pm...FAILED \n")
264         SblErrLoop(__FILE__, __LINE__);
265     }
267     if (SBL_LOG_LEVEL > SBL_LOG_NONE)
268     {
269         /* Re-init UART for logging */
270         UART_HwAttrs uart_cfg;
272         SBL_ADD_PROFILE_POINT;
273         UART_socGetInitCfg(BOARD_UART_INSTANCE, &uart_cfg);
274         uart_cfg.frequency = SBL_SYSFW_UART_MODULE_INPUT_CLK;
275         UART_socSetInitCfg(BOARD_UART_INSTANCE, &uart_cfg);
276         UART_stdioInit(BOARD_UART_INSTANCE);
277     }
278 #endif
280 #ifndef SBL_SKIP_BRD_CFG_SEC
281     SBL_ADD_PROFILE_POINT;
282     sblBoardCfgSecPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLowSec;
283     sblBoardCfgSecPrms.boardConfigHigh = 0;
284     sblBoardCfgSecPrms.boardConfigSize = boardCfgInfo.boardCfgLowSecSize;
285     sblBoardCfgSecPrms.devGrp = SBL_DEVGRP;
286     status = Sciclient_boardCfgSec(&sblBoardCfgSecPrms);
287     if (status != CSL_PASS)
288     {
289         SBL_log(SBL_LOG_ERR,"Sciclient board config sec...FAILED \n");
290         SblErrLoop(__FILE__, __LINE__);
291     }
292 #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200)
293     /* Secure ROM has left firewall regions for FSS DAT0 set.  Disable them for DMA usage. */
294     uint16_t i;
295     struct tisci_msg_fwl_set_firewall_region_resp respFwCtrl = {0};
296     struct tisci_msg_fwl_set_firewall_region_req reqFwCtrl =
297     {
298         .fwl_id = (uint16_t) MCU_FSS0_S0_FWID,
299         .region = (uint16_t) 0,
300         .n_permission_regs = (uint32_t) 3,
301         /* Set .control to zero to disable the firewall region */
302         .control = (uint32_t) 0,
303         .permissions[0] = (uint32_t) 0,
304         .permissions[1] = (uint32_t) 0,
305         .permissions[2] = (uint32_t) 0,
306         .start_address = 0,
307         .end_address = 0
308     };
310     for (i = 0; i < MCU_FSS0_S0_FW_REGIONS; i++)
311     {
312         reqFwCtrl.region = i;
313         status = Sciclient_firewallSetRegion(&reqFwCtrl, &respFwCtrl, SCICLIENT_SERVICE_WAIT_FOREVER);
314         if (status != CSL_PASS)
315         {
316             SBL_log(SBL_LOG_ERR,"MCU FSS0_S0 firewall region # %d disable...FAILED \n", i);
317         }
318     }
319 #endif
320 #endif
322 #ifndef SBL_SKIP_BRD_CFG_RM
323     SBL_ADD_PROFILE_POINT;
324     sblBoardCfgRmPrms.boardConfigLow = (uint32_t)boardCfgInfo.boardCfgLowRm;
325     sblBoardCfgRmPrms.boardConfigHigh = 0;
326     sblBoardCfgRmPrms.boardConfigSize = boardCfgInfo.boardCfgLowRmSize;
327     sblBoardCfgRmPrms.devGrp = SBL_DEVGRP;
328     gCertLength = boardcfgRmFindCertSize((uint32_t*)boardCfgInfo.boardCfgLowRm);
329     status = Sciclient_boardCfgRm(&sblBoardCfgRmPrms);
330     if (status != CSL_PASS)
331     {
332         SBL_log(SBL_LOG_ERR,"Sciclient board config rm...FAILED \n");
333         SblErrLoop(__FILE__, __LINE__);
334     }
335 #endif
337     /* Get SYSFW/TIFS version */
338     SBL_ADD_PROFILE_POINT;
340     if (SBL_LOG_LEVEL > SBL_LOG_ERR)
341     {
342         struct tisci_msg_version_req req = {0};
343         const Sciclient_ReqPrm_t      reqPrm =
344         {
345             TISCI_MSG_VERSION,
346             TISCI_MSG_FLAG_AOP,
347             (const uint8_t *)&req,
348             sizeof(req),
349             SCICLIENT_SERVICE_WAIT_FOREVER
350         };
352         struct tisci_msg_version_resp response;
353         Sciclient_RespPrm_t           respPrm =
354         {
355             0,
356             (uint8_t *) &response,
357             (uint32_t)sizeof (response)
358         };
360         status = Sciclient_service(&reqPrm, &respPrm);
361         if (CSL_PASS == status)
362         {
363             if (respPrm.flags == (uint32_t)TISCI_MSG_FLAG_ACK)
364             {
365                 SBL_ADD_PROFILE_POINT;
366 #if defined(SOC_J721E) || defined(SOC_J7200)
367                 SBL_log(SBL_LOG_MIN,"TIFS  ver: %s\n", (char *) response.str);
368 #else
369                 SBL_log(SBL_LOG_MIN,"SYSFW  ver: %s\n", (char *) response.str);
370 #endif
371             }
372             else
373             {
374 #if defined(SOC_J721E) || defined(SOC_J7200)
375                 SBL_log(SBL_LOG_ERR,"TIFS Get Version failed \n");
376 #else
377                 SBL_log(SBL_LOG_ERR,"SYSFW Get Version failed \n");
378 #endif
379                 SblErrLoop(__FILE__, __LINE__);
380             }
381         }
382     }
385 #if (!defined(SBL_SKIP_BRD_CFG_PM)) || (!defined(SBL_SKIP_BRD_CFG_RM))
386     status = Sciclient_setBoardConfigHeader();
387     if (CSL_PASS == status)
388     {
389         SBL_log(SBL_LOG_MAX,"Sciclient_setBoardConfigHeader... PASSED\n");
390     }
391     else
392     {
393         SBL_log(SBL_LOG_ERR,"Sciclient_setBoardConfigHeader... FAILED\n");
394         SblErrLoop(__FILE__, __LINE__);
395     }
396 #endif
399 #if !defined(SBL_SKIP_MCU_RESET)
400     /* RTI seems to be turned on by ROM. Turning it off so that Power domain can transition */
401     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI0, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
402     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI1, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
403 #if defined(SOC_AM64X)
404     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI8, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
405     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI9, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
406     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI10, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
407     Sciclient_pmSetModuleState(SBL_DEV_ID_RTI11, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
408     Sciclient_pmSetModuleState(SBL_DEV_ID_MCU_RTI0, TISCI_MSG_VALUE_DEVICE_SW_STATE_AUTO_OFF, TISCI_MSG_FLAG_AOP, SCICLIENT_SERVICE_WAIT_FOREVER);
409 #endif
410 #endif
413 #endif
415     SBL_ADD_PROFILE_POINT;
418 #if (!defined(SBL_SKIP_BRD_CFG_PM)) || (!defined(SBL_SKIP_BRD_CFG_RM))
419 static int32_t Sciclient_setBoardConfigHeader ()
421     int32_t status = CSL_PASS;
422 #if defined (SOC_J7200) || defined (SOC_J721E)
423     //uint32_t alignedOffset = ((SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES + 128U)/128U)*128U;
424     uint32_t alignedOffset = SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES;
425     Sciclient_BoardCfgPrms_t boardCfgPrms_pm =
426     {
427         .boardConfigLow = (uint32_t)SCISERVER_BOARDCONFIG_DATA_ADDR,
428         .boardConfigHigh = 0,
429         .boardConfigSize = (uint16_t)SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES,
430         .devGrp = DEVGRP_ALL
431     };
432     Sciclient_BoardCfgPrms_t boardCfgPrms_rm =
433     {
434         .boardConfigLow =
435             (uint32_t) SCISERVER_BOARDCONFIG_DATA_ADDR + alignedOffset,
436         .boardConfigHigh = 0,
437         .boardConfigSize = (uint16_t)SCICLIENT_BOARDCFG_RM_SIZE_IN_BYTES - gCertLength,
438         .devGrp = DEVGRP_ALL
439     };
440     status = Sciclient_boardCfgPrepHeader (
441         (uint8_t *) SCISERVER_COMMON_X509_HEADER_ADDR,
442         (uint8_t *) SCISERVER_BOARDCONFIG_HEADER_ADDR,
443         &boardCfgPrms_pm, &boardCfgPrms_rm);
444     if (CSL_PASS == status)
445     {
446         SBL_log(SBL_LOG_MAX,"SCISERVER Board Configuration header population... ");
447         SBL_log(SBL_LOG_MAX,"PASSED\n");
448     }
449     else
450     {
451         SBL_log(SBL_LOG_MIN,"SCISERVER Board Configuration header population... ");
452         SBL_log(SBL_LOG_MIN,"FAILED\n");
453     }
454     memcpy((void *)boardCfgPrms_pm.boardConfigLow, (void *) sblBoardCfgPmPrms.boardConfigLow, SCICLIENT_BOARDCFG_PM_SIZE_IN_BYTES);
455     memcpy((void *)boardCfgPrms_rm.boardConfigLow, (void *) sblBoardCfgRmPrms.boardConfigLow, SCICLIENT_BOARDCFG_RM_SIZE_IN_BYTES - gCertLength);
456 #endif
457     return status;
459 #endif