genesi/linux-legacy
1
0
Fork 0
mirror of https://github.com/genesi/linux-legacy.git synced 2026-02-04 08:04:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

amd-gpu: remove aperture concept from the memory manager

Browse Source 
Now everything is one big memarena instead of a separate PHYS and EMEM,
and instead of having to micromanage the split between Z160 (always PHYS
here) and GPU (99% of it's allocations come out of EMEM), we give blocks
from the same memory pool.

This should effect some more efficient allocation strategies and allow
Xorg acceleration to proceed with much less movement of data (when it
evicts for low memory in PHYS, it moves it to userspace and uses pixman
to render everything, which is CPU intensive) at the potential cost of
leaving slightly less memory around for the 3D GPU, but userspace apps
using the GPU should be doing better with texture management so as not
to soak up >32MiB of reserved GPU memory needlessly.

Moving away from gsl_memmgr to genalloc is not desirable right now since
the driver requires multiple allocation alignment orders and genalloc can
only really guarantee a minimum alignment (i.e. size of allocation
represented by each bit in the allocation bitmap).

Moving to a dma_alloc_coherent/writecombine-only model also poses a
problem since significant amounts of code expects to be able to find the
"base" GPU memory address and with individual allocations instead of a
pooled area, there is no such thing.

Signed-off-by: Matt Sealey <matt@genesi-usa.com>
This commit is contained in:
Matt Sealey
2013-06-06 10:38:12 -05:00
parent 9ab968f3c9
commit 7115396a0f
7 changed files with 85 additions and 553 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
drivers/mxc/amd-gpu/gsl_device.c
View File

@@ -306,7 +306,7 @@ kgsl_device_getproperty(gsl_deviceid_t device_id, gsl_property_type_t type, void
DEBUG_ASSERT(sizebytes == sizeof(gsl_shmemprop_t));
shem->numapertures = gsl_driver.shmem.numapertures;
shem->numapertures = 1;
shem->aperture_mask = GSL_APERTURE_MASK;
shem->aperture_shift = GSL_APERTURE_SHIFT;
@@ -320,19 +320,15 @@ kgsl_device_getproperty(gsl_deviceid_t device_id, gsl_property_type_t type, void
DEBUG_ASSERT(sizebytes == (sizeof(gsl_apertureprop_t) * gsl_driver.shmem.numapertures));
for (i = 0; i < gsl_driver.shmem.numapertures; i++)
if (gsl_driver.shmem.memarena)
{
if (gsl_driver.shmem.apertures[i].memarena)
{
aperture->gpuaddr = GSL_APERTURE_GETGPUADDR(gsl_driver.shmem, i);
aperture->hostaddr = GSL_APERTURE_GETHOSTADDR(gsl_driver.shmem, i);
}
else
{
aperture->gpuaddr = 0x0;
aperture->hostaddr = 0x0;
}
aperture++;
aperture->gpuaddr = GSL_SHMEM_MEMARENA_GETGPUADDR(gsl_driver.shmem);
aperture->hostaddr = GSL_SHMEM_MEMARENA_GETHOSTADDR(gsl_driver.shmem);
}
else
{
aperture->gpuaddr = 0x0;
aperture->hostaddr = 0x0;
}
break;

189
drivers/mxc/amd-gpu/gsl_hal.c
View File

@@ -48,58 +48,15 @@ extern int gpu_2d_regsize;
extern phys_addr_t gpu_3d_regbase;
extern int gpu_3d_regsize;
extern int gmem_size;
extern phys_addr_t gpu_reserved_mem;
extern int gpu_reserved_mem_size;
extern int gpu_2d_irq, gpu_3d_irq;
extern int enable_mmu;
KGSLHAL_API int
kgsl_hal_allocphysical(unsigned int virtaddr, unsigned int numpages, unsigned int scattergatterlist[])
{
/* allocate physically contiguous memory */
int i;
void *va;
va = gsl_linux_map_alloc(virtaddr, numpages*PAGE_SIZE);
if (!va)
return GSL_FAILURE_OUTOFMEM;
for (i = 0; i < numpages; i++) {
scattergatterlist[i] = page_to_phys(vmalloc_to_page(va));
va += PAGE_SIZE;
}
return GSL_SUCCESS;
}
/* --------------------------------------------------------------------------- */
KGSLHAL_API int
kgsl_hal_freephysical(unsigned int virtaddr, unsigned int numpages, unsigned int scattergatterlist[])
{
/* free physical memory */
gsl_linux_map_free(virtaddr);
return GSL_SUCCESS;
}
/* ---------------------------------------------------------------------------- */
KGSLHAL_API int
kgsl_hal_init(void)
{
gsl_hal_t *hal;
unsigned long res_size;
unsigned int va, pa;
if (!gpu_reserved_mem || !gpu_reserved_mem_size) {
printk(KERN_ERR "%s: no GPU reserved memory! Cannot continue!\n", DRVNAME);
return GSL_FAILURE_SYSTEMERROR;
}
unsigned int va;
if (gsl_driver.hal) {
return GSL_FAILURE_ALREADYINITIALIZED;
@@ -139,9 +96,9 @@ kgsl_hal_init(void)
}
#ifdef GSL_HAL_DEBUG
pr_info("%s: hal->z430_regspace.mmio_phys_base = 0x%p\n", DRVNAME, (void *)hal->z430_regspace.mmio_phys_base);
pr_info("%s: hal->z430_regspace.mmio_virt_base = 0x%p\n", DRVNAME, (void *)hal->z430_regspace.mmio_virt_base);
pr_info("%s: hal->z430_regspace.sizebytes = 0x%08x\n", DRVNAME, hal->z430_regspace.sizebytes);
pr_info("%s: Z430: phys 0x%p virt 0x%p size 0x%08x irq %d\n", DRVNAME, (void *)hal->z430_regspace.mmio_phys_base,
(void *)hal->z430_regspace.mmio_virt_base,
hal->z430_regspace.sizebytes, gpu_3d_irq);
#endif
}
@@ -155,77 +112,14 @@ kgsl_hal_init(void)
}
#ifdef GSL_HAL_DEBUG
pr_info("%s: hal->z160_regspace.mmio_phys_base = 0x%p\n", DRVNAME, (void *)hal->z160_regspace.mmio_phys_base);
pr_info("%s: hal->z160_regspace.mmio_virt_base = 0x%p\n", DRVNAME, (void *)hal->z160_regspace.mmio_virt_base);
pr_info("%s: hal->z160_regspace.sizebytes = 0x%08x\n", DRVNAME, hal->z160_regspace.sizebytes);
pr_info("%s: Z160: phys 0x%p virt 0x%p size 0x%08x irq %d\n", DRVNAME, (void *)hal->z160_regspace.mmio_phys_base,
(void *)hal->z160_regspace.mmio_virt_base,
hal->z160_regspace.sizebytes, gpu_2d_irq);
#endif
}
if (gsl_driver.enable_mmu) {
pr_info("%s: GPU MMU enabled\n", DRVNAME);
pa = gpu_reserved_mem;
va = (unsigned int)ioremap_wc(gpu_reserved_mem, gpu_reserved_mem_size);
if (!va)
pr_err("%s: ioremap failed!\n", DRVNAME);
res_size = gpu_reserved_mem_size;
} else {
pr_info("%s: GPU MMU disabled\n", DRVNAME);
pa = gpu_reserved_mem;
va = (unsigned int)ioremap(gpu_reserved_mem, gpu_reserved_mem_size);
if (!va)
pr_err("%s: ioremap failed!\n", DRVNAME);
res_size = gpu_reserved_mem_size;
}
if (va) {
/* it would be awesome if we didn't have to do this on module init.. */
memset((void *)va, 0, gpu_reserved_mem_size);
/* set up a "memchunk" so we know what we can iounmap on exit */
hal->memchunk.mmio_virt_base = (void *)va;
hal->memchunk.mmio_phys_base = pa;
hal->memchunk.sizebytes = gpu_reserved_mem_size;
#ifdef GSL_HAL_DEBUG
pr_info("%s: Reserved memory: pa = 0x%p va = 0x%p size = 0x%08x\n", DRVNAME,
(void *)hal->memchunk.mmio_phys_base,
(void *)hal->memchunk.mmio_virt_base,
hal->memchunk.sizebytes);
#endif
hal->memspace[GSL_HAL_MEM2].mmio_virt_base = (void *) va;
hal->memspace[GSL_HAL_MEM2].gpu_base = pa;
hal->memspace[GSL_HAL_MEM2].sizebytes = GSL_HAL_SHMEM_SIZE_EMEM_NOMMU_PHYS;
va += hal->memspace[GSL_HAL_MEM2].sizebytes;
pa += hal->memspace[GSL_HAL_MEM2].sizebytes;
#ifdef GSL_HAL_DEBUG
pr_info("%s: GSL_HAL_MEM2 aperture (PHYS) pa = 0x%p va = 0x%p size = 0x%08x\n", DRVNAME,
(void *)hal->memspace[GSL_HAL_MEM2].gpu_base,
(void *)hal->memspace[GSL_HAL_MEM2].mmio_virt_base,
hal->memspace[GSL_HAL_MEM2].sizebytes);
#endif
if (gsl_driver.enable_mmu) {
gsl_linux_map_init();
hal->memspace[GSL_HAL_MEM1].mmio_virt_base = (void *)GSL_LINUX_MAP_RANGE_START;
hal->memspace[GSL_HAL_MEM1].gpu_base = GSL_LINUX_MAP_RANGE_START;
hal->memspace[GSL_HAL_MEM1].sizebytes = GSL_HAL_SHMEM_SIZE_EMEM_MMU;
} else {
hal->memspace[GSL_HAL_MEM1].mmio_virt_base = (void *) va;
hal->memspace[GSL_HAL_MEM1].gpu_base = pa;
hal->memspace[GSL_HAL_MEM1].sizebytes = GSL_HAL_SHMEM_SIZE_EMEM_NOMMU_EMEM;
}
#ifdef GSL_HAL_DEBUG
pr_info("%s: GSL_HAL_MEM1 aperture (%s) pa = 0x%p va = 0x%p size = 0x%08x\n", DRVNAME,
gsl_driver.enable_mmu ? "MMU" : "EMEM",
(void *)hal->memspace[GSL_HAL_MEM1].gpu_base,
(void *)hal->memspace[GSL_HAL_MEM1].mmio_virt_base,
hal->memspace[GSL_HAL_MEM1].sizebytes);
#endif
} else {
return GSL_FAILURE_SYSTEMERROR;
}
return GSL_SUCCESS;
@@ -252,17 +146,11 @@ kgsl_hal_close(void)
iounmap(hal->z160_regspace.mmio_virt_base);
}
/* free physical block */
if (hal->memchunk.mmio_virt_base && gpu_reserved_mem) {
iounmap(hal->memchunk.mmio_virt_base);
} else {
dma_free_coherent(0, hal->memchunk.sizebytes, hal->memchunk.mmio_virt_base, hal->memchunk.mmio_phys_base);
}
/*
if (gsl_driver.enable_mmu) {
gsl_linux_map_destroy();
}
*/
/* release hal struct */
memset(hal, 0, sizeof(gsl_hal_t));
kfree(gsl_driver.hal);
@@ -272,43 +160,6 @@ kgsl_hal_close(void)
return GSL_SUCCESS;
}
/* ---------------------------------------------------------------------------- */
KGSLHAL_API int
kgsl_hal_getshmemconfig(gsl_shmemconfig_t *config)
{
int status = GSL_FAILURE_DEVICEERROR;
gsl_hal_t *hal = (gsl_hal_t *) gsl_driver.hal;
memset(config, 0, sizeof(gsl_shmemconfig_t));
if (hal) {
config->numapertures = GSL_SHMEM_MAX_APERTURES;
if (gsl_driver.enable_mmu) {
config->apertures[0].id = GSL_APERTURE_MMU;
} else {
config->apertures[0].id = GSL_APERTURE_EMEM;
}
config->apertures[0].channel = GSL_CHANNEL_1;
config->apertures[0].hostbase = (unsigned int)hal->memspace[GSL_HAL_MEM1].mmio_virt_base;
config->apertures[0].gpubase = hal->memspace[GSL_HAL_MEM1].gpu_base;
config->apertures[0].sizebytes = hal->memspace[GSL_HAL_MEM1].sizebytes;
config->apertures[1].id = GSL_APERTURE_PHYS;
config->apertures[1].channel = GSL_CHANNEL_1;
config->apertures[1].hostbase = (unsigned int)hal->memspace[GSL_HAL_MEM2].mmio_virt_base;
config->apertures[1].gpubase = hal->memspace[GSL_HAL_MEM2].gpu_base;
config->apertures[1].sizebytes = hal->memspace[GSL_HAL_MEM2].sizebytes;
status = GSL_SUCCESS;
}
return status;
}
/* ---------------------------------------------------------------------------- */
KGSLHAL_API int
kgsl_hal_getdevconfig(gsl_deviceid_t device_id, gsl_devconfig_t *config)
{
@@ -327,6 +178,7 @@ kgsl_hal_getdevconfig(gsl_deviceid_t device_id, gsl_devconfig_t *config)
config->gmemspace.gpu_base = 0;
config->gmemspace.mmio_virt_base = 0;
config->gmemspace.mmio_phys_base = 0;
if (gmem_size) {
config->gmemspace.sizebytes = gmem_size;
} else {
@@ -340,6 +192,7 @@ kgsl_hal_getdevconfig(gsl_deviceid_t device_id, gsl_devconfig_t *config)
mmu_config.f.mmu_enable = 1;
/*
if (gsl_driver.enable_mmu) {
mmu_config.f.split_mode_enable = 0;
mmu_config.f.rb_w_clnt_behavior = 1;
@@ -354,17 +207,20 @@ kgsl_hal_getdevconfig(gsl_deviceid_t device_id, gsl_devconfig_t *config)
mmu_config.f.tc_r_clnt_behavior = 1;
mmu_config.f.pa_w_clnt_behavior = 1;
}
*/
config->mmu_config = mmu_config.val;
/*
if (gsl_driver.enable_mmu) {
config->va_base = hal->memspace[GSL_HAL_MEM1].gpu_base;
config->va_range = hal->memspace[GSL_HAL_MEM1].sizebytes;
config->va_base = hal->memspace.gpu_base;
config->va_range = hal->memspace.sizebytes;
} else {
*/
config->va_base = 0x00000000;
config->va_range = 0x00000000;
/*
}
*/
/* turn off memory protection unit by setting acceptable physical address range to include all pages */
config->mpu_base = 0x00000000; /* hal->memchunk.mmio_virt_base; */
config->mpu_range = 0xFFFFF000; /* hal->memchunk.sizebytes; */
@@ -384,16 +240,19 @@ kgsl_hal_getdevconfig(gsl_deviceid_t device_id, gsl_devconfig_t *config)
mmu_config.f.mmu_enable = 1;
/*
if (gsl_driver.enable_mmu) {
config->mmu_config = 0x00555551;
config->va_base = hal->memspace[GSL_HAL_MEM1].gpu_base;
config->va_range = hal->memspace[GSL_HAL_MEM1].sizebytes;
config->va_base = hal->memspace.gpu_base;
config->va_range = hal->memspace.sizebytes;
} else {
*/
config->mmu_config = mmu_config.val;
config->va_base = 0x00000000;
config->va_range = 0x00000000;
/*
}
*/
config->mpu_base = 0x00000000; /* (unsigned int) hal->memchunk.mmio_virt_base; */
config->mpu_range = 0xFFFFF000; /* hal->memchunk.sizebytes; */

15
drivers/mxc/amd-gpu/gsl_memmgr.c
View File

@@ -27,13 +27,11 @@
* these are a bit overzealous: a whole byte for a bit flag?
*/
#define GSL_MEMARENAPRIV_SIGNATURE_MASK 0x0000FFFF
#define GSL_MEMARENAPRIV_APERTUREID_MASK 0xF0000000
#define GSL_MEMARENAPRIV_MMUVIRTUALIZED_MASK 0x0F000000
#define GSL_MEMARENAPRIV_CONPHYS_MASK 0x00F00000 //neko
#define GSL_MEMARENAPRIV_SIGNATURE_SHIFT 0
#define GSL_MEMARENAPRIV_MMUVIRTUALIZED_SHIFT 24
#define GSL_MEMARENAPRIV_APERTUREID_SHIFT 28
#define GSL_MEMARENAPRIV_CONPHYS_SHIFT 20 //neko
#define GSL_MEMARENA_INSTANCE_SIGNATURE 0x0000CAFE
@@ -48,12 +46,10 @@
// macros
#define GSL_MEMARENA_SET_SIGNATURE (memarena->priv |= ((GSL_MEMARENA_INSTANCE_SIGNATURE << GSL_MEMARENAPRIV_SIGNATURE_SHIFT) & GSL_MEMARENAPRIV_SIGNATURE_MASK))
#define GSL_MEMARENA_SET_MMU_VIRTUALIZED (memarena->priv |= ((mmu_virtualized << GSL_MEMARENAPRIV_MMUVIRTUALIZED_SHIFT) & GSL_MEMARENAPRIV_MMUVIRTUALIZED_MASK))
#define GSL_MEMARENA_SET_ID (memarena->priv |= ((aperture_id << GSL_MEMARENAPRIV_APERTUREID_SHIFT) & GSL_MEMARENAPRIV_APERTUREID_MASK))
#define GSL_MEMARENA_SET_CONPHYS (memarena->priv |= ((conphys << GSL_MEMARENAPRIV_CONPHYS_SHIFT) & GSL_MEMARENAPRIV_CONPHYS_MASK))//neko
#define GSL_MEMARENA_GET_SIGNATURE ((memarena->priv & GSL_MEMARENAPRIV_SIGNATURE_MASK) >> GSL_MEMARENAPRIV_SIGNATURE_SHIFT)
#define GSL_MEMARENA_IS_MMU_VIRTUALIZED ((memarena->priv & GSL_MEMARENAPRIV_MMUVIRTUALIZED_MASK) >> GSL_MEMARENAPRIV_MMUVIRTUALIZED_SHIFT)
#define GSL_MEMARENA_GET_ID ((memarena->priv & GSL_MEMARENAPRIV_APERTUREID_MASK) >> GSL_MEMARENAPRIV_APERTUREID_SHIFT)
#define GSL_MEMARENA_IS_CONPHYS ((memarena->priv & GSL_MEMARENAPRIV_CONPHYS_MASK) >> GSL_MEMARENAPRIV_CONPHYS_SHIFT)//neko
// validate
@@ -267,13 +263,13 @@ kgsl_memarena_releasememblknode(gsl_memarena_t *memarena, memblk_t *memblk)
//----------------------------------------------------------------------------
gsl_memarena_t*
kgsl_memarena_create(int aperture_id, int mmu_virtualized, unsigned int hostbaseaddr, gpuaddr_t gpubaseaddr, int sizebytes)
kgsl_memarena_create(int mmu_virtualized, unsigned int hostbaseaddr, gpuaddr_t gpubaseaddr, int sizebytes)
{
static int count = 0;
gsl_memarena_t *memarena;
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE,
"--> gsl_memarena_t* kgsl_memarena_create(int aperture_id=%d, gpuaddr_t gpubaseaddr=0x%08x, int sizebytes=%d)\n", aperture_id, gpubaseaddr, sizebytes );
"--> gsl_memarena_t* kgsl_memarena_create(gpuaddr_t gpubaseaddr=0x%08x, int sizebytes=%d)\n", gpubaseaddr, sizebytes );
memarena = (gsl_memarena_t *)kmalloc(sizeof(gsl_memarena_t), GFP_KERNEL);
@@ -289,7 +285,6 @@ kgsl_memarena_create(int aperture_id, int mmu_virtualized, unsigned int hostbase
GSL_MEMARENA_SET_SIGNATURE;
GSL_MEMARENA_SET_MMU_VIRTUALIZED;
GSL_MEMARENA_SET_ID;
mutex_init(&memarena->lock);
@@ -338,13 +333,10 @@ kgsl_memarena_destroy(gsl_memarena_t *memarena)
// memory leak check
if (memarena->freelist.head->blksize != memarena->sizebytes)
{
if (GSL_MEMARENA_GET_ID == GSL_APERTURE_EMEM)
{
// external memory leak detected
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_FATAL,
"ERROR: External memory leak detected.\n" );
return (GSL_FAILURE);
}
}
#endif // _DEBUG
@@ -524,8 +516,6 @@ kgsl_memarena_alloc(gsl_memarena_t *memarena, gsl_flags_t flags, int size, gsl_m
//
// when allocating from external memory aperture, round up size of requested block to multiple of page size if needed
if (GSL_MEMARENA_GET_ID == GSL_APERTURE_EMEM)
{
if ((flags & GSL_MEMFLAGS_FORCEPAGESIZE) || GSL_MEMARENA_IS_MMU_VIRTUALIZED)
{
if (size & (GSL_PAGESIZE-1))
@@ -533,7 +523,6 @@ kgsl_memarena_alloc(gsl_memarena_t *memarena, gsl_flags_t flags, int size, gsl_m
size = ((size >> GSL_PAGESIZE_SHIFT) + 1) << GSL_PAGESIZE_SHIFT;
}
}
}
// determine shift count for alignment requested
alignmentshift = gsl_memarena_alignmentshift(flags);

345
drivers/mxc/amd-gpu/gsl_sharedmem.c
View File

@@ -25,22 +25,6 @@
/////////////////////////////////////////////////////////////////////////////
// macros
//////////////////////////////////////////////////////////////////////////////
#define GSL_SHMEM_APERTURE_MARK(aperture_id) \
(shmem->priv |= (((aperture_id + 1) << GSL_APERTURE_SHIFT) & GSL_APERTURE_MASK))
#define GSL_SHMEM_APERTURE_ISMARKED(aperture_id) \
(((shmem->priv & GSL_APERTURE_MASK) >> GSL_APERTURE_SHIFT) & (aperture_id + 1))
#define GSL_MEMFLAGS_APERTURE_GET(flags, aperture_id) \
aperture_id = (gsl_apertureid_t)((flags & GSL_MEMFLAGS_APERTURE_MASK) >> GSL_MEMFLAGS_APERTURE_SHIFT); \
DEBUG_ASSERT(aperture_id < GSL_APERTURE_MAX);
#define GSL_MEMFLAGS_CHANNEL_GET(flags, channel_id) \
channel_id = (gsl_channelid_t)((flags & GSL_MEMFLAGS_CHANNEL_MASK) >> GSL_MEMFLAGS_CHANNEL_SHIFT); \
DEBUG_ASSERT(channel_id < GSL_CHANNEL_MAX);
#define GSL_MEMDESC_APERTURE_SET(memdesc, aperture_index) \
memdesc->priv = (memdesc->priv & ~GSL_APERTURE_MASK) | ((aperture_index << GSL_APERTURE_SHIFT) & GSL_APERTURE_MASK);
#define GSL_MEMDESC_DEVICE_SET(memdesc, device_id) \
memdesc->priv = (memdesc->priv & ~GSL_DEVICEID_MASK) | ((device_id << GSL_DEVICEID_SHIFT) & GSL_DEVICEID_MASK);
@@ -48,11 +32,6 @@
#define GSL_MEMDESC_EXTALLOC_SET(memdesc, flag) \
memdesc->priv = (memdesc->priv & ~GSL_EXTALLOC_MASK) | ((flag << GSL_EXTALLOC_SHIFT) & GSL_EXTALLOC_MASK);
#define GSL_MEMDESC_APERTURE_GET(memdesc, aperture_index) \
DEBUG_ASSERT(memdesc); \
aperture_index = ((memdesc->priv & GSL_APERTURE_MASK) >> GSL_APERTURE_SHIFT); \
DEBUG_ASSERT(aperture_index < GSL_SHMEM_MAX_APERTURES);
#define GSL_MEMDESC_DEVICE_GET(memdesc, device_id) \
DEBUG_ASSERT(memdesc); \
device_id = (gsl_deviceid_t)((memdesc->priv & GSL_DEVICEID_MASK) >> GSL_DEVICEID_SHIFT); \
@@ -62,17 +41,6 @@
((memdesc->priv & GSL_EXTALLOC_MASK) >> GSL_EXTALLOC_SHIFT)
//////////////////////////////////////////////////////////////////////////////
// aperture index in shared memory object
//////////////////////////////////////////////////////////////////////////////
static __inline int
kgsl_sharedmem_getapertureindex(gsl_sharedmem_t *shmem, gsl_apertureid_t aperture_id, gsl_channelid_t channel_id)
{
DEBUG_ASSERT(shmem->aperturelookup[aperture_id][channel_id] < shmem->numapertures);
return (shmem->aperturelookup[aperture_id][channel_id]);
}
//////////////////////////////////////////////////////////////////////////////
// functions
@@ -81,12 +49,9 @@ kgsl_sharedmem_getapertureindex(gsl_sharedmem_t *shmem, gsl_apertureid_t apertur
int
kgsl_sharedmem_init(gsl_sharedmem_t *shmem)
{
int i;
int status;
gsl_shmemconfig_t config;
int mmu_virtualized;
gsl_apertureid_t aperture_id;
gsl_channelid_t channel_id;
unsigned int hostbaseaddr;
gpuaddr_t gpubaseaddr;
int sizebytes;
@@ -107,63 +72,28 @@ kgsl_sharedmem_init(gsl_sharedmem_t *shmem)
return (status);
}
shmem->numapertures = config.numapertures;
hostbaseaddr = config.emem_hostbase;
gpubaseaddr = config.emem_gpubase;
sizebytes = config.emem_sizebytes;
mmu_virtualized = 0;
for (i = 0; i < shmem->numapertures; i++)
// make sure aligned to page size
DEBUG_ASSERT((gpubaseaddr & ((1 << GSL_PAGESIZE_SHIFT) - 1)) == 0);
// make a multiple of page size
sizebytes = (sizebytes & ~((1 << GSL_PAGESIZE_SHIFT) - 1));
if (sizebytes > 0)
{
aperture_id = config.apertures[i].id;
channel_id = config.apertures[i].channel;
hostbaseaddr = config.apertures[i].hostbase;
gpubaseaddr = config.apertures[i].gpubase;
sizebytes = config.apertures[i].sizebytes;
mmu_virtualized = 0;
shmem->memarena = kgsl_memarena_create(mmu_virtualized, hostbaseaddr, gpubaseaddr, sizebytes);
// handle mmu virtualized aperture
if (aperture_id == GSL_APERTURE_MMU)
{
mmu_virtualized = 1;
aperture_id = GSL_APERTURE_EMEM;
}
// make sure aligned to page size
DEBUG_ASSERT((gpubaseaddr & ((1 << GSL_PAGESIZE_SHIFT) - 1)) == 0);
// make a multiple of page size
sizebytes = (sizebytes & ~((1 << GSL_PAGESIZE_SHIFT) - 1));
if (sizebytes > 0)
{
shmem->apertures[i].memarena = kgsl_memarena_create(aperture_id, mmu_virtualized, hostbaseaddr, gpubaseaddr, sizebytes);
if (!shmem->apertures[i].memarena)
if (!shmem->memarena)
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Unable to allocate memarena.\n" );
kgsl_sharedmem_close(shmem);
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_init. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
}
shmem->apertures[i].id = aperture_id;
shmem->apertures[i].channel = channel_id;
shmem->apertures[i].numbanks = 1;
// create aperture lookup table
if (GSL_SHMEM_APERTURE_ISMARKED(aperture_id))
{
// update "current aperture_id"/"current channel_id" index
shmem->aperturelookup[aperture_id][channel_id] = i;
}
else
{
// initialize "current aperture_id"/"channel_id" indexes
for (channel_id = GSL_CHANNEL_1; channel_id < GSL_CHANNEL_MAX; channel_id++)
{
shmem->aperturelookup[aperture_id][channel_id] = i;
}
GSL_SHMEM_APERTURE_MARK(aperture_id);
}
}
}
shmem->flags |= GSL_FLAGS_INITIALIZED;
@@ -178,20 +108,16 @@ kgsl_sharedmem_init(gsl_sharedmem_t *shmem)
int
kgsl_sharedmem_close(gsl_sharedmem_t *shmem)
{
int i;
int result = GSL_SUCCESS;
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "--> int kgsl_sharedmem_close(gsl_sharedmem_t *shmem=0x%08x)\n", shmem );
if (shmem->flags & GSL_FLAGS_INITIALIZED)
{
for (i = 0; i < shmem->numapertures; i++)
{
if (shmem->apertures[i].memarena)
if (shmem->memarena)
{
result = kgsl_memarena_destroy(shmem->apertures[i].memarena);
result = kgsl_memarena_destroy(shmem->memarena);
}
}
memset(shmem, 0, sizeof(gsl_sharedmem_t));
}
@@ -206,12 +132,8 @@ kgsl_sharedmem_close(gsl_sharedmem_t *shmem)
int
kgsl_sharedmem_alloc0(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes, gsl_memdesc_t *memdesc)
{
gsl_apertureid_t aperture_id;
gsl_channelid_t channel_id;
gsl_deviceid_t tmp_id;
int aperture_index, org_index;
int result = GSL_FAILURE;
gsl_mmu_t *mmu = NULL;
gsl_sharedmem_t *shmem = &gsl_driver.shmem;
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE,
@@ -221,9 +143,6 @@ kgsl_sharedmem_alloc0(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes
DEBUG_ASSERT(sizebytes);
DEBUG_ASSERT(memdesc);
GSL_MEMFLAGS_APERTURE_GET(flags, aperture_id);
GSL_MEMFLAGS_CHANNEL_GET(flags, channel_id);
memset(memdesc, 0, sizeof(gsl_memdesc_t));
if (!(shmem->flags & GSL_FLAGS_INITIALIZED))
@@ -273,110 +192,7 @@ kgsl_sharedmem_alloc0(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes
DEBUG_ASSERT(device_id > GSL_DEVICE_ANY && device_id <= GSL_DEVICE_MAX);
// get mmu reference
mmu = &gsl_driver.device[device_id-1].mmu;
aperture_index = kgsl_sharedmem_getapertureindex(shmem, aperture_id, channel_id);
//do not proceed if it is a strict request, the aperture requested is not present, and the MMU is enabled
if (!((flags & GSL_MEMFLAGS_STRICTREQUEST) && aperture_id != shmem->apertures[aperture_index].id && kgsl_mmu_isenabled(mmu)))
{
// do allocation
result = kgsl_memarena_alloc(shmem->apertures[aperture_index].memarena, flags, sizebytes, memdesc);
// if allocation failed
if (result != GSL_SUCCESS)
{
org_index = aperture_index;
// then failover to other channels within the current aperture
for (channel_id = GSL_CHANNEL_1; channel_id < GSL_CHANNEL_MAX; channel_id++)
{
aperture_index = kgsl_sharedmem_getapertureindex(shmem, aperture_id, channel_id);
if (aperture_index != org_index)
{
// do allocation
result = kgsl_memarena_alloc(shmem->apertures[aperture_index].memarena, flags, sizebytes, memdesc);
if (result == GSL_SUCCESS)
{
break;
}
}
}
// if allocation still has not succeeded, then failover to EMEM/MMU aperture, but
// not if it's a strict request and the MMU is enabled
if (result != GSL_SUCCESS && aperture_id != GSL_APERTURE_EMEM
&& !((flags & GSL_MEMFLAGS_STRICTREQUEST) && kgsl_mmu_isenabled(mmu)))
{
aperture_id = GSL_APERTURE_EMEM;
// try every channel
for (channel_id = GSL_CHANNEL_1; channel_id < GSL_CHANNEL_MAX; channel_id++)
{
aperture_index = kgsl_sharedmem_getapertureindex(shmem, aperture_id, channel_id);
if (aperture_index != org_index)
{
// do allocation
result = kgsl_memarena_alloc(shmem->apertures[aperture_index].memarena, flags, sizebytes, memdesc);
if (result == GSL_SUCCESS)
{
break;
}
}
}
}
}
}
if (result == GSL_SUCCESS)
{
GSL_MEMDESC_APERTURE_SET(memdesc, aperture_index);
GSL_MEMDESC_DEVICE_SET(memdesc, device_id);
if (kgsl_memarena_isvirtualized(shmem->apertures[aperture_index].memarena))
{
gsl_scatterlist_t scatterlist;
scatterlist.contiguous = 0;
scatterlist.num = memdesc->size / GSL_PAGESIZE;
if (memdesc->size & (GSL_PAGESIZE-1))
{
scatterlist.num++;
}
scatterlist.pages = kmalloc(sizeof(unsigned int) * scatterlist.num, GFP_KERNEL);
if (scatterlist.pages)
{
// allocate physical pages
result = kgsl_hal_allocphysical(memdesc->gpuaddr, scatterlist.num, scatterlist.pages);
if (result == GSL_SUCCESS)
{
result = kgsl_mmu_map(mmu, memdesc->gpuaddr, &scatterlist, flags, current->tgid);
if (result != GSL_SUCCESS)
{
kgsl_hal_freephysical(memdesc->gpuaddr, scatterlist.num, scatterlist.pages);
}
}
kfree(scatterlist.pages);
}
else
{
result = GSL_FAILURE;
}
if (result != GSL_SUCCESS)
{
kgsl_memarena_free(shmem->apertures[aperture_index].memarena, memdesc);
}
}
}
result = kgsl_memarena_alloc(shmem->memarena, flags, sizebytes, memdesc);
KGSL_DEBUG_TBDUMP_SETMEM( memdesc->gpuaddr, 0, memdesc->size );
@@ -403,30 +219,18 @@ int
kgsl_sharedmem_free0(gsl_memdesc_t *memdesc, unsigned int pid)
{
int status = GSL_SUCCESS;
int aperture_index;
gsl_deviceid_t device_id;
gsl_sharedmem_t *shmem;
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "--> int kgsl_sharedmem_free(gsl_memdesc_t *memdesc=%M)\n", memdesc );
GSL_MEMDESC_APERTURE_GET(memdesc, aperture_index);
GSL_MEMDESC_DEVICE_GET(memdesc, device_id);
shmem = &gsl_driver.shmem;
if (shmem->flags & GSL_FLAGS_INITIALIZED)
{
if (kgsl_memarena_isvirtualized(shmem->apertures[aperture_index].memarena))
{
status |= kgsl_mmu_unmap(&gsl_driver.device[device_id-1].mmu, memdesc->gpuaddr, memdesc->size, pid);
if (!GSL_MEMDESC_EXTALLOC_ISMARKED(memdesc))
{
status |= kgsl_hal_freephysical(memdesc->gpuaddr, memdesc->size / GSL_PAGESIZE, NULL);
}
}
kgsl_memarena_free(shmem->apertures[aperture_index].memarena, memdesc);
kgsl_memarena_free(shmem->memarena, memdesc);
// clear descriptor
memset(memdesc, 0, sizeof(gsl_memdesc_t));
@@ -458,7 +262,6 @@ kgsl_sharedmem_free(gsl_memdesc_t *memdesc)
int
kgsl_sharedmem_read0(const gsl_memdesc_t *memdesc, void *dst, unsigned int offsetbytes, unsigned int sizebytes, unsigned int touserspace)
{
int aperture_index;
gsl_sharedmem_t *shmem;
unsigned int gpuoffsetbytes;
@@ -466,8 +269,6 @@ kgsl_sharedmem_read0(const gsl_memdesc_t *memdesc, void *dst, unsigned int offse
"--> int kgsl_sharedmem_read(gsl_memdesc_t *memdesc=%M, void *dst=0x%08x, uint offsetbytes=%u, uint sizebytes=%u)\n",
memdesc, dst, offsetbytes, sizebytes );
GSL_MEMDESC_APERTURE_GET(memdesc, aperture_index);
if (GSL_MEMDESC_EXTALLOC_ISMARKED(memdesc))
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_read. Return value %B\n", GSL_FAILURE_BADPARAM );
@@ -486,19 +287,19 @@ kgsl_sharedmem_read0(const gsl_memdesc_t *memdesc, void *dst, unsigned int offse
DEBUG_ASSERT(dst);
DEBUG_ASSERT(sizebytes);
if (memdesc->gpuaddr < shmem->apertures[aperture_index].memarena->gpubaseaddr)
if (memdesc->gpuaddr < shmem->memarena->gpubaseaddr)
{
return (GSL_FAILURE_BADPARAM);
}
if (memdesc->gpuaddr + sizebytes > shmem->apertures[aperture_index].memarena->gpubaseaddr + shmem->apertures[aperture_index].memarena->sizebytes)
if ((memdesc->gpuaddr + sizebytes) > (shmem->memarena->gpubaseaddr + shmem->memarena->sizebytes))
{
return (GSL_FAILURE_BADPARAM);
}
gpuoffsetbytes = (memdesc->gpuaddr - shmem->apertures[aperture_index].memarena->gpubaseaddr) + offsetbytes;
gpuoffsetbytes = (memdesc->gpuaddr - shmem->memarena->gpubaseaddr) + offsetbytes;
GSL_HAL_MEM_READ(dst, shmem->apertures[aperture_index].memarena->hostbaseaddr, gpuoffsetbytes, sizebytes, touserspace);
GSL_HAL_MEM_READ(dst, shmem->memarena->hostbaseaddr, gpuoffsetbytes, sizebytes, touserspace);
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_read. Return value %B\n", GSL_SUCCESS );
@@ -522,7 +323,6 @@ kgsl_sharedmem_read(const gsl_memdesc_t *memdesc, void *dst, unsigned int offset
int
kgsl_sharedmem_write0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, void *src, unsigned int sizebytes, unsigned int fromuserspace)
{
int aperture_index;
gsl_sharedmem_t *shmem;
unsigned int gpuoffsetbytes;
@@ -530,8 +330,6 @@ kgsl_sharedmem_write0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, vo
"--> int kgsl_sharedmem_write(gsl_memdesc_t *memdesc=%M, uint offsetbytes=%u, void *src=0x%08x, uint sizebytes=%u)\n",
memdesc, offsetbytes, src, sizebytes );
GSL_MEMDESC_APERTURE_GET(memdesc, aperture_index);
if (GSL_MEMDESC_EXTALLOC_ISMARKED(memdesc))
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_write. Return value %B\n", GSL_FAILURE_BADPARAM );
@@ -549,12 +347,12 @@ kgsl_sharedmem_write0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, vo
DEBUG_ASSERT(src);
DEBUG_ASSERT(sizebytes);
DEBUG_ASSERT(memdesc->gpuaddr >= shmem->apertures[aperture_index].memarena->gpubaseaddr);
DEBUG_ASSERT((memdesc->gpuaddr + sizebytes) <= (shmem->apertures[aperture_index].memarena->gpubaseaddr + shmem->apertures[aperture_index].memarena->sizebytes));
DEBUG_ASSERT(memdesc->gpuaddr >= shmem->memarena->gpubaseaddr);
DEBUG_ASSERT((memdesc->gpuaddr + sizebytes) <= (shmem->memarena->gpubaseaddr + shmem->memarena->sizebytes));
gpuoffsetbytes = (memdesc->gpuaddr - shmem->apertures[aperture_index].memarena->gpubaseaddr) + offsetbytes;
gpuoffsetbytes = (memdesc->gpuaddr - shmem->memarena->gpubaseaddr) + offsetbytes;
GSL_HAL_MEM_WRITE(shmem->apertures[aperture_index].memarena->hostbaseaddr, gpuoffsetbytes, src, sizebytes, fromuserspace);
GSL_HAL_MEM_WRITE(shmem->memarena->hostbaseaddr, gpuoffsetbytes, src, sizebytes, fromuserspace);
KGSL_DEBUG(GSL_DBGFLAGS_PM4MEM, KGSL_DEBUG_DUMPMEMWRITE((memdesc->gpuaddr + offsetbytes), sizebytes, src));
@@ -582,7 +380,6 @@ kgsl_sharedmem_write(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, voi
int
kgsl_sharedmem_set0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsigned int value, unsigned int sizebytes)
{
int aperture_index;
gsl_sharedmem_t *shmem;
unsigned int gpuoffsetbytes;
@@ -590,8 +387,6 @@ kgsl_sharedmem_set0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsi
"--> int kgsl_sharedmem_set(gsl_memdesc_t *memdesc=%M, unsigned int offsetbytes=%d, unsigned int value=0x%08x, unsigned int sizebytes=%d)\n",
memdesc, offsetbytes, value, sizebytes );
GSL_MEMDESC_APERTURE_GET(memdesc, aperture_index);
if (GSL_MEMDESC_EXTALLOC_ISMARKED(memdesc))
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_set. Return value %B\n", GSL_FAILURE_BADPARAM );
@@ -608,12 +403,12 @@ kgsl_sharedmem_set0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsi
}
DEBUG_ASSERT(sizebytes);
DEBUG_ASSERT(memdesc->gpuaddr >= shmem->apertures[aperture_index].memarena->gpubaseaddr);
DEBUG_ASSERT((memdesc->gpuaddr + sizebytes) <= (shmem->apertures[aperture_index].memarena->gpubaseaddr + shmem->apertures[aperture_index].memarena->sizebytes));
DEBUG_ASSERT(memdesc->gpuaddr >= shmem->memarena->gpubaseaddr);
DEBUG_ASSERT((memdesc->gpuaddr + sizebytes) <= (shmem->memarena->gpubaseaddr + shmem->memarena->sizebytes));
gpuoffsetbytes = (memdesc->gpuaddr - shmem->apertures[aperture_index].memarena->gpubaseaddr) + offsetbytes;
gpuoffsetbytes = (memdesc->gpuaddr - shmem->memarena->gpubaseaddr) + offsetbytes;
GSL_HAL_MEM_SET(shmem->apertures[aperture_index].memarena->hostbaseaddr, gpuoffsetbytes, value, sizebytes);
GSL_HAL_MEM_SET(shmem->memarena->hostbaseaddr, gpuoffsetbytes, value, sizebytes);
KGSL_DEBUG(GSL_DBGFLAGS_PM4MEM, KGSL_DEBUG_DUMPMEMSET((memdesc->gpuaddr + offsetbytes), sizebytes, value));
@@ -641,9 +436,6 @@ kgsl_sharedmem_set(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsig
unsigned int
kgsl_sharedmem_largestfreeblock(gsl_deviceid_t device_id, gsl_flags_t flags)
{
gsl_apertureid_t aperture_id;
gsl_channelid_t channel_id;
int aperture_index;
unsigned int result = 0;
gsl_sharedmem_t *shmem;
@@ -656,9 +448,6 @@ kgsl_sharedmem_largestfreeblock(gsl_deviceid_t device_id, gsl_flags_t flags)
"--> int kgsl_sharedmem_largestfreeblock(gsl_deviceid_t device_id=%D, gsl_flags_t flags=%x)\n",
device_id, flags );
GSL_MEMFLAGS_APERTURE_GET(flags, aperture_id);
GSL_MEMFLAGS_CHANNEL_GET(flags, channel_id);
mutex_lock(&gsl_driver.lock);
shmem = &gsl_driver.shmem;
@@ -671,12 +460,7 @@ kgsl_sharedmem_largestfreeblock(gsl_deviceid_t device_id, gsl_flags_t flags)
return (0);
}
aperture_index = kgsl_sharedmem_getapertureindex(shmem, aperture_id, channel_id);
if (aperture_id == shmem->apertures[aperture_index].id)
{
result = kgsl_memarena_getlargestfreeblock(shmem->apertures[aperture_index].memarena, flags);
}
result = kgsl_memarena_getlargestfreeblock(shmem->memarena, flags);
mutex_unlock(&gsl_driver.lock);
@@ -692,7 +476,6 @@ kgsl_sharedmem_map(gsl_deviceid_t device_id, gsl_flags_t flags, const gsl_scatte
{
int status = GSL_FAILURE;
gsl_sharedmem_t *shmem = &gsl_driver.shmem;
int aperture_index;
gsl_deviceid_t tmp_id;
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE,
@@ -741,17 +524,14 @@ kgsl_sharedmem_map(gsl_deviceid_t device_id, gsl_flags_t flags, const gsl_scatte
if (shmem->flags & GSL_FLAGS_INITIALIZED)
{
aperture_index = kgsl_sharedmem_getapertureindex(shmem, GSL_APERTURE_EMEM, GSL_CHANNEL_1);
if (kgsl_memarena_isvirtualized(shmem->apertures[aperture_index].memarena))
if (kgsl_memarena_isvirtualized(shmem->memarena))
{
DEBUG_ASSERT(scatterlist->num);
DEBUG_ASSERT(scatterlist->pages);
status = kgsl_memarena_alloc(shmem->apertures[aperture_index].memarena, flags, scatterlist->num *GSL_PAGESIZE, memdesc);
status = kgsl_memarena_alloc(shmem->memarena, flags, scatterlist->num *GSL_PAGESIZE, memdesc);
if (status == GSL_SUCCESS)
{
GSL_MEMDESC_APERTURE_SET(memdesc, aperture_index);
GSL_MEMDESC_DEVICE_SET(memdesc, device_id);
// mark descriptor's memory as externally allocated -- i.e. outside GSL
@@ -760,7 +540,7 @@ kgsl_sharedmem_map(gsl_deviceid_t device_id, gsl_flags_t flags, const gsl_scatte
status = kgsl_mmu_map(&gsl_driver.device[device_id-1].mmu, memdesc->gpuaddr, scatterlist, flags, current->tgid);
if (status != GSL_SUCCESS)
{
kgsl_memarena_free(shmem->apertures[aperture_index].memarena, memdesc);
kgsl_memarena_free(shmem->memarena, memdesc);
}
}
}
@@ -785,7 +565,6 @@ int
kgsl_sharedmem_getmap(const gsl_memdesc_t *memdesc, gsl_scatterlist_t *scatterlist)
{
int status = GSL_SUCCESS;
int aperture_index;
gsl_deviceid_t device_id;
gsl_sharedmem_t *shmem;
@@ -793,7 +572,6 @@ kgsl_sharedmem_getmap(const gsl_memdesc_t *memdesc, gsl_scatterlist_t *scatterli
"--> int kgsl_sharedmem_getmap(gsl_memdesc_t *memdesc=%M, gsl_scatterlist_t scatterlist=%S)\n",
memdesc, scatterlist );
GSL_MEMDESC_APERTURE_GET(memdesc, aperture_index);
GSL_MEMDESC_DEVICE_GET(memdesc, device_id);
shmem = &gsl_driver.shmem;
@@ -802,12 +580,12 @@ kgsl_sharedmem_getmap(const gsl_memdesc_t *memdesc, gsl_scatterlist_t *scatterli
{
DEBUG_ASSERT(scatterlist->num);
DEBUG_ASSERT(scatterlist->pages);
DEBUG_ASSERT(memdesc->gpuaddr >= shmem->apertures[aperture_index].memarena->gpubaseaddr);
DEBUG_ASSERT((memdesc->gpuaddr + memdesc->size) <= (shmem->apertures[aperture_index].memarena->gpubaseaddr + shmem->apertures[aperture_index].memarena->sizebytes));
DEBUG_ASSERT(memdesc->gpuaddr >= shmem->memarena->gpubaseaddr);
DEBUG_ASSERT((memdesc->gpuaddr + memdesc->size) <= (shmem->memarena->gpubaseaddr + shmem->memarena->sizebytes));
memset(scatterlist->pages, 0, sizeof(unsigned int) * scatterlist->num);
if (kgsl_memarena_isvirtualized(shmem->apertures[aperture_index].memarena))
if (kgsl_memarena_isvirtualized(shmem->memarena))
{
status = kgsl_mmu_getmap(&gsl_driver.device[device_id-1].mmu, memdesc->gpuaddr, memdesc->size, scatterlist, current->tgid);
}
@@ -826,60 +604,18 @@ kgsl_sharedmem_getmap(const gsl_memdesc_t *memdesc, gsl_scatterlist_t *scatterli
//----------------------------------------------------------------------------
int
kgsl_sharedmem_querystats(gsl_sharedmem_t *shmem, gsl_sharedmem_stats_t *stats)
{
#ifdef GSL_STATS_MEM
int status = GSL_SUCCESS;
int i;
DEBUG_ASSERT(stats);
if (shmem->flags & GSL_FLAGS_INITIALIZED)
{
for (i = 0; i < shmem->numapertures; i++)
{
if (shmem->apertures[i].memarena)
{
stats->apertures[i].id = shmem->apertures[i].id;
stats->apertures[i].channel = shmem->apertures[i].channel;
status |= kgsl_memarena_querystats(shmem->apertures[i].memarena, &stats->apertures[i].memarena);
}
}
}
else
{
memset(stats, 0, sizeof(gsl_sharedmem_stats_t));
}
return (status);
#else
// unreferenced formal parameters
(void) shmem;
(void) stats;
return (GSL_FAILURE_NOTSUPPORTED);
#endif // GSL_STATS_MEM
}
//----------------------------------------------------------------------------
unsigned int
kgsl_sharedmem_convertaddr(unsigned int addr, int type)
{
gsl_sharedmem_t *shmem = &gsl_driver.shmem;
unsigned int cvtaddr = 0;
unsigned int gpubaseaddr, hostbaseaddr, sizebytes;
int i;
if ((shmem->flags & GSL_FLAGS_INITIALIZED))
{
for (i = 0; i < shmem->numapertures; i++)
{
hostbaseaddr = shmem->apertures[i].memarena->hostbaseaddr;
gpubaseaddr = shmem->apertures[i].memarena->gpubaseaddr;
sizebytes = shmem->apertures[i].memarena->sizebytes;
hostbaseaddr = shmem->memarena->hostbaseaddr;
gpubaseaddr = shmem->memarena->gpubaseaddr;
sizebytes = shmem->memarena->sizebytes;
// convert from gpu to host
if (type == 0)
@@ -887,7 +623,6 @@ kgsl_sharedmem_convertaddr(unsigned int addr, int type)
if (addr >= gpubaseaddr && addr < (gpubaseaddr + sizebytes))
{
cvtaddr = hostbaseaddr + (addr - gpubaseaddr);
break;
}
}
// convert from host to gpu
@@ -896,10 +631,8 @@ kgsl_sharedmem_convertaddr(unsigned int addr, int type)
if (addr >= hostbaseaddr && addr < (hostbaseaddr + sizebytes))
{
cvtaddr = gpubaseaddr + (addr - hostbaseaddr);
break;
}
}
}
}
return (cvtaddr);

21
drivers/mxc/amd-gpu/include/gsl_hal.h
View File

@@ -88,32 +88,21 @@ typedef struct _gsl_devconfig_t {
} gsl_devconfig_t;
// ----------------------
// memory aperture config
// ----------------------
typedef struct _gsl_apertureconfig_t
{
gsl_apertureid_t id;
gsl_channelid_t channel;
unsigned int hostbase;
unsigned int gpubase;
unsigned int sizebytes;
} gsl_apertureconfig_t;
// --------------------
// shared memory config
// --------------------
typedef struct _gsl_shmemconfig_t
typedef struct _gsl_shmemconfig_t
{
int numapertures;
gsl_apertureconfig_t apertures[GSL_SHMEM_MAX_APERTURES];
unsigned int emem_hostbase;
unsigned int emem_gpubase;
unsigned int emem_sizebytes;
} gsl_shmemconfig_t;
typedef struct _gsl_hal_t {
gsl_memregion_t z160_regspace;
gsl_memregion_t z430_regspace;
gsl_memregion_t memchunk;
gsl_memregion_t memspace[GSL_SHMEM_MAX_APERTURES];
gsl_memregion_t memspace;
unsigned int has_z160;
unsigned int has_z430;
} gsl_hal_t;

2
drivers/mxc/amd-gpu/include/gsl_memmgr.h
View File

@@ -111,7 +111,7 @@ typedef struct _gsl_memarena_t {
//////////////////////////////////////////////////////////////////////////////
// prototypes
//////////////////////////////////////////////////////////////////////////////
gsl_memarena_t* kgsl_memarena_create(int aperture_id, int mmu_virtualized, unsigned int hostbaseaddr, gpuaddr_t gpubaseaddr, int sizebytes);
gsl_memarena_t* kgsl_memarena_create(int mmu_virtualized, unsigned int hostbaseaddr, gpuaddr_t gpubaseaddr, int sizebytes);
int kgsl_memarena_destroy(gsl_memarena_t *memarena);
int kgsl_memarena_isvirtualized(gsl_memarena_t *memarena);
int kgsl_memarena_querystats(gsl_memarena_t *memarena, gsl_memarena_stats_t *stats);

44
drivers/mxc/amd-gpu/include/gsl_sharedmem.h
View File

@@ -34,53 +34,22 @@
// defines
//////////////////////////////////////////////////////////////////////////////
#define GSL_APERTURE_MASK 0x000000FF
#define GSL_DEVICEID_MASK 0x0000FF00
#define GSL_EXTALLOC_MASK 0x000F0000
#define GSL_APERTURE_SHIFT 0
#define GSL_DEVICEID_SHIFT 8
#define GSL_EXTALLOC_SHIFT 16
#define GSL_APERTURE_GETGPUADDR(shmem, aperture_index) \
shmem.apertures[aperture_index].memarena->gpubaseaddr;
#define GSL_SHMEM_MEMARENA_GETGPUADDR(shmem) shmem.memarena->gpubaseaddr;
#define GSL_SHMEM_MEMARENA_GETHOSTADDR(shmem) shmem.memarena->hostbaseaddr;
#define GSL_APERTURE_GETHOSTADDR(shmem, aperture_index) \
shmem.apertures[aperture_index].memarena->hostbaseaddr;
#define GSL_APERTURE_MASK 0x000000FF
#define GSL_APERTURE_SHIFT 0
//////////////////////////////////////////////////////////////////////////////
// types
//////////////////////////////////////////////////////////////////////////////
// ---------------------
// memory aperture stats
// ---------------------
typedef struct _gsl_aperture_stats_t
{
gsl_apertureid_t id;
gsl_channelid_t channel;
gsl_memarena_stats_t memarena;
} gsl_aperture_stats_t;
// -------------------
// shared memory stats
// -------------------
typedef struct _gsl_sharedmem_stats_t
{
gsl_aperture_stats_t apertures[GSL_SHMEM_MAX_APERTURES];
} gsl_sharedmem_stats_t;
// ---------------
// memory aperture
// ---------------
typedef struct _gsl_aperture_t
{
gsl_apertureid_t id;
gsl_channelid_t channel;
int numbanks;
gsl_memarena_t *memarena;
} gsl_aperture_t;
// --------------------
// shared memory object
// --------------------
@@ -88,9 +57,7 @@ typedef struct _gsl_sharedmem_t
{
gsl_flags_t flags;
unsigned int priv;
int numapertures;
gsl_aperture_t apertures[GSL_SHMEM_MAX_APERTURES];
int aperturelookup[GSL_APERTURE_MAX][GSL_CHANNEL_MAX];
gsl_memarena_t *memarena;
} gsl_sharedmem_t;
@@ -104,7 +71,6 @@ int kgsl_sharedmem_free0(gsl_memdesc_t *memdesc, unsigned int pid);
int kgsl_sharedmem_read0(const gsl_memdesc_t *memdesc, void *dst, unsigned int offsetbytes, unsigned int sizebytes, unsigned int touserspace);
int kgsl_sharedmem_write0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, void *src, unsigned int sizebytes, unsigned int fromuserspace);
int kgsl_sharedmem_set0(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsigned int value, unsigned int sizebytes);
int kgsl_sharedmem_querystats(gsl_sharedmem_t *shmem, gsl_sharedmem_stats_t *stats);
unsigned int kgsl_sharedmem_convertaddr(unsigned int addr, int type);
#endif // __GSL_SHAREDMEM_H