/* cpu2phys.c */
/*****************************************************************************/
/* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only */
/* */
/* AS */
/* */
/* CPU->Physical Address Translation */
/* */
/*****************************************************************************/
#include "stdinc.h"
#include <stddef.h>
#include <assert.h>
#include <string.h>
#include "strutil.h"
#include "tempresult.h"
#include "asmdef.h"
#include "cpu2phys.h"
typedef struct
{
LargeWord cpu_start, cpu_end;
LargeWord phys_start, phys_end;
} cpu_2_phys_area_t;
typedef struct
{
cpu_2_phys_area_t *areas;
size_t capacity;
size_t cnt;
LargeWord end;
} cpu_2_phys_area_list_t;
static cpu_2_phys_area_list_t area_lists[SegCount];
/*!------------------------------------------------------------------------
* \fn cpu_2_phys_area_t *insert_area(cpu_2_phys_area_list_t *p_list, unsigned index)
* \brief make space for area at given index, implicitly increasing array size
* \param p_list list to operate on
* \param index place to insert
* \return * to freed and cleared area
* ------------------------------------------------------------------------ */
static cpu_2_phys_area_t *insert_area(cpu_2_phys_area_list_t *p_list, unsigned index)
{
cpu_2_phys_area_t *p_ret;
if (p_list->cnt >= p_list->capacity)
{
size_t new_capacity = p_list->cnt + 1;
size_t new_alloc = new_capacity * sizeof(*p_list->areas);
p_list->areas = p_list->capacity
? (cpu_2_phys_area_t
*) realloc(p_list
->areas
, new_alloc
) : (cpu_2_phys_area_t
*) malloc(new_alloc
); p_list->capacity = new_capacity;
}
p_ret = &p_list->areas[index];
p_list->cnt++;
memmove(p_ret
+ 1, p_ret
, sizeof(*p_ret
) * (p_list
->cnt
- 1 - index
)); memset(p_ret
, 0, sizeof(*p_ret
)); return p_ret;
}
/*!------------------------------------------------------------------------
* \fn delete_area(cpu_2_phys_area_list_t *p_list, unsigned index)
* \brief delete entry from table
* \param p_list list to operate on
* \param index place to delete
* ------------------------------------------------------------------------ */
static void delete_area(cpu_2_phys_area_list_t *p_list, unsigned index)
{
cpu_2_phys_area_t *p_ret;
p_ret = &p_list->areas[index];
memmove(p_ret
, p_ret
+ 1, sizeof(*p_ret
) * (p_list
->cnt
- 1 - index
)); p_list->cnt--;
}
/*!------------------------------------------------------------------------
* \fn get_list(as_addrspace_t addr_space)
* \brief retrieve list per address space
* \param addr_space address space
* \return * to list
* ------------------------------------------------------------------------ */
static cpu_2_phys_area_list_t *get_list(as_addrspace_t addr_space)
{
assert(addr_space
< SegCount
); return &area_lists[addr_space];
}
/*!------------------------------------------------------------------------
* \fn cpu_2_phys_area_clear(as_addrspace_t addr_space)
* \brief clear tables before adding new ones
* \param addr_space address space to operate on
* ------------------------------------------------------------------------ */
void cpu_2_phys_area_clear(as_addrspace_t addr_space)
{
assert(addr_space
< SegCount
); area_lists[addr_space].cnt = 0;
area_lists[addr_space].end = 0;
}
/*!------------------------------------------------------------------------
* \fn cpu_2_phys_area_add(as_addrspace_t addr_space, LargeWord new_cpu_start, LargeWord new_phys_start, LargeWord new_len)
* \brief add another area
* \param addr_space address space to operate on
* \param new_cpu_start start address in CPU address space
* \param new_phys_start start address in physical address space
* \param new_len area size in <gran>
* ------------------------------------------------------------------------ */
void cpu_2_phys_area_add(as_addrspace_t addr_space, LargeWord new_cpu_start, LargeWord new_phys_start, LargeWord new_len)
{
size_t z, z2;
cpu_2_phys_area_list_t *p_list = get_list(addr_space);
cpu_2_phys_area_t *p_area;
LargeWord new_cpu_end = new_cpu_start + (new_len - 1);
LargeWord overlap_start, overlap_end, delta;
Boolean change;
/* Do not add zero-length areas */
if (!new_len)
return;
/* sort in according to CPU start address */
for (z = 0; z < p_list->cnt; z++)
if (p_list->areas[z].cpu_start >= new_cpu_start)
break;
p_area = insert_area(p_list, z);
p_area->cpu_start = new_cpu_start;
p_area->cpu_end = new_cpu_end;
p_area->phys_start = new_phys_start;
p_area->phys_end = new_phys_start + (new_len - 1);
/* shrink/delete (partially) overlapping areas: */
do
{
change = False;
for (z2 = 0; z2 < p_list->cnt; z2++)
{
/* do not test overlap with new entry itself */
if (z2 == z)
continue;
/* deduce overlapping area */
overlap_start = max(p_list->areas[z].cpu_start, p_list->areas[z2].cpu_start);
overlap_end = min(p_list->areas[z].cpu_end, p_list->areas[z2].cpu_end);
if (overlap_start >= overlap_end)
continue;
/* Delete old area entirely? -> possibly correct index of new entry and restart */
if ((overlap_start == p_list->areas[z2].cpu_start)
&& (overlap_end == p_list->areas[z2].cpu_end))
{
delete_area(p_list, z2);
if (z2 < z)
z--;
change = True;
break;
}
/* shorten old area at beginning? */
else if (overlap_start == p_list->areas[z2].cpu_start)
{
delta = overlap_end - overlap_start + 1;
p_list->areas[z2].cpu_start += delta;
p_list->areas[z2].phys_start += delta;
}
/* shorten old area at end? */
else if (overlap_end == p_list->areas[z2].cpu_end)
{
delta = overlap_end - overlap_start + 1;
p_list->areas[z2].cpu_end -= delta;
p_list->areas[z2].phys_end -= delta;
}
/* Overlap cuts out in the mid, split into parts. Assuming the addresses were sorted,
z2 equals z - 1 and the old area's part surround the new one: */
else
{
cpu_2_phys_area_t save = p_list->areas[z2];
delta = save.cpu_end - overlap_start + 1;
p_list->areas[z2].cpu_end -= delta;
p_list->areas[z2].phys_end -= delta;
p_area = insert_area(p_list, z + 1);
*p_area = save;
delta = overlap_end - save.cpu_start + 1;
p_area->cpu_start += delta;
p_area->phys_start += delta;
change = True;
break;
}
}
}
while (change);
}
/*!------------------------------------------------------------------------
* \fn cpu_2_phys_area_set_cpu_end(as_addrspace_t addr_space, LargeWord cpu_end)
* \brief set the end of the CPU's address space
* \param addr_space address space to operate on
* \param cpu_end end of CPU address space
* ------------------------------------------------------------------------ */
void cpu_2_phys_area_set_cpu_end(as_addrspace_t addr_space, LargeWord cpu_end)
{
cpu_2_phys_area_list_t *p_list = get_list(addr_space);
p_list->end = cpu_end;
}
/*!------------------------------------------------------------------------
* \fn cpu_2_phys_area_fill(as_addrspace_t addr_space, LargeWord cpu_start, LargeWord cpu_end)
* \brief fill gaps in the CPU-side address space with 1:1 mappings
* \param addr_space address space to operate on
* \param cpu_start start of CPU address space
* \param cpu_end end of CPU address space
* ------------------------------------------------------------------------ */
void cpu_2_phys_area_fill(as_addrspace_t addr_space, LargeWord cpu_start, LargeWord cpu_end)
{
LargeWord expected_start;
size_t z;
cpu_2_phys_area_list_t *p_list = get_list(addr_space);
cpu_2_phys_area_t *p_area;
/* For each mapping, check whether there is no gap between its start address
and the predecessor's end address. If so, insert a 1:1 mapped area to
fill the gap: */
z = 0;
while (z < p_list->cnt)
{
expected_start = z ? p_list->areas[z - 1].cpu_end + 1 : cpu_start;
/* no gap -> just continue with the next entry */
if ((z < p_list->cnt) && (p_list->areas[z].cpu_start <= expected_start))
{
z++;
continue;
}
p_area = insert_area(p_list, z);
p_area->cpu_start =
p_area->phys_start = expected_start;
p_area->cpu_end =
p_area->phys_end = (z + 1 < p_list->cnt) ? p_list->areas[z + 1].cpu_start - 1 : cpu_end;
/* We know the entries at z (freshly inserted) and z+1 (moved up one index) are
continuous, so we may increase the counter by two: */
z += 2;
}
/* Do the same test once again at the very end of the array, to be sure it covers everything
up to the given cpu_end: */
if (!p_list->cnt || p_list->areas[p_list->cnt - 1].cpu_end < cpu_end)
{
expected_start = p_list->cnt ? p_list->areas[p_list->cnt - 1].cpu_end + 1 : cpu_start;
p_area = insert_area(p_list, p_list->cnt);
p_area->cpu_start =
p_area->phys_start = expected_start;
p_area->cpu_end =
p_area->phys_end = cpu_end;
}
/* Save the cpu_end for usage in phys_2_cpu(): */
cpu_2_phys_area_set_cpu_end(addr_space, cpu_end);
}
/*!------------------------------------------------------------------------
* \fn cpu_2_phys_area_dump(as_addrspace_t addr_space, FILE *p_file)
* \brief output current mapping
* \param addr_space address space to operate on
* \param p_file where to dump
* ------------------------------------------------------------------------ */
void cpu_2_phys_area_dump(as_addrspace_t addr_space, FILE *p_file)
{
cpu_2_phys_area_list_t *p_list = get_list(addr_space);
char str[100];
size_t z;
int cpu_max_len = 0, phys_max_len = 0;
for (z = 0; z < p_list->cnt; z++)
{
int this_len;
this_len = as_snprintf(str, sizeof str, "%lllx", p_list->areas[z].cpu_end);
if (this_len > cpu_max_len)
cpu_max_len = this_len;
this_len = as_snprintf(str, sizeof str, "%lllx", p_list->areas[z].phys_end);
if (this_len > phys_max_len)
phys_max_len = this_len;
}
for (z = 0; z < p_list->cnt; z++)
{
as_snprintf(str, sizeof str, "[%2u] %0*lllx...%0*lllx -> %0*lllx...%0*lllx\n", z,
cpu_max_len, p_list->areas[z].cpu_start,
cpu_max_len, p_list->areas[z].cpu_end,
phys_max_len, p_list->areas[z].phys_start,
phys_max_len, p_list->areas[z].phys_end);
}
}
/*!------------------------------------------------------------------------
* \fn def_phys_2_cpu(as_addrspace_t addr_space, LargeWord *p_address)
* \brief physical -> CPU address translation
* \param addr_space address space to operate on
* \param p_address address to translate
* \return True if translation succeeded
* ------------------------------------------------------------------------ */
Boolean def_phys_2_cpu(as_addrspace_t addr_space, LargeWord *p_address)
{
cpu_2_phys_area_list_t *p_list = get_list(addr_space);
size_t win;
for (win = 0; win < p_list->cnt; win++)
if ((*p_address >= p_list->areas[win].phys_start) && (*p_address <= p_list->areas[win].phys_end))
{
*p_address = (*p_address - p_list->areas[win].phys_start) + p_list->areas[win].cpu_start;
return True;
}
return False;
}
/*!------------------------------------------------------------------------
* \fn def_cpu_2_phys(as_addrspace_t addr_space, LargeWord *p_address)
* \brief CPU -> physical address translation
* \param addr_space address space to operate on
* \param p_address address to translate
* \return True if translation succeeded
* ------------------------------------------------------------------------ */
Boolean def_cpu_2_phys(as_addrspace_t addr_space, LargeWord *p_address)
{
cpu_2_phys_area_list_t *p_list = get_list(addr_space);
size_t win;
for (win = 0; win < p_list->cnt; win++)
if ((*p_address >= p_list->areas[win].cpu_start) && (*p_address <= p_list->areas[win].cpu_end))
{
*p_address = (*p_address - p_list->areas[win].cpu_start) + p_list->areas[win].phys_start;
return True;
}
return False;
}
/*!------------------------------------------------------------------------
* \fn fnc_phys_2_cpu(TempResult *p_ret, const TempResult *p_args, unsigned arg_cnt)
* \brief built-in function for physical -> CPU address translation
* \param p_ret returns CPU address
* \param p_args physical address argument
* \return True if translation possible at all
* ------------------------------------------------------------------------ */
Boolean fnc_phys_2_cpu(TempResult *p_ret, const TempResult *p_args, unsigned arg_cnt)
{
LargeWord address;
UNUSED(arg_cnt);
if (!area_lists[ActPC].cnt)
return False;
address = p_args[0].Contents.Int;
as_tempres_set_int(p_ret, def_phys_2_cpu(ActPC, &address) ? address : area_lists[ActPC].end + 1);
return True;
}
/*!------------------------------------------------------------------------
* \fn fnc_cpu_2_phys(TempResult *p_ret, const TempResult *p_args, unsigned arg_cnt)
* \brief built-in function for CPU -> physical address translation
* \param p_ret returns physical address
* \param p_args CPU address argument
* \return True if translation possible at all
* ------------------------------------------------------------------------ */
Boolean fnc_cpu_2_phys(TempResult *p_ret, const TempResult *p_args, unsigned arg_cnt)
{
LargeWord address;
UNUSED(arg_cnt);
if (!area_lists[ActPC].cnt)
return False;
address = p_args[0].Contents.Int;
as_tempres_set_int(p_ret, def_cpu_2_phys(ActPC, &address) ? address : SegLimits[ActPC] + 1);
return True;
}