summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorr80085 <thomas.peng@freescale.com>2010-07-19 18:00:16 -0500
committerJustin Waters <justin.waters@timesys.com>2010-12-17 12:10:52 -0500
commitd93d51e0de7f8162e7fa4185872cad8ac11ae530 (patch)
tree0249648af8a697fe044c81589eee0f6dcde90bc7
parentee7ed985bb53ccba77007393c8be2d14c8a2cdf2 (diff)
ENGR00125256 Integrate AMD Rc16/EA VG/GL fix to GPU kernel module
Fix the VG/GL issue in GPU kernel module when running VG/GL at the same time Signed-off-by: Gene Chouiniere <Gene.Chouiniere@amd.com> Signed-off-by: r80085 <thomas.peng@freescale.com> Acked-by: Rob Herring <r.herring@freescale.com>
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_cmdstream.c109
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_cmdwindow.c52
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_device.c19
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_drawctxt.c63
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_g12.c176
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_intrmgr.c10
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_memmgr.c4
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_mmu.c95
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_ringbuffer.c122
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_sharedmem.c100
-rw-r--r--drivers/mxc/amd-gpu/common/gsl_yamato.c77
-rw-r--r--drivers/mxc/amd-gpu/include/gsl_cmdstream.h5
-rw-r--r--drivers/mxc/amd-gpu/include/gsl_cmdwindow.h1
-rw-r--r--drivers/mxc/amd-gpu/include/gsl_device.h3
-rw-r--r--drivers/mxc/amd-gpu/include/gsl_mmu.h1
-rw-r--r--drivers/mxc/amd-gpu/include/gsl_ringbuffer.h19
-rw-r--r--drivers/mxc/amd-gpu/include/gsl_sharedmem.h5
-rw-r--r--drivers/mxc/amd-gpu/os/kernel/include/kos_libapi.h18
-rw-r--r--drivers/mxc/amd-gpu/os/kernel/src/linux/kos_lib.c447
-rw-r--r--drivers/mxc/amd-gpu/platform/hal/MX35/gsl_buildconfig.h2
-rw-r--r--drivers/mxc/amd-gpu/platform/hal/MX35/linux/gsl_hal.c7
-rw-r--r--drivers/mxc/amd-gpu/platform/hal/MX51/gsl_buildconfig.h2
-rw-r--r--drivers/mxc/amd-gpu/platform/hal/MX51/linux/gsl_hal.c10
-rw-r--r--drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod.c206
-rw-r--r--drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod_cleanup.c4
25 files changed, 517 insertions, 1040 deletions
diff --git a/drivers/mxc/amd-gpu/common/gsl_cmdstream.c b/drivers/mxc/amd-gpu/common/gsl_cmdstream.c
index 3c587281427b..338192c7ba32 100644
--- a/drivers/mxc/amd-gpu/common/gsl_cmdstream.c
+++ b/drivers/mxc/amd-gpu/common/gsl_cmdstream.c
@@ -20,20 +20,6 @@
#include "gsl_hal.h"
#include "gsl_cmdstream.h"
-#ifdef GSL_LOCKING_FINEGRAIN
-#define GSL_CMDSTREAM_MUTEX_CREATE() device->cmdstream_mutex = kos_mutex_create("gsl_cmdstream"); \
- if (!device->cmdstream_mutex) return (GSL_FAILURE);
-#define GSL_CMDSTREAM_MUTEX_LOCK() kos_mutex_lock(device->cmdstream_mutex)
-#define GSL_CMDSTREAM_MUTEX_UNLOCK() kos_mutex_unlock(device->cmdstream_mutex)
-#define GSL_CMDSTREAM_MUTEX_FREE() kos_mutex_free(device->cmdstream_mutex); device->cmdstream_mutex = 0;
-#else
-#define GSL_CMDSTREAM_MUTEX_CREATE() (void) device // unreferenced formal parameter
-#define GSL_CMDSTREAM_MUTEX_LOCK()
-#define GSL_CMDSTREAM_MUTEX_UNLOCK()
-#define GSL_CMDSTREAM_MUTEX_FREE() (void) device // unreferenced formal parameter
-#endif
-
-
//////////////////////////////////////////////////////////////////////////////
// functions
//////////////////////////////////////////////////////////////////////////////
@@ -41,8 +27,6 @@
int
kgsl_cmdstream_init(gsl_device_t *device)
{
- GSL_CMDSTREAM_MUTEX_CREATE();
-
return GSL_SUCCESS;
}
@@ -51,29 +35,21 @@ kgsl_cmdstream_init(gsl_device_t *device)
int
kgsl_cmdstream_close(gsl_device_t *device)
{
- GSL_CMDSTREAM_MUTEX_FREE();
-
return GSL_SUCCESS;
}
//----------------------------------------------------------------------------
-KGSL_API gsl_timestamp_t
-kgsl_cmdstream_readtimestamp(gsl_deviceid_t device_id, gsl_timestamp_type_t type)
+gsl_timestamp_t
+kgsl_cmdstream_readtimestamp0(gsl_deviceid_t device_id, gsl_timestamp_type_t type)
{
gsl_timestamp_t timestamp = -1;
gsl_device_t* device = &gsl_driver.device[device_id-1];
-
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE,
"--> gsl_timestamp_t kgsl_cmdstream_readtimestamp(gsl_deviceid_t device_id=%d gsl_timestamp_type_t type=%d)\n", device_id, type );
-
- GSL_API_MUTEX_LOCK();
-
#if (defined(GSL_BLD_G12) && defined(IRQTHREAD_POLL))
kos_event_signal(device->irqthread_event);
#endif
-
-
if (type == GSL_TIMESTAMP_CONSUMED)
{
// start-of-pipeline timestamp
@@ -81,38 +57,40 @@ kgsl_cmdstream_readtimestamp(gsl_deviceid_t device_id, gsl_timestamp_type_t type
}
else if (type == GSL_TIMESTAMP_RETIRED)
{
- // end-of-pipeline timestamp
- GSL_CMDSTREAM_GET_EOP_TIMESTAMP(device, (unsigned int*)&timestamp);
- }
-
- GSL_API_MUTEX_UNLOCK();
-
+ // end-of-pipeline timestamp
+ GSL_CMDSTREAM_GET_EOP_TIMESTAMP(device, (unsigned int*)&timestamp);
+ }
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_ringbuffer_readtimestamp. Return value %d\n", timestamp );
-
return (timestamp);
}
//----------------------------------------------------------------------------
+KGSL_API gsl_timestamp_t
+kgsl_cmdstream_readtimestamp(gsl_deviceid_t device_id, gsl_timestamp_type_t type)
+{
+ gsl_timestamp_t timestamp = -1;
+ GSL_API_MUTEX_LOCK();
+ timestamp = kgsl_cmdstream_readtimestamp0(device_id, type);
+ GSL_API_MUTEX_UNLOCK();
+ return timestamp;
+}
+
+//----------------------------------------------------------------------------
+
KGSL_API int
kgsl_cmdstream_issueibcmds(gsl_deviceid_t device_id, int drawctxt_index, gpuaddr_t ibaddr, int sizedwords, gsl_timestamp_t *timestamp, unsigned int flags)
{
gsl_device_t* device = &gsl_driver.device[device_id-1];
- int status;
-
+ int status = GSL_FAILURE;
GSL_API_MUTEX_LOCK();
-
+
kgsl_device_active(device);
-
+
if (device->ftbl.cmdstream_issueibcmds)
{
status = device->ftbl.cmdstream_issueibcmds(device, drawctxt_index, ibaddr, sizedwords, timestamp, flags);
}
- else
- {
- status = GSL_FAILURE;
- }
-
GSL_API_MUTEX_UNLOCK();
return status;
}
@@ -123,19 +101,12 @@ KGSL_API int
kgsl_add_timestamp(gsl_deviceid_t device_id, gsl_timestamp_t *timestamp)
{
gsl_device_t* device = &gsl_driver.device[device_id-1];
- int status;
-
+ int status = GSL_FAILURE;
GSL_API_MUTEX_LOCK();
-
if (device->ftbl.device_addtimestamp)
{
status = device->ftbl.device_addtimestamp(device, timestamp);
}
- else
- {
- status = GSL_FAILURE;
- }
-
GSL_API_MUTEX_UNLOCK();
return status;
}
@@ -147,7 +118,6 @@ int kgsl_cmdstream_waittimestamp(gsl_deviceid_t device_id, gsl_timestamp_t times
{
gsl_device_t* device = &gsl_driver.device[device_id-1];
int status = GSL_FAILURE;
-
if (device->ftbl.device_waittimestamp)
{
status = device->ftbl.device_waittimestamp(device, timestamp, timeout);
@@ -163,36 +133,25 @@ kgsl_cmdstream_memqueue_drain(gsl_device_t *device)
gsl_memnode_t *memnode, *nextnode, *freehead;
gsl_timestamp_t timestamp, ts_processed;
gsl_memqueue_t *memqueue = &device->memqueue;
-
- GSL_CMDSTREAM_MUTEX_LOCK();
-
// check head
if (memqueue->head == NULL)
{
- GSL_CMDSTREAM_MUTEX_UNLOCK();
return;
}
-
// get current EOP timestamp
- ts_processed = kgsl_cmdstream_readtimestamp(device->id, GSL_TIMESTAMP_RETIRED);
-
+ ts_processed = kgsl_cmdstream_readtimestamp0(device->id, GSL_TIMESTAMP_RETIRED);
timestamp = memqueue->head->timestamp;
-
// check head timestamp
if (!(((ts_processed - timestamp) >= 0) || ((ts_processed - timestamp) < -20000)))
{
- GSL_CMDSTREAM_MUTEX_UNLOCK();
return;
}
-
memnode = memqueue->head;
freehead = memqueue->head;
-
// get node list to free
for(;;)
{
nextnode = memnode->next;
-
if (nextnode == NULL)
{
// entire queue drained
@@ -200,9 +159,7 @@ kgsl_cmdstream_memqueue_drain(gsl_device_t *device)
memqueue->tail = NULL;
break;
}
-
timestamp = nextnode->timestamp;
-
if (!(((ts_processed - timestamp) >= 0) || ((ts_processed - timestamp) < -20000)))
{
// drained up to a point
@@ -210,12 +167,8 @@ kgsl_cmdstream_memqueue_drain(gsl_device_t *device)
memnode->next = NULL;
break;
}
-
memnode = nextnode;
}
-
- GSL_CMDSTREAM_MUTEX_UNLOCK();
-
// free nodes
while (freehead)
{
@@ -231,17 +184,21 @@ kgsl_cmdstream_memqueue_drain(gsl_device_t *device)
int
kgsl_cmdstream_freememontimestamp(gsl_deviceid_t device_id, gsl_memdesc_t *memdesc, gsl_timestamp_t timestamp, gsl_timestamp_type_t type)
{
- gsl_memnode_t *memnode;
- gsl_device_t* device = &gsl_driver.device[device_id-1];
- gsl_memqueue_t *memqueue = &device->memqueue;
+ gsl_memnode_t *memnode;
+ gsl_device_t *device = &gsl_driver.device[device_id-1];
+ gsl_memqueue_t *memqueue;
+ (void)type; // unref. For now just use EOP timestamp
+
+ GSL_API_MUTEX_LOCK();
- (void) type; // unref. For now just use EOP timestamp
+ memqueue = &device->memqueue;
memnode = kos_malloc(sizeof(gsl_memnode_t));
if (!memnode)
{
// other solution is to idle and free which given that the upper level driver probably wont check, probably a better idea
+ GSL_API_MUTEX_UNLOCK();
return (GSL_FAILURE);
}
@@ -250,8 +207,6 @@ kgsl_cmdstream_freememontimestamp(gsl_deviceid_t device_id, gsl_memdesc_t *memde
memnode->next = NULL;
kos_memcpy(&memnode->memdesc, memdesc, sizeof(gsl_memdesc_t));
- GSL_CMDSTREAM_MUTEX_LOCK();
-
// add to end of queue
if (memqueue->tail != NULL)
{
@@ -265,7 +220,7 @@ kgsl_cmdstream_freememontimestamp(gsl_deviceid_t device_id, gsl_memdesc_t *memde
memqueue->tail = memnode;
}
- GSL_CMDSTREAM_MUTEX_UNLOCK();
+ GSL_API_MUTEX_UNLOCK();
return (GSL_SUCCESS);
}
@@ -279,6 +234,6 @@ static int kgsl_cmdstream_timestamp_cmp(gsl_timestamp_t ts_new, gsl_timestamp_t
int kgsl_cmdstream_check_timestamp(gsl_deviceid_t device_id, gsl_timestamp_t timestamp)
{
gsl_timestamp_t ts_processed;
- ts_processed = kgsl_cmdstream_readtimestamp(device_id, GSL_TIMESTAMP_RETIRED);
+ ts_processed = kgsl_cmdstream_readtimestamp0(device_id, GSL_TIMESTAMP_RETIRED);
return kgsl_cmdstream_timestamp_cmp(ts_processed, timestamp);
}
diff --git a/drivers/mxc/amd-gpu/common/gsl_cmdwindow.c b/drivers/mxc/amd-gpu/common/gsl_cmdwindow.c
index ea106a2735af..4d70da5b25c8 100644
--- a/drivers/mxc/amd-gpu/common/gsl_cmdwindow.c
+++ b/drivers/mxc/amd-gpu/common/gsl_cmdwindow.c
@@ -31,31 +31,12 @@
//////////////////////////////////////////////////////////////////////////////
-// macros
-//////////////////////////////////////////////////////////////////////////////
-#ifdef GSL_LOCKING_FINEGRAIN
-#define GSL_CMDWINDOW_MUTEX_CREATE() device->cmdwindow_mutex = kos_mutex_create("gsl_cmdwindow"); \
- if (!device->cmdwindow_mutex) return (GSL_FAILURE);
-#define GSL_CMDWINDOW_MUTEX_LOCK() kos_mutex_lock(device->cmdwindow_mutex)
-#define GSL_CMDWINDOW_MUTEX_UNLOCK() kos_mutex_unlock(device->cmdwindow_mutex)
-#define GSL_CMDWINDOW_MUTEX_FREE() kos_mutex_free(device->cmdwindow_mutex); device->cmdwindow_mutex = 0;
-#else
-#define GSL_CMDWINDOW_MUTEX_CREATE() (void) device // unreferenced formal parameter
-#define GSL_CMDWINDOW_MUTEX_LOCK()
-#define GSL_CMDWINDOW_MUTEX_UNLOCK()
-#define GSL_CMDWINDOW_MUTEX_FREE() (void) device // unreferenced formal parameter
-#endif
-
-
-//////////////////////////////////////////////////////////////////////////////
// functions
//////////////////////////////////////////////////////////////////////////////
int
kgsl_cmdwindow_init(gsl_device_t *device)
{
- GSL_CMDWINDOW_MUTEX_CREATE();
-
return (GSL_SUCCESS);
}
@@ -64,8 +45,6 @@ kgsl_cmdwindow_init(gsl_device_t *device)
int
kgsl_cmdwindow_close(gsl_device_t *device)
{
- GSL_CMDWINDOW_MUTEX_FREE();
-
return (GSL_SUCCESS);
}
@@ -73,8 +52,8 @@ kgsl_cmdwindow_close(gsl_device_t *device)
//----------------------------------------------------------------------------
-KGSL_API int
-kgsl_cmdwindow_write(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned int addr, unsigned int data)
+int
+kgsl_cmdwindow_write0(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned int addr, unsigned int data)
{
#ifdef GSL_BLD_G12
gsl_device_t *device;
@@ -84,14 +63,10 @@ kgsl_cmdwindow_write(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE,
"--> int kgsl_cmdwindow_write( gsl_device_id_t device_id=%d, gsl_cmdwindow_t target=%d, unsigned int addr=0x%08x, unsigned int data=0x%08x)\n", device_id, target, addr, data );
- GSL_API_MUTEX_LOCK();
-
device = &gsl_driver.device[device_id-1]; // device_id is 1 based
if (target < GSL_CMDWINDOW_MIN || target > GSL_CMDWINDOW_MAX)
{
- GSL_API_MUTEX_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_ERROR, "ERROR: Invalid target.\n" );
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_cmdwindow_write. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
@@ -100,7 +75,6 @@ kgsl_cmdwindow_write(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned
if ((!(device->flags & GSL_FLAGS_INITIALIZED) && target == GSL_CMDWINDOW_MMU) ||
(!(device->flags & GSL_FLAGS_STARTED) && target != GSL_CMDWINDOW_MMU))
{
- GSL_API_MUTEX_UNLOCK();
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_ERROR, "ERROR: Invalid device state to write to selected targer.\n" );
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_cmdwindow_write. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
@@ -110,7 +84,6 @@ kgsl_cmdwindow_write(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned
if (target == GSL_CMDWINDOW_MMU)
{
#ifdef GSL_NO_MMU
- GSL_API_MUTEX_UNLOCK();
return (GSL_SUCCESS);
#endif
cmdstream = ADDR_VGC_MMUCOMMANDSTREAM;
@@ -125,21 +98,16 @@ kgsl_cmdwindow_write(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned
cmdwinaddr = ((target << GSL_CMDWINDOW_TARGET_SHIFT) & GSL_CMDWINDOW_TARGET_MASK);
cmdwinaddr |= ((addr << GSL_CMDWINDOW_ADDR_SHIFT) & GSL_CMDWINDOW_ADDR_MASK);
- GSL_CMDWINDOW_MUTEX_LOCK();
-
#ifndef GSL_NO_MMU
// set mmu pagetable
kgsl_mmu_setpagetable(device, GSL_CALLER_PROCESSID_GET());
#endif
// write command window address
- kgsl_device_regwrite(device_id, (cmdstream)>>2, cmdwinaddr);
+ device->ftbl.device_regwrite(device, (cmdstream)>>2, cmdwinaddr);
// write data
- kgsl_device_regwrite(device_id, (cmdstream)>>2, data);
-
- GSL_CMDWINDOW_MUTEX_UNLOCK();
- GSL_API_MUTEX_UNLOCK();
+ device->ftbl.device_regwrite(device, (cmdstream)>>2, data);
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_cmdwindow_write. Return value %B\n", GSL_SUCCESS );
@@ -154,3 +122,15 @@ kgsl_cmdwindow_write(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned
return (GSL_FAILURE);
#endif // GSL_BLD_G12
}
+
+//----------------------------------------------------------------------------
+
+KGSL_API int
+kgsl_cmdwindow_write(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned int addr, unsigned int data)
+{
+ int status = GSL_SUCCESS;
+ GSL_API_MUTEX_LOCK();
+ status = kgsl_cmdwindow_write0(device_id, target, addr, data);
+ GSL_API_MUTEX_UNLOCK();
+ return status;
+}
diff --git a/drivers/mxc/amd-gpu/common/gsl_device.c b/drivers/mxc/amd-gpu/common/gsl_device.c
index b748acb9d0d4..9ebe2abe78b0 100644
--- a/drivers/mxc/amd-gpu/common/gsl_device.c
+++ b/drivers/mxc/amd-gpu/common/gsl_device.c
@@ -15,7 +15,7 @@
* 02110-1301, USA.
*
*/
-
+
#include "gsl.h"
#include "gsl_hal.h"
@@ -96,13 +96,13 @@ kgsl_device_init(gsl_device_t *device, gsl_deviceid_t device_id)
}
// allocate memory store
- status = kgsl_sharedmem_alloc(device->id, GSL_MEMFLAGS_ALIGNPAGE | GSL_MEMFLAGS_CONPHYS, sizeof(gsl_devmemstore_t), &device->memstore);
+ status = kgsl_sharedmem_alloc0(device->id, GSL_MEMFLAGS_ALIGNPAGE | GSL_MEMFLAGS_CONPHYS, sizeof(gsl_devmemstore_t), &device->memstore);
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX,
{
// dumpx needs this to be in EMEM0 aperture
- kgsl_sharedmem_free(&device->memstore);
- status = kgsl_sharedmem_alloc(device->id, GSL_MEMFLAGS_ALIGNPAGE, sizeof(gsl_devmemstore_t), &device->memstore);
+ kgsl_sharedmem_free0(&device->memstore, GSL_CALLER_PROCESSID_GET());
+ status = kgsl_sharedmem_alloc0(device->id, GSL_MEMFLAGS_ALIGNPAGE, sizeof(gsl_devmemstore_t), &device->memstore);
});
if (status != GSL_SUCCESS)
@@ -110,7 +110,7 @@ kgsl_device_init(gsl_device_t *device, gsl_deviceid_t device_id)
kgsl_device_stop(device->id);
return (status);
}
- kgsl_sharedmem_set(&device->memstore, 0, 0, device->memstore.size);
+ kgsl_sharedmem_set0(&device->memstore, 0, 0, device->memstore.size);
// init memqueue
device->memqueue.head = NULL;
@@ -174,7 +174,7 @@ kgsl_device_close(gsl_device_t *device)
// DumpX allocates memstore from MMU aperture
if (device->memstore.hostptr && !(gsl_driver.flags_debug & GSL_DBGFLAGS_DUMPX))
{
- kgsl_sharedmem_free(&device->memstore);
+ kgsl_sharedmem_free0(&device->memstore, GSL_CALLER_PROCESSID_GET());
}
#ifndef _LINUX
@@ -418,9 +418,9 @@ kgsl_device_start(gsl_deviceid_t device_id, gsl_flags_t flags)
GSL_API_MUTEX_LOCK();
device = &gsl_driver.device[device_id-1]; // device_id is 1 based
-
+
kgsl_device_active(device);
-
+
if (!(device->flags & GSL_FLAGS_INITIALIZED))
{
GSL_API_MUTEX_UNLOCK();
@@ -515,7 +515,7 @@ kgsl_device_idle(gsl_deviceid_t device_id, unsigned int timeout)
device = &gsl_driver.device[device_id-1]; // device_id is 1 based
kgsl_device_active(device);
-
+
if (device->ftbl.device_idle)
{
status = device->ftbl.device_idle(device, timeout);
@@ -646,3 +646,4 @@ kgsl_device_runpending(gsl_device_t *device)
return (status);
}
+
diff --git a/drivers/mxc/amd-gpu/common/gsl_drawctxt.c b/drivers/mxc/amd-gpu/common/gsl_drawctxt.c
index 14c413e8e908..afa44e618794 100644
--- a/drivers/mxc/amd-gpu/common/gsl_drawctxt.c
+++ b/drivers/mxc/amd-gpu/common/gsl_drawctxt.c
@@ -117,23 +117,6 @@
#define CONTEXT_SIZE (SHADER_OFFSET + 3 * SHADER_SHADOW_SIZE)
-/////////////////////////////////////////////////////////////////////////////
-// macros
-//////////////////////////////////////////////////////////////////////////////
-#ifdef GSL_LOCKING_FINEGRAIN
-#define GSL_CONTEXT_MUTEX_CREATE() device->drawctxt_mutex = kos_mutex_create("gsl_drawctxt"); \
- if (!device->drawctxt_mutex) {return (GSL_FAILURE);}
-#define GSL_CONTEXT_MUTEX_LOCK() kos_mutex_lock(device->drawctxt_mutex)
-#define GSL_CONTEXT_MUTEX_UNLOCK() kos_mutex_unlock(device->drawctxt_mutex)
-#define GSL_CONTEXT_MUTEX_FREE() kos_mutex_free(device->drawctxt_mutex); device->drawctxt_mutex = 0;
-#else
-#define GSL_CONTEXT_MUTEX_CREATE() (void) device // unreferenced formal parameter
-#define GSL_CONTEXT_MUTEX_LOCK()
-#define GSL_CONTEXT_MUTEX_UNLOCK()
-#define GSL_CONTEXT_MUTEX_FREE() (void) device // unreferenced formal parameter
-#endif
-
-
//////////////////////////////////////////////////////////////////////////////
// temporary work structure
//////////////////////////////////////////////////////////////////////////////
@@ -1279,13 +1262,13 @@ create_gpustate_shadow(gsl_device_t *device, gsl_drawctxt_t *drawctxt, ctx_t *ct
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, flags = (GSL_MEMFLAGS_EMEM | GSL_MEMFLAGS_ALIGN8K));
// allocate memory to allow HW to save sub-blocks for efficient context save/restore
- if (kgsl_sharedmem_alloc(device->id, flags, CONTEXT_SIZE, &drawctxt->gpustate) != GSL_SUCCESS)
+ if (kgsl_sharedmem_alloc0(device->id, flags, CONTEXT_SIZE, &drawctxt->gpustate) != GSL_SUCCESS)
return GSL_FAILURE;
drawctxt->flags |= CTXT_FLAGS_STATE_SHADOW;
// Blank out h/w register, constant, and command buffer shadows.
- kgsl_sharedmem_set(&drawctxt->gpustate, 0, 0, CONTEXT_SIZE);
+ kgsl_sharedmem_set0(&drawctxt->gpustate, 0, 0, CONTEXT_SIZE);
// set-up command and vertex buffer pointers
ctx->cmd = ctx->start = (unsigned int *) ((char *)drawctxt->gpustate.hostptr + CMD_OFFSET);
@@ -1307,12 +1290,12 @@ static int
allocate_gmem_shadow_buffer(gsl_device_t *device, gsl_drawctxt_t *drawctxt)
{
// allocate memory for GMEM shadow
- if (kgsl_sharedmem_alloc(device->id, (GSL_MEMFLAGS_EMEM | GSL_MEMFLAGS_ALIGN8K),
+ if (kgsl_sharedmem_alloc0(device->id, (GSL_MEMFLAGS_CONPHYS | GSL_MEMFLAGS_ALIGN8K),
drawctxt->context_gmem_shadow.size, &drawctxt->context_gmem_shadow.gmemshadow) != GSL_SUCCESS)
return GSL_FAILURE;
// blank out gmem shadow.
- kgsl_sharedmem_set(&drawctxt->context_gmem_shadow.gmemshadow, 0, 0, drawctxt->context_gmem_shadow.size);
+ kgsl_sharedmem_set0(&drawctxt->context_gmem_shadow.gmemshadow, 0, 0, drawctxt->context_gmem_shadow.size);
return GSL_SUCCESS;
}
@@ -1375,8 +1358,6 @@ create_gmem_shadow(gsl_device_t *device, gsl_drawctxt_t *drawctxt, ctx_t *ctx)
int
kgsl_drawctxt_init(gsl_device_t *device)
{
- GSL_CONTEXT_MUTEX_CREATE();
-
return (GSL_SUCCESS);
}
@@ -1388,8 +1369,6 @@ kgsl_drawctxt_init(gsl_device_t *device)
int
kgsl_drawctxt_close(gsl_device_t *device)
{
- GSL_CONTEXT_MUTEX_FREE();
-
return (GSL_SUCCESS);
}
@@ -1405,14 +1384,10 @@ kgsl_drawctxt_create(gsl_device_t* device, gsl_context_type_t type, unsigned int
int index;
ctx_t ctx;
- GSL_CONTEXT_MUTEX_LOCK();
-
kgsl_device_active(device);
-
+
if (device->drawctxt_count >= GSL_CONTEXT_MAX)
{
- GSL_CONTEXT_MUTEX_UNLOCK();
- GSL_API_MUTEX_UNLOCK();
return (GSL_FAILURE);
}
@@ -1428,7 +1403,6 @@ kgsl_drawctxt_create(gsl_device_t* device, gsl_context_type_t type, unsigned int
if (index >= GSL_CONTEXT_MAX)
{
- GSL_CONTEXT_MUTEX_UNLOCK();
return (GSL_FAILURE);
}
@@ -1448,7 +1422,6 @@ kgsl_drawctxt_create(gsl_device_t* device, gsl_context_type_t type, unsigned int
if (create_gpustate_shadow(device, drawctxt, &ctx) != GSL_SUCCESS)
{
kgsl_drawctxt_destroy(device, index);
- GSL_CONTEXT_MUTEX_UNLOCK();
return (GSL_FAILURE);
}
@@ -1465,7 +1438,6 @@ kgsl_drawctxt_create(gsl_device_t* device, gsl_context_type_t type, unsigned int
if (create_gmem_shadow(device, drawctxt, &ctx) != GSL_SUCCESS)
{
kgsl_drawctxt_destroy(device, index);
- GSL_CONTEXT_MUTEX_UNLOCK();
return (GSL_FAILURE);
}
@@ -1475,7 +1447,6 @@ kgsl_drawctxt_create(gsl_device_t* device, gsl_context_type_t type, unsigned int
*drawctxt_id = index;
- GSL_CONTEXT_MUTEX_UNLOCK();
return (GSL_SUCCESS);
}
@@ -1489,8 +1460,6 @@ kgsl_drawctxt_destroy(gsl_device_t* device, unsigned int drawctxt_id)
{
gsl_drawctxt_t *drawctxt;
- GSL_CONTEXT_MUTEX_LOCK();
-
drawctxt = &device->drawctxt[drawctxt_id];
if (drawctxt->flags != CTXT_FLAGS_NOT_IN_USE)
@@ -1504,17 +1473,17 @@ kgsl_drawctxt_destroy(gsl_device_t* device, unsigned int drawctxt_id)
kgsl_drawctxt_switch(device, GSL_CONTEXT_NONE, 0);
}
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
// destroy state shadow, if allocated
if (drawctxt->flags & CTXT_FLAGS_STATE_SHADOW)
- kgsl_sharedmem_free(&drawctxt->gpustate);
+ kgsl_sharedmem_free0(&drawctxt->gpustate, GSL_CALLER_PROCESSID_GET());
// destroy gmem shadow, if allocated
if (drawctxt->context_gmem_shadow.gmemshadow.size > 0)
{
- kgsl_sharedmem_free(&drawctxt->context_gmem_shadow.gmemshadow);
+ kgsl_sharedmem_free0(&drawctxt->context_gmem_shadow.gmemshadow, GSL_CALLER_PROCESSID_GET());
drawctxt->context_gmem_shadow.gmemshadow.size = 0;
}
@@ -1525,8 +1494,6 @@ kgsl_drawctxt_destroy(gsl_device_t* device, unsigned int drawctxt_id)
KOS_ASSERT(device->drawctxt_count >= 0);
}
- GSL_CONTEXT_MUTEX_UNLOCK();
-
return (GSL_SUCCESS);
}
@@ -1561,11 +1528,8 @@ KGSL_API int kgsl_drawctxt_bind_gmem_shadow(gsl_deviceid_t device_id, unsigned i
GSL_API_MUTEX_LOCK();
-
device = &gsl_driver.device[device_id-1]; // device_id is 1 based
- GSL_CONTEXT_MUTEX_LOCK();
-
drawctxt = &device->drawctxt[drawctxt_id];
shadow = &drawctxt->user_gmem_shadow[buffer_id];
@@ -1650,7 +1614,7 @@ KGSL_API int kgsl_drawctxt_bind_gmem_shadow(gsl_deviceid_t device_id, unsigned i
// Release context GMEM shadow if found
if (drawctxt->context_gmem_shadow.gmemshadow.size > 0)
{
- kgsl_sharedmem_free(&drawctxt->context_gmem_shadow.gmemshadow);
+ kgsl_sharedmem_free0(&drawctxt->context_gmem_shadow.gmemshadow, GSL_CALLER_PROCESSID_GET());
drawctxt->context_gmem_shadow.gmemshadow.size = 0;
}
}
@@ -1665,7 +1629,6 @@ KGSL_API int kgsl_drawctxt_bind_gmem_shadow(gsl_deviceid_t device_id, unsigned i
}
}
- GSL_CONTEXT_MUTEX_UNLOCK();
GSL_API_MUTEX_UNLOCK();
return (GSL_SUCCESS);
@@ -1803,8 +1766,6 @@ kgsl_drawctxt_destroyall(gsl_device_t *device)
int i;
gsl_drawctxt_t *drawctxt;
- GSL_CONTEXT_MUTEX_LOCK();
-
for (i = 0; i < GSL_CONTEXT_MAX; i++)
{
drawctxt = &device->drawctxt[i];
@@ -1813,12 +1774,12 @@ kgsl_drawctxt_destroyall(gsl_device_t *device)
{
// destroy state shadow, if allocated
if (drawctxt->flags & CTXT_FLAGS_STATE_SHADOW)
- kgsl_sharedmem_free(&drawctxt->gpustate);
+ kgsl_sharedmem_free0(&drawctxt->gpustate, GSL_CALLER_PROCESSID_GET());
// destroy gmem shadow, if allocated
if (drawctxt->context_gmem_shadow.gmemshadow.size > 0)
{
- kgsl_sharedmem_free(&drawctxt->context_gmem_shadow.gmemshadow);
+ kgsl_sharedmem_free0(&drawctxt->context_gmem_shadow.gmemshadow, GSL_CALLER_PROCESSID_GET());
drawctxt->context_gmem_shadow.gmemshadow.size = 0;
}
@@ -1829,8 +1790,6 @@ kgsl_drawctxt_destroyall(gsl_device_t *device)
}
}
- GSL_CONTEXT_MUTEX_UNLOCK();
-
return (GSL_SUCCESS);
}
diff --git a/drivers/mxc/amd-gpu/common/gsl_g12.c b/drivers/mxc/amd-gpu/common/gsl_g12.c
index 922f0d8a94a5..7c85e39941c3 100644
--- a/drivers/mxc/amd-gpu/common/gsl_g12.c
+++ b/drivers/mxc/amd-gpu/common/gsl_g12.c
@@ -21,7 +21,6 @@
#include "kos_libapi.h"
#include "gsl_cmdstream.h"
#ifdef _LINUX
-#include <linux/kthread.h>
#include <linux/sched.h>
#endif
@@ -133,7 +132,7 @@ kgsl_g12_intrcallback(gsl_intrid_t id, void *cookie)
// error condition interrupt
case GSL_INTR_G12_FIFO:
- kgsl_device_destroy(device);
+ device->ftbl.device_destroy(device);
break;
case GSL_INTR_G12_MH:
@@ -157,7 +156,7 @@ kgsl_g12_isr(gsl_device_t *device)
#endif // DEBUG
// determine if G12 is interrupting
- kgsl_device_regread(device->id, (ADDR_VGC_IRQSTATUS >> 2), &status);
+ device->ftbl.device_regread(device, (ADDR_VGC_IRQSTATUS >> 2), &status);
if (status)
{
@@ -166,8 +165,8 @@ kgsl_g12_isr(gsl_device_t *device)
{
#ifdef _DEBUG
// obtain mh error information
- kgsl_device_regread(device->id, ADDR_MH_MMU_PAGE_FAULT, (unsigned int *)&page_fault);
- kgsl_device_regread(device->id, ADDR_MH_AXI_ERROR, (unsigned int *)&axi_error);
+ device->ftbl.device_regread(device, ADDR_MH_MMU_PAGE_FAULT, (unsigned int *)&page_fault);
+ device->ftbl.device_regread(device, ADDR_MH_AXI_ERROR, (unsigned int *)&axi_error);
#endif // DEBUG
kgsl_intr_decode(device, GSL_INTR_BLOCK_G12_MH);
@@ -193,7 +192,7 @@ kgsl_g12_tlbinvalidate(gsl_device_t *device, unsigned int reg_invalidate, unsign
mh_mmu_invalidate.INVALIDATE_ALL = 1;
mh_mmu_invalidate.INVALIDATE_TC = 1;
- kgsl_device_regwrite(device->id, reg_invalidate, *(unsigned int *) &mh_mmu_invalidate);
+ device->ftbl.device_regwrite(device, reg_invalidate, *(unsigned int *) &mh_mmu_invalidate);
#else
(void)device;
(void)reg_invalidate;
@@ -206,13 +205,11 @@ kgsl_g12_tlbinvalidate(gsl_device_t *device, unsigned int reg_invalidate, unsign
int
kgsl_g12_setpagetable(gsl_device_t *device, unsigned int reg_ptbase, gpuaddr_t ptbase, unsigned int pid)
{
-#ifndef GSL_NO_MMU
- // unreferenced formal parameter
+ // unreferenced formal parameter
(void) pid;
-
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
-
- kgsl_device_regwrite(device->id, reg_ptbase, ptbase);
+#ifndef GSL_NO_MMU
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_regwrite(device, reg_ptbase, ptbase);
#else
(void)device;
(void)reg_ptbase;
@@ -227,11 +224,11 @@ kgsl_g12_setpagetable(gsl_device_t *device, unsigned int reg_ptbase, gpuaddr_t p
static void kgsl_g12_updatetimestamp(gsl_device_t *device)
{
unsigned int count = 0;
- kgsl_device_regread(device->id, (ADDR_VGC_IRQ_ACTIVE_CNT >> 2), &count);
+ device->ftbl.device_regread(device, (ADDR_VGC_IRQ_ACTIVE_CNT >> 2), &count);
count >>= 8;
count &= 255;
device->timestamp += count;
- kgsl_sharedmem_write(&device->memstore, GSL_DEVICE_MEMSTORE_OFFSET(eoptimestamp), &device->timestamp, 4, 0);
+ kgsl_sharedmem_write0(&device->memstore, GSL_DEVICE_MEMSTORE_OFFSET(eoptimestamp), &device->timestamp, 4, 0);
}
//----------------------------------------------------------------------------
@@ -256,18 +253,18 @@ kgsl_g12_init(gsl_device_t *device)
kgsl_hal_setpowerstate(device->id, GSL_PWRFLAGS_POWER_ON, 100);
// setup MH arbiter - MH offsets are considered to be dword based, therefore no down shift
- kgsl_device_regwrite(device->id, ADDR_MH_ARBITER_CONFIG, *(unsigned int *) &gsl_cfg_g12_mharb);
+ device->ftbl.device_regwrite(device, ADDR_MH_ARBITER_CONFIG, *(unsigned int *) &gsl_cfg_g12_mharb);
// init interrupt
status = kgsl_intr_init(device);
if (status != GSL_SUCCESS)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
return (status);
}
// enable irq
- kgsl_device_regwrite(device->id, (ADDR_VGC_IRQENABLE >> 2), 0x3);
+ device->ftbl.device_regwrite(device, (ADDR_VGC_IRQENABLE >> 2), 0x3);
#ifndef GSL_NO_MMU
// enable master interrupt for G12 MH
@@ -278,7 +275,7 @@ kgsl_g12_init(gsl_device_t *device)
status = kgsl_mmu_init(device);
if (status != GSL_SUCCESS)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
return (status);
}
#endif
@@ -318,20 +315,15 @@ kgsl_g12_init(gsl_device_t *device)
int
kgsl_g12_close(gsl_device_t *device)
{
-#if defined(_LINUX)
- int status;
-// printk(KERN_INFO "\npid=%u, %s\n", current->pid, __func__);
-#endif
+ int status = GSL_FAILURE;
if (device->refcnt == 0)
{
// wait pending interrupts before shutting down G12 intr thread to
// empty irq counters. Otherwise there's a possibility to have them in
// registers next time systems starts up and this results in a hang.
-#ifndef _WIN32_WCE
- status = kgsl_g12_idle(device, 1000);
+ status = device->ftbl.device_idle(device, 1000);
KOS_ASSERT(status == GSL_SUCCESS);
-#endif
#ifndef _LINUX
kos_thread_destroy(device->irq_thread_handle);
@@ -359,7 +351,7 @@ kgsl_g12_close(gsl_device_t *device)
kgsl_hal_setpowerstate(device->id, GSL_PWRFLAGS_POWER_OFF, 0);
- kgsl_device_idle(device->id, GSL_TIMEOUT_NONE);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_NONE);
device->flags &= ~GSL_FLAGS_INITIALIZED;
#if defined(__SYMBIAN32__)
@@ -396,7 +388,7 @@ kgsl_g12_destroy(gsl_device_t *device)
pid = device->callerprocess[i];
if (pid)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
kgsl_driver_destroy(pid);
// todo: terminate client process?
@@ -421,7 +413,7 @@ kgsl_g12_start(gsl_device_t *device, gsl_flags_t flags)
status = kgsl_cmdwindow_init(device);
if (status != GSL_SUCCESS)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
return (status);
}
@@ -442,7 +434,7 @@ kgsl_g12_stop(gsl_device_t *device)
KOS_ASSERT(device->refcnt == 0);
/* wait for device to idle before setting it's clock off */
- status = kgsl_g12_idle(device, 1000);
+ status = device->ftbl.device_idle(device, 1000);
KOS_ASSERT(status == GSL_SUCCESS);
status = kgsl_hal_setpowerstate(device->id, GSL_PWRFLAGS_CLK_OFF, 0);
@@ -509,21 +501,18 @@ kgsl_g12_setproperty(gsl_device_t *device, gsl_property_type_t type, void *value
int
kgsl_g12_idle(gsl_device_t *device, unsigned int timeout)
{
- unsigned int timestamp;
- int deltaTimestamp = 0;
- // unreferenced formal parameters
- (void) timeout;
+ if ( device->flags & GSL_FLAGS_STARTED )
+ {
+ for ( ; ; )
+ {
+ gsl_timestamp_t retired = kgsl_cmdstream_readtimestamp0( device->id, GSL_TIMESTAMP_RETIRED );
+ gsl_timestamp_t ts_diff = retired - device->current_timestamp;
+ if ( ts_diff >= 0 || ts_diff < -GSL_TIMESTAMP_EPSILON )
+ break;
+ kos_sleep(10);
+ }
+ }
- if ((device->flags & GSL_FLAGS_STARTED))
- {
- do
- {
- timestamp = kgsl_cmdstream_readtimestamp( device->id, GSL_TIMESTAMP_RETIRED );
- kos_sleep( 0 );
- deltaTimestamp = timestamp - device->current_timestamp;
- }
- while(!((deltaTimestamp >= 0) || (deltaTimestamp < -GSL_TIMESTAMP_EPSILON)));
- }
return (GSL_SUCCESS);
}
@@ -537,10 +526,10 @@ kgsl_g12_regread(gsl_device_t *device, unsigned int offsetwords, unsigned int *v
(offsetwords >= ADDR_MH_MMU_CONFIG && offsetwords <= ADDR_MH_MMU_MPU_END))
{
#ifdef _Z180
- kgsl_device_regwrite(device->id, (ADDR_VGC_MH_READ_ADDR >> 2), offsetwords);
+ device->ftbl.device_regwrite(device, (ADDR_VGC_MH_READ_ADDR >> 2), offsetwords);
GSL_HAL_REG_READ(device->id, (unsigned int) device->regspace.mmio_virt_base, (ADDR_VGC_MH_READ_ADDR >> 2), value);
#else
- kgsl_device_regwrite(device->id, (ADDR_MMU_READ_ADDR >> 2), offsetwords);
+ device->ftbl.device_regwrite(device, (ADDR_MMU_READ_ADDR >> 2), offsetwords);
GSL_HAL_REG_READ(device->id, (unsigned int) device->regspace.mmio_virt_base, (ADDR_MMU_READ_DATA >> 2), value);
#endif
}
@@ -561,7 +550,7 @@ kgsl_g12_regwrite(gsl_device_t *device, unsigned int offsetwords, unsigned int v
if ((offsetwords >= ADDR_MH_ARBITER_CONFIG && offsetwords <= ADDR_MH_AXI_HALT_CONTROL) ||
(offsetwords >= ADDR_MH_MMU_CONFIG && offsetwords <= ADDR_MH_MMU_MPU_END))
{
- kgsl_cmdwindow_write(device->id, GSL_CMDWINDOW_MMU, offsetwords, value);
+ kgsl_cmdwindow_write0(device->id, GSL_CMDWINDOW_MMU, offsetwords, value);
}
else
{
@@ -571,7 +560,7 @@ kgsl_g12_regwrite(gsl_device_t *device, unsigned int offsetwords, unsigned int v
// idle device when running in safe mode
if (device->flags & GSL_FLAGS_SAFEMODE)
{
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
}
return (GSL_SUCCESS);
@@ -607,12 +596,12 @@ kgsl_g12_waitirq(gsl_device_t *device, gsl_intrid_t intr_id, unsigned int *count
{
unsigned int cntrs;
int i;
- kgsl_device_active(device);
+ kgsl_device_active(device);
#ifndef VG_HDK
kos_event_reset(device->intr.evnt[intr_id]);
- kgsl_device_regread(device->id, (ADDR_VGC_IRQ_ACTIVE_CNT >> 2), &cntrs);
+ device->ftbl.device_regread(device, (ADDR_VGC_IRQ_ACTIVE_CNT >> 2), &cntrs);
#else
- kgsl_device_regread(device->id, (0x38 >> 2), &cntrs);
+ device->ftbl.device_regread(device, (0x38 >> 2), &cntrs);
#endif
for (i = 0; i < GSL_G12_INTR_COUNT; i++)
@@ -763,10 +752,7 @@ kgsl_g12_issueibcmds(gsl_device_t* device, int drawctxt_index, gpuaddr_t ibaddr,
GSL_CMDSTREAM_GET_EOP_TIMESTAMP(device, (int *)&processed_timestamp);
}
- device->current_timestamp++;
- g_z1xx.timestamp[nextbuf] = device->current_timestamp;
-
- *timestamp = device->current_timestamp;
+ *timestamp = g_z1xx.timestamp[nextbuf] = device->current_timestamp + 1;
/* context switch */
if (drawctxt_index != (int)g_z1xx.prevctx)
@@ -780,18 +766,21 @@ kgsl_g12_issueibcmds(gsl_device_t* device, int drawctxt_index, gpuaddr_t ibaddr,
beginpacket(&g_z1xx, cmd+ofs, cnt);
tmp.gpuaddr=ibaddr+(sizedwords*sizeof(unsigned int));
- kgsl_sharedmem_write(&tmp, 4, &nextaddr, 4, false);
- kgsl_sharedmem_write(&tmp, 8, &nextcnt, 4, false);
+ kgsl_sharedmem_write0(&tmp, 4, &nextaddr, 4, false);
+ kgsl_sharedmem_write0(&tmp, 8, &nextcnt, 4, false);
/* sync mem */
- kgsl_sharedmem_write((const gsl_memdesc_t *)&g_z1xx.cmdbufdesc[g_z1xx.curr], 0, g_z1xx.cmdbuf[g_z1xx.curr], (512 + 13) * sizeof(unsigned int), false);
+ kgsl_sharedmem_write0((const gsl_memdesc_t *)&g_z1xx.cmdbufdesc[g_z1xx.curr], 0, g_z1xx.cmdbuf[g_z1xx.curr], (512 + 13) * sizeof(unsigned int), false);
g_z1xx.offs = 0;
g_z1xx.curr = nextbuf;
- // quick & dirty hack --- note mark count is transferred through flags argument for now!!! FIX API
- kgsl_cmdwindow_write(2, GSL_CMDWINDOW_2D, ADDR_VGV3_CONTROL, flags);
- kgsl_cmdwindow_write(2, GSL_CMDWINDOW_2D, ADDR_VGV3_CONTROL, 0);
+ /* increment mark counter */
+ kgsl_cmdwindow_write0(2, GSL_CMDWINDOW_2D, ADDR_VGV3_CONTROL, flags);
+ kgsl_cmdwindow_write0(2, GSL_CMDWINDOW_2D, ADDR_VGV3_CONTROL, 0);
+
+ /* increment consumed timestamp */
+ device->current_timestamp++;
return (GSL_SUCCESS);
}
@@ -804,14 +793,14 @@ kgsl_g12_context_create(gsl_device_t* device, gsl_context_type_t type, unsigned
int status = 0;
int i;
int cmd;
- gsl_flags_t gslflags = (GSL_MEMFLAGS_ALIGN4K);
+ gsl_flags_t gslflags = (GSL_MEMFLAGS_CONPHYS | GSL_MEMFLAGS_ALIGNPAGE);
// unreferenced formal parameters
(void) device;
(void) type;
//(void) drawctxt_id;
(void) flags;
-
+
kgsl_device_active(device);
if (g_z1xx.numcontext==0)
@@ -819,7 +808,7 @@ kgsl_g12_context_create(gsl_device_t* device, gsl_context_type_t type, unsigned
/* todo: move this to device create or start. Error checking!! */
for (i=0;i<GSL_HAL_NUMCMDBUFFERS;i++)
{
- status = kgsl_sharedmem_alloc(GSL_DEVICE_ANY, gslflags, GSL_HAL_CMDBUFFERSIZE, &g_z1xx.cmdbufdesc[i]);
+ status = kgsl_sharedmem_alloc0(GSL_DEVICE_ANY, gslflags, GSL_HAL_CMDBUFFERSIZE, &g_z1xx.cmdbufdesc[i]);
KOS_ASSERT(status == GSL_SUCCESS);
g_z1xx.cmdbuf[i]=kos_malloc(GSL_HAL_CMDBUFFERSIZE);
KOS_ASSERT(g_z1xx.cmdbuf[i]);
@@ -828,33 +817,33 @@ kgsl_g12_context_create(gsl_device_t* device, gsl_context_type_t type, unsigned
g_z1xx.curr = i;
g_z1xx.offs = 0;
addmarker(&g_z1xx);
- status = kgsl_sharedmem_write(&g_z1xx.cmdbufdesc[i],0, g_z1xx.cmdbuf[i], (512 + 13) * sizeof(unsigned int), false);
+ status = kgsl_sharedmem_write0(&g_z1xx.cmdbufdesc[i],0, g_z1xx.cmdbuf[i], (512 + 13) * sizeof(unsigned int), false);
KOS_ASSERT(status == GSL_SUCCESS);
}
g_z1xx.curr = 0;
cmd = (int)(((VGV3_NEXTCMD_JUMP) & VGV3_NEXTCMD_NEXTCMD_FMASK)<< VGV3_NEXTCMD_NEXTCMD_FSHIFT);
/* set cmd stream buffer to hw */
- status |= kgsl_cmdwindow_write(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, ADDR_VGV3_MODE, 4);
- status |= kgsl_cmdwindow_write(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, ADDR_VGV3_NEXTADDR, g_z1xx.cmdbufdesc[0].gpuaddr );
- status |= kgsl_cmdwindow_write(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, ADDR_VGV3_NEXTCMD, cmd | 5);
+ status |= kgsl_cmdwindow_write0(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, ADDR_VGV3_MODE, 4);
+ status |= kgsl_cmdwindow_write0(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, ADDR_VGV3_NEXTADDR, g_z1xx.cmdbufdesc[0].gpuaddr );
+ status |= kgsl_cmdwindow_write0(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, ADDR_VGV3_NEXTCMD, cmd | 5);
KOS_ASSERT(status == GSL_SUCCESS);
/* Edge buffer setup todo: move register setup to own function.
This function can be then called, if power managemnet is used and clocks are turned off and then on.
*/
- status |= kgsl_sharedmem_alloc(GSL_DEVICE_ANY, gslflags, GSL_HAL_EDGE0BUFSIZE, &g_z1xx.e0);
- status |= kgsl_sharedmem_alloc(GSL_DEVICE_ANY, gslflags, GSL_HAL_EDGE1BUFSIZE, &g_z1xx.e1);
- status |= kgsl_sharedmem_set(&g_z1xx.e0, 0, 0, GSL_HAL_EDGE0BUFSIZE);
- status |= kgsl_sharedmem_set(&g_z1xx.e1, 0, 0, GSL_HAL_EDGE1BUFSIZE);
+ status |= kgsl_sharedmem_alloc0(GSL_DEVICE_ANY, gslflags, GSL_HAL_EDGE0BUFSIZE, &g_z1xx.e0);
+ status |= kgsl_sharedmem_alloc0(GSL_DEVICE_ANY, gslflags, GSL_HAL_EDGE1BUFSIZE, &g_z1xx.e1);
+ status |= kgsl_sharedmem_set0(&g_z1xx.e0, 0, 0, GSL_HAL_EDGE0BUFSIZE);
+ status |= kgsl_sharedmem_set0(&g_z1xx.e1, 0, 0, GSL_HAL_EDGE1BUFSIZE);
- status |= kgsl_cmdwindow_write(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, GSL_HAL_EDGE0REG, g_z1xx.e0.gpuaddr);
- status |= kgsl_cmdwindow_write(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, GSL_HAL_EDGE1REG, g_z1xx.e1.gpuaddr);
+ status |= kgsl_cmdwindow_write0(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, GSL_HAL_EDGE0REG, g_z1xx.e0.gpuaddr);
+ status |= kgsl_cmdwindow_write0(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, GSL_HAL_EDGE1REG, g_z1xx.e1.gpuaddr);
#ifdef _Z180
- kgsl_sharedmem_alloc(GSL_DEVICE_ANY, gslflags, GSL_HAL_EDGE2BUFSIZE, &g_z1xx.e2);
- kgsl_sharedmem_set(&g_z1xx.e2, 0, 0, GSL_HAL_EDGE2BUFSIZE);
- kgsl_cmdwindow_write(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, GSL_HAL_EDGE2REG, g_z1xx.e2.gpuaddr);
+ kgsl_sharedmem_alloc0(GSL_DEVICE_ANY, gslflags, GSL_HAL_EDGE2BUFSIZE, &g_z1xx.e2);
+ kgsl_sharedmem_set0(&g_z1xx.e2, 0, 0, GSL_HAL_EDGE2BUFSIZE);
+ kgsl_cmdwindow_write0(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, GSL_HAL_EDGE2REG, g_z1xx.e2.gpuaddr);
#endif
KOS_ASSERT(status == GSL_SUCCESS);
}
@@ -895,13 +884,13 @@ kgsl_g12_context_destroy(gsl_device_t* device, unsigned int drawctxt_id)
int i;
for (i=0;i<GSL_HAL_NUMCMDBUFFERS;i++)
{
- kgsl_sharedmem_free(&g_z1xx.cmdbufdesc[i]);
+ kgsl_sharedmem_free0(&g_z1xx.cmdbufdesc[i], GSL_CALLER_PROCESSID_GET());
kos_free(g_z1xx.cmdbuf[i]);
}
- kgsl_sharedmem_free(&g_z1xx.e0);
- kgsl_sharedmem_free(&g_z1xx.e1);
+ kgsl_sharedmem_free0(&g_z1xx.e0, GSL_CALLER_PROCESSID_GET());
+ kgsl_sharedmem_free0(&g_z1xx.e1, GSL_CALLER_PROCESSID_GET());
#ifdef _Z180
- kgsl_sharedmem_free(&g_z1xx.e2);
+ kgsl_sharedmem_free0(&g_z1xx.e2, GSL_CALLER_PROCESSID_GET());
#endif
kos_memset(&g_z1xx,0,sizeof(gsl_z1xx_t));
}
@@ -957,7 +946,7 @@ static void irq_thread(void)
#ifdef VG_HDK
device->timestamp = timestamp;
#else
- kgsl_sharedmem_write(&device->memstore, GSL_DEVICE_MEMSTORE_OFFSET(eoptimestamp), &timestamp, 4, false);
+ kgsl_sharedmem_write0(&device->memstore, GSL_DEVICE_MEMSTORE_OFFSET(eoptimestamp), &timestamp, 4, false);
#endif
/* Notify timestamp event */
@@ -967,29 +956,14 @@ static void irq_thread(void)
{
/* Timeout */
- /* Read a timestamp value */
-#ifdef VG_HDK
- timestamp = device->timestamp;
-#else
- GSL_CMDSTREAM_GET_EOP_TIMESTAMP(device, (int *)&timestamp);
-#endif
-
- /* TODO Add power management code */
-
- if(timestamp < device->current_timestamp)
+
+ if(!(device->flags&GSL_FLAGS_INITIALIZED))
{
- /* There is still pending IRQ's from HW */
- }
- else
- {
- if(!(device->flags&GSL_FLAGS_INITIALIZED))
- {
- /* if device is closed -> thread exit */
+ /* if device is closed -> thread exit */
#if defined(__SYMBIAN32__)
- device->irq_thread = 0;
+ device->irq_thread = 0;
#endif
- return;
- }
+ return;
}
}
}
diff --git a/drivers/mxc/amd-gpu/common/gsl_intrmgr.c b/drivers/mxc/amd-gpu/common/gsl_intrmgr.c
index 8914e5752d7b..2c8b278dfe7a 100644
--- a/drivers/mxc/amd-gpu/common/gsl_intrmgr.c
+++ b/drivers/mxc/amd-gpu/common/gsl_intrmgr.c
@@ -58,13 +58,13 @@ kgsl_intr_decode(gsl_device_t *device, gsl_intrblock_t block_id)
unsigned int status;
// read the block's interrupt status bits
- kgsl_device_regread(device->id, block->status_reg, &status);
+ device->ftbl.device_regread(device, block->status_reg, &status);
// mask off any interrupts which are disabled
status &= device->intr.enabled[block->id];
// acknowledge the block's interrupts
- kgsl_device_regwrite(device->id, block->clear_reg, status);
+ device->ftbl.device_regwrite(device, block->clear_reg, status);
// loop through the block's masks, determine which interrupt bits are active, and call callback (or TODO queue DPC)
for (id = block->first_id; id <= block->last_id; id++)
@@ -91,7 +91,7 @@ kgsl_intr_isr()
if (device->intr.flags & GSL_FLAGS_INITIALIZED)
{
- kgsl_device_active(device);
+ kgsl_device_active(device);
device->ftbl.intr_isr(device);
}
}
@@ -186,7 +186,7 @@ int kgsl_intr_enable(gsl_intr_t *intr, gsl_intrid_t id)
enabled |= mask;
intr->enabled[block->id] = enabled;
- kgsl_device_regwrite(intr->device->id, block->mask_reg, enabled);
+ intr->device->ftbl.device_regwrite(intr->device, block->mask_reg, enabled);
}
return (GSL_SUCCESS);
@@ -223,7 +223,7 @@ int kgsl_intr_disable(gsl_intr_t *intr, gsl_intrid_t id)
{
enabled &= ~mask;
intr->enabled[block->id] = enabled;
- kgsl_device_regwrite(intr->device->id, block->mask_reg, enabled);
+ intr->device->ftbl.device_regwrite(intr->device, block->mask_reg, enabled);
kos_event_signal(intr->evnt[id]); // wake up waiting threads before destroying the event
kos_event_destroy(intr->evnt[id]);
diff --git a/drivers/mxc/amd-gpu/common/gsl_memmgr.c b/drivers/mxc/amd-gpu/common/gsl_memmgr.c
index c506ba81dee3..75f250ae59b1 100644
--- a/drivers/mxc/amd-gpu/common/gsl_memmgr.c
+++ b/drivers/mxc/amd-gpu/common/gsl_memmgr.c
@@ -18,10 +18,6 @@
#include "gsl.h"
#include "gsl_hal.h"
-#if defined(_LINUX) && !defined(PAGE_SIZE)
-#define PAGE_SIZE (1<<12)
-#define PAGE_SHIFT (12)
-#endif
//////////////////////////////////////////////////////////////////////////////
// defines
diff --git a/drivers/mxc/amd-gpu/common/gsl_mmu.c b/drivers/mxc/amd-gpu/common/gsl_mmu.c
index 2b0b110790a0..310677d926f0 100644
--- a/drivers/mxc/amd-gpu/common/gsl_mmu.c
+++ b/drivers/mxc/amd-gpu/common/gsl_mmu.c
@@ -18,10 +18,6 @@
#include "gsl.h"
#include "gsl_hal.h"
-#if defined(_LINUX) && !defined(PAGE_SIZE)
-#define PAGE_SIZE (1<<12)
-#define PAGE_SHIFT (12)
-#endif
//////////////////////////////////////////////////////////////////////////////
@@ -67,18 +63,6 @@ const unsigned int GSL_PT_PAGE_AP[4] = {(GSL_PT_PAGE_READ | GSL_PT_PAGE_WRITE),
/////////////////////////////////////////////////////////////////////////////
// macros
//////////////////////////////////////////////////////////////////////////////
-#ifdef GSL_LOCKING_FINEGRAIN
-#define GSL_MMU_MUTEX_CREATE() mmu->mutex = kos_mutex_create("gsl_mmu"); \
- if (!mmu->mutex) {return (GSL_FAILURE);}
-#define GSL_MMU_LOCK() kos_mutex_lock(mmu->mutex)
-#define GSL_MMU_UNLOCK() kos_mutex_unlock(mmu->mutex)
-#define GSL_MMU_MUTEX_FREE() kos_mutex_free(mmu->mutex); mmu->mutex = 0;
-#else
-#define GSL_MMU_MUTEX_CREATE()
-#define GSL_MMU_LOCK()
-#define GSL_MMU_UNLOCK()
-#define GSL_MMU_MUTEX_FREE()
-#endif
#define GSL_PT_ENTRY_GET(va) ((va - pagetable->va_base) >> GSL_PAGESIZE_SHIFT)
#define GSL_PT_VIRT_GET(pte) (pagetable->va_base + (pte * GSL_PAGESIZE))
@@ -160,7 +144,7 @@ kgsl_mh_intrcallback(gsl_intrid_t id, void *cookie)
id == gsl_cfg_mh_intr[devindex].AXI_WRITE_ERROR ||
id == gsl_cfg_mh_intr[devindex].MMU_PAGE_FAULT)
{
- kgsl_device_destroy(mmu->device);
+ mmu->device->ftbl.device_destroy(mmu->device);
}
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_mh_intrcallback.\n" );
@@ -176,14 +160,14 @@ kgsl_mmu_debug(gsl_mmu_t *mmu, gsl_mmu_debug_t *regs)
kos_memset(regs, 0, sizeof(gsl_mmu_debug_t));
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].CONFIG, &regs->config);
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].MPU_BASE, &regs->mpu_base);
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].MPU_END, &regs->mpu_end);
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].VA_RANGE, &regs->va_range);
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].PT_BASE, &regs->pt_base);
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].PAGE_FAULT, &regs->page_fault);
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].TRAN_ERROR, &regs->trans_error);
- kgsl_device_regread(mmu->device->id, gsl_cfg_mmu_reg[devindex].INVALIDATE, &regs->invalidate);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].CONFIG, &regs->config);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].MPU_BASE, &regs->mpu_base);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].MPU_END, &regs->mpu_end);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].VA_RANGE, &regs->va_range);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].PT_BASE, &regs->pt_base);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].PAGE_FAULT, &regs->page_fault);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].TRAN_ERROR, &regs->trans_error);
+ mmu->device->ftbl.device_regread(mmu->device, gsl_cfg_mmu_reg[devindex].INVALIDATE, &regs->invalidate);
}
#endif
@@ -269,7 +253,7 @@ kgsl_mmu_destroypagetableobject(gsl_mmu_t *mmu, unsigned int pid)
if (pagetable->base.gpuaddr)
{
- kgsl_sharedmem_free(&pagetable->base);
+ kgsl_sharedmem_free0(&pagetable->base, GSL_CALLER_PROCESSID_GET());
}
kos_free(pagetable);
@@ -365,12 +349,12 @@ kgsl_mmu_createpagetableobject(gsl_mmu_t *mmu, unsigned int pid)
// allocate page table memory
flags = (GSL_MEMFLAGS_ALIGN4K | GSL_MEMFLAGS_CONPHYS | GSL_MEMFLAGS_STRICTREQUEST);
- status = kgsl_sharedmem_alloc(mmu->device->id, flags, mmu->pagetable[pindex]->max_entries * GSL_PT_ENTRY_SIZEBYTES, &mmu->pagetable[pindex]->base);
+ status = kgsl_sharedmem_alloc0(mmu->device->id, flags, mmu->pagetable[pindex]->max_entries * GSL_PT_ENTRY_SIZEBYTES, &mmu->pagetable[pindex]->base);
if (status == GSL_SUCCESS)
{
// reset page table entries
- kgsl_sharedmem_set(&mmu->pagetable[pindex]->base, 0, 0, mmu->pagetable[pindex]->base.size);
+ kgsl_sharedmem_set0(&mmu->pagetable[pindex]->base, 0, 0, mmu->pagetable[pindex]->base.size);
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, KGSL_DEBUG_DUMPX(BB_DUMP_MMU_TBLADDR, mmu->pagetable[pindex]->base.gpuaddr, 0, mmu->pagetable[pindex]->base.size, "kgsl_mmu_init"));
}
@@ -401,8 +385,6 @@ kgsl_mmu_setpagetable(gsl_device_t *device, unsigned int pid)
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE,
"--> gsl_pagetable_t* kgsl_mmu_setpagetable(gsl_device_t *device=0x%08x)\n", device );
- GSL_MMU_LOCK();
-
if (mmu->flags & GSL_FLAGS_STARTED)
{
#ifdef GSL_MMU_PAGETABLE_PERPROCESS
@@ -441,8 +423,6 @@ kgsl_mmu_setpagetable(gsl_device_t *device, unsigned int pid)
}
}
- GSL_MMU_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_mmu_setpagetable. Return value %B\n", status );
return (status);
@@ -494,7 +474,7 @@ kgsl_mmu_init(gsl_device_t *device)
}
// setup MMU and sub-client behavior
- kgsl_device_regwrite(device->id, gsl_cfg_mmu_reg[devindex].CONFIG, mmu->config);
+ device->ftbl.device_regwrite(device, gsl_cfg_mmu_reg[devindex].CONFIG, mmu->config);
// enable axi interrupts
kgsl_intr_attach(&device->intr, gsl_cfg_mh_intr[devindex].AXI_READ_ERROR, kgsl_mh_intrcallback, (void *) mmu);
@@ -509,15 +489,15 @@ kgsl_mmu_init(gsl_device_t *device)
if (mmu->config & 0x1)
{
// idle device
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
// make sure aligned to pagesize
KOS_ASSERT((mmu->mpu_base & ((1 << GSL_PAGESIZE_SHIFT)-1)) == 0);
KOS_ASSERT(((mmu->mpu_base + mmu->mpu_range) & ((1 << GSL_PAGESIZE_SHIFT)-1)) == 0);
// define physical memory range accessible by the core
- kgsl_device_regwrite(device->id, gsl_cfg_mmu_reg[devindex].MPU_BASE, mmu->mpu_base);
- kgsl_device_regwrite(device->id, gsl_cfg_mmu_reg[devindex].MPU_END, mmu->mpu_base + mmu->mpu_range);
+ device->ftbl.device_regwrite(device, gsl_cfg_mmu_reg[devindex].MPU_BASE, mmu->mpu_base);
+ device->ftbl.device_regwrite(device, gsl_cfg_mmu_reg[devindex].MPU_END, mmu->mpu_base + mmu->mpu_range);
// enable page fault interrupt
kgsl_intr_attach(&device->intr, gsl_cfg_mh_intr[devindex].MMU_PAGE_FAULT, kgsl_mh_intrcallback, (void *) mmu);
@@ -528,8 +508,6 @@ kgsl_mmu_init(gsl_device_t *device)
// sub-client MMU lookups require address translation
if ((mmu->config & ~0x1) > 0)
{
- GSL_MMU_MUTEX_CREATE();
-
// make sure virtual address range is a multiple of 64Kb
KOS_ASSERT((mmu->va_range & ((1 << 16)-1)) == 0);
@@ -557,14 +535,14 @@ kgsl_mmu_init(gsl_device_t *device)
GSL_TLBFLUSH_FILTER_RESET();
// set page table base
- kgsl_device_regwrite(device->id, gsl_cfg_mmu_reg[devindex].PT_BASE, mmu->hwpagetable->base.gpuaddr);
+ device->ftbl.device_regwrite(device, gsl_cfg_mmu_reg[devindex].PT_BASE, mmu->hwpagetable->base.gpuaddr);
// define virtual address range
- kgsl_device_regwrite(device->id, gsl_cfg_mmu_reg[devindex].VA_RANGE, (mmu->hwpagetable->va_base | (mmu->hwpagetable->va_range >> 16)));
+ device->ftbl.device_regwrite(device, gsl_cfg_mmu_reg[devindex].VA_RANGE, (mmu->hwpagetable->va_base | (mmu->hwpagetable->va_range >> 16)));
// allocate memory used for completing r/w operations that cannot be mapped by the MMU
flags = (GSL_MEMFLAGS_ALIGN32 | GSL_MEMFLAGS_CONPHYS | GSL_MEMFLAGS_STRICTREQUEST);
- status = kgsl_sharedmem_alloc(device->id, flags, 32, &mmu->dummyspace);
+ status = kgsl_sharedmem_alloc0(device->id, flags, 32, &mmu->dummyspace);
if (status != GSL_SUCCESS)
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Unable to allocate dummy space memory.\n" );
@@ -573,7 +551,7 @@ kgsl_mmu_init(gsl_device_t *device)
return (status);
}
- kgsl_device_regwrite(device->id, gsl_cfg_mmu_reg[devindex].TRAN_ERROR, mmu->dummyspace.gpuaddr);
+ device->ftbl.device_regwrite(device, gsl_cfg_mmu_reg[devindex].TRAN_ERROR, mmu->dummyspace.gpuaddr);
// call device specific tlb invalidate
device->ftbl.mmu_tlbinvalidate(device, gsl_cfg_mmu_reg[devindex].INVALIDATE, mmu->hwpagetable->pid);
@@ -622,12 +600,9 @@ kgsl_mmu_map(gsl_mmu_t *mmu, gpuaddr_t gpubaseaddr, const gsl_scatterlist_t *sca
// get gpu access permissions
ap = GSL_PT_PAGE_AP[((flags & GSL_MEMFLAGS_GPUAP_MASK) >> GSL_MEMFLAGS_GPUAP_SHIFT)];
- GSL_MMU_LOCK();
-
pagetable = kgsl_mmu_getpagetableobject(mmu, pid);
if (!pagetable)
{
- GSL_MMU_UNLOCK();
return (GSL_FAILURE);
}
@@ -702,8 +677,6 @@ kgsl_mmu_map(gsl_mmu_t *mmu, gpuaddr_t gpubaseaddr, const gsl_scatterlist_t *sca
status = GSL_FAILURE;
}
- GSL_MMU_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_mmu_map. Return value %B\n", GSL_SUCCESS );
return (status);
@@ -740,12 +713,9 @@ kgsl_mmu_unmap(gsl_mmu_t *mmu, gpuaddr_t gpubaseaddr, int range, unsigned int pi
numpages++;
}
- GSL_MMU_LOCK();
-
pagetable = kgsl_mmu_getpagetableobject(mmu, pid);
if (!pagetable)
{
- GSL_MMU_UNLOCK();
return (GSL_FAILURE);
}
@@ -797,8 +767,6 @@ kgsl_mmu_unmap(gsl_mmu_t *mmu, gpuaddr_t gpubaseaddr, int range, unsigned int pi
// invalidate tlb, debug only
KGSL_DEBUG(GSL_DBGFLAGS_MMU, mmu->device->ftbl.mmu_tlbinvalidate(mmu->device, gsl_cfg_mmu_reg[mmu->device->id-1].INVALIDATE, pagetable->pid));
- GSL_MMU_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_mmu_unmap. Return value %B\n", GSL_SUCCESS );
return (status);
@@ -833,12 +801,9 @@ kgsl_mmu_getmap(gsl_mmu_t *mmu, gpuaddr_t gpubaseaddr, int range, gsl_scatterlis
return (GSL_FAILURE);
}
- GSL_MMU_LOCK();
-
pagetable = kgsl_mmu_getpagetableobject(mmu, pid);
if (!pagetable)
{
- GSL_MMU_UNLOCK();
return (GSL_FAILURE);
}
@@ -872,8 +837,6 @@ kgsl_mmu_getmap(gsl_mmu_t *mmu, gpuaddr_t gpubaseaddr, int range, gsl_scatterlis
scatterlist->pages[0] = GSL_PT_MAP_GETADDR(ptefirst);
}
- GSL_MMU_UNLOCK();
-
scatterlist->contiguous = contiguous;
return (GSL_SUCCESS);
@@ -931,7 +894,7 @@ kgsl_mmu_close(gsl_device_t *device)
kgsl_intr_detach(&device->intr, gsl_cfg_mh_intr[devindex].MMU_PAGE_FAULT);
// disable MMU
- kgsl_device_regwrite(device->id, gsl_cfg_mmu_reg[devindex].CONFIG, 0x00000000);
+ device->ftbl.device_regwrite(device, gsl_cfg_mmu_reg[devindex].CONFIG, 0x00000000);
if (mmu->tlbflushfilter.base)
{
@@ -940,11 +903,9 @@ kgsl_mmu_close(gsl_device_t *device)
if (mmu->dummyspace.gpuaddr)
{
- kgsl_sharedmem_free(&mmu->dummyspace);
+ kgsl_sharedmem_free0(&mmu->dummyspace, GSL_CALLER_PROCESSID_GET());
}
- GSL_MMU_MUTEX_FREE();
-
mmu->flags &= ~GSL_FLAGS_STARTED;
mmu->flags &= ~GSL_FLAGS_INITIALIZED;
mmu->flags &= ~GSL_FLAGS_INITIALIZED0;
@@ -971,8 +932,6 @@ kgsl_mmu_attachcallback(gsl_mmu_t *mmu, unsigned int pid)
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "--> int kgsl_mmu_attachcallback(gsl_mmu_t *mmu=0x%08x, unsigned int pid=0x%08x)\n", mmu, pid );
- GSL_MMU_LOCK();
-
if (mmu->flags & GSL_FLAGS_INITIALIZED0)
{
// attach to current device mmu
@@ -993,8 +952,6 @@ kgsl_mmu_attachcallback(gsl_mmu_t *mmu, unsigned int pid)
}
}
- GSL_MMU_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_mmu_attachcallback. Return value %B\n", status );
return (status);
@@ -1013,8 +970,6 @@ kgsl_mmu_detachcallback(gsl_mmu_t *mmu, unsigned int pid)
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "--> int kgsl_mmu_detachcallback(gsl_mmu_t *mmu=0x%08x, unsigned int pid=0x%08x)\n", mmu, pid );
- GSL_MMU_LOCK();
-
if (mmu->flags & GSL_FLAGS_INITIALIZED0)
{
// detach from current device mmu
@@ -1035,8 +990,6 @@ kgsl_mmu_detachcallback(gsl_mmu_t *mmu, unsigned int pid)
}
}
- GSL_MMU_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_mmu_detachcallback. Return value %B\n", status );
return (status);
@@ -1052,8 +1005,6 @@ kgsl_mmu_querystats(gsl_mmu_t *mmu, gsl_mmustats_t *stats)
KOS_ASSERT(stats);
- GSL_MMU_LOCK();
-
if (mmu->flags & GSL_FLAGS_STARTED)
{
kos_memcpy(stats, &mmu->stats, sizeof(gsl_mmustats_t));
@@ -1063,8 +1014,6 @@ kgsl_mmu_querystats(gsl_mmu_t *mmu, gsl_mmustats_t *stats)
kos_memset(stats, 0, sizeof(gsl_mmustats_t));
}
- GSL_MMU_UNLOCK();
-
return (status);
#else
// unreferenced formal parameters
diff --git a/drivers/mxc/amd-gpu/common/gsl_ringbuffer.c b/drivers/mxc/amd-gpu/common/gsl_ringbuffer.c
index 2ccf58c5f2bc..c4b62b0174d2 100644
--- a/drivers/mxc/amd-gpu/common/gsl_ringbuffer.c
+++ b/drivers/mxc/amd-gpu/common/gsl_ringbuffer.c
@@ -87,7 +87,7 @@ kgsl_cp_intrcallback(gsl_intrid_t id, void *cookie)
case GSL_INTR_YDX_CP_RESERVED_BIT_ERROR:
case GSL_INTR_YDX_CP_IB_ERROR:
- kgsl_device_destroy(rb->device);
+ rb->device->ftbl.device_destroy(rb->device);
break;
// non-error condition interrupt
@@ -120,8 +120,6 @@ kgsl_ringbuffer_watchdog()
if (rb->flags & GSL_FLAGS_STARTED)
{
- GSL_RB_MUTEX_LOCK();
-
GSL_RB_GET_READPTR(rb, &rb->rptr);
// ringbuffer is currently not empty
@@ -137,7 +135,7 @@ kgsl_ringbuffer_watchdog()
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_FATAL,
"ERROR: Watchdog detected core hung.\n" );
- kgsl_device_destroy(rb->device);
+ rb->device->ftbl.device_destroy(rb->device);
return;
}
}
@@ -152,7 +150,6 @@ kgsl_ringbuffer_watchdog()
rb->watchdog.flags &= ~GSL_FLAGS_ACTIVE;
}
- GSL_RB_MUTEX_UNLOCK();
}
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_ringbuffer_watchdog.\n" );
@@ -350,16 +347,16 @@ kgsl_ringbuffer_submit(gsl_ringbuffer_t *rb)
KOS_ASSERT(rb->wptr != 0);
kgsl_device_active(rb->device);
-
+
GSL_RB_UPDATE_WPTR_POLLING(rb);
// send the wptr to the hw
- kgsl_device_regwrite(rb->device->id, mmCP_RB_WPTR, rb->wptr);
+ rb->device->ftbl.device_regwrite(rb->device, mmCP_RB_WPTR, rb->wptr);
// force wptr register to be updated
do
{
- kgsl_device_regread(rb->device->id, mmCP_RB_WPTR, &value);
+ rb->device->ftbl.device_regread(rb->device, mmCP_RB_WPTR, &value);
} while (value != rb->wptr);
rb->flags |= GSL_FLAGS_ACTIVE;
@@ -497,66 +494,66 @@ kgsl_ringbuffer_start(gsl_ringbuffer_t *rb)
}
// clear memptrs values
- kgsl_sharedmem_set(&rb->memptrs_desc, 0, 0, sizeof(gsl_rbmemptrs_t));
+ kgsl_sharedmem_set0(&rb->memptrs_desc, 0, 0, sizeof(gsl_rbmemptrs_t));
// clear ringbuffer
- kgsl_sharedmem_set(&rb->buffer_desc, 0, 0x12341234, (rb->sizedwords << 2));
+ kgsl_sharedmem_set0(&rb->buffer_desc, 0, 0x12341234, (rb->sizedwords << 2));
// setup WPTR polling address
- kgsl_device_regwrite(device->id, mmCP_RB_WPTR_BASE, (rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_WPTRPOLL_OFFSET));
+ device->ftbl.device_regwrite(device, mmCP_RB_WPTR_BASE, (rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_WPTRPOLL_OFFSET));
// setup WPTR delay
- kgsl_device_regwrite(device->id, mmCP_RB_WPTR_DELAY, 0/*0x70000010*/);
+ device->ftbl.device_regwrite(device, mmCP_RB_WPTR_DELAY, 0/*0x70000010*/);
// setup RB_CNTL
- kgsl_device_regread(device->id, mmCP_RB_CNTL, (unsigned int *)&cp_rb_cntl);
+ device->ftbl.device_regread(device, mmCP_RB_CNTL, (unsigned int *)&cp_rb_cntl);
cp_rb_cntl.f.rb_bufsz = gsl_ringbuffer_sizelog2quadwords(rb->sizedwords); // size of ringbuffer
cp_rb_cntl.f.rb_blksz = rb->blksizequadwords; // quadwords to read before updating mem RPTR
cp_rb_cntl.f.rb_poll_en = GSL_RB_CNTL_POLL_EN; // WPTR polling
cp_rb_cntl.f.rb_no_update = GSL_RB_CNTL_NO_UPDATE; // mem RPTR writebacks
- kgsl_device_regwrite(device->id, mmCP_RB_CNTL, cp_rb_cntl.val);
+ device->ftbl.device_regwrite(device, mmCP_RB_CNTL, cp_rb_cntl.val);
// setup RB_BASE
- kgsl_device_regwrite(device->id, mmCP_RB_BASE, rb->buffer_desc.gpuaddr);
+ device->ftbl.device_regwrite(device, mmCP_RB_BASE, rb->buffer_desc.gpuaddr);
// setup RPTR_ADDR
- kgsl_device_regwrite(device->id, mmCP_RB_RPTR_ADDR, rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_RPTR_OFFSET);
+ device->ftbl.device_regwrite(device, mmCP_RB_RPTR_ADDR, rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_RPTR_OFFSET);
// explicitly clear all cp interrupts when running in safe mode
if (rb->device->flags & GSL_FLAGS_SAFEMODE)
{
- kgsl_device_regwrite(device->id, mmCP_INT_ACK, 0xFFFFFFFF);
+ device->ftbl.device_regwrite(device, mmCP_INT_ACK, 0xFFFFFFFF);
}
// setup scratch/timestamp addr
- kgsl_device_regwrite(device->id, mmSCRATCH_ADDR, device->memstore.gpuaddr + GSL_DEVICE_MEMSTORE_OFFSET(soptimestamp));
+ device->ftbl.device_regwrite(device, mmSCRATCH_ADDR, device->memstore.gpuaddr + GSL_DEVICE_MEMSTORE_OFFSET(soptimestamp));
// setup scratch/timestamp mask
- kgsl_device_regwrite(device->id, mmSCRATCH_UMSK, GSL_RB_MEMPTRS_SCRATCH_MASK);
+ device->ftbl.device_regwrite(device, mmSCRATCH_UMSK, GSL_RB_MEMPTRS_SCRATCH_MASK);
// load the CP ucode
- kgsl_device_regwrite(device->id, mmCP_DEBUG, 0x02000000);
- kgsl_device_regwrite(device->id, mmCP_ME_RAM_WADDR, 0);
+ device->ftbl.device_regwrite(device, mmCP_DEBUG, 0x02000000);
+ device->ftbl.device_regwrite(device, mmCP_ME_RAM_WADDR, 0);
for (i = 0; i < PM4_MICROCODE_SIZE; i++ )
{
- kgsl_device_regwrite(device->id, mmCP_ME_RAM_DATA, aPM4_Microcode[i][0]);
- kgsl_device_regwrite(device->id, mmCP_ME_RAM_DATA, aPM4_Microcode[i][1]);
- kgsl_device_regwrite(device->id, mmCP_ME_RAM_DATA, aPM4_Microcode[i][2]);
+ device->ftbl.device_regwrite(device, mmCP_ME_RAM_DATA, aPM4_Microcode[i][0]);
+ device->ftbl.device_regwrite(device, mmCP_ME_RAM_DATA, aPM4_Microcode[i][1]);
+ device->ftbl.device_regwrite(device, mmCP_ME_RAM_DATA, aPM4_Microcode[i][2]);
}
// load the prefetch parser ucode
- kgsl_device_regwrite(device->id, mmCP_PFP_UCODE_ADDR, 0);
+ device->ftbl.device_regwrite(device, mmCP_PFP_UCODE_ADDR, 0);
for ( i = 0; i < PFP_MICROCODE_SIZE_NRT; i++ )
{
- kgsl_device_regwrite(device->id, mmCP_PFP_UCODE_DATA, aPFP_Microcode_nrt[i]);
+ device->ftbl.device_regwrite(device, mmCP_PFP_UCODE_DATA, aPFP_Microcode_nrt[i]);
}
// queue thresholds ???
- kgsl_device_regwrite(device->id, mmCP_QUEUE_THRESHOLDS, 0x000C0804);
+ device->ftbl.device_regwrite(device, mmCP_QUEUE_THRESHOLDS, 0x000C0804);
// reset pointers
rb->rptr = 0;
@@ -567,7 +564,7 @@ kgsl_ringbuffer_start(gsl_ringbuffer_t *rb)
GSL_RB_INIT_TIMESTAMP(rb);
// clear ME_HALT to start micro engine
- kgsl_device_regwrite(device->id, mmCP_ME_CNTL, 0);
+ device->ftbl.device_regwrite(device, mmCP_ME_CNTL, 0);
// ME_INIT
cmds = kgsl_ringbuffer_addcmds(rb, 19);
@@ -598,7 +595,7 @@ kgsl_ringbuffer_start(gsl_ringbuffer_t *rb)
kgsl_ringbuffer_submit(rb);
// idle device to validate ME INIT
- status = kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
+ status = device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
if (status == GSL_SUCCESS)
{
@@ -652,7 +649,7 @@ kgsl_ringbuffer_stop(gsl_ringbuffer_t *rb)
kgsl_intr_detach(&rb->device->intr, GSL_INTR_YDX_CP_RING_BUFFER);
// ME_HALT
- kgsl_device_regwrite(rb->device->id, mmCP_ME_CNTL, 0x10000000);
+ rb->device->ftbl.device_regwrite(rb->device, mmCP_ME_CNTL, 0x10000000);
rb->flags &= ~GSL_FLAGS_STARTED;
}
@@ -678,14 +675,12 @@ kgsl_ringbuffer_init(gsl_device_t *device)
rb->sizedwords = (2 << gsl_cfg_rb_sizelog2quadwords);
rb->blksizequadwords = gsl_cfg_rb_blksizequadwords;
- GSL_RB_MUTEX_CREATE();
-
// allocate memory for ringbuffer, needs to be double octword aligned
// align on page from contiguous physical memory
flags = (GSL_MEMFLAGS_ALIGNPAGE | GSL_MEMFLAGS_CONPHYS | GSL_MEMFLAGS_STRICTREQUEST);
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, flags = (GSL_MEMFLAGS_ALIGNPAGE | GSL_MEMFLAGS_STRICTREQUEST)); /* set MMU table for ringbuffer */
- status = kgsl_sharedmem_alloc(device->id, flags, (rb->sizedwords << 2), &rb->buffer_desc);
+ status = kgsl_sharedmem_alloc0(device->id, flags, (rb->sizedwords << 2), &rb->buffer_desc);
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, KGSL_DEBUG_DUMPX(BB_DUMP_RINGBUF_SET, (unsigned int)rb->buffer_desc.gpuaddr, (unsigned int)rb->buffer_desc.hostptr, 0, "kgsl_ringbuffer_init"));
@@ -700,7 +695,7 @@ kgsl_ringbuffer_init(gsl_device_t *device)
flags = (GSL_MEMFLAGS_ALIGN32 | GSL_MEMFLAGS_CONPHYS);
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, flags = GSL_MEMFLAGS_ALIGN32);
- status = kgsl_sharedmem_alloc(device->id, flags, sizeof(gsl_rbmemptrs_t), &rb->memptrs_desc);
+ status = kgsl_sharedmem_alloc0(device->id, flags, sizeof(gsl_rbmemptrs_t), &rb->memptrs_desc);
if (status != GSL_SUCCESS)
{
@@ -742,29 +737,23 @@ kgsl_ringbuffer_close(gsl_ringbuffer_t *rb)
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE,
"--> int kgsl_ringbuffer_close(gsl_ringbuffer_t *rb=0x%08x)\n", rb );
- GSL_RB_MUTEX_LOCK();
-
// stop ringbuffer
kgsl_ringbuffer_stop(rb);
// free buffer
if (rb->buffer_desc.hostptr)
{
- kgsl_sharedmem_free(&rb->buffer_desc);
+ kgsl_sharedmem_free0(&rb->buffer_desc, GSL_CALLER_PROCESSID_GET());
}
// free memory pointers
if (rb->memptrs_desc.hostptr)
{
- kgsl_sharedmem_free(&rb->memptrs_desc);
+ kgsl_sharedmem_free0(&rb->memptrs_desc, GSL_CALLER_PROCESSID_GET());
}
rb->flags &= ~GSL_FLAGS_INITIALIZED;
- GSL_RB_MUTEX_UNLOCK();
-
- GSL_RB_MUTEX_FREE();
-
kos_memset(rb, 0, sizeof(gsl_ringbuffer_t));
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_ringbuffer_close. Return value %B\n", GSL_SUCCESS );
@@ -787,11 +776,8 @@ kgsl_ringbuffer_issuecmds(gsl_device_t *device, int pmodeoff, unsigned int *cmds
"--> gsl_timestamp_t kgsl_ringbuffer_issuecmds(gsl_device_t *device=0x%08x, int pmodeoff=%d, unsigned int *cmds=0x%08x, int sizedwords=%d, unsigned int pid=0x%08x)\n",
device, pmodeoff, cmds, sizedwords, pid );
- GSL_RB_MUTEX_LOCK();
-
if (!(device->ringbuffer.flags & GSL_FLAGS_STARTED))
{
- GSL_RB_MUTEX_UNLOCK();
return (0);
}
@@ -859,8 +845,6 @@ kgsl_ringbuffer_issuecmds(gsl_device_t *device, int pmodeoff, unsigned int *cmds
GSL_RB_STATS(rb->stats.wordstotal += sizedwords);
GSL_RB_STATS(rb->stats.issues++);
- GSL_RB_MUTEX_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_COMMAND | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_ringbuffer_issuecmds. Return value %d\n", timestamp );
// return timestamp of issued commands
@@ -890,7 +874,6 @@ kgsl_ringbuffer_issueibcmds(gsl_device_t *device, int drawctxt_index, gpuaddr_t
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, dumpx_swap = kgsl_dumpx_parse_ibs(ibaddr, sizedwords));
- GSL_RB_MUTEX_LOCK();
// context switch if needed
kgsl_drawctxt_switch(device, &device->drawctxt[drawctxt_index], flags);
@@ -903,7 +886,7 @@ kgsl_ringbuffer_issueibcmds(gsl_device_t *device, int drawctxt_index, gpuaddr_t
// idle device when running in safe mode
if (device->flags & GSL_FLAGS_SAFEMODE)
{
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
}
else
{
@@ -911,10 +894,9 @@ kgsl_ringbuffer_issueibcmds(gsl_device_t *device, int drawctxt_index, gpuaddr_t
{
// insert wait for idle after every IB1
// this is conservative but works reliably and is ok even for performance simulations
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
});
}
- GSL_RB_MUTEX_UNLOCK();
KGSL_DEBUG(GSL_DBGFLAGS_DUMPX,
{
if(dumpx_swap)
@@ -940,19 +922,19 @@ kgsl_ringbuffer_debug(gsl_ringbuffer_t *rb, gsl_rb_debug_t *rb_debug)
rb_debug->pm4_ucode_rel = PM4_MICROCODE_VERSION;
rb_debug->pfp_ucode_rel = PFP_MICROCODE_VERSION;
- kgsl_device_regread(rb->device->id, mmCP_RB_BASE, (unsigned int *)&rb_debug->cp_rb_base);
- kgsl_device_regread(rb->device->id, mmCP_RB_CNTL, (unsigned int *)&rb_debug->cp_rb_cntl);
- kgsl_device_regread(rb->device->id, mmCP_RB_RPTR_ADDR, (unsigned int *)&rb_debug->cp_rb_rptr_addr);
- kgsl_device_regread(rb->device->id, mmCP_RB_RPTR, (unsigned int *)&rb_debug->cp_rb_rptr);
- kgsl_device_regread(rb->device->id, mmCP_RB_WPTR, (unsigned int *)&rb_debug->cp_rb_wptr);
- kgsl_device_regread(rb->device->id, mmCP_RB_WPTR_BASE, (unsigned int *)&rb_debug->cp_rb_wptr_base);
- kgsl_device_regread(rb->device->id, mmSCRATCH_UMSK, (unsigned int *)&rb_debug->scratch_umsk);
- kgsl_device_regread(rb->device->id, mmSCRATCH_ADDR, (unsigned int *)&rb_debug->scratch_addr);
- kgsl_device_regread(rb->device->id, mmCP_ME_CNTL, (unsigned int *)&rb_debug->cp_me_cntl);
- kgsl_device_regread(rb->device->id, mmCP_ME_STATUS, (unsigned int *)&rb_debug->cp_me_status);
- kgsl_device_regread(rb->device->id, mmCP_DEBUG, (unsigned int *)&rb_debug->cp_debug);
- kgsl_device_regread(rb->device->id, mmCP_STAT, (unsigned int *)&rb_debug->cp_stat);
- kgsl_device_regread(rb->device->id, mmRBBM_STATUS, (unsigned int *)&rb_debug->rbbm_status);
+ rb->device->ftbl.device_regread(rb->device, mmCP_RB_BASE, (unsigned int *)&rb_debug->cp_rb_base);
+ rb->device->ftbl.device_regread(rb->device, mmCP_RB_CNTL, (unsigned int *)&rb_debug->cp_rb_cntl);
+ rb->device->ftbl.device_regread(rb->device, mmCP_RB_RPTR_ADDR, (unsigned int *)&rb_debug->cp_rb_rptr_addr);
+ rb->device->ftbl.device_regread(rb->device, mmCP_RB_RPTR, (unsigned int *)&rb_debug->cp_rb_rptr);
+ rb->device->ftbl.device_regread(rb->device, mmCP_RB_WPTR, (unsigned int *)&rb_debug->cp_rb_wptr);
+ rb->device->ftbl.device_regread(rb->device, mmCP_RB_WPTR_BASE, (unsigned int *)&rb_debug->cp_rb_wptr_base);
+ rb->device->ftbl.device_regread(rb->device, mmSCRATCH_UMSK, (unsigned int *)&rb_debug->scratch_umsk);
+ rb->device->ftbl.device_regread(rb->device, mmSCRATCH_ADDR, (unsigned int *)&rb_debug->scratch_addr);
+ rb->device->ftbl.device_regread(rb->device, mmCP_ME_CNTL, (unsigned int *)&rb_debug->cp_me_cntl);
+ rb->device->ftbl.device_regread(rb->device, mmCP_ME_STATUS, (unsigned int *)&rb_debug->cp_me_status);
+ rb->device->ftbl.device_regread(rb->device, mmCP_DEBUG, (unsigned int *)&rb_debug->cp_debug);
+ rb->device->ftbl.device_regread(rb->device, mmCP_STAT, (unsigned int *)&rb_debug->cp_stat);
+ rb->device->ftbl.device_regread(rb->device, mmRBBM_STATUS, (unsigned int *)&rb_debug->rbbm_status);
rb_debug->sop_timestamp = kgsl_cmdstream_readtimestamp(rb->device->id, GSL_TIMESTAMP_CONSUMED);
rb_debug->eop_timestamp = kgsl_cmdstream_readtimestamp(rb->device->id, GSL_TIMESTAMP_RETIRED);
}
@@ -1022,7 +1004,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb)
kgsl_ringbuffer_submit(rb);
- status = kgsl_device_idle(rb->device->id, GSL_TIMEOUT_DEFAULT);
+ status = rb->device->ftbl.device_idle(rb->device, GSL_TIMEOUT_DEFAULT);
if (status != GSL_SUCCESS)
{
@@ -1049,7 +1031,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb)
kgsl_ringbuffer_submit(rb);
- status = kgsl_device_idle(rb->device->id, GSL_TIMEOUT_DEFAULT);
+ status = rb->device->ftbl.device_idle(rb->device, GSL_TIMEOUT_DEFAULT);
if (status != GSL_SUCCESS)
{
@@ -1060,7 +1042,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb)
return (status);
}
- kgsl_device_regread(rb->device->id, mmSCRATCH_REG7, &temp);
+ rb->device->ftbl.device_regread(rb->device, mmSCRATCH_REG7, &temp);
if (temp != 0xFEEDF00D)
{
@@ -1097,7 +1079,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb)
kgsl_ringbuffer_submit(rb);
- status = kgsl_device_idle(rb->device->id, GSL_TIMEOUT_DEFAULT);
+ status = rb->device->ftbl.device_idle(rb->device, GSL_TIMEOUT_DEFAULT);
if (status != GSL_SUCCESS)
{
@@ -1108,7 +1090,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb)
return (status);
}
- kgsl_device_regread(rb->device->id, mmSCRATCH_REG7, &temp);
+ rb->device->ftbl.device_regread(rb->device, mmSCRATCH_REG7, &temp);
if (temp != k)
{
@@ -1137,7 +1119,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb)
kgsl_ringbuffer_submit(rb);
- status = kgsl_device_idle(rb->device->id, GSL_TIMEOUT_DEFAULT);
+ status = rb->device->ftbl.device_idle(rb->device, GSL_TIMEOUT_DEFAULT);
if (status != GSL_SUCCESS)
{
diff --git a/drivers/mxc/amd-gpu/common/gsl_sharedmem.c b/drivers/mxc/amd-gpu/common/gsl_sharedmem.c
index 21835ed8d062..2892668d7c45 100644
--- a/drivers/mxc/amd-gpu/common/gsl_sharedmem.c
+++ b/drivers/mxc/amd-gpu/common/gsl_sharedmem.c
@@ -18,10 +18,6 @@
#include "gsl.h"
#include "gsl_hal.h"
-#if defined(_LINUX) && !defined(PAGE_SIZE)
-#define PAGE_SIZE (1<<12)
-#define PAGE_SHIFT (12)
-#endif
/////////////////////////////////////////////////////////////////////////////
// macros
@@ -204,8 +200,8 @@ kgsl_sharedmem_close(gsl_sharedmem_t *shmem)
//----------------------------------------------------------------------------
-KGSL_API int
-kgsl_sharedmem_alloc(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes, gsl_memdesc_t *memdesc)
+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;
@@ -227,12 +223,9 @@ kgsl_sharedmem_alloc(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes,
kos_memset(memdesc, 0, sizeof(gsl_memdesc_t));
- GSL_API_MUTEX_LOCK();
-
if (!(shmem->flags & GSL_FLAGS_INITIALIZED))
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Shared memory not initialized.\n" );
- GSL_API_MUTEX_UNLOCK();
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_alloc. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
}
@@ -269,7 +262,6 @@ kgsl_sharedmem_alloc(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes,
else
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Invalid device.\n" );
- GSL_API_MUTEX_UNLOCK();
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_alloc. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
}
@@ -338,8 +330,6 @@ kgsl_sharedmem_alloc(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes,
}
}
- GSL_API_MUTEX_UNLOCK();
-
if (result == GSL_SUCCESS)
{
GSL_MEMDESC_APERTURE_SET(memdesc, aperture_index);
@@ -394,6 +384,18 @@ kgsl_sharedmem_alloc(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes,
//----------------------------------------------------------------------------
+KGSL_API int
+kgsl_sharedmem_alloc(gsl_deviceid_t device_id, gsl_flags_t flags, int sizebytes, gsl_memdesc_t *memdesc)
+{
+ int status = GSL_SUCCESS;
+ GSL_API_MUTEX_LOCK();
+ status = kgsl_sharedmem_alloc0(device_id, flags, sizebytes, memdesc);
+ GSL_API_MUTEX_UNLOCK();
+ return status;
+}
+
+//----------------------------------------------------------------------------
+
int
kgsl_sharedmem_free0(gsl_memdesc_t *memdesc, unsigned int pid)
{
@@ -407,8 +409,6 @@ kgsl_sharedmem_free0(gsl_memdesc_t *memdesc, unsigned int pid)
GSL_MEMDESC_APERTURE_GET(memdesc, aperture_index);
GSL_MEMDESC_DEVICE_GET(memdesc, device_id);
- GSL_API_MUTEX_LOCK();
-
shmem = &gsl_driver.shmem;
if (shmem->flags & GSL_FLAGS_INITIALIZED)
@@ -433,8 +433,6 @@ kgsl_sharedmem_free0(gsl_memdesc_t *memdesc, unsigned int pid)
status = GSL_FAILURE;
}
- GSL_API_MUTEX_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_free. Return value %B\n", status );
return (status);
@@ -445,13 +443,17 @@ kgsl_sharedmem_free0(gsl_memdesc_t *memdesc, unsigned int pid)
KGSL_API int
kgsl_sharedmem_free(gsl_memdesc_t *memdesc)
{
- return (kgsl_sharedmem_free0(memdesc, GSL_CALLER_PROCESSID_GET()));
+ int status = GSL_SUCCESS;
+ GSL_API_MUTEX_LOCK();
+ status = kgsl_sharedmem_free0(memdesc, GSL_CALLER_PROCESSID_GET());
+ GSL_API_MUTEX_UNLOCK();
+ return status;
}
//----------------------------------------------------------------------------
-KGSL_API int
-kgsl_sharedmem_read(const gsl_memdesc_t *memdesc, void *dst, unsigned int offsetbytes, unsigned int sizebytes, unsigned int touserspace)
+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;
@@ -469,14 +471,11 @@ kgsl_sharedmem_read(const gsl_memdesc_t *memdesc, void *dst, unsigned int offset
return (GSL_FAILURE_BADPARAM);
}
- GSL_API_MUTEX_LOCK();
-
shmem = &gsl_driver.shmem;
if (!(shmem->flags & GSL_FLAGS_INITIALIZED))
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Shared memory not initialized.\n" );
- GSL_API_MUTEX_UNLOCK();
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_read. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
}
@@ -490,8 +489,6 @@ kgsl_sharedmem_read(const gsl_memdesc_t *memdesc, void *dst, unsigned int offset
GSL_HAL_MEM_READ(dst, shmem->apertures[aperture_index].memarena->hostbaseaddr, gpuoffsetbytes, sizebytes, touserspace);
- GSL_API_MUTEX_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_read. Return value %B\n", GSL_SUCCESS );
return (GSL_SUCCESS);
@@ -500,7 +497,19 @@ kgsl_sharedmem_read(const gsl_memdesc_t *memdesc, void *dst, unsigned int offset
//----------------------------------------------------------------------------
KGSL_API int
-kgsl_sharedmem_write(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, void *src, unsigned int sizebytes, unsigned int fromuserspace)
+kgsl_sharedmem_read(const gsl_memdesc_t *memdesc, void *dst, unsigned int offsetbytes, unsigned int sizebytes, unsigned int touserspace)
+{
+ int status = GSL_SUCCESS;
+ GSL_API_MUTEX_LOCK();
+ status = kgsl_sharedmem_read0(memdesc, dst, offsetbytes, sizebytes, touserspace);
+ GSL_API_MUTEX_UNLOCK();
+ return status;
+}
+
+//----------------------------------------------------------------------------
+
+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;
@@ -518,14 +527,11 @@ kgsl_sharedmem_write(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, voi
return (GSL_FAILURE_BADPARAM);
}
- GSL_API_MUTEX_LOCK();
-
shmem = &gsl_driver.shmem;
if (!(shmem->flags & GSL_FLAGS_INITIALIZED))
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Shared memory not initialized.\n" );
- GSL_API_MUTEX_UNLOCK();
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_write. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
}
@@ -543,8 +549,6 @@ kgsl_sharedmem_write(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, voi
KGSL_DEBUG_TBDUMP_SYNCMEM( (memdesc->gpuaddr + offsetbytes), src, sizebytes );
- GSL_API_MUTEX_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_write. Return value %B\n", GSL_SUCCESS );
return (GSL_SUCCESS);
@@ -553,7 +557,19 @@ kgsl_sharedmem_write(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, voi
//----------------------------------------------------------------------------
KGSL_API int
-kgsl_sharedmem_set(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsigned int value, unsigned int sizebytes)
+kgsl_sharedmem_write(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, void *src, unsigned int sizebytes, unsigned int fromuserspace)
+{
+ int status = GSL_SUCCESS;
+ GSL_API_MUTEX_LOCK();
+ status = kgsl_sharedmem_write0(memdesc, offsetbytes, src, sizebytes, fromuserspace);
+ GSL_API_MUTEX_UNLOCK();
+ return status;
+}
+
+//----------------------------------------------------------------------------
+
+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;
@@ -571,14 +587,11 @@ kgsl_sharedmem_set(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsig
return (GSL_FAILURE_BADPARAM);
}
- GSL_API_MUTEX_LOCK();
-
shmem = &gsl_driver.shmem;
if (!(shmem->flags & GSL_FLAGS_INITIALIZED))
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Shared memory not initialized.\n" );
- GSL_API_MUTEX_UNLOCK();
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_set. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
}
@@ -595,8 +608,6 @@ kgsl_sharedmem_set(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsig
KGSL_DEBUG_TBDUMP_SETMEM( (memdesc->gpuaddr + offsetbytes), value, sizebytes );
- GSL_API_MUTEX_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_set. Return value %B\n", GSL_SUCCESS );
return (GSL_SUCCESS);
@@ -604,6 +615,18 @@ kgsl_sharedmem_set(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsig
//----------------------------------------------------------------------------
+KGSL_API int
+kgsl_sharedmem_set(const gsl_memdesc_t *memdesc, unsigned int offsetbytes, unsigned int value, unsigned int sizebytes)
+{
+ int status = GSL_SUCCESS;
+ GSL_API_MUTEX_LOCK();
+ status = kgsl_sharedmem_set0(memdesc, offsetbytes, value, sizebytes);
+ GSL_API_MUTEX_UNLOCK();
+ return status;
+}
+
+//----------------------------------------------------------------------------
+
KGSL_API unsigned int
kgsl_sharedmem_largestfreeblock(gsl_deviceid_t device_id, gsl_flags_t flags)
{
@@ -665,8 +688,6 @@ kgsl_sharedmem_map(gsl_deviceid_t device_id, gsl_flags_t flags, const gsl_scatte
"--> int kgsl_sharedmem_map(gsl_deviceid_t device_id=%D, gsl_flags_t flags=0x%08x, gsl_scatterlist_t scatterlist=%M, gsl_memdesc_t *memdesc=%M)\n",
device_id, flags, memdesc, scatterlist );
- GSL_API_MUTEX_LOCK();
-
// execute pending device action
tmp_id = (device_id != GSL_DEVICE_ANY) ? device_id : device_id+1;
for ( ; tmp_id <= GSL_DEVICE_MAX; tmp_id++)
@@ -699,7 +720,6 @@ kgsl_sharedmem_map(gsl_deviceid_t device_id, gsl_flags_t flags, const gsl_scatte
else
{
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_ERROR, "ERROR: Invalid device.\n" );
- GSL_API_MUTEX_UNLOCK();
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_map. Return value %B\n", GSL_FAILURE );
return (GSL_FAILURE);
}
@@ -735,8 +755,6 @@ kgsl_sharedmem_map(gsl_deviceid_t device_id, gsl_flags_t flags, const gsl_scatte
}
}
- GSL_API_MUTEX_UNLOCK();
-
kgsl_log_write( KGSL_LOG_GROUP_MEMORY | KGSL_LOG_LEVEL_TRACE, "<-- kgsl_sharedmem_map. Return value %B\n", status );
return (status);
diff --git a/drivers/mxc/amd-gpu/common/gsl_yamato.c b/drivers/mxc/amd-gpu/common/gsl_yamato.c
index 965220408060..d74c9efe2f36 100644
--- a/drivers/mxc/amd-gpu/common/gsl_yamato.c
+++ b/drivers/mxc/amd-gpu/common/gsl_yamato.c
@@ -52,7 +52,7 @@ kgsl_yamato_gmeminit(gsl_device_t *device)
rb_edram_info.f.edram_mapping_mode = 0; // EDRAM_MAP_UPPER
rb_edram_info.f.edram_range = (device->gmemspace.gpu_base >> 14); // must be aligned to size
- kgsl_device_regwrite(device->id, mmRB_EDRAM_INFO, (unsigned int)rb_edram_info.val);
+ device->ftbl.device_regwrite(device, mmRB_EDRAM_INFO, (unsigned int)rb_edram_info.val);
return (GSL_SUCCESS);
}
@@ -62,7 +62,7 @@ kgsl_yamato_gmeminit(gsl_device_t *device)
static int
kgsl_yamato_gmemclose(gsl_device_t *device)
{
- kgsl_device_regwrite(device->id, mmRB_EDRAM_INFO, 0x00000000);
+ device->ftbl.device_regwrite(device, mmRB_EDRAM_INFO, 0x00000000);
return (GSL_SUCCESS);
}
@@ -79,7 +79,7 @@ kgsl_yamato_rbbmintrcallback(gsl_intrid_t id, void *cookie)
// error condition interrupt
case GSL_INTR_YDX_RBBM_READ_ERROR:
- kgsl_device_destroy(device);
+ device->ftbl.device_destroy(device);
break;
// non-error condition interrupt
@@ -189,15 +189,15 @@ kgsl_yamato_isr(gsl_device_t *device)
#endif // DEBUG
// determine if yamato is interrupting, and if so, which block
- kgsl_device_regread(device->id, mmMASTER_INT_SIGNAL, &status);
+ device->ftbl.device_regread(device, mmMASTER_INT_SIGNAL, &status);
if (status & MASTER_INT_SIGNAL__MH_INT_STAT)
{
#ifdef _DEBUG
// obtain mh error information
- kgsl_device_regread(device->id, mmMH_MMU_PAGE_FAULT, (unsigned int *)&page_fault);
- kgsl_device_regread(device->id, mmMH_AXI_ERROR, (unsigned int *)&axi_error);
- kgsl_device_regread(device->id, mmMH_CLNT_AXI_ID_REUSE, (unsigned int *)&clnt_axi_id_reuse);
+ device->ftbl.device_regread(device, mmMH_MMU_PAGE_FAULT, (unsigned int *)&page_fault);
+ device->ftbl.device_regread(device, mmMH_AXI_ERROR, (unsigned int *)&axi_error);
+ device->ftbl.device_regread(device, mmMH_CLNT_AXI_ID_REUSE, (unsigned int *)&clnt_axi_id_reuse);
#endif // DEBUG
kgsl_intr_decode(device, GSL_INTR_BLOCK_YDX_MH);
@@ -212,7 +212,7 @@ kgsl_yamato_isr(gsl_device_t *device)
{
#ifdef _DEBUG
// obtain rbbm error information
- kgsl_device_regread(device->id, mmRBBM_READ_ERROR, (unsigned int *)&read_error);
+ device->ftbl.device_regread(device, mmRBBM_READ_ERROR, (unsigned int *)&read_error);
#endif // DEBUG
kgsl_intr_decode(device, GSL_INTR_BLOCK_YDX_RBBM);
@@ -248,7 +248,7 @@ kgsl_yamato_tlbinvalidate(gsl_device_t *device, unsigned int reg_invalidate, uns
else
{
- kgsl_device_regwrite(device->id, reg_invalidate, mh_mmu_invalidate.val);
+ device->ftbl.device_regwrite(device, reg_invalidate, mh_mmu_invalidate.val);
}
return (GSL_SUCCESS);
@@ -307,9 +307,8 @@ kgsl_yamato_setpagetable(gsl_device_t *device, unsigned int reg_ptbase, gpuaddr_
}
else
{
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
-
- kgsl_device_regwrite(device->id, reg_ptbase, ptbase);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_regwrite(device, reg_ptbase, ptbase);
}
return (GSL_SUCCESS);
@@ -329,29 +328,29 @@ kgsl_yamato_init(gsl_device_t *device)
//We need to make sure all blocks are powered up and clocked before
//issuing a soft reset. The overrides will be turned off (set to 0)
//later in kgsl_yamato_start.
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE1, 0xfffffffe);
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE2, 0xffffffff);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE1, 0xfffffffe);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE2, 0xffffffff);
// soft reset
- kgsl_device_regwrite(device->id, mmRBBM_SOFT_RESET, 0xFFFFFFFF);
+ device->ftbl.device_regwrite(device, mmRBBM_SOFT_RESET, 0xFFFFFFFF);
kos_sleep(50);
- kgsl_device_regwrite(device->id, mmRBBM_SOFT_RESET, 0x00000000);
+ device->ftbl.device_regwrite(device, mmRBBM_SOFT_RESET, 0x00000000);
// RBBM control
- kgsl_device_regwrite(device->id, mmRBBM_CNTL, 0x00004442);
+ device->ftbl.device_regwrite(device, mmRBBM_CNTL, 0x00004442);
// setup MH arbiter
- kgsl_device_regwrite(device->id, mmMH_ARBITER_CONFIG, *(unsigned int *) &gsl_cfg_yamato_mharb);
+ device->ftbl.device_regwrite(device, mmMH_ARBITER_CONFIG, *(unsigned int *) &gsl_cfg_yamato_mharb);
// SQ_*_PROGRAM
- kgsl_device_regwrite(device->id, mmSQ_VS_PROGRAM, 0x00000000);
- kgsl_device_regwrite(device->id, mmSQ_PS_PROGRAM, 0x00000000);
+ device->ftbl.device_regwrite(device, mmSQ_VS_PROGRAM, 0x00000000);
+ device->ftbl.device_regwrite(device, mmSQ_PS_PROGRAM, 0x00000000);
// init interrupt
status = kgsl_intr_init(device);
if (status != GSL_SUCCESS)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
return (status);
}
@@ -359,7 +358,7 @@ kgsl_yamato_init(gsl_device_t *device)
status = kgsl_mmu_init(device);
if (status != GSL_SUCCESS)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
return (status);
}
@@ -409,7 +408,7 @@ kgsl_yamato_destroy(gsl_device_t *device)
pid = device->callerprocess[i];
if (pid)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
kgsl_driver_destroy(pid);
// todo: terminate client process?
@@ -436,8 +435,8 @@ kgsl_yamato_start(gsl_device_t *device, gsl_flags_t flags)
// default power management override when running in safe mode
pm1 = (device->flags & GSL_FLAGS_SAFEMODE) ? 0xFFFFFFFE : 0x00000000;
pm2 = (device->flags & GSL_FLAGS_SAFEMODE) ? 0x000000FF : 0x00000000;
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE1, pm1);
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE2, pm2);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE1, pm1);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE2, pm2);
// enable rbbm interrupts
kgsl_intr_attach(&device->intr, GSL_INTR_YDX_RBBM_READ_ERROR, kgsl_yamato_rbbmintrcallback, (void *) device);
@@ -465,7 +464,7 @@ kgsl_yamato_start(gsl_device_t *device, gsl_flags_t flags)
status = kgsl_ringbuffer_init(device);
if (status != GSL_SUCCESS)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
return (status);
}
@@ -473,7 +472,7 @@ kgsl_yamato_start(gsl_device_t *device, gsl_flags_t flags)
status = kgsl_drawctxt_init(device);
if (status != GSL_SUCCESS)
{
- kgsl_device_stop(device->id);
+ device->ftbl.device_stop(device);
return (status);
}
@@ -570,13 +569,13 @@ kgsl_yamato_setproperty(gsl_device_t *device, gsl_property_type_t type, void *va
{
if (power->flags & GSL_PWRFLAGS_OVERRIDE_ON)
{
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE1, 0xfffffffe);
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE2, 0xffffffff);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE1, 0xfffffffe);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE2, 0xffffffff);
}
else if (power->flags & GSL_PWRFLAGS_OVERRIDE_OFF)
{
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE1, 0x00000000);
- kgsl_device_regwrite(device->id, mmRBBM_PM_OVERRIDE2, 0x00000000);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE1, 0x00000000);
+ device->ftbl.device_regwrite(device, mmRBBM_PM_OVERRIDE2, 0x00000000);
}
else
{
@@ -730,10 +729,7 @@ kgsl_yamato_idle(gsl_device_t *device, unsigned int timeout)
(void) timeout; // unreferenced formal parameter
- KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, KGSL_DEBUG_DUMPX(BB_DUMP_REGPOLL, device->id, mmRBBM_STATUS, 0x80000000, "kgsl_device_idle"));
-
- GSL_RB_MUTEX_LOCK();
- GSL_API_MUTEX_UNLOCK();
+ KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, KGSL_DEBUG_DUMPX(BB_DUMP_REGPOLL, device->id, mmRBBM_STATUS, 0x80000000, "kgsl_yamato_idle"));
// first, wait until the CP has consumed all the commands in the ring buffer
if (rb->flags & GSL_FLAGS_STARTED)
@@ -748,7 +744,7 @@ kgsl_yamato_idle(gsl_device_t *device, unsigned int timeout)
// now, wait for the GPU to finish its operations
for ( ; ; )
{
- kgsl_device_regread(device->id, mmRBBM_STATUS, (unsigned int *)&rbbm_status);
+ device->ftbl.device_regread(device, mmRBBM_STATUS, (unsigned int *)&rbbm_status);
if (!(rbbm_status.val & 0x80000000))
{
@@ -758,9 +754,6 @@ kgsl_yamato_idle(gsl_device_t *device, unsigned int timeout)
}
- GSL_API_MUTEX_LOCK();
- GSL_RB_MUTEX_UNLOCK();
-
return (status);
}
@@ -798,7 +791,7 @@ kgsl_yamato_regwrite(gsl_device_t *device, unsigned int offsetwords, unsigned in
// idle device when running in safe mode
if (device->flags & GSL_FLAGS_SAFEMODE)
{
- kgsl_device_idle(device->id, GSL_TIMEOUT_DEFAULT);
+ device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT);
}
return (GSL_SUCCESS);
@@ -816,18 +809,14 @@ kgsl_yamato_waitirq(gsl_device_t *device, gsl_intrid_t intr_id, unsigned int *co
{
if (kgsl_intr_isenabled(&device->intr, intr_id) == GSL_SUCCESS)
{
- GSL_API_MUTEX_UNLOCK();
-
// wait until intr completion event is received
if (kos_event_wait(device->intr.evnt[intr_id], timeout) == OS_SUCCESS)
{
- GSL_API_MUTEX_LOCK();
*count = 1;
status = GSL_SUCCESS;
}
else
{
- GSL_API_MUTEX_LOCK();
status = GSL_FAILURE_TIMEOUT;
}
}
diff --git a/drivers/mxc/amd-gpu/include/gsl_cmdstream.h b/drivers/mxc/amd-gpu/include/gsl_cmdstream.h
index 652b3750f193..550d5d0005ab 100644
--- a/drivers/mxc/amd-gpu/include/gsl_cmdstream.h
+++ b/drivers/mxc/amd-gpu/include/gsl_cmdstream.h
@@ -37,13 +37,13 @@
#ifdef VG_HDK
#define GSL_CMDSTREAM_GET_SOP_TIMESTAMP(device, data)
#else
-#define GSL_CMDSTREAM_GET_SOP_TIMESTAMP(device, data) kgsl_sharedmem_read(&device->memstore, (data), GSL_DEVICE_MEMSTORE_OFFSET(soptimestamp), 4, false)
+#define GSL_CMDSTREAM_GET_SOP_TIMESTAMP(device, data) kgsl_sharedmem_read0(&device->memstore, (data), GSL_DEVICE_MEMSTORE_OFFSET(soptimestamp), 4, false)
#endif
#ifdef VG_HDK
#define GSL_CMDSTREAM_GET_EOP_TIMESTAMP(device, data) (*((int*)data) = (gsl_driver.device[GSL_DEVICE_G12-1]).timestamp)
#else
-#define GSL_CMDSTREAM_GET_EOP_TIMESTAMP(device, data) kgsl_sharedmem_read(&device->memstore, (data), GSL_DEVICE_MEMSTORE_OFFSET(eoptimestamp), 4, false)
+#define GSL_CMDSTREAM_GET_EOP_TIMESTAMP(device, data) kgsl_sharedmem_read0(&device->memstore, (data), GSL_DEVICE_MEMSTORE_OFFSET(eoptimestamp), 4, false)
#endif
@@ -54,6 +54,7 @@
//////////////////////////////////////////////////////////////////////////////
// functions
//////////////////////////////////////////////////////////////////////////////
+gsl_timestamp_t kgsl_cmdstream_readtimestamp0(gsl_deviceid_t device_id, gsl_timestamp_type_t type);
void kgsl_cmdstream_memqueue_drain(gsl_device_t *device);
int kgsl_cmdstream_init(gsl_device_t *device);
int kgsl_cmdstream_close(gsl_device_t *device);
diff --git a/drivers/mxc/amd-gpu/include/gsl_cmdwindow.h b/drivers/mxc/amd-gpu/include/gsl_cmdwindow.h
index 93ecf8220244..0152dd75a631 100644
--- a/drivers/mxc/amd-gpu/include/gsl_cmdwindow.h
+++ b/drivers/mxc/amd-gpu/include/gsl_cmdwindow.h
@@ -46,5 +46,6 @@
//////////////////////////////////////////////////////////////////////////////
int kgsl_cmdwindow_init(gsl_device_t *device);
int kgsl_cmdwindow_close(gsl_device_t *device);
+int kgsl_cmdwindow_write0(gsl_deviceid_t device_id, gsl_cmdwindow_t target, unsigned int addr, unsigned int data);
#endif // __GSL_CMDWINDOW_H
diff --git a/drivers/mxc/amd-gpu/include/gsl_device.h b/drivers/mxc/amd-gpu/include/gsl_device.h
index 3276e6ffb717..433dc6963dfd 100644
--- a/drivers/mxc/amd-gpu/include/gsl_device.h
+++ b/drivers/mxc/amd-gpu/include/gsl_device.h
@@ -91,14 +91,12 @@ struct _gsl_device_t {
#ifdef GSL_BLD_YAMATO
gsl_memregion_t gmemspace;
gsl_ringbuffer_t ringbuffer;
- oshandle_t drawctxt_mutex;
unsigned int drawctxt_count;
gsl_drawctxt_t *drawctxt_active;
gsl_drawctxt_t drawctxt[GSL_CONTEXT_MAX];
#endif // GSL_BLD_YAMATO
#ifdef GSL_BLD_G12
- oshandle_t cmdwindow_mutex;
unsigned int intrcnt[GSL_G12_INTR_COUNT];
gsl_timestamp_t current_timestamp;
gsl_timestamp_t timestamp;
@@ -110,7 +108,6 @@ struct _gsl_device_t {
oshandle_t irqthread_event;
#endif
#endif // GSL_BLD_G12
- oshandle_t cmdstream_mutex;
#ifndef _LINUX
oshandle_t timestamp_event;
#else
diff --git a/drivers/mxc/amd-gpu/include/gsl_mmu.h b/drivers/mxc/amd-gpu/include/gsl_mmu.h
index e894cb7dc822..868c5156f290 100644
--- a/drivers/mxc/amd-gpu/include/gsl_mmu.h
+++ b/drivers/mxc/amd-gpu/include/gsl_mmu.h
@@ -135,7 +135,6 @@ typedef struct _gsl_tlbflushfilter_t {
// mmu object
// ----------
typedef struct _gsl_mmu_t {
- oshandle_t mutex;
unsigned int refcnt;
gsl_flags_t flags;
gsl_device_t *device;
diff --git a/drivers/mxc/amd-gpu/include/gsl_ringbuffer.h b/drivers/mxc/amd-gpu/include/gsl_ringbuffer.h
index d4bdf34c0bae..6081c396f6e4 100644
--- a/drivers/mxc/amd-gpu/include/gsl_ringbuffer.h
+++ b/drivers/mxc/amd-gpu/include/gsl_ringbuffer.h
@@ -137,8 +137,6 @@ typedef struct _gsl_ringbuffer_t {
gsl_device_t *device;
gsl_flags_t flags;
- oshandle_t mutex;
-
gsl_memdesc_t buffer_desc; // allocated memory descriptor
gsl_memdesc_t memptrs_desc;
@@ -165,19 +163,6 @@ typedef struct _gsl_ringbuffer_t {
// macros
//////////////////////////////////////////////////////////////////////////////
-#ifdef GSL_LOCKING_FINEGRAIN
-#define GSL_RB_MUTEX_CREATE() rb->mutex = kos_mutex_create("gsl_ringbuffer"); \
- if (!rb->mutex) {return (GSL_FAILURE);}
-#define GSL_RB_MUTEX_LOCK() kos_mutex_lock(rb->mutex)
-#define GSL_RB_MUTEX_UNLOCK() kos_mutex_unlock(rb->mutex)
-#define GSL_RB_MUTEX_FREE() kos_mutex_free(rb->mutex); rb->mutex = 0;
-#else
-#define GSL_RB_MUTEX_CREATE()
-#define GSL_RB_MUTEX_LOCK()
-#define GSL_RB_MUTEX_UNLOCK()
-#define GSL_RB_MUTEX_FREE()
-#endif
-
// ----------
// ring write
// ----------
@@ -206,10 +191,10 @@ typedef struct _gsl_ringbuffer_t {
// --------
#ifdef GSL_RB_USE_MEM_RPTR
#define GSL_RB_CNTL_NO_UPDATE 0x0 // enable
-#define GSL_RB_GET_READPTR(rb, data) kgsl_sharedmem_read(&(rb)->memptrs_desc, (data), GSL_RB_MEMPTRS_RPTR_OFFSET, 4, false)
+#define GSL_RB_GET_READPTR(rb, data) kgsl_sharedmem_read0(&(rb)->memptrs_desc, (data), GSL_RB_MEMPTRS_RPTR_OFFSET, 4, false)
#else
#define GSL_RB_CNTL_NO_UPDATE 0x1 // disable
-#define GSL_RB_GET_READPTR(rb, data) kgsl_device_regread((rb)->device->id, mmCP_RB_RPTR,(data))
+#define GSL_RB_GET_READPTR(rb, data) (rb)->device->fbtl.device_regread((rb)->device, mmCP_RB_RPTR,(data))
#endif // GSL_RB_USE_MEMRPTR
// ------------
diff --git a/drivers/mxc/amd-gpu/include/gsl_sharedmem.h b/drivers/mxc/amd-gpu/include/gsl_sharedmem.h
index 1cb2d659d9e1..bb9692cc1e44 100644
--- a/drivers/mxc/amd-gpu/include/gsl_sharedmem.h
+++ b/drivers/mxc/amd-gpu/include/gsl_sharedmem.h
@@ -48,7 +48,6 @@
#define GSL_APERTURE_GETHOSTADDR(shmem, aperture_index) \
shmem.apertures[aperture_index].memarena->hostbaseaddr;
-
//////////////////////////////////////////////////////////////////////////////
// types
//////////////////////////////////////////////////////////////////////////////
@@ -100,7 +99,11 @@ typedef struct _gsl_sharedmem_t
//////////////////////////////////////////////////////////////////////////////
int kgsl_sharedmem_init(gsl_sharedmem_t *shmem);
int 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);
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);
diff --git a/drivers/mxc/amd-gpu/os/kernel/include/kos_libapi.h b/drivers/mxc/amd-gpu/os/kernel/include/kos_libapi.h
index 6042b25765f7..a02c396c22a9 100644
--- a/drivers/mxc/amd-gpu/os/kernel/include/kos_libapi.h
+++ b/drivers/mxc/amd-gpu/os/kernel/include/kos_libapi.h
@@ -57,9 +57,9 @@ extern "C" {
// KOS lib entrypoints
//////////////////////////////////////////////////////////////////////////////
#ifdef __KOSLIB_EXPORTS
-#define KOS_API extern //KOS_DLLEXPORT
+#define KOS_API KOS_DLLEXPORT
#else
-#define KOS_API extern //KOS_DLLIMPORT
+#define KOS_API KOS_DLLIMPORT
#endif // __KOSLIB_EXPORTS
//////////////////////////////////////////////////////////////////////////////
@@ -79,16 +79,12 @@ KOS_API void kos_assert_hook(const char* file, int line, int
//#include <assert.h>
//#define KOS_ASSERT(expression) assert(expression)
#define KOS_ASSERT(expression) /**/
-#elif defined(_LINUX)
-#include <assert.h>
-#define KOS_ASSERT(expression) //BUG_ON(!(expression));
-#error KOS_ASSERT DEFINED, FINALLY!
#elif defined(__ARM__)
#define KOS_ASSERT(expression)
-#endif // _WIN32 _WIN32_WCE
-
#elif defined(_LINUX)
- #define KOS_ASSERT(expression) //kos_assert_hook(__FILE__, __LINE__, (int)(expression));
+#define KOS_ASSERT(expression) //kos_assert_hook(__FILE__, __LINE__, (int)(expression))
+#endif
+
#else
#define KOS_ASSERT(expression)
@@ -381,7 +377,7 @@ KOS_API unsigned int kos_strtoul(const char* nptr, char** endptr, int base);
* \param void* name Name string for the new mutex.
* \return Returns a handle to the mutex.
*//*-------------------------------------------------------------------*/
-KOS_API oshandle_t kos_mutex_create(char* name);
+KOS_API oshandle_t kos_mutex_create(const char* name);
/*-------------------------------------------------------------------*//*!
* \external
* \brief Get a handle to an already existing mutex.
@@ -390,7 +386,7 @@ KOS_API oshandle_t kos_mutex_create(char* name);
* \param void* name Name string for the new mutex.
* \return Returns a handle to the mutex.
*//*-------------------------------------------------------------------*/
-KOS_API oshandle_t kos_mutex_open(char* name);
+KOS_API oshandle_t kos_mutex_open(const char* name);
/*-------------------------------------------------------------------*//*!
* \external
* \brief Free the given mutex.
diff --git a/drivers/mxc/amd-gpu/os/kernel/src/linux/kos_lib.c b/drivers/mxc/amd-gpu/os/kernel/src/linux/kos_lib.c
index f3271ddcad37..4ead84ffe0dc 100644
--- a/drivers/mxc/amd-gpu/os/kernel/src/linux/kos_lib.c
+++ b/drivers/mxc/amd-gpu/os/kernel/src/linux/kos_lib.c
@@ -23,7 +23,8 @@
#include <linux/limits.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
-#include <linux/semaphore.h>
+#include <linux/mutex.h>
+#include <asm/atomic.h>
#include <asm/current.h>
#include <linux/sched.h>
#include <linux/jiffies.h>
@@ -33,40 +34,26 @@
//////////////////////////////////////////////////////////////////////////////
// defines
//////////////////////////////////////////////////////////////////////////////
-#define KOS_STATS_ENABLE
-#define _CRT_SECURE_NO_DEPRECATE
-
+//#define KOS_STATS_ENABLE
//////////////////////////////////////////////////////////////////////////////
-// includes
+// macros
//////////////////////////////////////////////////////////////////////////////
-#define __KOSLIB_EXPORTS
-
-
#define KOS_MALLOC(s) kmalloc(s, GFP_KERNEL)
#define KOS_CALLOC(num, size) kcalloc(num, size, GFP_KERNEL)
#define KOS_REALLOC(p, s) krealloc(p, s, GFP_KERNEL)
#define KOS_FREE(p) kfree(p); p = 0
#define KOS_DBGFLAGS_SET(flag)
-
//////////////////////////////////////////////////////////////////////////////
// stats
//////////////////////////////////////////////////////////////////////////////
-
#ifdef KOS_STATS_ENABLE
-
os_stats_t kos_stats = {0, 0, 0, 0, 0, 0, 0, 0};
-
#define KOS_STATS(x) x
-
#else
#define KOS_STATS(x)
-#endif // KOS_STATS_ENABLE
-
-
-extern unsigned int get_current_fd(void); // QUICK HACK
-
+#endif
//////////////////////////////////////////////////////////////////////////////
// assert API
@@ -242,10 +229,7 @@ KOS_API int
kos_alloc_physical(void** virt_addr, void** phys_addr, int pages)
{
*virt_addr = dma_alloc_coherent(NULL, pages*PAGE_SIZE, (dma_addr_t*)*phys_addr, GFP_DMA | GFP_KERNEL);
- if(*virt_addr == NULL)
- printk(KERN_ERR "%s:dma_alloc_coherent error:pages=%d\n", __func__, pages);
-
- return OS_SUCCESS;
+ return *virt_addr ? OS_SUCCESS : OS_FAILURE;
}
//----------------------------------------------------------------------------
@@ -359,77 +343,39 @@ kos_strlen(const char* string)
return strlen(string);
}
-//----------------------------------------------------------------------------
-#if 0
-KOS_API int
-kos_atoi(const char* string)
-{
- return atoi(string);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API unsigned int
-kos_strtoul(const char* nptr, char** endptr, int base)
-{
- return (unsigned int)strtoul(nptr, endptr, base);
-}
-#endif
-
-
//////////////////////////////////////////////////////////////////////////////
// sync API
//////////////////////////////////////////////////////////////////////////////
-#define kos_mutex_get(mutexhandle, mutex) \
- if (!mutexhandle) return (OS_FAILURE); \
- mutex = (struct mutex *)mutexhandle;
-
-//----------------------------------------------------------------------------
-
-oshandle_t
-kos_mutex_create(char* name)
+KOS_API oshandle_t
+kos_mutex_create(const char *name)
{
- struct mutex *mutex;
-
- mutex = kos_malloc(sizeof(struct mutex));
- KOS_ASSERT(mutex);
- if (!mutex) return (OS_HANDLE_NULL);
-
- mutex_init(mutex);
-
- KOS_STATS(kos_stats.objects_alloc++);
-
- return (oshandle_t)mutex;
+ struct mutex *mutex = KOS_MALLOC(sizeof(struct mutex));
+ if (!mutex)
+ return 0;
+ mutex_init(mutex);
+ return mutex;
}
//----------------------------------------------------------------------------
-/*
+
KOS_API oshandle_t
-kos_mutex_open(char* name)
+kos_mutex_open(const char *name)
{
- // only for inter-process mutexes
- if (name == NULL)
- return (OS_HANDLE_NULL);
-
- return (kos_mutex_create(name));
+ // not implemented
+ return 0;
}
-*/
//----------------------------------------------------------------------------
KOS_API int
kos_mutex_free(oshandle_t mutexhandle)
{
- struct mutex *mutex;
- kos_mutex_get(mutexhandle, mutex);
-
- KOS_ASSERT(mutex);
- kos_free(mutex);
-
- KOS_STATS(kos_stats.objects_free++);
-
- return (OS_SUCCESS);
+ struct mutex *mutex = (struct mutex *)mutexhandle;
+ if (!mutex)
+ return OS_FAILURE;
+ KOS_FREE(mutex);
+ return OS_SUCCESS;
}
//----------------------------------------------------------------------------
@@ -437,13 +383,12 @@ kos_mutex_free(oshandle_t mutexhandle)
KOS_API int
kos_mutex_lock(oshandle_t mutexhandle)
{
- struct mutex *mutex;
- kos_mutex_get(mutexhandle, mutex);
-
- KOS_ASSERT(mutex);
- mutex_lock(mutex);
-
- return (OS_SUCCESS);
+ struct mutex *mutex = (struct mutex *)mutexhandle;
+ if (!mutex)
+ return OS_FAILURE;
+ if (mutex_lock_interruptible(mutex) == -EINTR)
+ return OS_FAILURE;
+ return OS_SUCCESS;
}
//----------------------------------------------------------------------------
@@ -451,125 +396,37 @@ kos_mutex_lock(oshandle_t mutexhandle)
KOS_API int
kos_mutex_locktry(oshandle_t mutexhandle)
{
- struct mutex *mutex;
- kos_mutex_get(mutexhandle, mutex);
-
- KOS_ASSERT(mutex);
- return mutex_trylock(mutex);
+ struct mutex *mutex = (struct mutex *)mutexhandle;
+ if (!mutex)
+ return OS_FAILURE;
+ if (!mutex_trylock(mutex))
+ return OS_FAILURE;
+ return OS_SUCCESS;
}
//----------------------------------------------------------------------------
-#if 0
-KOS_API int
-kos_mutex_lockwait(oshandle_t mutexhandle, int millisecondstowait)
-{
- struct mutex *mutex;
- kos_mutex_get(mutexhandle, mutex);
-
- if (mutex->named)
- {
- DWORD result;
-
- if (millisecondstowait == OS_INFINITE) millisecondstowait = INFINITE;
-
- result = WaitForSingleObject(mutex->handle, millisecondstowait);
-
- if (result != WAIT_OBJECT_0) return (OS_FAILURE);
- }
- else
- {
- // WTF???? windows does not have this but wince50 does??
- //BOOL result;
- //result = TryEnterCriticalSection(mutex->critical_section);
- //if (!result) return (OS_FAILURE);
- EnterCriticalSection(&mutex->critical_section);
- }
-
- return (OS_SUCCESS);
-}
-#endif
-//----------------------------------------------------------------------------
KOS_API int
kos_mutex_unlock(oshandle_t mutexhandle)
{
- struct mutex *mutex;
- kos_mutex_get(mutexhandle, mutex);
-
- KOS_ASSERT(mutex);
- mutex_unlock(mutex);
-
- return (OS_SUCCESS);
-}
-
-KOS_API unsigned int
-kos_process_getid(void)
-{
-return get_current_fd();
-// return current->pid;
-}
-
-//----------------------------------------------------------------------------
-#if 0
-KOS_API int
-kos_interlock_incr(int* ptr)
-{
- int retval;
-
- retval = InterlockedIncrement((LONG*)ptr);
-
- return (retval);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_interlock_decr(int* ptr)
-{
- int retval;
-
- retval = InterlockedDecrement((LONG*)ptr);
-
- return (retval);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_interlock_xchg(int* ptr, int value)
-{
- int retval;
-
- retval = InterlockedExchange((LONG*)ptr, value);
-
- return (retval);
+ struct mutex *mutex = (struct mutex *)mutexhandle;
+ if (!mutex)
+ return OS_FAILURE;
+ KOS_ASSERT(mutex_is_locked(mutex));
+ mutex_unlock(mutex);
+ return OS_SUCCESS;
}
//----------------------------------------------------------------------------
-KOS_API int
-kos_interlock_compxchg(int* ptr, int value, int compvalue)
+KOS_API unsigned int
+kos_process_getid(void)
{
- int retval;
-
- retval = InterlockedCompareExchange((LONG*)ptr, value, compvalue);
-
- return ((int)retval);
+ return current->tgid;
}
//----------------------------------------------------------------------------
-KOS_API int
-kos_interlock_xchgadd(int* ptr, int value)
-{
- int retval;
-
- retval = InterlockedExchangeAdd((LONG*)ptr, value);
-
- return (retval);
-}
-#endif
-
/* ------------------------------------------------------------------- *//*
* \brief Creates new event semaphore
* \param uint32 a_manualReset
@@ -667,114 +524,6 @@ kos_event_wait(oshandle_t a_event, int a_milliSeconds)
return (OS_SUCCESS);
}
-#if 0
-//////////////////////////////////////////////////////////////////////////////
-// interrupt handler API
-//////////////////////////////////////////////////////////////////////////////
-KOS_API int
-kos_interrupt_enable(int interrupt)
-{
- (void) interrupt; // unreferenced formal parameter
- KOS_ASSERT(0); // not implemented
-
- return (OS_SUCCESS);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_interrupt_disable(int interrupt)
-{
- (void) interrupt; // unreferenced formal parameter
- KOS_ASSERT(0); // not implemented
-
- return (OS_SUCCESS);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_interrupt_setcallback(int interrupt, void* handler)
-{
-
- KOS_ASSERT(handler);
-
- (void) interrupt; // unreferenced formal parameter
- (void) handler; // unreferenced formal parameter
- KOS_ASSERT(0); // not implemented
-
- return (OS_SUCCESS);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_interrupt_clearcallback(int interrupt, void* handler)
-{
- KOS_ASSERT(handler);
-
- (void) interrupt; // unreferenced formal parameter
- (void) handler; // unreferenced formal parameter
- KOS_ASSERT(0); // not implemented
-
- return (OS_SUCCESS);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-// thread and process API
-//////////////////////////////////////////////////////////////////////////////
-KOS_API unsigned int
-kos_tls_alloc(void)
-{
- DWORD index;
- index = TlsAlloc();
-
- if (index == TLS_OUT_OF_INDEXES) return (OS_TLS_OUTOFINDEXES);
-
- return (index);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_tls_free(unsigned int tlsindex)
-{
- BOOL result;
-
- result = TlsFree(tlsindex);
-
- if (!result) return (OS_FAILURE);
- return (OS_SUCCESS);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API void*
-kos_tls_read(unsigned int tlsindex)
-{
- void* value;
-
- value = TlsGetValue(tlsindex);
-
- return (value);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_tls_write(unsigned int tlsindex, void* tlsvalue)
-{
- BOOL result;
-
- result = TlsSetValue(tlsindex, tlsvalue);
-
- if (!result) return (OS_FAILURE);
- return (OS_SUCCESS);
-}
-
-#endif
-
//----------------------------------------------------------------------------
KOS_API void
@@ -783,112 +532,6 @@ kos_sleep(unsigned int milliseconds)
msleep(milliseconds);
}
-#if 0
-//----------------------------------------------------------------------------
-
-KOS_API unsigned int
-kos_process_getid(void)
-{
- DWORD id;
-
- id = GetCurrentProcessId();
-
- return(id);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API unsigned int
-kos_thread_getid(void)
-{
- DWORD id;
-
- id = GetCurrentThreadId();
-
- return (id);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-// timing API
-//////////////////////////////////////////////////////////////////////////////
-KOS_API unsigned int
-kos_timestamp(void)
-{
- unsigned int milliseconds;
-
- milliseconds = GetTickCount();
-
- return (milliseconds);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-// libary API
-//////////////////////////////////////////////////////////////////////////////
-KOS_API oshandle_t
-kos_lib_map(char* libraryname)
-{
- kos_library_t* lib;
- HMODULE module;
-
- KOS_ASSERT(libraryname);
-
- module = LoadLibrary(libraryname);
-
- if (!module) return (OS_HANDLE_NULL);
-
- lib = (kos_library_t*)kos_malloc(sizeof(kos_library_t));
-
- if (!lib)
- {
- FreeLibrary(module);
- return (OS_HANDLE_NULL);
- }
-
- lib->module = module;
-
- KOS_STATS(kos_stats.objects_alloc++);
-
- return (oshandle_t) lib;
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API int
-kos_lib_unmap(oshandle_t libhandle)
-{
- BOOL result;
- kos_library_t* lib = (kos_library_t*)libhandle;
-
- KOS_ASSERT(lib);
-
- result = FreeLibrary(lib->module);
-
- kos_free(lib);
-
- KOS_STATS(kos_stats.objects_free++);
-
- if (!result) return (OS_FAILURE);
- return (OS_SUCCESS);
-}
-
-//----------------------------------------------------------------------------
-
-KOS_API void*
-kos_lib_getaddr(oshandle_t libhandle, char* procname)
-{
- FARPROC procaddr;
- kos_library_t* lib = (kos_library_t*)libhandle;
-
- KOS_ASSERT(lib);
-
- procaddr = GetProcAddress(lib->module, procname);
-
- return (void*)procaddr;
-}
-#endif
-
//////////////////////////////////////////////////////////////////////////////
// query API
//////////////////////////////////////////////////////////////////////////////
@@ -932,7 +575,7 @@ kos_get_sysinfo(os_sysinfo_t* sysinfo)
//----------------------------------------------------------------------------
-#ifdef KOS_STATS
+#ifdef KOS_STATS_ENABLE
KOS_API int
kos_get_stats(os_stats_t* stats)
{
@@ -943,7 +586,7 @@ kos_get_stats(os_stats_t* stats)
KOS_API int
kos_get_stats(os_stats_t* stats)
{
- return (KOS_NOTSUPPORTED);
+ return (OS_FAILURE);
}
#endif // KOS_STATS
diff --git a/drivers/mxc/amd-gpu/platform/hal/MX35/gsl_buildconfig.h b/drivers/mxc/amd-gpu/platform/hal/MX35/gsl_buildconfig.h
index 49e61b527191..9cfe9fe5b3b8 100644
--- a/drivers/mxc/amd-gpu/platform/hal/MX35/gsl_buildconfig.h
+++ b/drivers/mxc/amd-gpu/platform/hal/MX35/gsl_buildconfig.h
@@ -31,7 +31,7 @@
#define GSL_BLD_G12
-//#define GSL_LOCKING_COURSEGRAIN
+#define GSL_LOCKING_COURSEGRAIN
#define GSL_MMU_TRANSLATION_ENABLED
//#define GSL_MMU_PAGETABLE_PERPROCESS
diff --git a/drivers/mxc/amd-gpu/platform/hal/MX35/linux/gsl_hal.c b/drivers/mxc/amd-gpu/platform/hal/MX35/linux/gsl_hal.c
index dbe52501b25a..294cd9eb5af9 100644
--- a/drivers/mxc/amd-gpu/platform/hal/MX35/linux/gsl_hal.c
+++ b/drivers/mxc/amd-gpu/platform/hal/MX35/linux/gsl_hal.c
@@ -453,6 +453,7 @@ kgsl_hal_getplatformtype(char *platform)
KGSLHAL_API int
kgsl_hal_setpowerstate(gsl_deviceid_t device_id, int state, unsigned int value)
{
+ gsl_device_t *device = &gsl_driver.device[device_id-1]; // device_id is 1 based
struct clk *gpu_clk = 0;
// unreferenced formal parameters
@@ -473,15 +474,15 @@ kgsl_hal_setpowerstate(gsl_deviceid_t device_id, int state, unsigned int value)
switch (state)
{
case GSL_PWRFLAGS_CLK_ON:
- break;
+ break;
case GSL_PWRFLAGS_POWER_ON:
clk_enable(gpu_clk);
kgsl_device_autogate_init(&gsl_driver.device[device_id-1]);
break;
case GSL_PWRFLAGS_CLK_OFF:
- break;
+ break;
case GSL_PWRFLAGS_POWER_OFF:
- if (kgsl_device_idle(device_id, GSL_TIMEOUT_DEFAULT) != GSL_SUCCESS)
+ if (device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT) != GSL_SUCCESS)
{
return (GSL_FAILURE_DEVICEERROR);
}
diff --git a/drivers/mxc/amd-gpu/platform/hal/MX51/gsl_buildconfig.h b/drivers/mxc/amd-gpu/platform/hal/MX51/gsl_buildconfig.h
index 4b1ff9445e83..82824f511d5e 100644
--- a/drivers/mxc/amd-gpu/platform/hal/MX51/gsl_buildconfig.h
+++ b/drivers/mxc/amd-gpu/platform/hal/MX51/gsl_buildconfig.h
@@ -32,7 +32,7 @@
#define GSL_BLD_YAMATO
#define GSL_BLD_G12
-//#define GSL_LOCKING_COURSEGRAIN
+#define GSL_LOCKING_COURSEGRAIN
#define GSL_STATS_MEM
#define GSL_STATS_RINGBUFFER
diff --git a/drivers/mxc/amd-gpu/platform/hal/MX51/linux/gsl_hal.c b/drivers/mxc/amd-gpu/platform/hal/MX51/linux/gsl_hal.c
index e39c2b4d6fba..965416b59ec1 100644
--- a/drivers/mxc/amd-gpu/platform/hal/MX51/linux/gsl_hal.c
+++ b/drivers/mxc/amd-gpu/platform/hal/MX51/linux/gsl_hal.c
@@ -462,18 +462,19 @@ kgsl_hal_getdevconfig(gsl_deviceid_t device_id, gsl_devconfig_t *config)
KGSLHAL_API gsl_chipid_t
kgsl_hal_getchipid(gsl_deviceid_t device_id)
{
+ gsl_device_t *device = &gsl_driver.device[device_id-1];
gsl_chipid_t chipid;
unsigned int coreid, majorid, minorid, patchid, revid;
// YDX
- kgsl_device_regread(device_id, mmRBBM_PERIPHID1, &coreid);
+ device->ftbl.device_regread(device, mmRBBM_PERIPHID1, &coreid);
coreid &= 0xF;
// 2.
- kgsl_device_regread(device_id, mmRBBM_PERIPHID2, &majorid);
+ device->ftbl.device_regread(device, mmRBBM_PERIPHID2, &majorid);
majorid = (majorid >> 4) & 0xF;
- kgsl_device_regread(device_id, mmRBBM_PATCH_RELEASE, &revid);
+ device->ftbl.device_regread(device, mmRBBM_PATCH_RELEASE, &revid);
// 2.
minorid = ((revid >> 0) & 0xFF); // this is a 16bit field, but extremely unlikely it would ever get this high
@@ -507,6 +508,7 @@ kgsl_hal_getplatformtype(char *platform)
KGSLHAL_API int
kgsl_hal_setpowerstate(gsl_deviceid_t device_id, int state, unsigned int value)
{
+ gsl_device_t *device = &gsl_driver.device[device_id-1];
struct clk *gpu_clk = 0;
struct clk *garb_clk = clk_get(0, "garb_clk");
struct clk *emi_garb_clk = clk_get(0, "emi_garb_clk");
@@ -542,7 +544,7 @@ kgsl_hal_setpowerstate(gsl_deviceid_t device_id, int state, unsigned int value)
case GSL_PWRFLAGS_CLK_OFF:
break;
case GSL_PWRFLAGS_POWER_OFF:
- if (kgsl_device_idle(device_id, GSL_TIMEOUT_DEFAULT) != GSL_SUCCESS)
+ if (device->ftbl.device_idle(device, GSL_TIMEOUT_DEFAULT) != GSL_SUCCESS)
{
return (GSL_FAILURE_DEVICEERROR);
}
diff --git a/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod.c b/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod.c
index 28339699f7d5..8af59c77b381 100644
--- a/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod.c
+++ b/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod.c
@@ -15,7 +15,7 @@
* 02110-1301, USA.
*
*/
-
+
#include "gsl_types.h"
#include "gsl.h"
#include "gsl_buildconfig.h"
@@ -34,12 +34,10 @@
#include <asm/uaccess.h>
#include <linux/mm.h>
#include <linux/mutex.h>
-#include <linux/platform_device.h>
-#include <linux/vmalloc.h>
+#include <linux/cdev.h>
-static int gsl_kmod_major; // TODO: move to gsl_kmod_data
-static struct vm_operations_struct gsl_kmod_vmops = {0};
-DEFINE_MUTEX(gsl_mutex); // TODO: move to gsl_kmod_data?
+#include <linux/platform_device.h>
+#include <linux/vmalloc.h>
static int gpu_2d_irq, gpu_3d_irq;
@@ -51,27 +49,133 @@ int gmem_size;
phys_addr_t gpu_reserved_mem;
int gpu_reserved_mem_size;
-/* structure to hold kernel module specific data. */
-struct gsl_kmod_data
+static ssize_t gsl_kmod_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr);
+static ssize_t gsl_kmod_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr);
+static int gsl_kmod_ioctl(struct inode *inode, struct file *fd, unsigned int cmd, unsigned long arg);
+static int gsl_kmod_mmap(struct file *fd, struct vm_area_struct *vma);
+static int gsl_kmod_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
+static int gsl_kmod_open(struct inode *inode, struct file *fd);
+static int gsl_kmod_release(struct inode *inode, struct file *fd);
+static irqreturn_t z160_irq_handler(int irq, void *dev_id);
+#if defined(MX51)
+static irqreturn_t z430_irq_handler(int irq, void *dev_id);
+#endif
+
+static int gsl_kmod_major;
+static struct class *gsl_kmod_class;
+DEFINE_MUTEX(gsl_mutex);
+
+static const struct file_operations gsl_kmod_fops =
+{
+ .owner = THIS_MODULE,
+ .read = gsl_kmod_read,
+ .write = gsl_kmod_write,
+ .ioctl = gsl_kmod_ioctl,
+ .mmap = gsl_kmod_mmap,
+ .open = gsl_kmod_open,
+ .release = gsl_kmod_release
+};
+
+static struct vm_operations_struct gsl_kmod_vmops =
{
-// unsigned int major;
- struct device *device;
- /* stores the current open file descriptor during user process calls.
- * It's a hack but in Linux the upper level driver cannot track processes
- * as they are unique in Linux and not represent thread group as in WinCE.
- */
- struct file *current_fd;
+ .fault = gsl_kmod_fault,
};
-static struct gsl_kmod_data gsl_kmod_data = {0};
+static int __init gsl_kmod_init(void)
+{
+ struct device *dev;
+
+ if (kgsl_driver_init() != GSL_SUCCESS)
+ {
+ printk(KERN_ERR "%s: kgsl_driver_init error\n", __func__);
+ goto kgsl_driver_init_error;
+ }
+
+#if defined(MX51)
+ if (request_irq(MX51_YDX_INTERRUPT, z430_irq_handler, 0, "ydx", NULL) < 0)
+ {
+ printk(KERN_ERR "%s: request_irq error\n", __func__);
+ goto request_irq_error;
+ }
+#endif
+
+#if defined(MX51)
+ if (request_irq(MX51_G12_INTERRUPT, z160_irq_handler, 0, "g12", NULL) < 0)
+#elif defined(MX35)
+ if (request_irq(MX35_G12_INTERRUPT, z160_irq_handler, 0, "g12", NULL) < 0)
+#endif
+ {
+ printk(KERN_ERR "%s: request_irq error\n", __func__);
+ goto request_irq_error;
+ }
+
+ gsl_kmod_major = register_chrdev(0, "gsl_kmod", &gsl_kmod_fops);
+ gsl_kmod_vmops.fault = gsl_kmod_fault;
+
+ if (gsl_kmod_major <= 0)
+ {
+ pr_err("%s: register_chrdev error\n", __func__);
+ goto register_chrdev_error;
+ }
+
+ gsl_kmod_class = class_create(THIS_MODULE, "gsl_kmod");
+
+ if (IS_ERR(gsl_kmod_class))
+ {
+ pr_err("%s: class_create error\n", __func__);
+ goto class_create_error;
+ }
+
+ #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28))
+ dev = device_create(gsl_kmod_class, NULL, MKDEV(gsl_kmod_major, 0), "gsl_kmod");
+ #else
+ dev = device_create(gsl_kmod_class, NULL, MKDEV(gsl_kmod_major, 0), NULL,"gsl_kmod");
+ #endif
+
+ if (!IS_ERR(dev))
+ {
+ return 0;
+ }
+
+ pr_err("%s: device_create error\n", __func__);
+
+class_create_error:
+ class_destroy(gsl_kmod_class);
+
+register_chrdev_error:
+ unregister_chrdev(gsl_kmod_major, "gsl_kmod");
-static unsigned int current_fd;
+request_irq_error:
+kgsl_driver_init_error:
+ kgsl_driver_close();
+ return 0; // TODO: return proper error code
+}
-unsigned int get_current_fd(void)
+static void __exit gsl_kmod_exit(void)
{
- return current_fd;
+ device_destroy(gsl_kmod_class, MKDEV(gsl_kmod_major, 0));
+ class_destroy(gsl_kmod_class);
+ unregister_chrdev(gsl_kmod_major, "gsl_kmod");
+#if defined(MX51)
+ free_irq(MX51_YDX_INTERRUPT, NULL);
+ free_irq(MX51_G12_INTERRUPT, NULL);
+#elif defined(MX35)
+ free_irq(MX35_G12_INTERRUPT, NULL);
+#endif
+ kgsl_driver_close();
}
+module_init(gsl_kmod_init);
+module_exit(gsl_kmod_exit);
+
+MODULE_AUTHOR("Advanced Micro Devices");
+#if defined(MX51)
+MODULE_DESCRIPTION("AMD 2D/3D graphics core driver for i.MX51");
+#elif defined(MX35)
+MODULE_DESCRIPTION("AMD 2D graphics core driver for i.MX35");
+#endif
+MODULE_LICENSE("GPL v2");
+
static ssize_t gsl_kmod_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr)
{
return 0;
@@ -86,12 +190,6 @@ static int gsl_kmod_ioctl(struct inode *inode, struct file *fd, unsigned int cmd
{
int kgslStatus = GSL_FAILURE;
- if(mutex_lock_interruptible(&gsl_mutex))
- {
- return -EINTR;
- }
- current_fd = (unsigned int)fd;
-
switch (cmd) {
case IOCTL_KGSL_DEVICE_START:
{
@@ -502,7 +600,7 @@ static int gsl_kmod_ioctl(struct inode *inode, struct file *fd, unsigned int cmd
{
printk(KERN_ERR "%s: kgsl_sharedmem_write failed\n", __func__);
}
-
+
break;
}
case IOCTL_KGSL_SHAREDMEM_SET:
@@ -603,6 +701,7 @@ static int gsl_kmod_ioctl(struct inode *inode, struct file *fd, unsigned int cmd
kgslStatus = GSL_SUCCESS;
break;
}
+
case IOCTL_KGSL_DEVICE_CLOCK:
{
kgsl_device_clock_t param;
@@ -620,10 +719,6 @@ static int gsl_kmod_ioctl(struct inode *inode, struct file *fd, unsigned int cmd
break;
}
- current_fd = 0;
-
- mutex_unlock(&gsl_mutex);
-
return kgslStatus;
}
@@ -639,13 +734,6 @@ static int gsl_kmod_mmap(struct file *fd, struct vm_area_struct *vma)
void *va;
#endif
- if(mutex_lock_interruptible(&gsl_mutex))
- {
- return -EINTR;
- }
-
- current_fd = (unsigned int)fd;
-
#ifdef GSL_MMU_TRANSLATION_ENABLED
if (addr < GSL_LINUX_MAP_RANGE_END && addr >= GSL_LINUX_MAP_RANGE_START)
{
@@ -654,8 +742,6 @@ static int gsl_kmod_mmap(struct file *fd, struct vm_area_struct *vma)
{
if (remap_pfn_range(vma, start, vmalloc_to_pfn(va), PAGE_SIZE, prot))
{
- current_fd = 0;
- mutex_unlock(&gsl_mutex);
return -EAGAIN;
}
start += PAGE_SIZE;
@@ -674,16 +760,9 @@ static int gsl_kmod_mmap(struct file *fd, struct vm_area_struct *vma)
vma->vm_ops = &gsl_kmod_vmops;
- current_fd = 0;
-
- mutex_unlock(&gsl_mutex);
-
return status;
}
-/* we install fault handler here to signal bus error if user tries to access
- * outside of VMA.
- */
static int gsl_kmod_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
return VM_FAULT_SIGBUS;
@@ -700,8 +779,6 @@ static int gsl_kmod_open(struct inode *inode, struct file *fd)
return -EINTR;
}
- current_fd = (unsigned int)fd;
-
if (kgsl_driver_entry(flags) != GSL_SUCCESS)
{
printk(KERN_INFO "%s: kgsl_driver_entry error\n", __func__);
@@ -726,8 +803,6 @@ static int gsl_kmod_open(struct inode *inode, struct file *fd)
}
}
- current_fd = 0;
-
mutex_unlock(&gsl_mutex);
return err;
@@ -743,8 +818,6 @@ static int gsl_kmod_release(struct inode *inode, struct file *fd)
return -EINTR;
}
- current_fd = (unsigned int)fd;
-
/* make sure contexts are destroyed */
del_all_devices_contexts(fd);
@@ -762,8 +835,6 @@ static int gsl_kmod_release(struct inode *inode, struct file *fd)
fd->private_data = 0;
}
- current_fd = 0;
-
mutex_unlock(&gsl_mutex);
return err;
@@ -771,17 +842,6 @@ static int gsl_kmod_release(struct inode *inode, struct file *fd)
static struct class *gsl_kmod_class;
-static const struct file_operations gsl_kmod_fops =
-{
- .owner = THIS_MODULE,
- .read = gsl_kmod_read,
- .write = gsl_kmod_write,
- .ioctl = gsl_kmod_ioctl,
- .mmap = gsl_kmod_mmap,
- .open = gsl_kmod_open,
- .release = gsl_kmod_release
-};
-
static irqreturn_t z160_irq_handler(int irq, void *dev_id)
{
kgsl_intr_isr();
@@ -891,7 +951,7 @@ static int gpu_probe(struct platform_device *pdev)
if (!IS_ERR(dev))
{
- gsl_kmod_data.device = dev;
+ // gsl_kmod_data.device = dev;
return 0;
}
@@ -987,20 +1047,6 @@ static struct platform_driver gpu_driver = {
.resume = gpu_resume,
};
-static int __init gsl_kmod_init(void)
-{
- int ret = platform_driver_register(&gpu_driver);
-
- return ret;
-}
-
-static void __exit gsl_kmod_exit(void)
-{
- platform_driver_unregister(&gpu_driver);
-}
-
-module_init(gsl_kmod_init);
-module_exit(gsl_kmod_exit);
MODULE_AUTHOR("Advanced Micro Devices Inc.");
#if defined(MX51)
diff --git a/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod_cleanup.c b/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod_cleanup.c
index 3947aa38795f..3685a5756baf 100644
--- a/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod_cleanup.c
+++ b/drivers/mxc/amd-gpu/platform/hal/linux/gsl_kmod_cleanup.c
@@ -15,7 +15,7 @@
* 02110-1301, USA.
*
*/
-
+
#include "gsl.h"
#include "gsl_kmod_cleanup.h"
@@ -173,8 +173,8 @@ int del_all_memblocks_from_allocated_list(struct file *fd)
printk(KERN_INFO "Not all allocated memory blocks were freed. Doing it now.\n");
list_for_each_entry_safe(cursor, next, head, node)
{
+ printk(KERN_INFO "Freeing list entry #%u, gpuaddr=%x\n", (u32)cursor->allocation_number, cursor->allocated_block.gpuaddr);
kgsl_sharedmem_free(&cursor->allocated_block);
- printk(KERN_INFO "Freeing list entry #%u\n", (u32)cursor->allocation_number);
list_del(&cursor->node);
kfree(cursor);
}