Libxlat Tables V2xlat Tables Privatehvslibxlat Mpuxlat Mpu Privateh

Updated 1,222 Days AgoPublic

Actions

/*                                                            /*
 * Copyright (c) 2017-2020, ARM Limited and Contributors.  |   * Copyright (c) 2017-2021, ARM Limited and Contributors. 
 *                                                             *
 * SPDX-License-Identifier: BSD-3-Clause                       * SPDX-License-Identifier: BSD-3-Clause
 */                                                            */

#ifndef XLAT_TABLES_PRIVATE_H                              |  #ifndef XLAT_MPU_PRIVATE_H
#define XLAT_TABLES_PRIVATE_H                              |  #define XLAT_MPU_PRIVATE_H

#include <stdbool.h>                                          #include <stdbool.h>

#include <platform_def.h>                                     #include <platform_def.h>

#include <lib/xlat_tables/xlat_tables_defs.h>                 #include <lib/xlat_tables/xlat_tables_defs.h>

#if PLAT_XLAT_TABLES_DYNAMIC                                  #if PLAT_XLAT_TABLES_DYNAMIC
/*                                                            /*
 * Private shifts and masks to access fields of an mmap at     * Private shifts and masks to access fields of an mmap at
 */                                                            */
/* Dynamic or static */                                       /* Dynamic or static */
#define MT_DYN_SHIFT            U(31)                         #define MT_DYN_SHIFT            U(31)

/*                                                            /*
 * Memory mapping private attributes                           * Memory mapping private attributes
 *                                                             *
 * Private attributes not exposed in the public header.        * Private attributes not exposed in the public header.
 */                                                            */

/*                                                         <
 * Regions mapped before the MMU can't be unmapped dynamic <
 * static) and regions mapped with MMU enabled can be unma <
 * behaviour can't be overridden.                          <
 *                                                         <
 * Static regions can overlap each other, dynamic regions  <
 */                                                        <
#define MT_STATIC       (U(0) << MT_DYN_SHIFT)             <
#define MT_DYNAMIC      (U(1) << MT_DYN_SHIFT)             <
                                                           <
#endif /* PLAT_XLAT_TABLES_DYNAMIC */                         #endif /* PLAT_XLAT_TABLES_DYNAMIC */

                                                           >  /* Calculate region-attributes byte for PRBAR part of MPU-
                                                           >  uint64_t prbar_attr_value (uint32_t attr);
                                                           >  /* Calculate region-attributes byte for PRLAR part of MPU-
                                                           >  uint64_t prlar_attr_value (uint32_t attr);
                                                           >  /* Calculates the attr value for a given PRBAR and PRLAR e
                                                           >  uint32_t region_attr (uint64_t prbar_attr, uint64_t prlar_
                                                           >
                                                           >  #define PRBAR_PRLAR_ADDR_MASK UL(0xffffffffffc0)
                                                           >          /* mask for PRBAR & PRLAR MPU-region field */
                                                           >  /* MPU region attribute bit fields: */
                                                           >  #define PRBAR_SH_SHIFT UL(4)
                                                           >  #define PRBAR_SH_MASK UL(0x3)
                                                           >  #define PRBAR_AP_SHIFT UL(2)
                                                           >  #define PRBAR_AP_MASK UL(0x3)
                                                           >  #define PRBAR_XN_SHIFT UL(1)
                                                           >  #define PRBAR_XN_MASK UL(0x3)
                                                           >  #define PRLAR_NS_SHIFT UL(4)
                                                           >  #define PRLAR_NS_MASK UL(0x3)
                                                           >  #define PRBAR_ATTR_SHIFT UL(0)
                                                           >  #define PRBAR_ATTR_MASK UL(0x3f)
                                                           >  #define PRLAR_ATTR_SHIFT UL(1)
                                                           >  #define PRLAR_ATTR_MASK UL(0x7)
                                                           >  #define PRLAR_EN_SHIFT UL(0)
                                                           >  #define PRLAR_EN_MASK UL(0x1)
                                                           >  /* Aspects of the source attributes not defined elsewhere:
                                                           >  #define MT_PERM_MASK UL(0x1)
                                                           >  #define MT_SEC_MASK UL(0x1)
                                                           >  #define MT_EXECUTE_MASK UL(0x3)
                                                           >  #define MT_TYPE_SHIFT UL(0)
                                                           >
extern uint64_t mmu_cfg_params[MMU_CFG_PARAM_MAX];            extern uint64_t mmu_cfg_params[MMU_CFG_PARAM_MAX];

/*                                                            /*
 * Return the execute-never mask that will prevent instruc     * Return the execute-never mask that will prevent instruc
 * given translation regime.                                   * given translation regime.
 */                                                            */
uint64_t xlat_arch_regime_get_xn_desc(int xlat_regime);       uint64_t xlat_arch_regime_get_xn_desc(int xlat_regime);

/*                                                         <
 * Invalidate all TLB entries that match the given virtual <
 * operation applies to all PEs in the same Inner Shareabl <
 * that executes this function. This functions must be cal <
 * translation table entry that is modified. It only affec <
 * translation regime.                                     <
 *                                                         <
 * Note, however, that it is architecturally UNDEFINED to  <
 * pertaining to a higher exception level, e.g. invalidati <
 * S-EL1.                                                  <
 */                                                        <
void xlat_arch_tlbi_va(uintptr_t va, int xlat_regime);     <
                                                           <
/*                                                         <
 * This function has to be called at the end of any code t <
 * xlat_arch_tlbi_va().                                    <
 */                                                        <
void xlat_arch_tlbi_va_sync(void);                         <
                                                           <
/* Print VA, PA, size and attributes of all regions in the    /* Print VA, PA, size and attributes of all regions in the
void xlat_mmap_print(const mmap_region_t *mmap);              void xlat_mmap_print(const mmap_region_t *mmap);

/*                                                            /*
 * Print the current state of the translation tables by re     * Print the current state of the translation tables by re
 * memory.                                                     * memory.
 */                                                            */
void xlat_tables_print(xlat_ctx_t *ctx);                      void xlat_tables_print(xlat_ctx_t *ctx);

/*                                                            /*
 * Returns a block/page table descriptor for the given lev     * Returns a block/page table descriptor for the given lev
 */                                                            */
uint64_t xlat_desc(const xlat_ctx_t *ctx, uint32_t attr,      uint64_t xlat_desc(const xlat_ctx_t *ctx, uint32_t attr,
                   unsigned long long addr_pa, unsigned in                       unsigned long long addr_pa, unsigned in

/*                                                            /*
 * Architecture-specific initialization code.                  * Architecture-specific initialization code.
 */                                                            */

/* Returns the current Exception Level. The returned EL mu    /* Returns the current Exception Level. The returned EL mu
unsigned int xlat_arch_current_el(void);                      unsigned int xlat_arch_current_el(void);

/*                                                            /*
 * Return the maximum physical address supported by the ha <
 * This value depends on the execution state (AArch32/AArc <
 */                                                        <
unsigned long long xlat_arch_get_max_supported_pa(void);   <
                                                           <
/*                                                         <
 * Returns true if the MMU of the translation regime manag     * Returns true if the MMU of the translation regime manag
 * xlat_ctx_t is enabled, false otherwise.                     * xlat_ctx_t is enabled, false otherwise.
 */                                                            */
bool is_mmu_enabled_ctx(const xlat_ctx_t *ctx);            |  bool is_mpu_enabled_ctx(const xlat_ctx_t *ctx);

/*                                                            /*
 * Returns minimum virtual address space size supported by     * Returns minimum virtual address space size supported by
 */                                                            */
uintptr_t xlat_get_min_virt_addr_space_size(void);            uintptr_t xlat_get_min_virt_addr_space_size(void);

#endif /* XLAT_TABLES_PRIVATE_H */                         |  #endif /* XLAT_MPU_PRIVATE_H */