1 /*
2 * Copyright (c) 2023, Advanced Micro Devices, Inc. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <errno.h>
9 #include <stdlib.h>
10 #include <string.h>
11
12 #include <common/debug.h>
13 #include <common/fdt_fixup.h>
14 #include <common/fdt_wrappers.h>
15 #include <drivers/arm/dcc.h>
16 #include <drivers/arm/pl011.h>
17 #include <drivers/cadence/cdns_uart.h>
18 #include <drivers/console.h>
19 #include <libfdt.h>
20 #include <plat_console.h>
21 #include <plat_fdt.h>
22
23 #include <platform_def.h>
24 #include <plat_private.h>
25
26 static console_t console;
27
28 #if (defined(XILINX_OF_BOARD_DTB_ADDR) && !IS_TFA_IN_OCM(BL31_BASE))
29 /**
30 * get_baudrate() - Get the baudrate form DTB.
31 * @dtb: Address of the Device Tree Blob (DTB).
32 *
33 * Return: On success returns the baudrate; on failure returns an error.
34 */
get_baudrate(void * dtb)35 static int32_t get_baudrate(void *dtb)
36 {
37 int node;
38 int32_t ret = 0;
39 const char *prop, *path;
40 char *end;
41 int32_t baud_rate = 0;
42
43 node = fdt_path_offset(dtb, "/secure-chosen");
44 if (node < 0) {
45 node = fdt_path_offset(dtb, "/chosen");
46 if (node < 0) {
47 ret = -FDT_ERR_NOTFOUND;
48 goto error;
49 }
50 }
51
52 prop = fdt_getprop(dtb, node, "stdout-path", NULL);
53 if (prop == NULL) {
54 ret = -FDT_ERR_NOTFOUND;
55 goto error;
56 }
57
58 /* Parse string serial0:115200n8 */
59 path = strchr(prop, ':');
60 if (!path) {
61 ret = -FDT_ERR_NOTFOUND;
62 goto error;
63 } else {
64
65 baud_rate = strtoul(path + 1, &end, 10);
66 if (baud_rate == 0 && end == path) {
67 ERROR("Conversion error occurred: %d\n", baud_rate);
68 ret = -FDT_ERR_NOTFOUND;
69 goto error;
70 }
71 ret = baud_rate;
72 }
73
74 error:
75 return ret;
76 }
77
78 /**
79 * get_node_status() - Get the DTB node status.
80 * @dtb: Address of the Device Tree Blob (DTB).
81 * @node: Node address in the device tree.
82 *
83 * Return: On success, it returns 1; on failure, it returns an 0.
84 */
get_node_status(void * dtb,int node)85 static uint32_t get_node_status(void *dtb, int node)
86 {
87 const char *status_cell;
88 uint32_t status = 0;
89
90 status_cell = fdt_getprop(dtb, node, "status", NULL);
91 if (!status_cell || strcmp(status_cell, "okay") == 0) {
92 status = 1;
93 } else {
94 status = 0;
95 }
96
97 return status;
98 }
99
100 /**
101 * fdt_add_uart_info() - Add DTB information to a UART structure.
102 * @info: Pointer to the UART information structure.
103 * @node: Node address in the device tree.
104 * @dtb: Address of the Device Tree Blob(DTB).
105 *
106 * Return: On success, it returns 1; on failure, it returns an 0.
107 */
fdt_add_uart_info(dt_uart_info_t * info,int node,void * dtb)108 static uint32_t fdt_add_uart_info(dt_uart_info_t *info, int node, void *dtb)
109 {
110 uintptr_t base_addr;
111 const char *com;
112 int32_t ret = 0;
113
114 com = fdt_getprop(dtb, node, "compatible", NULL);
115 if (com != NULL) {
116 strlcpy(info->compatible, com, sizeof(info->compatible));
117 } else {
118 ERROR("Compatible property not found in DTB node\n");
119 ret = -FDT_ERR_NOTFOUND;
120 goto error;
121 }
122
123 ret = fdt_get_reg_props_by_index(dtb, node, 0, &base_addr, NULL);
124 if (ret >= 0) {
125 info->base = base_addr;
126 } else {
127 ERROR("Failed to retrieve base address. Error code: %d\n", ret);
128 ret = -FDT_ERR_NOTFOUND;
129 goto error;
130 }
131
132 info->status = get_node_status(dtb, node);
133 info->baud_rate = get_baudrate(dtb);
134
135 error:
136 return ret;
137 }
138
139 /**
140 * fdt_get_uart_info() - Get the uart information form DTB.
141 * @info: Pointer to the UART information structure.
142 *
143 * Return: On success, it returns 0; on failure, it returns an error+reason.
144 */
fdt_get_uart_info(dt_uart_info_t * info)145 static int fdt_get_uart_info(dt_uart_info_t *info)
146 {
147 int node = 0, ret = 0;
148 void *dtb = (void *)XILINX_OF_BOARD_DTB_ADDR;
149
150 ret = is_valid_dtb(dtb);
151 if (ret < 0) {
152 ERROR("Invalid Device Tree at %p: error %d\n", dtb, ret);
153 ret = -FDT_ERR_NOTFOUND;
154 goto error;
155 }
156
157 node = fdt_get_stdout_node_offset(dtb);
158 if (node < 0) {
159 ERROR("DT get stdout node failed : %d\n", node);
160 ret = -FDT_ERR_NOTFOUND;
161 goto error;
162 }
163
164 ret = fdt_add_uart_info(info, node, dtb);
165 if (ret < 0) {
166 ERROR("Failed to add DT UART info: %d\n", ret);
167 ret = -FDT_ERR_NOTFOUND;
168 goto error;
169 }
170
171 error:
172 return ret;
173 }
174
175 /**
176 * check_fdt_uart_info() - Check early uart info with DTB uart info.
177 * @info: Pointer to the UART information structure.
178 *
179 * Return: On success, it returns 0; on failure, it returns an error+reason.
180 */
check_fdt_uart_info(dt_uart_info_t * info)181 static int32_t check_fdt_uart_info(dt_uart_info_t *info)
182 {
183 int32_t ret = 0;
184
185 if (info->status == 0) {
186 ret = -ENODEV;
187 goto error;
188 }
189
190 if ((info->base == console.base) &&
191 (info->baud_rate == UART_BAUDRATE) && !CONSOLE_IS(dcc)) {
192 ret = -ENODEV;
193 goto error;
194 }
195
196 error:
197 return ret;
198 }
199
200 /**
201 * console_boot_end() - Unregister the console_t instance form the console list.
202 * @boot_console: Pointer to the console information structure.
203 */
console_boot_end(console_t * boot_console)204 static void console_boot_end(console_t *boot_console)
205 {
206 if (CONSOLE_IS(dcc)) {
207 console_dcc_unregister();
208 } else {
209 console_flush();
210 (void)console_unregister(boot_console);
211 }
212 }
213
214 /**
215 * setup_runtime_console() - Registers the runtime uart with console list.
216 * @clock: UART clock.
217 * @info: Pointer to the UART information structure.
218 */
setup_runtime_console(uint32_t clock,dt_uart_info_t * info)219 static void setup_runtime_console(uint32_t clock, dt_uart_info_t *info)
220 {
221 static console_t bl31_runtime_console;
222 int32_t rc;
223
224 #if defined(PLAT_zynqmp)
225 rc = console_cdns_register(info->base,
226 clock,
227 info->baud_rate,
228 &bl31_runtime_console);
229 #else
230 rc = console_pl011_register(info->base,
231 clock,
232 info->baud_rate,
233 &bl31_runtime_console);
234 #endif
235 if (rc == 0) {
236 panic();
237 }
238
239 console_set_scope(&bl31_runtime_console,
240 CONSOLE_FLAG_BOOT | CONSOLE_FLAG_RUNTIME |
241 CONSOLE_FLAG_CRASH);
242 }
243
244
245 /**
246 * runtime_console_init() - Initializes the run time console information.
247 * @uart_info: Pointer to the UART information structure.
248 * @bl31_boot_console: Pointer to the console information structure.
249 * @clock: UART clock.
250 *
251 * Return: On success, it returns 0; on failure, it returns an error+reason;
252 */
runtime_console_init(dt_uart_info_t * uart_info,console_t * bl31_boot_console,uint32_t clock)253 static int32_t runtime_console_init(dt_uart_info_t *uart_info,
254 console_t *bl31_boot_console,
255 uint32_t clock)
256 {
257 int32_t rc = 0;
258
259 /* Parse UART information from Device Tree Blob (DTB) */
260 rc = fdt_get_uart_info(uart_info);
261 if (rc < 0) {
262 rc = -FDT_ERR_NOTFOUND;
263 goto error;
264 }
265
266 if (strncmp(uart_info->compatible, DT_UART_COMPAT,
267 strlen(DT_UART_COMPAT)) == 0) {
268
269 if (check_fdt_uart_info(uart_info) == 0) {
270 setup_runtime_console(clock, uart_info);
271 console_boot_end(bl31_boot_console);
272 INFO("Runtime console setup\n");
273 } else {
274 INFO("Early console and DTB console are same\n");
275 }
276 } else if (strncmp(uart_info->compatible, DT_UART_DCC_COMPAT,
277 strlen(DT_UART_DCC_COMPAT)) == 0) {
278 rc = console_dcc_register();
279 if (rc == 0) {
280 panic();
281 }
282 console_boot_end(bl31_boot_console);
283 } else {
284 WARN("BL31: No console device found in DT.\n");
285 }
286
287 error:
288 return rc;
289 }
290 #endif
291
setup_console(void)292 void setup_console(void)
293 {
294 int32_t rc;
295 uint32_t uart_clk = get_uart_clk();
296
297 #if defined(PLAT_zynqmp)
298 if (CONSOLE_IS(cadence) || (CONSOLE_IS(cadence1))) {
299 rc = console_cdns_register(UART_BASE,
300 uart_clk,
301 UART_BAUDRATE,
302 &console);
303 if (rc == 0) {
304 panic();
305 }
306
307 console_set_scope(&console, CONSOLE_FLAG_BOOT |
308 CONSOLE_FLAG_RUNTIME | CONSOLE_FLAG_CRASH);
309 }
310 #else
311 if (CONSOLE_IS(pl011) || (CONSOLE_IS(pl011_1))) {
312 /* Initialize the console to provide early debug support */
313 rc = console_pl011_register((uint32_t)UART_BASE,
314 uart_clk,
315 (uint32_t)UART_BAUDRATE,
316 &console);
317 if (rc == 0) {
318 panic();
319 }
320
321 console_set_scope(&console, CONSOLE_FLAG_BOOT |
322 CONSOLE_FLAG_RUNTIME | CONSOLE_FLAG_CRASH);
323 }
324 #endif
325 if (CONSOLE_IS(dcc)) {
326 /* Initialize the dcc console for debug */
327 rc = console_dcc_register();
328 if (rc == 0) {
329 panic();
330 }
331 }
332 INFO("BL31: Early console setup\n");
333
334 #if (defined(XILINX_OF_BOARD_DTB_ADDR) && !IS_TFA_IN_OCM(BL31_BASE))
335 static dt_uart_info_t uart_info = {0};
336
337 /* Initialize the runtime console using UART information from the DTB */
338 rc = runtime_console_init(&uart_info, &console, uart_clk);
339 if (rc < 0) {
340 ERROR("Failed to initialize runtime console: %d\n", rc);
341 }
342 #endif
343 }
344