xserver-kdrive-imageon: add (another) w100 based xserver, closes #1752

1 files changed, 751 insertions, 0 deletions

diff --git a/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch b/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch
new file mode 100644
index 0000000000..34d9d3d166
--- /dev/null
+++ b/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch
@@ -0,0 +1,751 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.c~kdrive-vidmemarea
++++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.c
+@@ -908,9 +908,10 @@
+         ret = (*pScreen->CloseScreen) (index, pScreen);
+     else
+ 	ret = TRUE;
+-    
+-    if (screen->off_screen_base < screen->memory_size)
+-	KdOffscreenFini (pScreen);
++
++    if (KdHasOffscreen(screen)) {
++        KdOffscreenFini(pScreen);
++    }
+     
+     if (pScreenPriv->dpmsState != KD_DPMS_NORMAL)
+ 	(*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
+@@ -1219,8 +1220,9 @@
+ 	if (!(*card->cfuncs->initAccel) (pScreen))
+ 	    screen->dumb = TRUE;
+ 
+-    if (screen->off_screen_base < screen->memory_size)
+-	KdOffscreenInit (pScreen);
++    if (KdHasOffscreen(screen)) {
++        KdOffscreenInit(pScreen);
++    }
+     
+ #ifdef PSEUDO8
+     (void) p8Init (pScreen, PSEUDO8_USE_DEFAULT);
+--- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.h~kdrive-vidmemarea
++++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.h
+@@ -63,6 +63,9 @@
+ #define KD_MAX_CARD_ADDRESS 8
+ #endif
+ 
++#define KD_VIDMEM_MINPRIO 0
++#define KD_VIDMEM_MAXPRIO 255
++
+ /*
+  * Configuration information per video card
+  */
+@@ -115,6 +118,13 @@
+ 
+ typedef void (*KdOffscreenSaveProc) (ScreenPtr pScreen, KdOffscreenArea *area);
+ 
++typedef struct _KdVideoMemArea {
++    CARD8  priority;
++    CARD8 *base;
++    CARD32 size;
++    CARD32 available_offset;
++} KdVideoMemArea;
++
+ typedef enum _KdOffscreenState {
+     KdOffscreenAvail,
+     KdOffscreenRemovable,
+@@ -127,7 +137,8 @@
+     int			size;
+     int			score;
+     pointer		privData;
+-    
++    KdVideoMemArea      *vidmem;
++    int                 pool;
+     KdOffscreenSaveProc save;
+ 
+     KdOffscreenState	state;
+@@ -138,6 +149,7 @@
+ #define RR_Rotate_All	(RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270)
+ #define RR_Reflect_All	(RR_Reflect_X|RR_Reflect_Y)
+ 
++
+ typedef struct _KdScreenInfo {
+     struct _KdScreenInfo    *next;
+     KdCardInfo	*card;
+@@ -155,9 +167,8 @@
+     int		mynum;
+     DDXPointRec	origin;
+     KdFrameBuffer   fb[KD_MAX_FB];
+-    CARD8	*memory_base;
+-    unsigned long   memory_size;
+-    unsigned long   off_screen_base;
++    KdVideoMemArea **videomem_areas;
++    int             num_videomem_areas;
+ } KdScreenInfo;
+ 
+ typedef struct _KdCardFuncs {
+@@ -187,7 +198,6 @@
+ 
+     void        (*getColors) (ScreenPtr, int, int, xColorItem *);
+     void        (*putColors) (ScreenPtr, int, int, xColorItem *);
+-
+ } KdCardFuncs;
+ 
+ #define KD_MAX_PSEUDO_DEPTH 8
+@@ -203,7 +213,8 @@
+ 
+     int		    dpmsState;
+     
+-    KdOffscreenArea *off_screen_areas;
++    KdOffscreenArea **offscreen_pools;
++    int             num_offscreen_pools;
+ 
+     ColormapPtr     pInstalledmap[KD_MAX_FB];         /* current colormap */
+     xColorItem      systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */
+@@ -881,6 +892,15 @@
+ KdOffscreenInit (ScreenPtr pScreen);
+ 
+ KdOffscreenArea *
++KdOffscreenAllocPrio (ScreenPtr pScreen, int size, int align,
++                      Bool locked,
++                      KdOffscreenSaveProc save,
++                      pointer privData,
++                      int minPriority,
++                      int maxPriority,
++                      Bool allowEviction);
++
++KdOffscreenArea *
+ KdOffscreenAlloc (ScreenPtr pScreen, int size, int align,
+ 		  Bool locked,
+ 		  KdOffscreenSaveProc save,
+--- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kaa.c~kdrive-vidmemarea
++++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kaa.c
+@@ -160,7 +160,7 @@
+ 		  pPixmap->drawable.width,
+ 		  pPixmap->drawable.height));
+     pPixmap->devKind = pitch;
+-    pPixmap->devPrivate.ptr = (pointer) ((CARD8 *) pScreenPriv->screen->memory_base + pKaaPixmap->area->offset);
++    pPixmap->devPrivate.ptr = (pointer) ((CARD8 *) pKaaPixmap->area->vidmem->base + pKaaPixmap->area->offset);
+     pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+     return TRUE;
+ }
+@@ -198,7 +198,7 @@
+ 
+     dst = pPixmap->devPrivate.ptr;
+     dst_pitch = pPixmap->devKind;
+-    
++
+     bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch;
+ 
+     kaaWaitSync (pPixmap->drawable.pScreen);
+@@ -336,10 +336,16 @@
+ {
+     ScreenPtr	pScreen = p->drawable.pScreen;
+     KdScreenPriv(pScreen);
++    int index;
+ 
+-    return ((unsigned long) ((CARD8 *) p->devPrivate.ptr - 
+-			     (CARD8 *) pScreenPriv->screen->memory_base) <
+-	    pScreenPriv->screen->memory_size);
++    for (index = 0; index < pScreenPriv->screen->num_videomem_areas; index++) {
++        KdVideoMemArea *vidmem = pScreenPriv->screen->videomem_areas[index];
++        if ((((CARD8 *)p->devPrivate.ptr) >= vidmem->base) &&
++            (((CARD8 *)p->devPrivate.ptr) <= (vidmem->base + vidmem->size))) {
++            return TRUE;
++        }
++    }
++    return FALSE;
+ }
+ 
+ PixmapPtr
+@@ -1060,6 +1066,7 @@
+     KdCheckPaintWindow (pWin, pRegion, what);
+ }
+ 
++
+ Bool
+ kaaDrawInit (ScreenPtr		pScreen,
+ 	     KaaScreenInfoPtr	pScreenInfo)
+@@ -1109,7 +1116,7 @@
+      * Hookup offscreen pixmaps
+      */
+     if ((pKaaScr->info->flags & KAA_OFFSCREEN_PIXMAPS) &&
+-	screen->off_screen_base < screen->memory_size)
++	KdHasOffscreen(screen))
+     {
+ 	if (!AllocatePixmapPrivate(pScreen, kaaPixmapPrivateIndex,
+ 				   sizeof (KaaPixmapPrivRec)))
+--- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/koffscreen.c~kdrive-vidmemarea
++++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/koffscreen.c
+@@ -41,16 +41,20 @@
+ {
+     KdScreenPriv (pScreen);
+     KdOffscreenArea *prev = 0, *area;
+-
+-    assert (pScreenPriv->screen->off_screen_areas->area.offset == 0);
+-    for (area = pScreenPriv->off_screen_areas; area; area = area->next)
+-    {
+-	if (prev)
+-	    assert (prev->offset + prev->size == area->offset);
++    int index;
++    
++    for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) {
++        area = pScreenPriv->offscreen_pools[index];
++        assert (area->vidmem->available_offset - area.offset == 0);
++        while(area) {
++            if (prev)
++                assert (prev->offset + prev->size == area->offset);
+ 	    
+-	prev = area;
++            prev = area;
++            area = area->next;
++        }
++        assert (prev->offset + prev->size == prev->vidmem->size);
+     }
+-    assert (prev->offset + prev->size == pScreenPriv->screen->memory_size);
+ }
+ #else
+ #define KdOffscreenValidate(s)
+@@ -65,101 +69,133 @@
+ }
+ 
+ KdOffscreenArea *
+-KdOffscreenAlloc (ScreenPtr pScreen, int size, int align,
+-		  Bool locked,
+-		  KdOffscreenSaveProc save,
+-		  pointer privData)
++KdOffscreenAllocPrio (ScreenPtr pScreen, int size, int align,
++                      Bool locked,
++                      KdOffscreenSaveProc save,
++                      pointer privData,
++                      int minPriority,
++                      int maxPriority,
++                      Bool allowEviction)
+ {
+     KdOffscreenArea *area, *begin, *best;
+     KdScreenPriv (pScreen);
+     int tmp, real_size = 0, best_score;
++    int index;
++    Bool canFit = FALSE;
+ 
+-    KdOffscreenValidate (pScreen);
+     if (!align)
+ 	align = 1;
+ 
+     if (!size)
+     {
+-	DBG_OFFSCREEN (("Alloc 0x%x -> EMPTY\n", size));
++	DBG_OFFSCREEN(("Alloc 0x%x -> EMPTY\n", size));
+ 	return NULL;
+     }
+ 
+     /* throw out requests that cannot fit */
+-    if (size > (pScreenPriv->screen->memory_size - pScreenPriv->screen->off_screen_base))
+-    {
+-	DBG_OFFSCREEN (("Alloc 0x%x -> TOBIG\n", size));
+-	return NULL;
++    for (index = 0; index < pScreenPriv->screen->num_videomem_areas; index++) {
++        KdVideoMemArea *vidmem = pScreenPriv->screen->videomem_areas[index];
++        if ((vidmem->priority <= maxPriority) && 
++            (vidmem->priority >= minPriority)) {
++            if (size <= (vidmem->size - vidmem->available_offset)) {
++                canFit = TRUE;
++                break;
++            }
++        }
+     }
+-    
+-    /* Try to find a free space that'll fit. */
+-    for (area = pScreenPriv->off_screen_areas; area; area = area->next)
++    if (!canFit)
+     {
+-	/* skip allocated areas */
+-	if (area->state != KdOffscreenAvail)
+-	    continue;
++        DBG_OFFSCREEN(("Alloc 0x%x -> TOOBIG\n", size));
++        return NULL;
++    }
+ 
+-	/* adjust size to match alignment requirement */
+-	real_size = size;
+-	tmp = area->offset % align;
+-	if (tmp)
+-	    real_size += (align - tmp);
+-	
+-	/* does it fit? */
+-	if (real_size <= area->size)
+-	    break;
++    for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) {
++        /* Look just in the head, as all the areas of the pool have
++           the same vidmem */
++        area = pScreenPriv->offscreen_pools[index];
++        if ((area->vidmem->priority > maxPriority) || 
++            (area->vidmem->priority < minPriority))
++            continue;
++
++        /* Try to find a free space that'll fit. */
++        for (area = pScreenPriv->offscreen_pools[index]; area;
++             area = area->next) {
++            /* skip allocated areas */
++            if (area->state != KdOffscreenAvail)
++                continue;
++            
++            /* adjust size to match alignment requirement */
++            real_size = size;
++            tmp = area->offset % align;
++            if (tmp)
++                real_size += (align - tmp);
++            
++            /* does it fit? */
++            if (real_size <= area->size)
++                break;
++        }
++        if (area)
++            break;
+     }
+-    
+-    if (!area)
+-    {
++
++    if (!area && allowEviction) {
+ 	/* 
+ 	 * Kick out existing users to make space.
+ 	 *
+ 	 * First, locate a region which can hold the desired object.
+ 	 */
++        for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) {
++            if ((area->vidmem->priority > maxPriority) || 
++                (area->vidmem->priority < minPriority))
++                continue;
+ 	
+-	/* prev points at the first object to boot */
+-	best = NULL;
+-	best_score = MAXINT;
+-	for (begin = pScreenPriv->off_screen_areas; begin != NULL;
+-	     begin = begin->next)
+-	{
+-	    int avail, score;
+-	    KdOffscreenArea *scan;
++            /* prev points at the first object to boot */
++            best = NULL;
++            best_score = MAXINT;
+ 
+-	    if (begin->state == KdOffscreenLocked)
+-		continue;
++            for (begin = pScreenPriv->offscreen_pools[index]; begin != NULL;
++                 begin = begin->next) {
++                int avail, score;
++                KdOffscreenArea *scan;
+ 
+-	    /* adjust size to match alignment requirement */
+-	    real_size = size;
+-	    tmp = begin->offset % align;
+-	    if (tmp)
+-		real_size += (align - tmp);
++                if (begin->state == KdOffscreenLocked)
++                    continue;
++
++                /* adjust size to match alignment requirement */
++                real_size = size;
++                tmp = begin->offset % align;
++                if (tmp)
++                    real_size += (align - tmp);
+ 	    
+-	    avail = 0;
+-	    score = 0;
+-	    /* now see if we can make room here, and how "costly" it'll be. */
+-	    for (scan = begin; scan != NULL; scan = scan->next)
+-	    {
+-		if (scan->state == KdOffscreenLocked) {
+-		    /* Can't make room here, start after this locked area. */
+-		    begin = scan->next;
+-		    break;
+-		}
+-		/* Score should only be non-zero for KdOffscreenRemovable */
+-		score += scan->score;
+-		avail += scan->size;
+-		if (avail >= real_size)
+-		    break;
+-	    }
+-	    /* Is it the best option we've found so far? */
+-	    if (avail >= real_size && score < best_score) {
+-		best = begin;
+-		best_score = score;
+-	    }
+-	}
+-	area = best;
+-	if (!area)
+-	{
++                avail = 0;
++                score = 0;
++                /* now see if we can make room here, 
++                   and how "costly" it'll be. */
++                for (scan = begin; scan != NULL; scan = scan->next) {
++                    if (scan->state == KdOffscreenLocked) {
++                        /* Can't make room here, 
++                           start after this locked area. */
++                        begin = scan->next;
++                        break;
++                    }
++                    /* Score should only be non-zero for KdOffscreenRemovable */
++                    score += scan->score;
++                    avail += scan->size;
++                    if (avail >= real_size)
++                        break;
++                }
++                /* Is it the best option we've found so far? */
++                if (avail >= real_size && score < best_score) {
++                    best = begin;
++                    best_score = score;
++                }
++            }
++            area = best;
++            if (area) 
++                break;
++        }
++
++	if (!area) {
+ 	    DBG_OFFSCREEN (("Alloc 0x%x -> NOSPACE\n", size));
+ 	    /* Could not allocate memory */
+ 	    KdOffscreenValidate (pScreen);
+@@ -180,16 +216,14 @@
+ 	/*
+ 	 * Now get the system to merge the other needed areas together
+ 	 */
+-	while (area->size < real_size)
+-	{
+-	    assert (area->next && area->next->state == KdOffscreenRemovable);
++	while (area->size < real_size) {
++            assert (area->next && area->next->state == KdOffscreenRemovable);
+ 	    (void) KdOffscreenKickOut (pScreen, area->next);
+ 	}
+     }
+-    
++
+     /* save extra space in new area */
+-    if (real_size < area->size)
+-    {
++    if (real_size < area->size) {
+ 	KdOffscreenArea   *new_area = xalloc (sizeof (KdOffscreenArea));
+ 	if (!new_area)
+ 	    return NULL;
+@@ -198,9 +232,14 @@
+ 	new_area->state = KdOffscreenAvail;
+ 	new_area->save = 0;
+ 	new_area->score = 0;
++        new_area->vidmem = area->vidmem;
++        new_area->pool = area->pool;
+ 	new_area->next = area->next;
+ 	area->next = new_area;
+ 	area->size = real_size;
++        DBG_OFFSCREEN (("New OffscreenArea at %p (offset:0x%08x, size:0x%08x, pool:%d\n", area, area->offset, area->size, area->pool));
++
++
+     }
+     /*
+      * Mark this area as in use
+@@ -212,42 +251,80 @@
+     area->privData = privData;
+     area->save = save;
+     area->score = 0;
+-
++    
+     area->save_offset = area->offset;
+     {
+ 	int tmp = area->offset % align;
+ 	if (tmp)
+ 	    area->offset += (align - tmp);
+     }
+-
++    
+     KdOffscreenValidate (pScreen);
+     
+     DBG_OFFSCREEN (("Alloc 0x%x -> 0x%x\n", size, area->offset));
+     return area;
+ }
+ 
++Bool
++KdHasOffscreen(KdScreenInfo *screen)
++{
++    int index;
++    DBG_OFFSCREEN (("KdHasOffscreen\n"));
++
++    for (index = 0; index < screen->num_videomem_areas; index++) {
++        KdVideoMemArea *vidmem = screen->videomem_areas[index];
++        if (vidmem->available_offset < vidmem->size) {
++            return TRUE;
++        }
++    }
++    return FALSE;
++}
++    
++KdOffscreenArea *
++KdOffscreenAlloc (ScreenPtr pScreen, int size, int align,
++		  Bool locked,
++		  KdOffscreenSaveProc save,
++		  pointer privData)
++{
++    DBG_OFFSCREEN (("KdOffscreenAlloc(size:%d, align:%d, locked:%d)\n",
++                    size, align, locked));
++    return KdOffscreenAllocPrio(pScreen, size, align,
++                                locked,
++                                save,
++                                privData,
++                                KD_VIDMEM_MINPRIO,
++                                KD_VIDMEM_MAXPRIO,
++                                TRUE);
++}
++
+ void
+ KdOffscreenSwapOut (ScreenPtr pScreen)
+ {
+     KdScreenPriv (pScreen);
++    int index;
++
++    DBG_OFFSCREEN (("KdOffscreenSwapOut\n"));
+ 
+     KdOffscreenValidate (pScreen);
+-    /* loop until a single free area spans the space */
+-    for (;;)
+-    {
+-	KdOffscreenArea *area = pScreenPriv->off_screen_areas;
++
++    for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) {
++        /* loop until a single free area spans the space */
++        for (;;)
++        {
++            KdOffscreenArea *area = pScreenPriv->offscreen_pools[index];
+ 	
+-	if (!area)
+-	    break;
+-	if (area->state == KdOffscreenAvail)
+-	{
+-	    area = area->next;
+-	    if (!area)
+-		break;
+-	}
+-	assert (area->state != KdOffscreenAvail);
+-	(void) KdOffscreenKickOut (pScreen, area);
+-	KdOffscreenValidate (pScreen);
++            if (!area)
++                break;
++            if (area->state == KdOffscreenAvail)
++            {
++                area = area->next;
++                if (!area)
++                    break;
++            }
++            assert (area->state != KdOffscreenAvail);
++            (void) KdOffscreenKickOut (pScreen, area);
++            KdOffscreenValidate (pScreen);
++        }
+     }    
+     KdOffscreenValidate (pScreen);
+     KdOffscreenFini (pScreen);
+@@ -256,6 +333,8 @@
+ void
+ KdOffscreenSwapIn (ScreenPtr pScreen)
+ {
++    KdScreenPriv (pScreen);
++    DBG_OFFSCREEN (("KdOffscreenSwapIn\n"));
+     KdOffscreenInit (pScreen);
+ }
+ 
+@@ -264,7 +343,7 @@
+ KdOffscreenMerge (KdOffscreenArea *area)
+ {
+     KdOffscreenArea	*next = area->next;
+-
++    //DBG_OFFSCREEN (("KdOffscreenMerge %p\n", area));
+     /* account for space */
+     area->size += next->size;
+     /* frob pointer */
+@@ -278,8 +357,9 @@
+     KdScreenPriv(pScreen);
+     KdOffscreenArea	*next = area->next;
+     KdOffscreenArea	*prev;
+-    
+-    DBG_OFFSCREEN (("Free 0x%x -> 0x%x\n", area->size, area->offset));
++
++    DBG_OFFSCREEN (("KdOffscreenFree 0x%x -> 0x%x\n", 
++                    area->size, area->offset));
+     KdOffscreenValidate (pScreen);
+ 
+     area->state = KdOffscreenAvail;
+@@ -290,10 +370,11 @@
+     /*
+      * Find previous area
+      */
+-    if (area == pScreenPriv->off_screen_areas)
++    if (area == pScreenPriv->offscreen_pools[area->pool])
+ 	prev = 0;
+     else
+-	for (prev = pScreenPriv->off_screen_areas; prev; prev = prev->next)
++	for (prev = pScreenPriv->offscreen_pools[area->pool]; 
++             prev; prev = prev->next)
+ 	    if (prev->next == area)
+ 		break;
+     
+@@ -317,21 +398,30 @@
+ {
+     KaaPixmapPriv (pPixmap);
+     KdScreenPriv (pPixmap->drawable.pScreen);
++    int index;
+     static int iter = 0;
+ 
++
+     if (!pKaaPixmap->area)
+ 	return;
+ 
++    /*
++    DBG_OFFSCREEN(("KdOffscreenMarkUsed(offset:0x%08x, pool:%d)\n", 
++                   pKaaPixmap->area->offset,
++                   pKaaPixmap->area->pool));
++    */
+     /* The numbers here are arbitrary.  We may want to tune these. */
+     pKaaPixmap->area->score += 100;
+     if (++iter == 10) {
+ 	KdOffscreenArea *area;
+-	for (area = pScreenPriv->off_screen_areas; area != NULL;
+-	     area = area->next)
+-	{
+-	    if (area->state == KdOffscreenRemovable)
+-		area->score = (area->score * 7) / 8;
+-	}
++        for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) {
++            for (area = pScreenPriv->offscreen_pools[index]; area != NULL;
++                 area = area->next)
++            {
++                if (area->state == KdOffscreenRemovable)
++                    area->score = (area->score * 7) / 8;
++            }
++        }
+     }
+ }
+ 
+@@ -340,23 +430,41 @@
+ {
+     KdScreenPriv (pScreen);
+     KdOffscreenArea *area;
++    KdVideoMemArea *vidmem;
++    int index, num_offscreen;
+ 
+-    /* Allocate a big free area */
+-    area = xalloc (sizeof (KdOffscreenArea));
++    DBG_OFFSCREEN (("KdOffscreenInit\n"));
++    num_offscreen = 0;
++    pScreenPriv->num_offscreen_pools = 0;
++    pScreenPriv->offscreen_pools = NULL;
+ 
+-    if (!area)
+-	return FALSE;
++    for (index = 0; index < pScreenPriv->screen->num_videomem_areas; index++) {
++        vidmem = pScreenPriv->screen->videomem_areas[index];
++        DBG_OFFSCREEN (("Searching vidmemarea base:0x%p, size:0x%08x, available_offset:0x%08x\n", vidmem->base, vidmem->size, vidmem->available_offset));
++        if (vidmem->available_offset < vidmem->size) {
++            pScreenPriv->offscreen_pools = xrealloc(pScreenPriv->offscreen_pools,
++                                                    sizeof(KdOffscreenArea*) * (pScreenPriv->num_offscreen_pools + 1));
++            if (!pScreenPriv->offscreen_pools) {
++                return FALSE;
++            }
++            pScreenPriv->offscreen_pools[pScreenPriv->num_offscreen_pools] =
++                area = xcalloc(sizeof(KdOffscreenArea), 1);
++            if (!area) 
++                return FALSE;
++
++            area->state = KdOffscreenAvail;
++            area->vidmem = vidmem;
++            area->offset = vidmem->available_offset;
++            area->size = vidmem->size - vidmem->available_offset;
++            area->save = 0;
++            area->pool = pScreenPriv->num_offscreen_pools;
++            area->next = NULL;
++            area->score = 0;
++            pScreenPriv->num_offscreen_pools++;
++            DBG_OFFSCREEN (("New OffscreenArea at %p (offset:0x%08x, size:0x%08x, pool:%d)\n", area, area->offset, area->size, area->pool));
++        }
++    }
+ 
+-    area->state = KdOffscreenAvail;
+-    area->offset = pScreenPriv->screen->off_screen_base;
+-    area->size = pScreenPriv->screen->memory_size - area->offset;
+-    area->save = 0;
+-    area->next = NULL;
+-    area->score = 0;
+-    
+-    /* Add it to the free areas */
+-    pScreenPriv->off_screen_areas = area;
+-    
+     KdOffscreenValidate (pScreen);
+ 
+     return TRUE;
+@@ -367,11 +475,17 @@
+ {
+     KdScreenPriv (pScreen);
+     KdOffscreenArea *area;
+-    
+-    /* just free all of the area records */
+-    while ((area = pScreenPriv->off_screen_areas))
+-    {
+-	pScreenPriv->off_screen_areas = area->next;
+-	xfree (area);
++    int index;
++
++    DBG_OFFSCREEN (("KdOffscreenFini\n"));
++    for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) {
++        /* just free all of the area records */
++        while ((area = pScreenPriv->offscreen_pools[index])) {
++            pScreenPriv->offscreen_pools[index] = area->next;
++            xfree (area);
++        }
+     }
++    xfree(pScreenPriv->offscreen_pools);
++    pScreenPriv->offscreen_pools = NULL;
++    pScreenPriv->num_offscreen_pools = 0;
+ }
+--- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/fbdev/fbdev.c~kdrive-vidmemarea
++++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/fbdev/fbdev.c
+@@ -330,6 +330,7 @@
+     FbdevScrPriv	*scrpriv = screen->driver;
+     KdMouseMatrix	m;
+     FbdevPriv		*priv = screen->card->driver;
++    KdVideoMemArea      *vidmem;
+ 
+     if (scrpriv->randr != RR_Rotate_0)
+ 	scrpriv->shadow = TRUE;
+@@ -342,15 +343,20 @@
+     
+     screen->width = priv->var.xres;
+     screen->height = priv->var.yres;
+-    screen->memory_base = (CARD8 *) (priv->fb);
+-    screen->memory_size = priv->fix.smem_len;
++    screen->videomem_areas = xcalloc(sizeof(KdVideoMemArea*), 1);
++    screen->videomem_areas[0] = vidmem = xcalloc(sizeof(KdVideoMemArea), 1);
++    screen->num_videomem_areas = 1;
++    
++    vidmem->priority = KD_VIDMEM_MINPRIO;
++    vidmem->base = (CARD8 *) (priv->fb);
++    vidmem->size = priv->fix.smem_len;
+     
+     if (scrpriv->shadow)
+     {
+ 	if (!KdShadowFbAlloc (screen, 0, 
+ 			      scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
+ 	    return FALSE;
+-	screen->off_screen_base = screen->memory_size;
++        vidmem->available_offset = vidmem->size;
+     }
+     else
+     {
+@@ -358,7 +364,7 @@
+         screen->fb[0].pixelStride = (priv->fix.line_length * 8 / 
+     				 priv->var.bits_per_pixel);
+         screen->fb[0].frameBuffer = (CARD8 *) (priv->fb);
+-	screen->off_screen_base = screen->fb[0].byteStride * screen->height;
++	vidmem->available_offset = screen->fb[0].byteStride * screen->height;
+     }
+     
+     return TRUE;