145 lines
4.2 KiB
C
145 lines
4.2 KiB
C
/*
|
|
* Copyright (c) 2023 Texas Instruments Incorporated
|
|
* Copyright (c) 2023 L Lakshmanan
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* @brief Driver handling Region based Address Translation (RAT)
|
|
* related functions
|
|
*
|
|
* RAT is a module that is used by certain Texas Instruments SoCs
|
|
* to allow some cores with a 32 bit address space to access
|
|
* the full 48 bit SoC address space. This is required for the
|
|
* core to be able to use peripherals.
|
|
*
|
|
* The driver uses the sys_mm_drv_page_phys_get() API to access
|
|
* the address space.
|
|
*/
|
|
|
|
#include <zephyr/kernel.h>
|
|
#include <zephyr/drivers/mm/rat.h>
|
|
#include <zephyr/drivers/mm/system_mm.h>
|
|
#include <zephyr/sys/__assert.h>
|
|
|
|
static struct address_trans_params translate_config;
|
|
|
|
/**
|
|
* @brief Set registers for the address regions being used
|
|
*
|
|
* @param addr_translate_config Pointer to config struct for the RAT module
|
|
* @param region_num Number of regions being initialised
|
|
* @param enable Region status
|
|
*/
|
|
|
|
static void address_trans_set_region(struct address_trans_params *addr_translate_config,
|
|
uint16_t region_num, uint32_t enable)
|
|
{
|
|
uint32_t rat_base_addr = addr_translate_config->rat_base_addr;
|
|
uint64_t system_addr = addr_translate_config->region_config[region_num].system_addr;
|
|
uint32_t local_addr = addr_translate_config->region_config[region_num].local_addr;
|
|
uint32_t size = addr_translate_config->region_config[region_num].size;
|
|
uint32_t system_addrL, system_addrH;
|
|
|
|
if (size > address_trans_region_size_4G) {
|
|
size = address_trans_region_size_4G;
|
|
}
|
|
system_addrL = (uint32_t)(system_addr & ~((uint32_t)((BIT64_MASK(size)))));
|
|
system_addrH = (uint32_t)((system_addr >> 32) & 0xFFFF);
|
|
local_addr = local_addr & ~((uint32_t)(BIT64_MASK(size)));
|
|
|
|
sys_write32(0, RAT_CTRL(rat_base_addr, region_num));
|
|
sys_write32(local_addr, RAT_BASE(rat_base_addr, region_num));
|
|
sys_write32(system_addrL, RAT_TRANS_L(rat_base_addr, region_num));
|
|
sys_write32(system_addrH, RAT_TRANS_H(rat_base_addr, region_num));
|
|
sys_write32(RAT_CTRL_W(enable, size), RAT_CTRL(rat_base_addr, region_num));
|
|
}
|
|
|
|
static void address_trans_init(struct address_trans_params *params)
|
|
{
|
|
uint32_t i;
|
|
|
|
if (params != NULL) {
|
|
translate_config = *params;
|
|
}
|
|
|
|
__ASSERT(translate_config.num_regions < ADDR_TRANSLATE_MAX_REGIONS,
|
|
"Exceeding maximum number of regions");
|
|
|
|
for (i = 0; i < translate_config.num_regions; i++) {
|
|
__ASSERT(translate_config.rat_base_addr != 0, "RAT base address cannot be 0");
|
|
__ASSERT(translate_config.region_config != NULL,
|
|
"RAT region config cannot be NULL");
|
|
|
|
/* enable regions setup by user */
|
|
address_trans_set_region(&translate_config, i, 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Initialise RAT module
|
|
*
|
|
* @param region_config Pointer to config struct for the regions
|
|
* @param rat_base_addr Base address for the RAT module
|
|
* @param translate_regions Number of regions being initialised
|
|
*/
|
|
|
|
void sys_mm_drv_ti_rat_init(void *region_config, uint64_t rat_base_addr, uint8_t translate_regions)
|
|
{
|
|
translate_config.num_regions = translate_regions;
|
|
translate_config.rat_base_addr = rat_base_addr;
|
|
translate_config.region_config = (struct address_trans_region_config *)region_config;
|
|
|
|
address_trans_init(&translate_config);
|
|
}
|
|
|
|
int sys_mm_drv_page_phys_get(void *virt, uintptr_t *phys)
|
|
{
|
|
if (virt == NULL) {
|
|
return -EINVAL;
|
|
}
|
|
uintptr_t pa = (uintptr_t) virt;
|
|
uintptr_t *va = phys;
|
|
|
|
uint32_t found, regionId;
|
|
|
|
__ASSERT(translate_config.num_regions < ADDR_TRANSLATE_MAX_REGIONS,
|
|
"Exceeding maximum number of regions");
|
|
|
|
found = 0;
|
|
|
|
for (regionId = 0; regionId < translate_config.num_regions; regionId++) {
|
|
uint64_t start_addr, end_addr;
|
|
uint32_t size_mask;
|
|
|
|
size_mask =
|
|
((uint32_t)((BIT64_MASK(translate_config.region_config[regionId].size))));
|
|
|
|
start_addr = translate_config.region_config[regionId].system_addr;
|
|
|
|
end_addr = start_addr + size_mask;
|
|
|
|
if (pa >= start_addr && pa <= end_addr) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (found) {
|
|
/* translate input address to output address */
|
|
uint32_t offset =
|
|
pa - translate_config.region_config[regionId].system_addr;
|
|
|
|
*va = (translate_config.region_config[regionId].local_addr + offset);
|
|
} else {
|
|
/* no mapping found, set output = input with 32b truncation */
|
|
*va = pa;
|
|
}
|
|
|
|
if (va == NULL) {
|
|
return -EFAULT;
|
|
}
|
|
return 0;
|
|
}
|