diff --git a/Makefile b/Makefile index d487eae..16c1039 100644 --- a/Makefile +++ b/Makefile @@ -396,12 +396,6 @@ $(error USE_COHERENT_MEM cannot be enabled with HW_ASSISTED_COHERENCY) endif -ifneq ($(MULTI_CONSOLE_API), 0) - ifeq (${ARCH},aarch32) - $(error "Error: MULTI_CONSOLE_API is not supported for AArch32") - endif -endif - #For now, BL2_IN_XIP_MEM is only supported when BL2_AT_EL3 is 1. ifeq ($(BL2_AT_EL3)-$(BL2_IN_XIP_MEM),0-1) $(error "BL2_IN_XIP_MEM is only supported when BL2_AT_EL3 is enabled") diff --git a/drivers/arm/pl011/aarch32/pl011_console.S b/drivers/arm/pl011/aarch32/pl011_console.S index 3718fff..b7892e1 100644 --- a/drivers/arm/pl011/aarch32/pl011_console.S +++ b/drivers/arm/pl011/aarch32/pl011_console.S @@ -1,10 +1,12 @@ /* - * Copyright (c) 2016-2017, ARM Limited and Contributors. All rights reserved. + * Copyright (c) 2016-2018, ARM Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ #include #include +#include +#include #include /* @@ -13,10 +15,18 @@ */ #include "../../../console/aarch32/console.S" - .globl console_core_init - .globl console_core_putc - .globl console_core_getc - .globl console_core_flush + /* + * "core" functions are low-level implementations that don't require + * writeable memory and are thus safe to call in BL1 crash context. + */ + .globl console_pl011_core_init + .globl console_pl011_core_putc + .globl console_pl011_core_getc + .globl console_pl011_core_flush + + .globl console_pl011_putc + .globl console_pl011_getc + .globl console_pl011_flush /* ----------------------------------------------- @@ -33,7 +43,7 @@ * Clobber list : r1, r2, r3 * ----------------------------------------------- */ -func console_core_init +func console_pl011_core_init /* Check the input base address */ cmp r0, #0 beq core_init_fail @@ -73,7 +83,53 @@ core_init_fail: mov r0, #0 bx lr -endfunc console_core_init +endfunc console_pl011_core_init + +#if MULTI_CONSOLE_API + .globl console_pl011_register + + /* ------------------------------------------------------- + * init console_pl011_register(console_pl011_t *console, + * uintptr_t base, uint32_t clk, uint32_t baud) + * Function to initialize and register a new PL011 + * console. Storage passed in for the console struct + * *must* be persistent (i.e. not from the stack). + * In: r0 - UART register base address + * r1 - UART clock in Hz + * r2 - Baud rate + * r3 - pointer to empty console_pl011_t struct + * Out: return 1 on success, 0 on error + * Clobber list : r0, r1, r2 + * ------------------------------------------------------- + */ +func console_pl011_register + push {r4, lr} + mov r4, r3 + cmp r4, #0 + beq register_fail + str r0, [r4, #CONSOLE_T_PL011_BASE] + + bl console_pl011_core_init + cmp r0, #0 + beq register_fail + + mov r0, r4 + pop {r4, lr} + finish_console_register pl011 + +register_fail: + pop {r4, pc} +endfunc console_pl011_register +#else + .globl console_core_init + .globl console_core_putc + .globl console_core_getc + .globl console_core_flush + .equ console_core_init, console_pl011_core_init + .equ console_core_putc, console_pl011_core_putc + .equ console_core_getc, console_pl011_core_getc + .equ console_core_flush, console_pl011_core_flush +#endif /* -------------------------------------------------------- * int console_core_putc(int c, uintptr_t base_addr) @@ -85,7 +141,7 @@ * Clobber list : r2 * -------------------------------------------------------- */ -func console_core_putc +func console_pl011_core_putc /* Check the input parameter */ cmp r1, #0 beq putc_error @@ -109,7 +165,26 @@ putc_error: mov r0, #-1 bx lr -endfunc console_core_putc +endfunc console_pl011_core_putc + + /* -------------------------------------------------------- + * int console_pl011_putc(int c, console_pl011_t *console) + * Function to output a character over the console. It + * returns the character printed on success or -1 on error. + * In: r0 - character to be printed + * r1 - pointer to console_t structure + * Out : return -1 on error else return character. + * Clobber list: r2 + * ------------------------------------------------------- + */ +func console_pl011_putc +#if ENABLE_ASSERTIONS + cmp r1, #0 + ASM_ASSERT(ne) +#endif /* ENABLE_ASSERTIONS */ + ldr r1, [r1, #CONSOLE_T_PL011_BASE] + b console_pl011_core_putc +endfunc console_pl011_putc /* --------------------------------------------- * int console_core_getc(uintptr_t base_addr) @@ -120,7 +195,7 @@ * Clobber list : r0, r1 * --------------------------------------------- */ -func console_core_getc +func console_pl011_core_getc cmp r0, #0 beq getc_error 1: @@ -134,7 +209,26 @@ getc_error: mov r0, #-1 bx lr -endfunc console_core_getc +endfunc console_pl011_core_getc + + /* ------------------------------------------------ + * int console_pl011_getc(console_pl011_t *console) + * Function to get a character from the console. + * It returns the character grabbed on success + * or -1 if no character is available. + * In : r0 - pointer to console_t structure + * Out: r0 - character if available, else -1 + * Clobber list: r0, r1 + * ------------------------------------------------ + */ +func console_pl011_getc +#if ENABLE_ASSERTIONS + cmp r0, #0 + ASM_ASSERT(ne) +#endif /* ENABLE_ASSERTIONS */ + ldr r0, [r0, #CONSOLE_T_PL011_BASE] + b console_pl011_core_getc +endfunc console_pl011_getc /* --------------------------------------------- * int console_core_flush(uintptr_t base_addr) @@ -145,7 +239,7 @@ * Clobber list : r0, r1 * --------------------------------------------- */ -func console_core_flush +func console_pl011_core_flush cmp r0, #0 beq flush_error @@ -160,4 +254,22 @@ flush_error: mov r0, #-1 bx lr -endfunc console_core_flush +endfunc console_pl011_core_flush + + /* --------------------------------------------- + * int console_pl011_flush(console_pl011_t *console) + * Function to force a write of all buffered + * data that hasn't been output. + * In : r0 - pointer to console_t structure + * Out : return -1 on error else return 0. + * Clobber list: r0, r1 + * --------------------------------------------- + */ +func console_pl011_flush +#if ENABLE_ASSERTIONS + cmp r0, #0 + ASM_ASSERT(ne) +#endif /* ENABLE_ASSERTIONS */ + ldr r0, [r0, #CONSOLE_T_PL011_BASE] + b console_pl011_core_flush +endfunc console_pl011_flush diff --git a/drivers/console/aarch32/console.S b/drivers/console/aarch32/console.S index a3c6546..f909609 100644 --- a/drivers/console/aarch32/console.S +++ b/drivers/console/aarch32/console.S @@ -3,104 +3,9 @@ * * SPDX-License-Identifier: BSD-3-Clause */ -#include - .globl console_init - .globl console_uninit - .globl console_putc - .globl console_getc - .globl console_flush - - /* - * The console base is in the data section and not in .bss - * even though it is zero-init. In particular, this allows - * the console functions to start using this variable before - * the runtime memory is initialized for images which do not - * need to copy the .data section from ROM to RAM. - */ -.section .data.console_base ; .align 2 - console_base: .word 0x0 - - /* ----------------------------------------------- - * int console_init(uintptr_t base_addr, - * unsigned int uart_clk, unsigned int baud_rate) - * Function to initialize the console without a - * C Runtime to print debug information. It saves - * the console base to the data section. - * In: r0 - console base address - * r1 - Uart clock in Hz - * r2 - Baud rate - * out: return 1 on success else 0 on error - * Clobber list : r1 - r3 - * ----------------------------------------------- - */ -func console_init - /* Check the input base address */ - cmp r0, #0 - beq init_fail - ldr r3, =console_base - str r0, [r3] - b console_core_init -init_fail: - bx lr -endfunc console_init - - /* ----------------------------------------------- - * void console_uninit(void) - * Function to finish the use of console driver. - * It sets the console_base as NULL so that any - * further invocation of `console_putc` or - * `console_getc` APIs would return error. - * ----------------------------------------------- - */ -func console_uninit - mov r0, #0 - ldr r3, =console_base - str r0, [r3] - bx lr -endfunc console_uninit - - /* --------------------------------------------- - * int console_putc(int c) - * Function to output a character over the - * console. It returns the character printed on - * success or -1 on error. - * In : r0 - character to be printed - * Out : return -1 on error else return character. - * Clobber list : r1, r2 - * --------------------------------------------- - */ -func console_putc - ldr r2, =console_base - ldr r1, [r2] - b console_core_putc -endfunc console_putc - - /* --------------------------------------------- - * int console_getc(void) - * Function to get a character from the console. - * It returns the character grabbed on success - * or -1 on error. - * Clobber list : r0, r1 - * --------------------------------------------- - */ -func console_getc - ldr r1, =console_base - ldr r0, [r1] - b console_core_getc -endfunc console_getc - - /* --------------------------------------------- - * int console_flush(void) - * Function to force a write of all buffered - * data that hasn't been output. It returns 0 - * upon successful completion, otherwise it - * returns -1. - * Clobber list : r0, r1 - * --------------------------------------------- - */ -func console_flush - ldr r1, =console_base - ldr r0, [r1] - b console_core_flush -endfunc console_flush + #if MULTI_CONSOLE_API + #include "multi_console.S" + #else + #include "deprecated_console.S" + #endif diff --git a/drivers/console/aarch32/deprecated_console.S b/drivers/console/aarch32/deprecated_console.S new file mode 100644 index 0000000..f7e3c4f --- /dev/null +++ b/drivers/console/aarch32/deprecated_console.S @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2016-2017, ARM Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#include + +/* + * This is the common console core code for the deprecated single-console API. + * New platforms should set MULTI_CONSOLE_API=1 and not use this file. + */ +#warning "Using deprecated console implementation. Please migrate to MULTI_CONSOLE_API" + + .globl console_init + .globl console_uninit + .globl console_putc + .globl console_getc + .globl console_flush + + /* + * The console base is in the data section and not in .bss + * even though it is zero-init. In particular, this allows + * the console functions to start using this variable before + * the runtime memory is initialized for images which do not + * need to copy the .data section from ROM to RAM. + */ +.section .data.console_base ; .align 2 + console_base: .word 0x0 + + /* ----------------------------------------------- + * int console_init(uintptr_t base_addr, + * unsigned int uart_clk, unsigned int baud_rate) + * Function to initialize the console without a + * C Runtime to print debug information. It saves + * the console base to the data section. + * In: r0 - console base address + * r1 - Uart clock in Hz + * r2 - Baud rate + * out: return 1 on success else 0 on error + * Clobber list : r1 - r3 + * ----------------------------------------------- + */ +func console_init + /* Check the input base address */ + cmp r0, #0 + beq init_fail + ldr r3, =console_base + str r0, [r3] + b console_core_init +init_fail: + bx lr +endfunc console_init + + /* ----------------------------------------------- + * void console_uninit(void) + * Function to finish the use of console driver. + * It sets the console_base as NULL so that any + * further invocation of `console_putc` or + * `console_getc` APIs would return error. + * ----------------------------------------------- + */ +func console_uninit + mov r0, #0 + ldr r3, =console_base + str r0, [r3] + bx lr +endfunc console_uninit + + /* --------------------------------------------- + * int console_putc(int c) + * Function to output a character over the + * console. It returns the character printed on + * success or -1 on error. + * In : r0 - character to be printed + * Out : return -1 on error else return character. + * Clobber list : r1, r2 + * --------------------------------------------- + */ +func console_putc + ldr r2, =console_base + ldr r1, [r2] + b console_core_putc +endfunc console_putc + + /* --------------------------------------------- + * int console_getc(void) + * Function to get a character from the console. + * It returns the character grabbed on success + * or -1 on error. + * Clobber list : r0, r1 + * --------------------------------------------- + */ +func console_getc + ldr r1, =console_base + ldr r0, [r1] + b console_core_getc +endfunc console_getc + + /* --------------------------------------------- + * int console_flush(void) + * Function to force a write of all buffered + * data that hasn't been output. It returns 0 + * upon successful completion, otherwise it + * returns -1. + * Clobber list : r0, r1 + * --------------------------------------------- + */ +func console_flush + ldr r1, =console_base + ldr r0, [r1] + b console_core_flush +endfunc console_flush diff --git a/drivers/console/aarch32/multi_console.S b/drivers/console/aarch32/multi_console.S new file mode 100644 index 0000000..e23b20e --- /dev/null +++ b/drivers/console/aarch32/multi_console.S @@ -0,0 +1,318 @@ +/* + * Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include +#include + + .globl console_register + .globl console_unregister + .globl console_is_registered + .globl console_set_scope + .globl console_switch_state + .globl console_putc + .globl console_getc + .globl console_flush + + /* + * The console list pointer is in the data section and not in + * .bss even though it is zero-init. In particular, this allows + * the console functions to start using this variable before + * the runtime memory is initialized for images which do not + * need to copy the .data section from ROM to RAM. + */ +.section .data.console_list ; .align 2 + console_list: .word 0x0 +.section .data.console_state ; .align 0 + console_state: .byte CONSOLE_FLAG_BOOT + + /* ----------------------------------------------- + * int console_register(console_t *console) + * Function to insert a new console structure into + * the console list. Should usually be called by + * console__register implementations. The + * data structure passed will be taken over by the + * console framework and *MUST* be allocated in + * persistent memory (e.g. the data section). + * In : r0 - address of console_t structure + * Out: r0 - Always 1 (for easier tail calling) + * Clobber list: r0, r1 + * ----------------------------------------------- + */ +func console_register + push {r6, lr} +#if ENABLE_ASSERTIONS + /* Assert that r0 isn't a NULL pointer */ + cmp r0, #0 + ASM_ASSERT(ne) + /* Assert that the struct isn't in the stack */ + ldr r1, =__STACKS_START__ + cmp r0, r1 + blo not_on_stack + ldr r1, =__STACKS_END__ + cmp r0, r1 + ASM_ASSERT(hs) +not_on_stack: + /* Assert that this struct isn't in the list */ + mov r1, r0 /* Preserve r0 and lr */ + bl console_is_registered + cmp r0, #0 + ASM_ASSERT(eq) + mov r0, r1 +#endif /* ENABLE_ASSERTIONS */ + ldr r6, =console_list + ldr r1, [r6] /* R1 = first struct in list */ + str r0, [r6] /* list head = new console */ + str r1, [r0, #CONSOLE_T_NEXT] /* new console next ptr = R1 */ + mov r0, #1 + pop {r6, pc} +endfunc console_register + + /* ----------------------------------------------- + * int console_unregister(console_t *console) + * Function to find a specific console in the list + * of currently active consoles and remove it. + * In: r0 - address of console_t struct to remove + * Out: r0 - removed address, or NULL if not found + * Clobber list: r0, r1 + * ----------------------------------------------- + */ +func console_unregister +#if ENABLE_ASSERTIONS + /* Assert that r0 isn't a NULL pointer */ + cmp r0, #0 + ASM_ASSERT(ne) +#endif /* ENABLE_ASSERTIONS */ + push {r6} + ldr r6, =console_list /* R6 = ptr to first struct */ + ldr r1, [r6] /* R1 = first struct */ + +unregister_loop: + cmp r1, #0 + beq unregister_not_found + cmp r0, r1 + beq unregister_found + ldr r6, [r6] /* R6 = next ptr of struct */ + ldr r1, [r6] /* R1 = next struct */ + b unregister_loop + +unregister_found: + ldr r1, [r1] /* R1 = next struct */ + str r1, [r6] /* prev->next = cur->next */ + pop {r6} + bx lr + +unregister_not_found: + mov r0, #0 /* return NULL if not found */ + pop {r6} + bx lr +endfunc console_unregister + + /* ----------------------------------------------- + * int console_is_registered(console_t *console) + * Function to detect if a specific console is + * registered or not. + * In: r0 - address of console_t struct to remove + * Out: r0 - 1 if it is registered, 0 if not. + * Clobber list: r0 + * ----------------------------------------------- + */ +func console_is_registered +#if ENABLE_ASSERTIONS + /* Assert that r0 isn't a NULL pointer */ + cmp r0, #0 + ASM_ASSERT(ne) +#endif /* ENABLE_ASSERTIONS */ + push {r6} + ldr r6, =console_list + ldr r6, [r6] /* R6 = first console struct */ +check_registered_loop: + cmp r6, #0 /* Check if end of list */ + beq console_not_registered + cmp r0, r6 /* Check if the pointers are different */ + beq console_registered + ldr r6, [r6, #CONSOLE_T_NEXT] /* Get pointer to next struct */ + b check_registered_loop +console_not_registered: + mov r0, #0 + pop {r6} + bx lr +console_registered: + mov r0, #1 + pop {r6} + bx lr +endfunc console_is_registered + + /* ----------------------------------------------- + * void console_switch_state(unsigned int new_state) + * Function to switch the current console state. + * The console state determines which of the + * registered consoles are actually used at a time. + * In : r0 - global console state to move to + * Clobber list: r0, r1 + * ----------------------------------------------- + */ +func console_switch_state + ldr r1, =console_state + strb r0, [r1] + bx lr +endfunc console_switch_state + + /* ----------------------------------------------- + * void console_set_scope(console_t *console, + * unsigned int scope) + * Function to update the states that a given console + * may be active in. + * In : r0 - pointer to console_t struct + * : r1 - new active state mask + * Clobber list: r0, r1, r2 + * ----------------------------------------------- + */ +func console_set_scope +#if ENABLE_ASSERTIONS + ands r2, r1, #~CONSOLE_FLAG_SCOPE_MASK + ASM_ASSERT(eq) +#endif /* ENABLE_ASSERTIONS */ + ldr r2, [r0, #CONSOLE_T_FLAGS] + and r2, r2, #~CONSOLE_FLAG_SCOPE_MASK + orr r2, r2, r1 + str r2, [r0, #CONSOLE_T_FLAGS] + bx lr +endfunc console_set_scope + + /* --------------------------------------------- + * int console_putc(int c) + * Function to output a character. Calls all + * active console's putc() handlers in succession. + * In : r0 - character to be printed + * Out: r0 - printed character on success, or < 0 + if at least one console had an error + * Clobber list : r0, r1, r2 + * --------------------------------------------- + */ +func console_putc + push {r4-r6, lr} + mov r5, #ERROR_NO_VALID_CONSOLE /* R5 = current return value */ + mov r4, r0 /* R4 = character to print */ + ldr r6, =console_list + ldr r6, [r6] /* R6 = first console struct */ + +putc_loop: + cmp r6, #0 + beq putc_done + ldr r1, =console_state + ldrb r1, [r1] + ldr r2, [r6, #CONSOLE_T_FLAGS] + tst r1, r2 + beq putc_continue + ldr r2, [r6, #CONSOLE_T_PUTC] + cmp r2, #0 + beq putc_continue + mov r0, r4 + mov r1, r6 + blx r2 + cmp r5, #ERROR_NO_VALID_CONSOLE /* update R5 if it's NOVALID */ + cmpne r0, #0 /* else update it if R0 < 0 */ + movlt r5, r0 +putc_continue: + ldr r6, [r6] /* R6 = next struct */ + b putc_loop + +putc_done: + mov r0, r5 + pop {r4-r6, pc} +endfunc console_putc + + /* --------------------------------------------- + * int console_getc(void) + * Function to get a character from any console. + * Keeps looping through all consoles' getc() + * handlers until one of them returns a + * character, then stops iterating and returns + * that character to the caller. Will stop looping + * if all active consoles report real errors + * (other than just not having a char available). + * Out : r0 - read character, or < 0 on error + * Clobber list : r0, r1 + * --------------------------------------------- + */ +func console_getc + push {r5-r6, lr} +getc_try_again: + mov r5, #ERROR_NO_VALID_CONSOLE /* R5 = current return value */ + ldr r6, =console_list + ldr r6, [r6] /* R6 = first console struct */ + cmp r6, #0 + bne getc_loop + mov r0, r5 /* If no consoles registered */ + pop {r5-r6, pc} /* return immediately. */ + +getc_loop: + ldr r0, =console_state + ldrb r0, [r0] + ldr r1, [r6, #CONSOLE_T_FLAGS] + tst r0, r1 + beq getc_continue + ldr r1, [r6, #CONSOLE_T_GETC] + cmp r1, #0 + beq getc_continue + mov r0, r6 + blx r1 + cmp r0, #0 /* if R0 >= 0: return */ + bge getc_found + cmp r5, #ERROR_NO_PENDING_CHAR /* may update R5 (NOCHAR has */ + movne r5, r0 /* precedence vs real errors) */ +getc_continue: + ldr r6, [r6] /* R6 = next struct */ + cmp r6, #0 + bne getc_loop + cmp r5, #ERROR_NO_PENDING_CHAR /* Keep scanning if at least */ + beq getc_try_again /* one console returns NOCHAR */ + mov r0, r5 + +getc_found: + pop {r5-r6, pc} +endfunc console_getc + + /* --------------------------------------------- + * int console_flush(void) + * Function to force a write of all buffered + * data that hasn't been output. Calls all + * console's flush() handlers in succession. + * Out: r0 - 0 on success, < 0 if at least one error + * Clobber list : r0, r1, r2 + * --------------------------------------------- + */ +func console_flush + push {r5-r6, lr} + mov r5, #ERROR_NO_VALID_CONSOLE /* R5 = current return value */ + ldr r6, =console_list + ldr r6, [r6] /* R6 = first console struct */ + +flush_loop: + cmp r6, #0 + beq flush_done + ldr r1, =console_state + ldrb r1, [r1] + ldr r2, [r6, #CONSOLE_T_FLAGS] + tst r1, r2 + beq flush_continue + ldr r1, [r6, #CONSOLE_T_FLUSH] + cmp r1, #0 + beq flush_continue + mov r0, r6 + blx r1 + cmp r5, #ERROR_NO_VALID_CONSOLE /* update R5 if it's NOVALID */ + cmpne r0, #0 /* else update it if R0 < 0 */ + movlt r5, r0 +flush_continue: + ldr r6, [r6] /* R6 = next struct */ + b flush_loop + +flush_done: + mov r0, r5 + pop {r5-r6, pc} +endfunc console_flush diff --git a/include/common/aarch32/console_macros.S b/include/common/aarch32/console_macros.S new file mode 100644 index 0000000..480e3c2 --- /dev/null +++ b/include/common/aarch32/console_macros.S @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2018, ARM Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef __CONSOLE_MACROS_S__ +#define __CONSOLE_MACROS_S__ + +#include + +/* + * This macro encapsulates the common setup that has to be done at the end of + * a console driver's register function. It will register all of the driver's + * callbacks in the console_t structure and initialize the flags field (by + * default consoles are enabled for the "boot" and "crash" states, this can be + * changed after registration with the console_set_scope() function). It ends + * with a tail call that will include return to the caller. + * REQUIRES console_t pointer in x0 and a valid return address in x30. + */ + .macro finish_console_register _driver + /* + * Add these weak definitions so we will automatically write a 0 if the + * function doesn't exist. I'd rather use .ifdef but that only works if + * the function was defined (not just declared .global) above this point + * in the file, which we can't guarantee. + */ + .weak console_\_driver\()_putc + .weak console_\_driver\()_getc + .weak console_\_driver\()_flush + + /* Don't use adrp on weak funcs! See GNU ld bugzilla issue 22589. */ + ldr r1, =console_\_driver\()_putc + str r1, [r0, #CONSOLE_T_PUTC] + ldr r1, =console_\_driver\()_getc + str r1, [r0, #CONSOLE_T_GETC] + ldr r1, =console_\_driver\()_flush + str r1, [r0, #CONSOLE_T_FLUSH] + mov r1, #(CONSOLE_FLAG_BOOT | CONSOLE_FLAG_CRASH) + str r1, [r0, #CONSOLE_T_FLAGS] + b console_register + .endm + +#endif /* __CONSOLE_MACROS_S__ */ diff --git a/plat/arm/common/aarch32/arm_helpers.S b/plat/arm/common/aarch32/arm_helpers.S index c4cfa8a..badddd3 100644 --- a/plat/arm/common/aarch32/arm_helpers.S +++ b/plat/arm/common/aarch32/arm_helpers.S @@ -48,7 +48,7 @@ ldr r0, =PLAT_ARM_CRASH_UART_BASE ldr r1, =PLAT_ARM_CRASH_UART_CLK_IN_HZ ldr r2, =ARM_CONSOLE_BAUDRATE - b console_core_init + b console_pl011_core_init endfunc plat_crash_console_init /* --------------------------------------------- @@ -60,7 +60,7 @@ */ func plat_crash_console_putc ldr r1, =PLAT_ARM_CRASH_UART_BASE - b console_core_putc + b console_pl011_core_putc endfunc plat_crash_console_putc /* --------------------------------------------- @@ -73,5 +73,5 @@ */ func plat_crash_console_flush ldr r0, =PLAT_ARM_CRASH_UART_BASE - b console_core_flush + b console_pl011_core_flush endfunc plat_crash_console_flush diff --git a/plat/arm/common/arm_common.mk b/plat/arm/common/arm_common.mk index 276f780..3fb1eff 100644 --- a/plat/arm/common/arm_common.mk +++ b/plat/arm/common/arm_common.mk @@ -123,9 +123,7 @@ SEPARATE_CODE_AND_RODATA := 1 # Use the multi console API, which is only available for AArch64 for now -ifeq (${ARCH}, aarch64) - MULTI_CONSOLE_API := 1 -endif +MULTI_CONSOLE_API := 1 # Disable ARM Cryptocell by default ARM_CRYPTOCELL_INTEG := 0 diff --git a/plat/arm/common/sp_min/arm_sp_min_setup.c b/plat/arm/common/sp_min/arm_sp_min_setup.c index 10c1914..b8234c1 100644 --- a/plat/arm/common/sp_min/arm_sp_min_setup.c +++ b/plat/arm/common/sp_min/arm_sp_min_setup.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -61,8 +62,7 @@ uintptr_t hw_config, void *plat_params_from_bl2) { /* Initialize the console to provide early debug support */ - console_init(PLAT_ARM_BOOT_UART_BASE, PLAT_ARM_BOOT_UART_CLK_IN_HZ, - ARM_CONSOLE_BAUDRATE); + arm_console_boot_init(); #if RESET_TO_SP_MIN /* There are no parameters from BL2 if SP_MIN is a reset vector */ @@ -152,8 +152,7 @@ void arm_sp_min_plat_runtime_setup(void) { /* Initialize the runtime console */ - console_init(PLAT_ARM_SP_MIN_RUN_UART_BASE, - PLAT_ARM_SP_MIN_RUN_UART_CLK_IN_HZ, ARM_CONSOLE_BAUDRATE); + arm_console_runtime_init(); } /******************************************************************************* diff --git a/plat/common/aarch32/plat_sp_min_common.c b/plat/common/aarch32/plat_sp_min_common.c index a9a92c7..f1b1e9c 100644 --- a/plat/common/aarch32/plat_sp_min_common.c +++ b/plat/common/aarch32/plat_sp_min_common.c @@ -21,5 +21,9 @@ * Finish the use of console driver in SP_MIN so that any runtime logs * from SP_MIN will be suppressed. */ +#if MULTI_CONSOLE_API + console_switch_state(CONSOLE_FLAG_RUNTIME); +#else console_uninit(); +#endif }