diff -up xf86-video-qxl-20130514/src/compat/compat-lookup3.c.compat2 xf86-video-qxl-20130514/src/compat/compat-lookup3.c

--- xf86-video-qxl-20130514/src/compat/compat-lookup3.c.compat2	2013-07-03 14:19:39.007334520 +1000

+++ xf86-video-qxl-20130514/src/compat/compat-lookup3.c	2013-07-03 14:19:56.102748510 +1000

@@ -3,17 +3,17 @@

 lookup3.c, by Bob Jenkins, May 2006, Public Domain.

 These are functions for producing 32-bit hashes for hash table lookup.

-hashword(), hashlittle(), hashlittle2(), hashbig(), mix(), and final() 

+compat_hashword(), compat_hashlittle(), compat_hashlittle2(), compat_hashbig(), mix(), and final() 

 are externally useful functions.  Routines to test the hash are included 

 if SELF_TEST is defined.  You can use this free for any purpose.  It's in

 the public domain.  It has no warranty.

-You probably want to use hashlittle().  hashlittle() and hashbig()

-hash byte arrays.  hashlittle() is is faster than hashbig() on

+You probably want to use compat_hashlittle().  compat_hashlittle() and compat_hashbig()

+hash byte arrays.  compat_hashlittle() is is faster than compat_hashbig() on

 little-endian machines.  Intel and AMD are little-endian machines.

-On second thought, you probably want hashlittle2(), which is identical to

-hashlittle() except it returns two 32-bit hashes for the price of one.  

-You could implement hashbig2() if you wanted but I haven't bothered here.

+On second thought, you probably want compat_hashlittle2(), which is identical to

+compat_hashlittle() except it returns two 32-bit hashes for the price of one.  

+You could implement compat_hashbig2() if you wanted but I haven't bothered here.

 If you want to find a hash of, say, exactly 7 integers, do

   a = i1;  b = i2;  c = i3;

@@ -23,9 +23,9 @@ If you want to find a hash of, say, exac

   a += i7;

   final(a,b,c);

 then use c as the hash value.  If you have a variable length array of

-4-byte integers to hash, use hashword().  If you have a byte array (like

-a character string), use hashlittle().  If you have several byte arrays, or

-a mix of things, see the comments above hashlittle().  

+4-byte integers to hash, use compat_hashword().  If you have a byte array (like

+a character string), use compat_hashlittle().  If you have several byte arrays, or

+a mix of things, see the comments above compat_hashlittle().  

 Why is this so big?  I read 12 bytes at a time into 3 4-byte integers, 

 then mix those integers.  This is fast (you can do a lot more thorough

@@ -161,14 +161,14 @@ and these came close:

  -- that the key be an array of uint32_t's, and

  -- that the length be the number of uint32_t's in the key

- The function hashword() is identical to hashlittle() on little-endian

- machines, and identical to hashbig() on big-endian machines,

+ The function compat_hashword() is identical to compat_hashlittle() on little-endian

+ machines, and identical to compat_hashbig() on big-endian machines,

  except that the length has to be measured in uint32_ts rather than in

- bytes.  hashlittle() is more complicated than hashword() only because

- hashlittle() has to dance around fitting the key bytes into registers.

+ bytes.  compat_hashlittle() is more complicated than compat_hashword() only because

+ compat_hashlittle() has to dance around fitting the key bytes into registers.

 --------------------------------------------------------------------

 */

-uint32_t hashword(

+uint32_t compat_hashword(

     const uint32_t *k,                   /* the key, an array of uint32_t values */

     size_t          length,               /* the length of the key, in uint32_ts */

     uint32_t        initval)         /* the previous hash, or an arbitrary value */

@@ -206,13 +206,13 @@ uint32_t hashword(

 /*

 --------------------------------------------------------------------

-hashword2() -- same as hashword(), but take two seeds and return two

+compat_hashword2() -- same as compat_hashword(), but take two seeds and return two

 32-bit values.  pc and pb must both be nonnull, and *pc and *pb must

 both be initialized with seeds.  If you pass in (*pb)==0, the output 

-(*pc) will be the same as the return value from hashword().

+(*pc) will be the same as the return value from compat_hashword().

 --------------------------------------------------------------------

 */

-void hashword2 (

+void compat_hashword2 (

 const uint32_t *k,                   /* the key, an array of uint32_t values */

 size_t          length,               /* the length of the key, in uint32_ts */

 uint32_t       *pc,                      /* IN: seed OUT: primary hash value */

@@ -252,7 +252,7 @@ uint32_t       *pb)               /* IN:

 /*

 -------------------------------------------------------------------------------

-hashlittle() -- hash a variable-length key into a 32-bit value

+compat_hashlittle() -- hash a variable-length key into a 32-bit value

   k       : the key (the unaligned variable-length array of bytes)

   length  : the length of the key, counting by bytes

   initval : can be any 4-byte value

@@ -267,7 +267,7 @@ use a bitmask.  For example, if you need

 In which case, the hash table should have hashsize(10) elements.

 If you are hashing n strings (uint8_t **)k, do it like this:

-  for (i=0, h=0; i

+  for (i=0, h=0; i

 By Bob Jenkins, 2006.  bob_jenkins@burtleburtle.net.  You may use this

 code any way you wish, private, educational, or commercial.  It's free.

@@ -277,7 +277,7 @@ acceptable.  Do NOT use for cryptographi

 -------------------------------------------------------------------------------

 */

-uint32_t hashlittle( const void *key, size_t length, uint32_t initval)

+uint32_t compat_hashlittle( const void *key, size_t length, uint32_t initval)

 {

   uint32_t a,b,c;                                          /* internal state */

   union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */

@@ -450,16 +450,16 @@ uint32_t hashlittle( const void *key, si

 /*

- * hashlittle2: return 2 32-bit hash values

+ * compat_hashlittle2: return 2 32-bit hash values

  *

- * This is identical to hashlittle(), except it returns two 32-bit hash

+ * This is identical to compat_hashlittle(), except it returns two 32-bit hash

  * values instead of just one.  This is good enough for hash table

  * lookup with 2^^64 buckets, or if you want a second hash if you're not

  * happy with the first, or if you want a probably-unique 64-bit ID for

  * the key.  *pc is better mixed than *pb, so use *pc first.  If you want

  * a 64-bit value do something like "*pc + (((uint64_t)*pb)<<32)".

  */

-void hashlittle2( 

+void compat_hashlittle2( 

   const void *key,       /* the key to hash */

   size_t      length,    /* length of the key */

   uint32_t   *pc,        /* IN: primary initval, OUT: primary hash */

@@ -638,12 +638,12 @@ void hashlittle2(

 /*

- * hashbig():

- * This is the same as hashword() on big-endian machines.  It is different

- * from hashlittle() on all machines.  hashbig() takes advantage of

+ * compat_hashbig():

+ * This is the same as compat_hashword() on big-endian machines.  It is different

+ * from compat_hashlittle() on all machines.  compat_hashbig() takes advantage of

  * big-endian byte ordering. 

  */

-uint32_t hashbig( const void *key, size_t length, uint32_t initval)

+uint32_t compat_hashbig( const void *key, size_t length, uint32_t initval)

 {

   uint32_t a,b,c;

   union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */

diff -up xf86-video-qxl-20130514/src/compat/compat-lookup3.h.compat2 xf86-video-qxl-20130514/src/compat/compat-lookup3.h

--- xf86-video-qxl-20130514/src/compat/compat-lookup3.h.compat2	2013-07-03 14:19:39.007334520 +1000

+++ xf86-video-qxl-20130514/src/compat/compat-lookup3.h	2013-07-03 14:19:56.102748510 +1000

@@ -21,6 +21,6 @@ typedef UINT8 uint8_t;

 #endif

-uint32_t hashlittle( const void *key, size_t length, uint32_t initval);

+uint32_t compat_hashlittle( const void *key, size_t length, uint32_t initval);

 #endif

diff -up xf86-video-qxl-20130514/src/compat/compat-qxl_cursor.c.compat2 xf86-video-qxl-20130514/src/compat/compat-qxl_cursor.c

--- xf86-video-qxl-20130514/src/compat/compat-qxl_cursor.c.compat2	2013-07-03 14:19:39.008334544 +1000

+++ xf86-video-qxl-20130514/src/compat/compat-qxl_cursor.c	2013-07-03 14:19:56.103748552 +1000

@@ -25,25 +25,25 @@

 #include <cursorstr.h>

 static void

-push_cursor (qxl_screen_t *qxl, struct qxl_cursor_cmd *cursor)

+push_cursor (compat_qxl_screen_t *compat_qxl, struct compat_qxl_cursor_cmd *cursor)

 {

-    struct qxl_command cmd;

+    struct compat_qxl_command cmd;

-    /* See comment on push_command() in qxl_driver.c */

-    if (qxl->rom->mode != ~0)

+    /* See comment on push_command() in compat_qxl_driver.c */

+    if (compat_qxl->rom->mode != ~0)

     {

         cmd.type = QXL_CMD_CURSOR;

-        cmd.data = physical_address (qxl, cursor);

+        cmd.data = physical_address (compat_qxl, cursor);

-        qxl_ring_push (qxl->cursor_ring, &cmd);

+        compat_qxl_ring_push (compat_qxl->cursor_ring, &cmd);

     }

 }

-static struct qxl_cursor_cmd *

-qxl_alloc_cursor_cmd(qxl_screen_t *qxl)

+static struct compat_qxl_cursor_cmd *

+compat_qxl_alloc_cursor_cmd(compat_qxl_screen_t *compat_qxl)

 {

-    struct qxl_cursor_cmd *cmd =

-	qxl_allocnf (qxl, sizeof(struct qxl_cursor_cmd));

+    struct compat_qxl_cursor_cmd *cmd =

+	compat_qxl_allocnf (compat_qxl, sizeof(struct compat_qxl_cursor_cmd));

     cmd->release_info.id = pointer_to_u64 (cmd) | 1;

@@ -51,43 +51,43 @@ qxl_alloc_cursor_cmd(qxl_screen_t *qxl)

 }

 static void

-qxl_set_cursor_position(ScrnInfoPtr pScrn, int x, int y)

+compat_qxl_set_cursor_position(ScrnInfoPtr pScrn, int x, int y)

 {

-    qxl_screen_t *qxl = pScrn->driverPrivate;

-    struct qxl_cursor_cmd *cmd = qxl_alloc_cursor_cmd(qxl);

+    compat_qxl_screen_t *compat_qxl = pScrn->driverPrivate;

+    struct compat_qxl_cursor_cmd *cmd = compat_qxl_alloc_cursor_cmd(compat_qxl);

-    qxl->cur_x = x;

-    qxl->cur_y = y;

+    compat_qxl->cur_x = x;

+    compat_qxl->cur_y = y;

     cmd->type = QXL_CURSOR_MOVE;

-    cmd->u.position.x = qxl->cur_x + qxl->hot_x;

-    cmd->u.position.y = qxl->cur_y + qxl->hot_y;

+    cmd->u.position.x = compat_qxl->cur_x + compat_qxl->hot_x;

+    cmd->u.position.y = compat_qxl->cur_y + compat_qxl->hot_y;

-    push_cursor(qxl, cmd);

+    push_cursor(compat_qxl, cmd);

 }

 static void

-qxl_load_cursor_image(ScrnInfoPtr pScrn, unsigned char *bits)

+compat_qxl_load_cursor_image(ScrnInfoPtr pScrn, unsigned char *bits)

 {

 }

 static void

-qxl_set_cursor_colors(ScrnInfoPtr pScrn, int bg, int fg)

+compat_qxl_set_cursor_colors(ScrnInfoPtr pScrn, int bg, int fg)

 {

     /* Should not be called since UseHWCursor returned FALSE */

 }

 static void

-qxl_load_cursor_argb (ScrnInfoPtr pScrn, CursorPtr pCurs)

+compat_qxl_load_cursor_argb (ScrnInfoPtr pScrn, CursorPtr pCurs)

 {

-    qxl_screen_t *qxl = pScrn->driverPrivate;

+    compat_qxl_screen_t *compat_qxl = pScrn->driverPrivate;

     int w = pCurs->bits->width;

     int h = pCurs->bits->height;

     int size = w * h * sizeof (CARD32);

-    struct qxl_cursor_cmd *cmd = qxl_alloc_cursor_cmd (qxl);

-    struct qxl_cursor *cursor =

-	qxl_allocnf(qxl, sizeof(struct qxl_cursor) + size);

+    struct compat_qxl_cursor_cmd *cmd = compat_qxl_alloc_cursor_cmd (compat_qxl);

+    struct compat_qxl_cursor *cursor =

+	compat_qxl_allocnf(compat_qxl, sizeof(struct compat_qxl_cursor) + size);

     cursor->header.unique = 0;

     cursor->header.type = CURSOR_TYPE_ALPHA;

@@ -121,20 +121,20 @@ qxl_load_cursor_argb (ScrnInfoPtr pScrn,

     }

 #endif

-    qxl->hot_x = pCurs->bits->xhot;

-    qxl->hot_y = pCurs->bits->yhot;

+    compat_qxl->hot_x = pCurs->bits->xhot;

+    compat_qxl->hot_y = pCurs->bits->yhot;

     cmd->type = QXL_CURSOR_SET;

-    cmd->u.set.position.x = qxl->cur_x + qxl->hot_x;

-    cmd->u.set.position.y = qxl->cur_y + qxl->hot_y;

-    cmd->u.set.shape = physical_address (qxl, cursor);

+    cmd->u.set.position.x = compat_qxl->cur_x + compat_qxl->hot_x;

+    cmd->u.set.position.y = compat_qxl->cur_y + compat_qxl->hot_y;

+    cmd->u.set.shape = physical_address (compat_qxl, cursor);

     cmd->u.set.visible = TRUE;

-    push_cursor(qxl, cmd);

+    push_cursor(compat_qxl, cmd);

 }    

 static Bool

-qxl_use_hw_cursor (ScreenPtr pScrn, CursorPtr pCurs)

+compat_qxl_use_hw_cursor (ScreenPtr pScrn, CursorPtr pCurs)

 {

     /* Old-school bitmap cursors are not

      * hardware accelerated for now.

@@ -143,36 +143,36 @@ qxl_use_hw_cursor (ScreenPtr pScrn, Curs

 }

 static Bool

-qxl_use_hw_cursorARGB (ScreenPtr pScrn, CursorPtr pCurs)

+compat_qxl_use_hw_cursorARGB (ScreenPtr pScrn, CursorPtr pCurs)

 {

     return TRUE;

 }

 static void

-qxl_hide_cursor(ScrnInfoPtr pScrn)

+compat_qxl_hide_cursor(ScrnInfoPtr pScrn)

 {

-    qxl_screen_t *qxl = pScrn->driverPrivate;

-    struct qxl_cursor_cmd *cursor = qxl_alloc_cursor_cmd(qxl);

+    compat_qxl_screen_t *compat_qxl = pScrn->driverPrivate;

+    struct compat_qxl_cursor_cmd *cursor = compat_qxl_alloc_cursor_cmd(compat_qxl);

     cursor->type = QXL_CURSOR_HIDE;

-    push_cursor(qxl, cursor);

+    push_cursor(compat_qxl, cursor);

 }

 static void

-qxl_show_cursor(ScrnInfoPtr pScrn)

+compat_qxl_show_cursor(ScrnInfoPtr pScrn)

 {

     /*

      * slightly hacky, but there's no QXL_CURSOR_SHOW.  Could maybe do

      * QXL_CURSOR_SET?

      */

-    qxl_screen_t *qxl = pScrn->driverPrivate;

+    compat_qxl_screen_t *compat_qxl = pScrn->driverPrivate;

-    qxl_set_cursor_position(pScrn, qxl->cur_x, qxl->cur_y);

+    compat_qxl_set_cursor_position(pScrn, compat_qxl->cur_x, compat_qxl->cur_y);

 }

 hidden void

-qxl_cursor_init(ScreenPtr pScreen)

+compat_qxl_cursor_init(ScreenPtr pScreen)

 {

     xf86CursorInfoPtr cursor;

@@ -182,14 +182,14 @@ qxl_cursor_init(ScreenPtr pScreen)

     cursor->MaxWidth = cursor->MaxHeight = 64;

     /* cursor->Flags; */

-    cursor->SetCursorPosition = qxl_set_cursor_position;

-    cursor->LoadCursorARGB = qxl_load_cursor_argb;

-    cursor->UseHWCursor = qxl_use_hw_cursor;

-    cursor->UseHWCursorARGB = qxl_use_hw_cursorARGB;

-    cursor->LoadCursorImage = qxl_load_cursor_image;

-    cursor->SetCursorColors = qxl_set_cursor_colors;

-    cursor->HideCursor = qxl_hide_cursor;

-    cursor->ShowCursor = qxl_show_cursor;

+    cursor->SetCursorPosition = compat_qxl_set_cursor_position;

+    cursor->LoadCursorARGB = compat_qxl_load_cursor_argb;

+    cursor->UseHWCursor = compat_qxl_use_hw_cursor;

+    cursor->UseHWCursorARGB = compat_qxl_use_hw_cursorARGB;

+    cursor->LoadCursorImage = compat_qxl_load_cursor_image;

+    cursor->SetCursorColors = compat_qxl_set_cursor_colors;

+    cursor->HideCursor = compat_qxl_hide_cursor;

+    cursor->ShowCursor = compat_qxl_show_cursor;

     if (!xf86InitCursor(pScreen, cursor))

 	xfree(cursor);

diff -up xf86-video-qxl-20130514/src/compat/compat-qxl_driver.c.compat2 xf86-video-qxl-20130514/src/compat/compat-qxl_driver.c

--- xf86-video-qxl-20130514/src/compat/compat-qxl_driver.c.compat2	2013-07-03 14:19:39.009334569 +1000

+++ xf86-video-qxl-20130514/src/compat/compat-qxl_driver.c	2013-07-03 14:19:56.103748552 +1000

@@ -20,10 +20,10 @@

  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  */

-/** \file qxl_driver.c

+/** \file compat_qxl_driver.c

  * \author Adam Jackson <ajax@redhat.com>

  *

- * This is qxl, a driver for the Qumranet paravirtualized graphics device

+ * This is compat_qxl, a driver for the Qumranet paravirtualized graphics device

  * in qemu.

  */

@@ -39,12 +39,12 @@

 #define CHECK_POINT()

 static int

-garbage_collect (qxl_screen_t *qxl)

+garbage_collect (compat_qxl_screen_t *compat_qxl)

 {

     uint64_t id;

     int i = 0;

-    while (qxl_ring_pop (qxl->release_ring, &id))

+    while (compat_qxl_ring_pop (compat_qxl->release_ring, &id))

     {

 	while (id)

 	{

@@ -54,9 +54,9 @@ garbage_collect (qxl_screen_t *qxl)

 	     */

 #define POINTER_MASK ((1 << 2) - 1)

-	    union qxl_release_info *info = u64_to_pointer (id & ~POINTER_MASK);

-	    struct qxl_cursor_cmd *cmd = (struct qxl_cursor_cmd *)info;

-	    struct qxl_drawable *drawable = (struct qxl_drawable *)info;

+	    union compat_qxl_release_info *info = u64_to_pointer (id & ~POINTER_MASK);

+	    struct compat_qxl_cursor_cmd *cmd = (struct compat_qxl_cursor_cmd *)info;

+	    struct compat_qxl_drawable *drawable = (struct compat_qxl_drawable *)info;

 	    int is_cursor = FALSE;

 	    if ((id & POINTER_MASK) == 1)

@@ -64,22 +64,22 @@ garbage_collect (qxl_screen_t *qxl)

 	    if (is_cursor && cmd->type == QXL_CURSOR_SET)

 	    {

-		struct qxl_cursor *cursor = (void *)virtual_address (

-		    qxl, u64_to_pointer (cmd->u.set.shape));

+		struct compat_qxl_cursor *cursor = (void *)virtual_address (

+		    compat_qxl, u64_to_pointer (cmd->u.set.shape));

-		qxl_free (qxl->mem, cursor);

+		compat_qxl_free (compat_qxl->mem, cursor);

 	    }

 	    else if (!is_cursor && drawable->type == QXL_DRAW_COPY)

 	    {

-		struct qxl_image *image = virtual_address (

-		    qxl, u64_to_pointer (drawable->u.copy.src_bitmap));

+		struct compat_qxl_image *image = virtual_address (

+		    compat_qxl, u64_to_pointer (drawable->u.copy.src_bitmap));

-		qxl_image_destroy (qxl, image);

+		compat_qxl_image_destroy (compat_qxl, image);

 	    }

 	    id = info->next;

-	    qxl_free (qxl->mem, info);

+	    compat_qxl_free (compat_qxl->mem, info);

 	}

     }

@@ -87,7 +87,7 @@ garbage_collect (qxl_screen_t *qxl)

 }

 static void

-qxl_usleep (int useconds)

+compat_qxl_usleep (int useconds)

 {

     struct timespec t;

@@ -102,35 +102,35 @@ qxl_usleep (int useconds)

 #if 0

 static void

-push_update_area (qxl_screen_t *qxl, const struct qxl_rect *area)

+push_update_area (compat_qxl_screen_t *compat_qxl, const struct compat_qxl_rect *area)

 {

-    struct qxl_update_cmd *update = qxl_allocnf (qxl, sizeof *update);

-    struct qxl_command cmd;

+    struct compat_qxl_update_cmd *update = compat_qxl_allocnf (compat_qxl, sizeof *update);

+    struct compat_qxl_command cmd;

     update->release_info.id = (uint64_t)update;

     update->area = *area;

     update->update_id = 0;

     cmd.type = QXL_CMD_UDPATE;

-    cmd.data = physical_address (qxl, update);

+    cmd.data = physical_address (compat_qxl, update);

-    qxl_ring_push (qxl->command_ring, &cmd);

+    compat_qxl_ring_push (compat_qxl->command_ring, &cmd);

 }

 #endif

 void *

-qxl_allocnf (qxl_screen_t *qxl, unsigned long size)

+compat_qxl_allocnf (compat_qxl_screen_t *compat_qxl, unsigned long size)

 {

     void *result;

     int n_attempts = 0;

     static int nth_oom = 1;

-    garbage_collect (qxl);

+    garbage_collect (compat_qxl);

-    while (!(result = qxl_alloc (qxl->mem, size)))

+    while (!(result = compat_qxl_alloc (compat_qxl->mem, size)))

     {

-	struct qxl_ram_header *ram_header = (void *)((unsigned long)qxl->ram +

-						     qxl->rom->ram_header_offset);

+	struct compat_qxl_ram_header *ram_header = (void *)((unsigned long)compat_qxl->ram +

+						     compat_qxl->rom->ram_header_offset);

 	/* Rather than go out of memory, we simply tell the

 	 * device to dump everything

@@ -140,21 +140,21 @@ qxl_allocnf (qxl_screen_t *qxl, unsigned

 	ram_header->update_area.left = 0;

 	ram_header->update_area.right = 800;

-	outb (qxl->io_base + QXL_IO_UPDATE_AREA, 0);

+	outb (compat_qxl->io_base + QXL_IO_UPDATE_AREA, 0);

  	ErrorF ("eliminated memory (%d)\n", nth_oom++);

-	outb (qxl->io_base + QXL_IO_NOTIFY_OOM, 0);

+	outb (compat_qxl->io_base + QXL_IO_NOTIFY_OOM, 0);

-	qxl_usleep (10000);

+	compat_qxl_usleep (10000);

-	if (garbage_collect (qxl))

+	if (garbage_collect (compat_qxl))

 	{

 	    n_attempts = 0;

 	}

 	else if (++n_attempts == 1000)

 	{

-	    qxl_mem_dump_stats (qxl->mem, "Out of mem - stats\n");

+	    compat_qxl_mem_dump_stats (compat_qxl->mem, "Out of mem - stats\n");

 	    fprintf (stderr, "Out of memory\n");

 	    exit (1);

@@ -165,127 +165,127 @@ qxl_allocnf (qxl_screen_t *qxl, unsigned

 }

 static Bool

-qxl_blank_screen(ScreenPtr pScreen, int mode)

+compat_qxl_blank_screen(ScreenPtr pScreen, int mode)

 {

     return TRUE;

 }

 static void

-qxl_unmap_memory(qxl_screen_t *qxl, int scrnIndex)

+compat_qxl_unmap_memory(compat_qxl_screen_t *compat_qxl, int scrnIndex)

 {

 #ifdef XSERVER_LIBPCIACCESS

-    if (qxl->ram)

-	pci_device_unmap_range(qxl->pci, qxl->ram, qxl->pci->regions[0].size);

-    if (qxl->vram)

-	pci_device_unmap_range(qxl->pci, qxl->vram, qxl->pci->regions[1].size);

-    if (qxl->rom)

-	pci_device_unmap_range(qxl->pci, qxl->rom, qxl->pci->regions[2].size);

+    if (compat_qxl->ram)

+	pci_device_unmap_range(compat_qxl->pci, compat_qxl->ram, compat_qxl->pci->regions[0].size);

+    if (compat_qxl->vram)

+	pci_device_unmap_range(compat_qxl->pci, compat_qxl->vram, compat_qxl->pci->regions[1].size);

+    if (compat_qxl->rom)

+	pci_device_unmap_range(compat_qxl->pci, compat_qxl->rom, compat_qxl->pci->regions[2].size);

 #else

-    if (qxl->ram)

-	xf86UnMapVidMem(scrnIndex, qxl->ram, (1 << qxl->pci->size[0]));

-    if (qxl->vram)

-	xf86UnMapVidMem(scrnIndex, qxl->vram, (1 << qxl->pci->size[1]));

-    if (qxl->rom)

-	xf86UnMapVidMem(scrnIndex, qxl->rom, (1 << qxl->pci->size[2]));

+    if (compat_qxl->ram)

+	xf86UnMapVidMem(scrnIndex, compat_qxl->ram, (1 << compat_qxl->pci->size[0]));

+    if (compat_qxl->vram)

+	xf86UnMapVidMem(scrnIndex, compat_qxl->vram, (1 << compat_qxl->pci->size[1]));

+    if (compat_qxl->rom)

+	xf86UnMapVidMem(scrnIndex, compat_qxl->rom, (1 << compat_qxl->pci->size[2]));

 #endif

-    qxl->ram = qxl->ram_physical = qxl->vram = qxl->rom = NULL;

+    compat_qxl->ram = compat_qxl->ram_physical = compat_qxl->vram = compat_qxl->rom = NULL;

-    qxl->num_modes = 0;

-    qxl->modes = NULL;

+    compat_qxl->num_modes = 0;

+    compat_qxl->modes = NULL;

 }

 static Bool

-qxl_map_memory(qxl_screen_t *qxl, int scrnIndex)

+compat_qxl_map_memory(compat_qxl_screen_t *compat_qxl, int scrnIndex)

 {

 #ifdef XSERVER_LIBPCIACCESS

-    pci_device_map_range(qxl->pci, qxl->pci->regions[0].base_addr, 

-			 qxl->pci->regions[0].size,

+    pci_device_map_range(compat_qxl->pci, compat_qxl->pci->regions[0].base_addr, 

+			 compat_qxl->pci->regions[0].size,

 			 PCI_DEV_MAP_FLAG_WRITABLE | PCI_DEV_MAP_FLAG_WRITE_COMBINE,

-			 &qxl->ram);

-    qxl->ram_physical = u64_to_pointer (qxl->pci->regions[0].base_addr);

+			 &compat_qxl->ram);

+    compat_qxl->ram_physical = u64_to_pointer (compat_qxl->pci->regions[0].base_addr);

-    pci_device_map_range(qxl->pci, qxl->pci->regions[1].base_addr, 

-			 qxl->pci->regions[1].size,

+    pci_device_map_range(compat_qxl->pci, compat_qxl->pci->regions[1].base_addr, 

+			 compat_qxl->pci->regions[1].size,

 			 PCI_DEV_MAP_FLAG_WRITABLE,

-			 &qxl->vram);

+			 &compat_qxl->vram);

-    pci_device_map_range(qxl->pci, qxl->pci->regions[2].base_addr, 

-			 qxl->pci->regions[2].size, 0,

-			 (void **)&qxl->rom);

+    pci_device_map_range(compat_qxl->pci, compat_qxl->pci->regions[2].base_addr, 

+			 compat_qxl->pci->regions[2].size, 0,

+			 (void **)&compat_qxl->rom);

-    qxl->io_base = qxl->pci->regions[3].base_addr;

+    compat_qxl->io_base = compat_qxl->pci->regions[3].base_addr;

 #else

-    qxl->ram = xf86MapPciMem(scrnIndex, VIDMEM_FRAMEBUFFER,

-			     qxl->pci_tag, qxl->pci->memBase[0],

-			     (1 << qxl->pci->size[0]));

-    qxl->ram_physical = (void *)qxl->pci->memBase[0];

-    

-    qxl->vram = xf86MapPciMem(scrnIndex, VIDMEM_MMIO | VIDMEM_MMIO_32BIT,

-			      qxl->pci_tag, qxl->pci->memBase[1],

-			      (1 << qxl->pci->size[1]));

-    

-    qxl->rom = xf86MapPciMem(scrnIndex, VIDMEM_MMIO | VIDMEM_MMIO_32BIT,

-			     qxl->pci_tag, qxl->pci->memBase[2],

-			     (1 << qxl->pci->size[2]));

+    compat_qxl->ram = xf86MapPciMem(scrnIndex, VIDMEM_FRAMEBUFFER,

+			     compat_qxl->pci_tag, compat_qxl->pci->memBase[0],

+			     (1 << compat_qxl->pci->size[0]));

+    compat_qxl->ram_physical = (void *)compat_qxl->pci->memBase[0];

+    

+    compat_qxl->vram = xf86MapPciMem(scrnIndex, VIDMEM_MMIO | VIDMEM_MMIO_32BIT,

+			      compat_qxl->pci_tag, compat_qxl->pci->memBase[1],

+			      (1 << compat_qxl->pci->size[1]));

+    

+    compat_qxl->rom = xf86MapPciMem(scrnIndex, VIDMEM_MMIO | VIDMEM_MMIO_32BIT,

+			     compat_qxl->pci_tag, compat_qxl->pci->memBase[2],

+			     (1 << compat_qxl->pci->size[2]));

-    qxl->io_base = qxl->pci->ioBase[3];

+    compat_qxl->io_base = compat_qxl->pci->ioBase[3];

 #endif

-    if (!qxl->ram || !qxl->vram || !qxl->rom)

+    if (!compat_qxl->ram || !compat_qxl->vram || !compat_qxl->rom)

 	return FALSE;

     xf86DrvMsg(scrnIndex, X_INFO, "ram at %p; vram at %p; rom at %p\n",

-	       qxl->ram, qxl->vram, qxl->rom);

+	       compat_qxl->ram, compat_qxl->vram, compat_qxl->rom);

-    qxl->num_modes = *(uint32_t *)((uint8_t *)qxl->rom + qxl->rom->modes_offset);

-    qxl->modes = (struct qxl_mode *)(((uint8_t *)qxl->rom) + qxl->rom->modes_offset + 4);

+    compat_qxl->num_modes = *(uint32_t *)((uint8_t *)compat_qxl->rom + compat_qxl->rom->modes_offset);

+    compat_qxl->modes = (struct compat_qxl_mode *)(((uint8_t *)compat_qxl->rom) + compat_qxl->rom->modes_offset + 4);

     return TRUE;

 }

 static void

-qxl_save_state(ScrnInfoPtr pScrn)

+compat_qxl_save_state(ScrnInfoPtr pScrn)

 {

-    qxl_screen_t *qxl = pScrn->driverPrivate;

+    compat_qxl_screen_t *compat_qxl = pScrn->driverPrivate;

-    vgaHWSaveFonts(pScrn, &qxl->vgaRegs);

+    vgaHWSaveFonts(pScrn, &compat_qxl->vgaRegs);

 }

 static void

-qxl_restore_state(ScrnInfoPtr pScrn)

+compat_qxl_restore_state(ScrnInfoPtr pScrn)

 {

-    qxl_screen_t *qxl = pScrn->driverPrivate;

+    compat_qxl_screen_t *compat_qxl = pScrn->driverPrivate;

-    vgaHWRestoreFonts(pScrn, &qxl->vgaRegs);

+    vgaHWRestoreFonts(pScrn, &compat_qxl->vgaRegs);

 }

 static Bool

-qxl_close_screen(int scrnIndex, ScreenPtr pScreen)

+compat_qxl_close_screen(int scrnIndex, ScreenPtr pScreen)

 {

     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];

-    qxl_screen_t *qxl = pScrn->driverPrivate;

+    compat_qxl_screen_t *compat_qxl = pScrn->driverPrivate;

     if (pScrn->vtSema) {

-        qxl_restore_state(pScrn);

-	qxl_unmap_memory(qxl, scrnIndex);

+        compat_qxl_restore_state(pScrn);

+	compat_qxl_unmap_memory(compat_qxl, scrnIndex);

     }

     pScrn->vtSema = FALSE;

-    xfree(qxl->fb);

+    xfree(compat_qxl->fb);

-    pScreen->CreateScreenResources = qxl->create_screen_resources;

-    pScreen->CloseScreen = qxl->close_screen;

+    pScreen->CreateScreenResources = compat_qxl->create_screen_resources;

+    pScreen->CloseScreen = compat_qxl->close_screen;

     return pScreen->CloseScreen(scrnIndex, pScreen);

 }

 static Bool

-qxl_switch_mode(int scrnIndex, DisplayModePtr p, int flags)

+compat_qxl_switch_mode(int scrnIndex, DisplayModePtr p, int flags)

 {

-    qxl_screen_t *qxl = xf86Screens[scrnIndex]->driverPrivate;

+    compat_qxl_screen_t *compat_qxl = xf86Screens[scrnIndex]->driverPrivate;

     int mode_index = (int)(unsigned long)p->Private;

-    struct qxl_mode *m = qxl->modes + mode_index;

-    ScreenPtr pScreen = qxl->pScrn->pScreen;

+    struct compat_qxl_mode *m = compat_qxl->modes + mode_index;

+    ScreenPtr pScreen = compat_qxl->pScrn->pScreen;

     if (!m)

 	return FALSE;

@@ -294,11 +294,11 @@ qxl_switch_mode(int scrnIndex, DisplayMo

     xf86DrvMsg (scrnIndex, X_INFO, "Setting mode %d (%d x %d) (%d x %d) %p\n",

 		m->id, m->x_res, m->y_res, p->HDisplay, p->VDisplay, p);

-    outb(qxl->io_base + QXL_IO_RESET, 0);

+    outb(compat_qxl->io_base + QXL_IO_RESET, 0);

-    outb(qxl->io_base + QXL_IO_SET_MODE, m->id);

+    outb(compat_qxl->io_base + QXL_IO_SET_MODE, m->id);

-    qxl->bytes_per_pixel = (qxl->pScrn->bitsPerPixel + 7) / 8;

+    compat_qxl->bytes_per_pixel = (compat_qxl->pScrn->bitsPerPixel + 7) / 8;

     /* If this happens out of ScreenInit, we won't have a screen yet. In that

      * case createScreenResources will make things right.

@@ -313,15 +313,15 @@ qxl_switch_mode(int scrnIndex, DisplayMo

 		pPixmap,

 		m->x_res, m->y_res,

 		-1, -1,

-		qxl->pScrn->displayWidth * qxl->bytes_per_pixel,

+		compat_qxl->pScrn->displayWidth * compat_qxl->bytes_per_pixel,

 		NULL);

 	}

     }