andrius
/
arm-trusted-firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #1509 from antonio-nino-diaz-arm/an/bool 

xlat: psci: Use bool instead of int
This commit is contained in:
Dimitris Papastamos 2018-08-03 10:53:12 +01:00 committed by GitHub
parent 0454f64b72 362030bf06
commit f943ce74ae
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 71 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/lib/xlat_tables/xlat_mmu_helpers.h
View File

@ -52,6 +52,7 @@
#ifndef __ASSEMBLY__
#include <stdbool.h>
#include <stdint.h>
#include <sys/types.h>
@ -78,7 +79,7 @@ void enable_mmu_direct_el1(unsigned int flags);
void enable_mmu_direct_el3(unsigned int flags);
#endif /* AARCH32 */
int xlat_arch_is_granule_size_supported(size_t size);
bool xlat_arch_is_granule_size_supported(size_t size);
size_t xlat_arch_get_max_supported_granule_size(void);
#endif /* __ASSEMBLY__ */

7
include/lib/xlat_tables/xlat_tables_v2_helpers.h
View File

@ -20,6 +20,7 @@
#include <cassert.h>
#include <platform_def.h>
#include <stdbool.h>
#include <stddef.h>
#include <xlat_tables_arch.h>
#include <xlat_tables_defs.h>
@ -95,8 +96,8 @@ struct xlat_ctx {
/* Level of the base translation table. */
unsigned int base_level;
/* Set to 1 when the translation tables are initialized. */
int initialized;
/* Set to true when the translation tables are initialized. */
bool initialized;
/*
* Translation regime managed by this xlat_ctx_t. It should be one of
@ -157,7 +158,7 @@ struct xlat_ctx {
.max_pa = 0U, \
.max_va = 0U, \
.next_table = 0, \
.initialized = 0, \
.initialized = false, \
}
#endif /*__ASSEMBLY__*/

2
lib/psci/psci_main.c
View File

@ -82,7 +82,7 @@ int psci_cpu_suspend(unsigned int power_state,
}
/* Fast path for CPU standby.*/
if (is_cpu_standby_req(is_power_down_state, target_pwrlvl) != 0) {
if (is_cpu_standby_req(is_power_down_state, target_pwrlvl)) {
if (psci_plat_pm_ops->cpu_standby == NULL)
return PSCI_E_INVALID_PARAMS;

7
lib/psci/psci_private.h
View File

@ -14,6 +14,7 @@
#include <cpu_data.h>
#include <psci.h>
#include <spinlock.h>
#include <stdbool.h>
/*
* The PSCI capability which are provided by the generic code but does not
@ -93,10 +94,10 @@ static inline plat_local_state_t psci_get_cpu_local_state_by_idx(int idx)
}
/* Helper function to identify a CPU standby request in PSCI Suspend call */
static inline int is_cpu_standby_req(unsigned int is_power_down_state,
unsigned int retn_lvl)
static inline bool is_cpu_standby_req(unsigned int is_power_down_state,
unsigned int retn_lvl)
{
return ((is_power_down_state == 0U) && (retn_lvl == 0U)) ? 1 : 0;
return (is_power_down_state == 0U) && (retn_lvl == 0U);
}
/*******************************************************************************

20
lib/xlat_tables/xlat_tables_common.c
View File

@ -11,6 +11,7 @@
#include <common_def.h>
#include <debug.h>
#include <platform_def.h>
#include <stdbool.h>
#include <string.h>
#include <types.h>
#include <utils.h>
@ -100,17 +101,16 @@ void mmap_add_region(unsigned long long base_pa, uintptr_t base_va,
* Check if one of the regions is completely inside the other
* one.
*/
int fully_overlapped_va =
(((base_va >= mm->base_va) && (end_va <= mm_end_va)) ||
((mm->base_va >= base_va) && (mm_end_va <= end_va)))
? 1 : 0;
bool fully_overlapped_va =
((base_va >= mm->base_va) && (end_va <= mm_end_va)) ||
((mm->base_va >= base_va) && (mm_end_va <= end_va));
/*
* Full VA overlaps are only allowed if both regions are
* identity mapped (zero offset) or have the same VA to PA
* offset. Also, make sure that it's not the exact same area.
*/
if (fully_overlapped_va == 1) {
if (fully_overlapped_va) {
assert((mm->base_va - mm->base_pa) ==
(base_va - base_pa));
assert((base_va != mm->base_va) || (size != mm->size));
@ -124,12 +124,12 @@ void mmap_add_region(unsigned long long base_pa, uintptr_t base_va,
unsigned long long mm_end_pa =
mm->base_pa + mm->size - 1;
int separated_pa = ((end_pa < mm->base_pa) ||
(base_pa > mm_end_pa)) ? 1 : 0;
int separated_va = ((end_va < mm->base_va) ||
(base_va > mm_end_va)) ? 1 : 0;
bool separated_pa = (end_pa < mm->base_pa) ||
(base_pa > mm_end_pa);
bool separated_va = (end_va < mm->base_va) ||
(base_va > mm_end_va);
assert((separated_va == 1) && (separated_pa == 1));
assert(separated_va && separated_pa);
}
}

10
lib/xlat_tables_v2/aarch32/xlat_tables_arch.c
View File

@ -9,7 +9,7 @@
#include <assert.h>
#include <cassert.h>
#include <platform_def.h>
#include <utils.h>
#include <stdbool.h>
#include <utils_def.h>
#include <xlat_tables_v2.h>
#include "../xlat_tables_private.h"
@ -19,15 +19,15 @@
#endif
/*
* Returns 1 if the provided granule size is supported, 0 otherwise.
* Returns true if the provided granule size is supported, false otherwise.
*/
int xlat_arch_is_granule_size_supported(size_t size)
bool xlat_arch_is_granule_size_supported(size_t size)
{
/*
* The library uses the long descriptor translation table format, which
* supports 4 KiB pages only.
*/
return (size == PAGE_SIZE_4KB) ? 1 : 0;
return size == PAGE_SIZE_4KB;
}
size_t xlat_arch_get_max_supported_granule_size(void)
@ -43,7 +43,7 @@ unsigned long long xlat_arch_get_max_supported_pa(void)
}
#endif /* ENABLE_ASSERTIONS*/
int is_mmu_enabled_ctx(const xlat_ctx_t *ctx __unused)
bool is_mmu_enabled_ctx(const xlat_ctx_t *ctx __unused)
{
return (read_sctlr() & SCTLR_M_BIT) != 0;
}

29
lib/xlat_tables_v2/aarch64/xlat_tables_arch.c
View File

@ -8,30 +8,31 @@
#include <arch_helpers.h>
#include <assert.h>
#include <cassert.h>
#include <stdbool.h>
#include <sys/types.h>
#include <utils_def.h>
#include <xlat_tables_v2.h>
#include "../xlat_tables_private.h"
/*
* Returns 1 if the provided granule size is supported, 0 otherwise.
* Returns true if the provided granule size is supported, false otherwise.
*/
int xlat_arch_is_granule_size_supported(size_t size)
bool xlat_arch_is_granule_size_supported(size_t size)
{
u_register_t id_aa64mmfr0_el1 = read_id_aa64mmfr0_el1();
if (size == PAGE_SIZE_4KB) {
return (((id_aa64mmfr0_el1 >> ID_AA64MMFR0_EL1_TGRAN4_SHIFT) &
return ((id_aa64mmfr0_el1 >> ID_AA64MMFR0_EL1_TGRAN4_SHIFT) &
ID_AA64MMFR0_EL1_TGRAN4_MASK) ==
ID_AA64MMFR0_EL1_TGRAN4_SUPPORTED) ? 1 : 0;
ID_AA64MMFR0_EL1_TGRAN4_SUPPORTED;
} else if (size == PAGE_SIZE_16KB) {
return (((id_aa64mmfr0_el1 >> ID_AA64MMFR0_EL1_TGRAN16_SHIFT) &
return ((id_aa64mmfr0_el1 >> ID_AA64MMFR0_EL1_TGRAN16_SHIFT) &
ID_AA64MMFR0_EL1_TGRAN16_MASK) ==
ID_AA64MMFR0_EL1_TGRAN16_SUPPORTED) ? 1 : 0;
ID_AA64MMFR0_EL1_TGRAN16_SUPPORTED;
} else if (size == PAGE_SIZE_64KB) {
return (((id_aa64mmfr0_el1 >> ID_AA64MMFR0_EL1_TGRAN64_SHIFT) &
return ((id_aa64mmfr0_el1 >> ID_AA64MMFR0_EL1_TGRAN64_SHIFT) &
ID_AA64MMFR0_EL1_TGRAN64_MASK) ==
ID_AA64MMFR0_EL1_TGRAN64_SUPPORTED) ? 1 : 0;
ID_AA64MMFR0_EL1_TGRAN64_SUPPORTED;
} else {
return 0;
}
@ -39,12 +40,12 @@ int xlat_arch_is_granule_size_supported(size_t size)
size_t xlat_arch_get_max_supported_granule_size(void)
{
if (xlat_arch_is_granule_size_supported(PAGE_SIZE_64KB) != 0) {
if (xlat_arch_is_granule_size_supported(PAGE_SIZE_64KB)) {
return PAGE_SIZE_64KB;
} else if (xlat_arch_is_granule_size_supported(PAGE_SIZE_16KB) != 0) {
} else if (xlat_arch_is_granule_size_supported(PAGE_SIZE_16KB)) {
return PAGE_SIZE_16KB;
} else {
assert(xlat_arch_is_granule_size_supported(PAGE_SIZE_4KB) != 0);
assert(xlat_arch_is_granule_size_supported(PAGE_SIZE_4KB));
return PAGE_SIZE_4KB;
}
}
@ -99,15 +100,15 @@ unsigned long long xlat_arch_get_max_supported_pa(void)
}
#endif /* ENABLE_ASSERTIONS*/
int is_mmu_enabled_ctx(const xlat_ctx_t *ctx)
bool is_mmu_enabled_ctx(const xlat_ctx_t *ctx)
{
if (ctx->xlat_regime == EL1_EL0_REGIME) {
assert(xlat_arch_current_el() >= 1U);
return ((read_sctlr_el1() & SCTLR_M_BIT) != 0U) ? 1 : 0;
return (read_sctlr_el1() & SCTLR_M_BIT) != 0U;
} else {
assert(ctx->xlat_regime == EL3_REGIME);
assert(xlat_arch_current_el() >= 3U);
return ((read_sctlr_el3() & SCTLR_M_BIT) != 0U) ? 1 : 0;
return (read_sctlr_el3() & SCTLR_M_BIT) != 0U;
}
}

45
lib/xlat_tables_v2/xlat_tables_core.c
View File

@ -9,6 +9,7 @@
#include <debug.h>
#include <errno.h>
#include <platform_def.h>
#include <stdbool.h>
#include <string.h>
#include <types.h>
#include <utils_def.h>
@ -39,7 +40,7 @@ static int xlat_table_get_index(const xlat_ctx_t *ctx, const uint64_t *table)
* Maybe we were asked to get the index of the base level table, which
* should never happen.
*/
assert(0);
assert(false);
return -1;
}
@ -73,10 +74,9 @@ static void xlat_table_dec_regions_count(const xlat_ctx_t *ctx,
}
/* Returns 0 if the specified table isn't empty, otherwise 1. */
static int xlat_table_is_empty(const xlat_ctx_t *ctx, const uint64_t *table)
static bool xlat_table_is_empty(const xlat_ctx_t *ctx, const uint64_t *table)
{
return (ctx->tables_mapped_regions[xlat_table_get_index(ctx, table)] == 0)
? 1 : 0;
return ctx->tables_mapped_regions[xlat_table_get_index(ctx, table)] == 0;
}
#else /* PLAT_XLAT_TABLES_DYNAMIC */
@ -333,7 +333,7 @@ static void xlat_tables_unmap_region(xlat_ctx_t *ctx, mmap_region_t *mm,
/*
* If the subtable is now empty, remove its reference.
*/
if (xlat_table_is_empty(ctx, subtable) != 0) {
if (xlat_table_is_empty(ctx, subtable)) {
table_base[table_idx] = INVALID_DESC;
xlat_arch_tlbi_va(table_idx_va,
ctx->xlat_regime);
@ -650,12 +650,11 @@ static int mmap_add_region_check(const xlat_ctx_t *ctx, const mmap_region_t *mm)
* Check if one of the regions is completely inside the other
* one.
*/
int fully_overlapped_va =
(((base_va >= mm_cursor->base_va) &&
bool fully_overlapped_va =
((base_va >= mm_cursor->base_va) &&
(end_va <= mm_cursor_end_va)) ||
((mm_cursor->base_va >= base_va) &&
(mm_cursor_end_va <= end_va)))
? 1 : 0;
((mm_cursor->base_va >= base_va) &&
(mm_cursor_end_va <= end_va));
/*
* Full VA overlaps are only allowed if both regions are
@ -663,7 +662,7 @@ static int mmap_add_region_check(const xlat_ctx_t *ctx, const mmap_region_t *mm)
* offset. Also, make sure that it's not the exact same area.
* This can only be done with static regions.
*/
if (fully_overlapped_va != 0) {
if (fully_overlapped_va) {
#if PLAT_XLAT_TABLES_DYNAMIC
if (((mm->attr & MT_DYNAMIC) != 0U) ||
@ -688,12 +687,12 @@ static int mmap_add_region_check(const xlat_ctx_t *ctx, const mmap_region_t *mm)
unsigned long long mm_cursor_end_pa =
mm_cursor->base_pa + mm_cursor->size - 1U;
int separated_pa = ((end_pa < mm_cursor->base_pa) ||
(base_pa > mm_cursor_end_pa)) ? 1 : 0;
int separated_va = ((end_va < mm_cursor->base_va) ||
(base_va > mm_cursor_end_va)) ? 1 : 0;
bool separated_pa = (end_pa < mm_cursor->base_pa) ||
(base_pa > mm_cursor_end_pa);
bool separated_va = (end_va < mm_cursor->base_va) ||
(base_va > mm_cursor_end_va);
if ((separated_va == 0) || (separated_pa == 0))
if (!separated_va || !separated_pa)
return -EPERM;
}
}
@ -715,12 +714,12 @@ void mmap_add_region_ctx(xlat_ctx_t *ctx, const mmap_region_t *mm)
return;
/* Static regions must be added before initializing the xlat tables. */
assert(ctx->initialized == 0);
assert(!ctx->initialized);
ret = mmap_add_region_check(ctx, mm);
if (ret != 0) {
ERROR("mmap_add_region_check() failed. error %d\n", ret);
assert(0);
assert(false);
return;
}
@ -856,7 +855,7 @@ int mmap_add_dynamic_region_ctx(xlat_ctx_t *ctx, mmap_region_t *mm)
* Update the translation tables if the xlat tables are initialized. If
* not, this region will be mapped when they are initialized.
*/
if (ctx->initialized != 0) {
if (ctx->initialized) {
end_va = xlat_tables_map_region(ctx, mm_cursor,
0U, ctx->base_table, ctx->base_table_entries,
ctx->base_level);
@ -948,7 +947,7 @@ int mmap_remove_dynamic_region_ctx(xlat_ctx_t *ctx, uintptr_t base_va,
update_max_pa_needed = 1;
/* Update the translation tables if needed */
if (ctx->initialized != 0) {
if (ctx->initialized) {
xlat_tables_unmap_region(ctx, mm, 0U, ctx->base_table,
ctx->base_table_entries,
ctx->base_level);
@ -987,10 +986,10 @@ int mmap_remove_dynamic_region_ctx(xlat_ctx_t *ctx, uintptr_t base_va,
void init_xlat_tables_ctx(xlat_ctx_t *ctx)
{
assert(ctx != NULL);
assert(ctx->initialized == 0);
assert(!ctx->initialized);
assert((ctx->xlat_regime == EL3_REGIME) ||
(ctx->xlat_regime == EL1_EL0_REGIME));
assert(is_mmu_enabled_ctx(ctx) == 0);
assert(!is_mmu_enabled_ctx(ctx));
mmap_region_t *mm = ctx->mmap;
@ -1028,7 +1027,7 @@ void init_xlat_tables_ctx(xlat_ctx_t *ctx)
assert(ctx->max_va <= ctx->va_max_address);
assert(ctx->max_pa <= ctx->pa_max_address);
ctx->initialized = 1;
ctx->initialized = true;
xlat_tables_print(ctx);
}

7
lib/xlat_tables_v2/xlat_tables_private.h
View File

@ -8,6 +8,7 @@
#define XLAT_TABLES_PRIVATE_H
#include <platform_def.h>
#include <stdbool.h>
#include <xlat_tables_defs.h>
#if PLAT_XLAT_TABLES_DYNAMIC
@ -91,9 +92,9 @@ unsigned int xlat_arch_current_el(void);
unsigned long long xlat_arch_get_max_supported_pa(void);
/*
* Return 1 if the MMU of the translation regime managed by the given xlat_ctx_t
* is enabled, 0 otherwise.
* Returns true if the MMU of the translation regime managed by the given
* xlat_ctx_t is enabled, false otherwise.
*/
int is_mmu_enabled_ctx(const xlat_ctx_t *ctx);
bool is_mmu_enabled_ctx(const xlat_ctx_t *ctx);
#endif /* XLAT_TABLES_PRIVATE_H */

7
lib/xlat_tables_v2/xlat_tables_utils.c
View File

@ -9,6 +9,7 @@
#include <debug.h>
#include <errno.h>
#include <platform_def.h>
#include <stdbool.h>
#include <types.h>
#include <utils_def.h>
#include <xlat_tables_defs.h>
@ -307,7 +308,7 @@ static uint64_t *find_xlat_table_entry(uintptr_t virtual_addr,
* This shouldn't be reached, the translation table walk should end at
* most at level XLAT_TABLE_LEVEL_MAX and return from inside the loop.
*/
assert(0);
assert(false);
return NULL;
}
@ -326,7 +327,7 @@ static int get_mem_attributes_internal(const xlat_ctx_t *ctx, uintptr_t base_va,
* Sanity-check arguments.
*/
assert(ctx != NULL);
assert(ctx->initialized != 0);
assert(ctx->initialized);
assert((ctx->xlat_regime == EL1_EL0_REGIME) ||
(ctx->xlat_regime == EL3_REGIME));
@ -422,7 +423,7 @@ int change_mem_attributes(const xlat_ctx_t *ctx,
/* Note: This implementation isn't optimized. */
assert(ctx != NULL);
assert(ctx->initialized != 0);
assert(ctx->initialized);
unsigned long long virt_addr_space_size =
(unsigned long long)ctx->va_max_address + 1U;