Implement memory managment which allows us to allocate static memory areas in

the framebuffer without exa.

5 files changed, 64 insertions, 72 deletions

diff --git a/src/glamo-cmdq.c b/src/glamo-cmdq.c
index c690407..0c082c5 100644
--- a/src/glamo-cmdq.c
+++ b/src/glamo-cmdq.c
@@ -330,33 +330,26 @@ GLAMODispatchCMDQCache(GlamoPtr pGlamo)
     /* Wrap around */
     if (ring_write >= new_ring_write) {
         rest_size = (ring_count - ring_write);
-        memcpy((char*)(pGlamo->ring_addr) + ring_write, addr, rest_size);
-        memcpy((char*)(pGlamo->ring_addr), addr+rest_size, count - rest_size);
+        memcpy(pGlamo->ring_addr + ring_write, addr, rest_size);
+        memcpy(pGlamo->ring_addr, addr+rest_size, count - rest_size);
 
         /* ring_write being 0 will result in a deadlock because the cmdq read
          * will never stop. To avoid such an behaviour insert an empty
          * instruction. */
         if (new_ring_write == 0) {
-            memset((char*)(pGlamo->ring_addr), 0, 4);
+            memset(pGlamo->ring_addr, 0, 4);
             new_ring_write = 4;
         }
 
-        /* Before changing write read has to stop */
-        GLAMOEngineWaitReal(pGlamo, GLAMO_ENGINE_CMDQ, FALSE);
-
         /* The write position has to change to trigger a read */
         if (ring_write == new_ring_write) {
-            memset((char*)(pGlamo->ring_addr + new_ring_write), 0, 4);
+            memset(pGlamo->ring_addr + new_ring_write, 0, 4);
             new_ring_write += 4;
-/*            MMIO_OUT16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRH,
-                       ((pGlamo->ring_write-4) >> 16) & CQ_MASKH);
-            MMIO_OUT16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRL,
-                       (pGlamo->ring_write-4) & CQ_MASKL);*/
         }
     } else {
-        memcpy((char*)(pGlamo->ring_addr) + ring_write, addr, count);
-        GLAMOEngineWaitReal(pGlamo, GLAMO_ENGINE_CMDQ, FALSE);
+        memcpy(pGlamo->ring_addr + ring_write, addr, count);
     }
+    GLAMOEngineWaitReal(pGlamo, GLAMO_ENGINE_CMDQ, FALSE);
     MMIOSetBitMask(mmio, GLAMO_REG_CLOCK_2D,
 					GLAMO_CLOCK_2D_EN_M6CLK,
 					0);
@@ -370,8 +363,6 @@ GLAMODispatchCMDQCache(GlamoPtr pGlamo)
                 GLAMO_CLOCK_2D_EN_M6CLK,
 					0xffff);
     buf->used = 0;
-
-    GLAMOEngineWaitReal(pGlamo, GLAMO_ENGINE_ALL, FALSE);
 }
 
 void
@@ -384,17 +375,16 @@ static void
 GLAMOCMDQResetCP(GlamoPtr pGlamo)
 {
 	volatile char *mmio = pGlamo->reg_base;
-	CARD32 queue_offset = pGlamo->exa_cmd_queue->offset;
 
 	/* make the decoder happy? */
-	memset((char*)pGlamo->ring_addr, 0, pGlamo->ring_len);
+	memset(pGlamo->ring_addr, 0, pGlamo->ring_len);
 
 	GLAMOEngineReset(pGlamo, GLAMO_ENGINE_CMDQ);
 
 	MMIO_OUT16(mmio, GLAMO_REG_CMDQ_BASE_ADDRL,
-		   queue_offset & 0xffff);
+		   pGlamo->ring_start & 0xffff);
 	MMIO_OUT16(mmio, GLAMO_REG_CMDQ_BASE_ADDRH,
-		   (queue_offset >> 16) & 0x7f);
+		   (pGlamo->ring_start >> 16) & 0x7f);
 	MMIO_OUT16(mmio, GLAMO_REG_CMDQ_LEN, CQ_LEN);
 
 	MMIO_OUT16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRH, 0);
@@ -408,15 +398,18 @@ GLAMOCMDQResetCP(GlamoPtr pGlamo)
 	GLAMOEngineWaitReal(pGlamo, GLAMO_ENGINE_ALL, FALSE);
 }
 
-Bool
-GLAMOCMDQInit(ScrnInfoPtr pScrn)
+size_t
+GLAMOCMDQInit(ScrnInfoPtr pScrn, size_t mem_start, size_t mem_size)
 {
     GlamoPtr pGlamo = GlamoPTR(pScrn);
     MemBuf *buf;
 
+    pGlamo->ring_start = mem_start;
+    pGlamo->ring_addr = pGlamo->fbstart + pGlamo->ring_start;
+
     pGlamo->ring_len = (CQ_LEN + 1) * 1024;
 
-    buf = (MemBuf *)xcalloc(1, sizeof(MemBuf) + pGlamo->ring_len - 1);
+    buf = (MemBuf *)xcalloc(1, sizeof(MemBuf) + pGlamo->ring_len);
 
     if (!buf) {
         return FALSE;
@@ -425,28 +418,15 @@ GLAMOCMDQInit(ScrnInfoPtr pScrn)
 	buf->size = pGlamo->ring_len;
 	buf->used = 0;
 
-    pGlamo->exa_cmd_queue = exaOffscreenAlloc(pGlamo->pScreen, pGlamo->ring_len,
-				                              pGlamo->exa->pixmapOffsetAlign,
-                                              TRUE, NULL, NULL);
-
-    if (!pGlamo->exa_cmd_queue) {
-        xfree(buf);
-        return FALSE;
-    }
-
-    pGlamo->ring_addr = (CARD16 *)(pGlamo->fbstart + pGlamo->exa_cmd_queue->offset);
-
 	pGlamo->cmd_queue_cache = buf;
 
-    return TRUE;
+    return pGlamo->ring_len;
 }
 
 Bool
 GLAMOCMDQEnable(ScrnInfoPtr pScrn) {
     GlamoPtr pGlamo = GlamoPTR(pScrn);
 
-    pGlamo->ring_addr =	(CARD16 *) (pGlamo->fbstart + pGlamo->exa_cmd_queue->offset);
-
     GLAMOEngineEnable(pGlamo, GLAMO_ENGINE_CMDQ);
     GLAMOCMDQResetCP(pGlamo);
 
@@ -471,10 +451,6 @@ GLAMOCMDQFini(ScrnInfoPtr pScrn) {
 	    xfree(pGlamo->cmd_queue_cache);
 	    pGlamo->cmd_queue_cache = NULL;
     }
-    if (pGlamo->exa_cmd_queue) {
-        exaOffscreenFree(pGlamo->pScreen, pGlamo->exa_cmd_queue);
-        pGlamo->exa_cmd_queue = NULL;
-    }
 }
 
 #if 0
diff --git a/src/glamo-cmdq.h b/src/glamo-cmdq.h
index ae2db7d..b6d9070 100644
--- a/src/glamo-cmdq.h
+++ b/src/glamo-cmdq.h
@@ -135,8 +135,8 @@ tv_le(struct timeval *tv1, struct timeval *tv2)
 void
 GLAMOFlushCMDQCache(GlamoPtr pGlamo, Bool discard);
 
-Bool
-GLAMOCMDQInit(ScrnInfoPtr pScrn);
+size_t
+GLAMOCMDQInit(ScrnInfoPtr pScrn, size_t mem_start, size_t mem_size);
 
 Bool
 GLAMOCMDQEnable(ScrnInfoPtr pScrn);
diff --git a/src/glamo-draw.c b/src/glamo-draw.c
index 2a951b1..78fcbf2 100644
--- a/src/glamo-draw.c
+++ b/src/glamo-draw.c
@@ -75,7 +75,7 @@ static const CARD8 GLAMOBltRop[16] = {
  ********************************/
 
 static Bool
-GLAMODrawExaInit(ScrnInfoPtr pScrn);
+GLAMODrawExaInit(ScrnInfoPtr pScrn, size_t mem_start, size_t mem_size);
 
 Bool
 GLAMOExaPrepareSolid(PixmapPtr      pPixmap,
@@ -171,17 +171,22 @@ GLAMOWakeupHandler(pointer blockData, int result, pointer readmask)
 {
 }
 
-Bool
-GLAMODrawInit(ScrnInfoPtr pScrn)
+size_t
+GLAMODrawInit(ScrnInfoPtr pScrn, size_t mem_start, size_t mem_size)
 {
-    if (!GLAMODrawExaInit(pScrn))
-        return FALSE;
+    size_t mem_used;
 
-	if (!GLAMOCMDQInit(pScrn)) {
+    mem_used = GLAMOCMDQInit(pScrn, mem_start, mem_size);
+
+	if (!mem_used) {
         GLAMODrawFini(pScrn);
         return FALSE;
     }
-    return TRUE;
+
+    if (!GLAMODrawExaInit(pScrn, mem_start + mem_used, mem_size - mem_used))
+        return 0;
+
+    return mem_size;
 }
 
 void
@@ -203,7 +208,10 @@ GLAMODrawEnable(ScrnInfoPtr pScrn)
 
 	GLAMOEngineEnable(pGlamo, GLAMO_ENGINE_2D);
 	GLAMOEngineReset(pGlamo, GLAMO_ENGINE_2D);
-    GLAMOCMDQEnable(pScrn);
+    if (!GLAMOCMDQEnable(pScrn)) {
+        GLAMODrawDisable(pScrn);
+        return FALSE;
+    }
 
 	GLAMOEngineWait(pGlamo, GLAMO_ENGINE_ALL);
 
@@ -219,7 +227,7 @@ GLAMODrawDisable(ScrnInfoPtr pScrn) {
 }
 
 static Bool
-GLAMODrawExaInit(ScrnInfoPtr pScrn)
+GLAMODrawExaInit(ScrnInfoPtr pScrn, size_t mem_start, size_t mem_size)
 {
     GlamoPtr pGlamo = GlamoPTR(pScrn);
 
@@ -233,10 +241,11 @@ GLAMODrawExaInit(ScrnInfoPtr pScrn)
     if(!exa)
         return FALSE;
 
-	exa->memoryBase = pGlamo->fbstart;
-	exa->memorySize = 1024 * 1024 * 4;
-	/*exa->offScreenBase = pGlamo->fboff;*/
-	exa->offScreenBase = 480 * 640 * 2;
+    pGlamo->exa->memoryBase = pGlamo->fbstart + mem_start;
+    pGlamo->exa->memorySize = mem_size;
+    /* TODO: Initalize offScreenBase based on the current screen resolution
+     * (width*height*depth) */
+    pGlamo->exa->offScreenBase = 480 * 640 * 2;
 
 	exa->exa_major = EXA_VERSION_MAJOR;
 	exa->exa_minor = EXA_VERSION_MINOR;
@@ -298,13 +307,24 @@ GLAMOExaPrepareSolid(PixmapPtr      pPix,
 	FbBits mask;
 	RING_LOCALS;
 
-	if (pPix->drawable.bitsPerPixel != 16)
-		GLAMO_FALLBACK(("Only 16bpp is supported\n"));
+/*	if (pPix->drawable.bitsPerPixel != 16)
+		GLAMO_FALLBACK(("Only 16bpp is supported\n"));*/
 
-	mask = FbFullMask(16);
+    mask = FbFullMask(16);
 	if ((pm & mask) != mask)
 		GLAMO_FALLBACK(("Can't do planemask 0x%08x\n",
 				(unsigned int) pm));
+    switch (pPix->drawable.bitsPerPixel) {
+        case 8:
+            if (pPix->devKind & 1)
+                return FALSE;
+            fg = (fg | fg << 8);
+        case 16:
+            break;
+        default:
+            return FALSE;
+            break;
+    }
 
 	op = GLAMOSolidRop[alu] << 8;
 	offset = exaGetPixmapOffset(pPix);
@@ -346,7 +366,6 @@ GLAMOExaDoneSolid(PixmapPtr pPix)
 {
 	ScrnInfoPtr pScrn = xf86Screens[pPix->drawable.pScreen->myNum];
 	GlamoPtr pGlamo = GlamoPTR(pScrn);
-
     GLAMOFlushCMDQCache(pGlamo, 1);
 	exaMarkSync(pGlamo->pScreen);
 }
@@ -420,7 +439,6 @@ GLAMOExaCopy(PixmapPtr       pDst,
 	GlamoPtr pGlamo = GlamoPTR(pScrn);
 
 	RING_LOCALS;
-
 	BEGIN_CMDQ(14);
 
 	OUT_REG(GLAMO_REG_2D_SRC_X, srcX);
@@ -438,7 +456,6 @@ GLAMOExaDoneCopy(PixmapPtr pDst)
 {
 	ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
 	GlamoPtr pGlamo = GlamoPTR(pScrn);
-
     GLAMOFlushCMDQCache(pGlamo, 1);
 	exaMarkSync(pGlamo->pScreen);
 }
@@ -493,7 +510,6 @@ GLAMOExaUploadToScreen(PixmapPtr pDst,
 {
 	ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
 	GlamoPtr pGlamo = GlamoPTR(pScrn);
-
 	int bpp, i;
 	CARD8 *dst_offset;
 	int dst_pitch;
@@ -521,12 +537,11 @@ GLAMOExaDownloadFromScreen(PixmapPtr pSrc,
 {
 	ScrnInfoPtr pScrn = xf86Screens[pSrc->drawable.pScreen->myNum];
 	GlamoPtr pGlamo = GlamoPTR(pScrn);
-
 	int bpp, i;
 	CARD8 *dst_offset, *src;
 	int src_pitch;
 
-	bpp = pSrc->drawable.bitsPerPixel;
+    bpp = pSrc->drawable.bitsPerPixel;
 	bpp /= 8;
 	src_pitch = pSrc->devKind;
 	src = pGlamo->exa->memoryBase + exaGetPixmapOffset(pSrc) +
@@ -547,7 +562,6 @@ GLAMOExaWaitMarker (ScreenPtr pScreen, int marker)
 {
 	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 	GlamoPtr pGlamo = GlamoPTR(pScrn);
-
 	GLAMOEngineWait(pGlamo, GLAMO_ENGINE_ALL);
 }
 
diff --git a/src/glamo-driver.c b/src/glamo-driver.c
index babf57d..ac3db86 100644
--- a/src/glamo-driver.c
+++ b/src/glamo-driver.c
@@ -522,6 +522,8 @@ GlamoScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     GlamoPtr pGlamo = GlamoPTR(pScrn);
     VisualPtr visual;
     int ret, flags;
+    size_t mem_start = 0;
+    size_t mem_size = 1024 * 1024 * 4;
 
     TRACE_ENTER("GlamoScreenInit");
 
@@ -594,7 +596,7 @@ GlamoScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
         xf86LoadSubModule(pScrn, "exa");
         xf86LoaderReqSymLists(exaSymbols, NULL);
 
-    	if (!GLAMODrawInit(pScrn)) {
+    	if (!GLAMODrawInit(pScrn, mem_start, mem_size)) {
             xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
                        "EXA hardware acceleration initialization failed\n");
         } else {
@@ -805,7 +807,7 @@ GlamoEnterVT(int scrnIndex, int flags) {
     GlamoSaveHW(pScrn);
 
     if (pGlamo->accel)
-        GLAMODrawEnable(pScrn);
+        pGlamo->accel = GLAMODrawEnable(pScrn);
 
     if (!xf86SetDesiredModes(pScrn))
         return FALSE;
diff --git a/src/glamo.h b/src/glamo.h
index 2cb3da0..8666b66 100644
--- a/src/glamo.h
+++ b/src/glamo.h
@@ -93,10 +93,10 @@ typedef struct {
 	ScreenPtr 				pScreen;
 
 	ExaDriverPtr exa;
-	ExaOffscreenArea *exa_cmd_queue;
 
-	CARD16 *ring_addr; /* Beginning of ring buffer. */
-	int ring_len;
+    unsigned char *ring_addr; /* Beginning of ring buffer. */
+    size_t ring_start;
+	size_t ring_len;
 
 	/*
 	 * cmd queue cache in system memory
@@ -151,8 +151,8 @@ MMIOSetBitMask(volatile char *mmio, CARD32 reg, CARD16 mask, CARD16 val)
 }
 
 /* glamo_draw.c */
-Bool
-GLAMODrawInit(ScrnInfoPtr pScrn);
+size_t
+GLAMODrawInit(ScrnInfoPtr pScrn, size_t mem_start, size_t mem_len);
 
 Bool
 GLAMODrawEnable(ScrnInfoPtr pScrn);